code:
import type { ExtractPropType } from 'element-plus/es/utils';
import type { ExtractPropTypes, Ref } from 'vue';
declare const _prop: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null) | ((new (...args: any[]) => (boolean | null) & {}) | (() => boolean | null))[], never, never, null, false>;
declare const _event: {
    readonly type: import("vue").PropType<(val: boolean) => void>;
    readonly required: false;
    readonly validator: ((val: unknown) => boolean) | undefined;
    __epPropKey: true;
};
export declare type UseModelTogglePropsRaw<T extends string> = {
    [K in T]: typeof _prop;
} & {
    [K in `onUpdate:${T}`]: typeof _event;
};
export declare type UseModelTogglePropsGeneric<T extends string> = {
    [K in T]: ExtractPropType<typeof _prop>;
} & {
    [K in `onUpdate:${T}`]: ExtractPropType<typeof _event>;
};
export declare const createModelToggleComposable: <T extends string>(name: T) => {
    useModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: ModelToggleParams) => {
        hide: (event?: Event) => void;
        show: (event?: Event) => void;
        toggle: () => void;
        hasUpdateHandler: import("vue").ComputedRef<boolean>;
    };
    useModelToggleProps: UseModelTogglePropsRaw<T>;
    useModelToggleEmits: `update:${T}`[];
};
declare const useModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: ModelToggleParams) => {
    hide: (event?: Event) => void;
    show: (event?: Event) => void;
    toggle: () => void;
    hasUpdateHandler: import("vue").ComputedRef<boolean>;
}, useModelToggleProps: UseModelTogglePropsRaw<"modelValue">, useModelToggleEmits: "update:modelValue"[];
export { useModelToggle, useModelToggleEmits, useModelToggleProps };
export declare type UseModelToggleProps = ExtractPropTypes<typeof useModelToggleProps>;
export declare type ModelToggleParams = {
    indicator: Ref<boolean>;
    toggleReason?: Ref<Event | undefined>;
    shouldHideWhenRouteChanges?: Ref<boolean>;
    shouldProceed?: () => boolean;
    onShow?: (event?: Event) => void;
    onHide?: (event?: Event) => void;
};


code:
import { getCurrentInstance, computed, watch, onMounted } from 'vue';
import '../../utils/index.mjs';
import { buildProp, definePropType } from '../../utils/vue/props/runtime.mjs';
import { isFunction } from '@vue/shared';
import { isClient } from '@vueuse/core';
import { isBoolean } from '../../utils/types.mjs';

const _prop = buildProp({
  type: definePropType(Boolean),
  default: null
});
const _event = buildProp({
  type: definePropType(Function)
});
const createModelToggleComposable = (name) => {
  const updateEventKey = `update:${name}`;
  const updateEventKeyRaw = `onUpdate:${name}`;
  const useModelToggleEmits2 = [updateEventKey];
  const useModelToggleProps2 = {
    [name]: _prop,
    [updateEventKeyRaw]: _event
  };
  const useModelToggle2 = ({
    indicator,
    toggleReason,
    shouldHideWhenRouteChanges,
    shouldProceed,
    onShow,
    onHide
  }) => {
    const instance = getCurrentInstance();
    const { emit } = instance;
    const props = instance.props;
    const hasUpdateHandler = computed(() => isFunction(props[updateEventKeyRaw]));
    const isModelBindingAbsent = computed(() => props[name] === null);
    const doShow = (event) => {
      if (indicator.value === true) {
        return;
      }
      indicator.value = true;
      if (toggleReason) {
        toggleReason.value = event;
      }
      if (isFunction(onShow)) {
        onShow(event);
      }
    };
    const doHide = (event) => {
      if (indicator.value === false) {
        return;
      }
      indicator.value = false;
      if (toggleReason) {
        toggleReason.value = event;
      }
      if (isFunction(onHide)) {
        onHide(event);
      }
    };
    const show = (event) => {
      if (props.disabled === true || isFunction(shouldProceed) && !shouldProceed())
        return;
      const shouldEmit = hasUpdateHandler.value && isClient;
      if (shouldEmit) {
        emit(updateEventKey, true);
      }
      if (isModelBindingAbsent.value || !shouldEmit) {
        doShow(event);
      }
    };
    const hide = (event) => {
      if (props.disabled === true || !isClient)
        return;
      const shouldEmit = hasUpdateHandler.value && isClient;
      if (shouldEmit) {
        emit(updateEventKey, false);
      }
      if (isModelBindingAbsent.value || !shouldEmit) {
        doHide(event);
      }
    };
    const onChange = (val) => {
      if (!isBoolean(val))
        return;
      if (props.disabled && val) {
        if (hasUpdateHandler.value) {
          emit(updateEventKey, false);
        }
      } else if (indicator.value !== val) {
        if (val) {
          doShow();
        } else {
          doHide();
        }
      }
    };
    const toggle = () => {
      if (indicator.value) {
        hide();
      } else {
        show();
      }
    };
    watch(() => props[name], onChange);
    if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
      watch(() => ({
        ...instance.proxy.$route
      }), () => {
        if (shouldHideWhenRouteChanges.value && indicator.value) {
          hide();
        }
      });
    }
    onMounted(() => {
      onChange(props[name]);
    });
    return {
      hide,
      show,
      toggle,
      hasUpdateHandler
    };
  };
  return {
    useModelToggle: useModelToggle2,
    useModelToggleProps: useModelToggleProps2,
    useModelToggleEmits: useModelToggleEmits2
  };
};
const { useModelToggle, useModelToggleProps, useModelToggleEmits } = createModelToggleComposable("modelValue");

export { createModelToggleComposable, useModelToggle, useModelToggleEmits, useModelToggleProps };
//# sourceMappingURL=index.mjs.map

license: mit


code:
import type { InjectionKey, Ref } from 'vue';
export declare const defaultNamespace = "el";
export declare const namespaceContextKey: InjectionKey<Ref<string | undefined>>;
export declare const useGetDerivedNamespace: (namespaceOverrides?: Ref<string | undefined>) => import("vue").ComputedRef<string>;
export declare const useNamespace: (block: string, namespaceOverrides?: Ref<string | undefined>) => {
    namespace: import("vue").ComputedRef<string>;
    b: (blockSuffix?: string) => string;
    e: (element?: string) => string;
    m: (modifier?: string) => string;
    be: (blockSuffix?: string, element?: string) => string;
    em: (element?: string, modifier?: string) => string;
    bm: (blockSuffix?: string, modifier?: string) => string;
    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
    is: {
        (name: string, state: boolean | undefined): string;
        (name: string): string;
    };
    cssVar: (object: Record<string, string>) => Record<string, string>;
    cssVarName: (name: string) => string;
    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
    cssVarBlockName: (name: string) => string;
};
export declare type UseNamespaceReturn = ReturnType<typeof useNamespace>;


code:
import { getCurrentInstance, inject, ref, computed, unref } from 'vue';

const defaultNamespace = "el";
const statePrefix = "is-";
const _bem = (namespace, block, blockSuffix, element, modifier) => {
  let cls = `${namespace}-${block}`;
  if (blockSuffix) {
    cls += `-${blockSuffix}`;
  }
  if (element) {
    cls += `__${element}`;
  }
  if (modifier) {
    cls += `--${modifier}`;
  }
  return cls;
};
const namespaceContextKey = Symbol("namespaceContextKey");
const useGetDerivedNamespace = (namespaceOverrides) => {
  const derivedNamespace = namespaceOverrides || (getCurrentInstance() ? inject(namespaceContextKey, ref(defaultNamespace)) : ref(defaultNamespace));
  const namespace = computed(() => {
    return unref(derivedNamespace) || defaultNamespace;
  });
  return namespace;
};
const useNamespace = (block, namespaceOverrides) => {
  const namespace = useGetDerivedNamespace(namespaceOverrides);
  const b = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
  const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
  const m = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
  const be = (blockSuffix, element) => blockSuffix && element ? _bem(namespace.value, block, blockSuffix, element, "") : "";
  const em = (element, modifier) => element && modifier ? _bem(namespace.value, block, "", element, modifier) : "";
  const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(namespace.value, block, blockSuffix, "", modifier) : "";
  const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(namespace.value, block, blockSuffix, element, modifier) : "";
  const is = (name, ...args) => {
    const state = args.length >= 1 ? args[0] : true;
    return name && state ? `${statePrefix}${name}` : "";
  };
  const cssVar = (object) => {
    const styles = {};
    for (const key in object) {
      if (object[key]) {
        styles[`--${namespace.value}-${key}`] = object[key];
      }
    }
    return styles;
  };
  const cssVarBlock = (object) => {
    const styles = {};
    for (const key in object) {
      if (object[key]) {
        styles[`--${namespace.value}-${block}-${key}`] = object[key];
      }
    }
    return styles;
  };
  const cssVarName = (name) => `--${namespace.value}-${name}`;
  const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
  return {
    namespace,
    b,
    e,
    m,
    be,
    em,
    bm,
    bem,
    is,
    cssVar,
    cssVarName,
    cssVarBlock,
    cssVarBlockName
  };
};

export { defaultNamespace, namespaceContextKey, useGetDerivedNamespace, useNamespace };
//# sourceMappingURL=index.mjs.map


code:
import type { ComponentInternalInstance } from 'vue';
export declare const useOrderedChildren: <T extends {
    uid: number;
}>(vm: ComponentInternalInstance, childComponentName: string) => {
    children: import("vue").ShallowRef<T[]>;
    addChild: (child: T) => void;
    removeChild: (uid: number) => void;
};


code:
import { isVNode, shallowRef } from 'vue';
import '../../utils/index.mjs';
import { flattedChildren } from '../../utils/vue/vnode.mjs';

const getOrderedChildren = (vm, childComponentName, children) => {
  const nodes = flattedChildren(vm.subTree).filter((n) => {
    var _a;
    return isVNode(n) && ((_a = n.type) == null ? void 0 : _a.name) === childComponentName && !!n.component;
  });
  const uids = nodes.map((n) => n.component.uid);
  return uids.map((uid) => children[uid]).filter((p) => !!p);
};
const useOrderedChildren = (vm, childComponentName) => {
  const children = {};
  const orderedChildren = shallowRef([]);
  const addChild = (child) => {
    children[child.uid] = child;
    orderedChildren.value = getOrderedChildren(vm, childComponentName, children);
  };
  const removeChild = (uid) => {
    delete children[uid];
    orderedChildren.value = orderedChildren.value.filter((children2) => children2.uid !== uid);
  };
  return {
    children: orderedChildren,
    addChild,
    removeChild
  };
};

export { useOrderedChildren };
//# sourceMappingURL=index.mjs.map


code:
export declare const usePopperContainerId: () => {
    id: import("vue").ComputedRef<string>;
    selector: import("vue").ComputedRef<string>;
};
export declare const usePopperContainer: () => {
    id: import("vue").ComputedRef<string>;
    selector: import("vue").ComputedRef<string>;
};


code:
import { computed, onBeforeMount } from 'vue';
import '../../utils/index.mjs';
import { useGetDerivedNamespace } from '../use-namespace/index.mjs';
import { useIdInjection } from '../use-id/index.mjs';
import { isClient } from '@vueuse/core';

const usePopperContainerId = () => {
  const namespace = useGetDerivedNamespace();
  const idInjection = useIdInjection();
  const id = computed(() => {
    return `${namespace.value}-popper-container-${idInjection.prefix}`;
  });
  const selector = computed(() => `#${id.value}`);
  return {
    id,
    selector
  };
};
const createContainer = (id) => {
  const container = document.createElement("div");
  container.id = id;
  document.body.appendChild(container);
  return container;
};
const usePopperContainer = () => {
  const { id, selector } = usePopperContainerId();
  onBeforeMount(() => {
    if (!isClient)
      return;
    if (process.env.NODE_ENV === "test" || !document.body.querySelector(selector.value)) {
      createContainer(id.value);
    }
  });
  return {
    id,
    selector
  };
};

export { usePopperContainer, usePopperContainerId };
//# sourceMappingURL=index.mjs.map


code:
import type { Ref } from 'vue';
import type { Instance, Modifier, Options, State, VirtualElement } from '@popperjs/core';
declare type ElementType = HTMLElement | undefined;
declare type ReferenceElement = ElementType | VirtualElement;
export declare type PartialOptions = Partial<Options>;
export declare const usePopper: (referenceElementRef: Ref<ReferenceElement>, popperElementRef: Ref<ElementType>, opts?: Ref<PartialOptions> | PartialOptions) => {
    state: import("vue").ComputedRef<{
        elements?: {
            reference: Element | VirtualElement;
            popper: HTMLElement;
            arrow?: HTMLElement | undefined;
        } | undefined;
        options?: import("@popperjs/core").OptionsGeneric<any> | undefined;
        placement?: import("@popperjs/core").Placement | undefined;
        strategy?: import("@popperjs/core").PositioningStrategy | undefined;
        orderedModifiers?: Modifier<any, any>[] | undefined;
        rects?: import("@popperjs/core").StateRects | undefined;
        scrollParents?: {
            reference: (Element | import("@popperjs/core").Window | import("@popperjs/core").VisualViewport)[];
            popper: (Element | import("@popperjs/core").Window | import("@popperjs/core").VisualViewport)[];
        } | undefined;
        styles?: {
            [key: string]: Partial<CSSStyleDeclaration>;
        } | undefined;
        attributes?: {
            [key: string]: {
                [key: string]: string | boolean;
            };
        } | undefined;
        modifiersData?: {
            [key: string]: any;
            arrow?: {
                x?: number | undefined;
                y?: number | undefined;
                centerOffset: number;
            } | undefined;
            hide?: {
                isReferenceHidden: boolean;
                hasPopperEscaped: boolean;
                referenceClippingOffsets: import("@popperjs/core").SideObject;
                popperEscapeOffsets: import("@popperjs/core").SideObject;
            } | undefined;
            offset?: {
                top?: import("@popperjs/core").Offsets | undefined;
                bottom?: import("@popperjs/core").Offsets | undefined;
                left?: import("@popperjs/core").Offsets | undefined;
                right?: import("@popperjs/core").Offsets | undefined;
                auto?: import("@popperjs/core").Offsets | undefined;
                "auto-start"?: import("@popperjs/core").Offsets | undefined;
                "auto-end"?: import("@popperjs/core").Offsets | undefined;
                "top-start"?: import("@popperjs/core").Offsets | undefined;
                "top-end"?: import("@popperjs/core").Offsets | undefined;
                "bottom-start"?: import("@popperjs/core").Offsets | undefined;
                "bottom-end"?: import("@popperjs/core").Offsets | undefined;
                "right-start"?: import("@popperjs/core").Offsets | undefined;
                "right-end"?: import("@popperjs/core").Offsets | undefined;
                "left-start"?: import("@popperjs/core").Offsets | undefined;
                "left-end"?: import("@popperjs/core").Offsets | undefined;
            } | undefined;
            preventOverflow?: import("@popperjs/core").Offsets | undefined;
            popperOffsets?: import("@popperjs/core").Offsets | undefined;
        } | undefined;
        reset?: boolean | undefined;
    }>;
    styles: import("vue").ComputedRef<{
        [key: string]: Partial<CSSStyleDeclaration>;
    }>;
    attributes: import("vue").ComputedRef<{
        [key: string]: {
            [key: string]: string | boolean;
        };
    }>;
    update: () => Promise<Partial<State>> | undefined;
    forceUpdate: () => void | undefined;
    instanceRef: import("vue").ComputedRef<Instance | undefined>;
};
export declare type UsePopperReturn = ReturnType<typeof usePopper>;
export {};


code:
import { computed, unref, shallowRef, ref, watch, onBeforeUnmount } from 'vue';
import { createPopper } from '@popperjs/core';
import { fromPairs } from 'lodash-unified';

const usePopper = (referenceElementRef, popperElementRef, opts = {}) => {
  const stateUpdater = {
    name: "updateState",
    enabled: true,
    phase: "write",
    fn: ({ state }) => {
      const derivedState = deriveState(state);
      Object.assign(states.value, derivedState);
    },
    requires: ["computeStyles"]
  };
  const options = computed(() => {
    const { onFirstUpdate, placement, strategy, modifiers } = unref(opts);
    return {
      onFirstUpdate,
      placement: placement || "bottom",
      strategy: strategy || "absolute",
      modifiers: [
        ...modifiers || [],
        stateUpdater,
        { name: "applyStyles", enabled: false }
      ]
    };
  });
  const instanceRef = shallowRef();
  const states = ref({
    styles: {
      popper: {
        position: unref(options).strategy,
        left: "0",
        top: "0"
      },
      arrow: {
        position: "absolute"
      }
    },
    attributes: {}
  });
  const destroy = () => {
    if (!instanceRef.value)
      return;
    instanceRef.value.destroy();
    instanceRef.value = void 0;
  };
  watch(options, (newOptions) => {
    const instance = unref(instanceRef);
    if (instance) {
      instance.setOptions(newOptions);
    }
  }, {
    deep: true
  });
  watch([referenceElementRef, popperElementRef], ([referenceElement, popperElement]) => {
    destroy();
    if (!referenceElement || !popperElement)
      return;
    instanceRef.value = createPopper(referenceElement, popperElement, unref(options));
  });
  onBeforeUnmount(() => {
    destroy();
  });
  return {
    state: computed(() => {
      var _a;
      return { ...((_a = unref(instanceRef)) == null ? void 0 : _a.state) || {} };
    }),
    styles: computed(() => unref(states).styles),
    attributes: computed(() => unref(states).attributes),
    update: () => {
      var _a;
      return (_a = unref(instanceRef)) == null ? void 0 : _a.update();
    },
    forceUpdate: () => {
      var _a;
      return (_a = unref(instanceRef)) == null ? void 0 : _a.forceUpdate();
    },
    instanceRef: computed(() => unref(instanceRef))
  };
};
function deriveState(state) {
  const elements = Object.keys(state.elements);
  const styles = fromPairs(elements.map((element) => [element, state.styles[element] || {}]));
  const attributes = fromPairs(elements.map((element) => [element, state.attributes[element]]));
  return {
    styles,
    attributes
  };
}

export { usePopper };
//# sourceMappingURL=index.mjs.map


code:
import type { Ref } from 'vue';
export declare const usePreventGlobal: <E extends keyof DocumentEventMap>(indicator: Ref<boolean>, evt: E, cb: (e: DocumentEventMap[E]) => boolean) => void;


code:
import { watch } from 'vue';
import { useEventListener } from '@vueuse/core';

const usePreventGlobal = (indicator, evt, cb) => {
  const prevent = (e) => {
    if (cb(e))
      e.stopImmediatePropagation();
  };
  let stop = void 0;
  watch(() => indicator.value, (val) => {
    if (val) {
      stop = useEventListener(document, evt, prevent, true);
    } else {
      stop == null ? void 0 : stop();
    }
  }, { immediate: true });
};

export { usePreventGlobal };
//# sourceMappingURL=index.mjs.map


code:
import type { ComputedRef } from 'vue';
export declare const useProp: <T>(name: string) => ComputedRef<T | undefined>;


code:
import { getCurrentInstance, computed } from 'vue';

const useProp = (name) => {
  const vm = getCurrentInstance();
  return computed(() => {
    var _a, _b;
    return (_b = (_a = vm == null ? void 0 : vm.proxy) == null ? void 0 : _a.$props) == null ? void 0 : _b[name];
  });
};

export { useProp };
//# sourceMappingURL=index.mjs.map


sourcesContent:
import { computed, getCurrentInstance } from 'vue'
import type { ComputedRef } from 'vue'

export const useProp = <T>(name: string): ComputedRef<T | undefined> => {
  const vm = getCurrentInstance()
  return computed(() => (vm?.proxy?.$props as any)?.[name])
}


code:
export declare const useSameTarget: (handleClick?: ((e: MouseEvent) => void) | undefined) => {
    onClick: (e: MouseEvent) => void;
    onMousedown: (e: MouseEvent) => void;
    onMouseup: (e: MouseEvent) => void;
};


code:
import '../../utils/index.mjs';
import { NOOP } from '@vue/shared';

const useSameTarget = (handleClick) => {
  if (!handleClick) {
    return { onClick: NOOP, onMousedown: NOOP, onMouseup: NOOP };
  }
  let mousedownTarget = false;
  let mouseupTarget = false;
  const onClick = (e) => {
    if (mousedownTarget && mouseupTarget) {
      handleClick(e);
    }
    mousedownTarget = mouseupTarget = false;
  };
  const onMousedown = (e) => {
    mousedownTarget = e.target === e.currentTarget;
  };
  const onMouseup = (e) => {
    mouseupTarget = e.target === e.currentTarget;
  };
  return { onClick, onMousedown, onMouseup };
};

export { useSameTarget };
//# sourceMappingURL=index.mjs.map


code:
import type { InjectionKey, Ref } from 'vue';
import type { ComponentSize } from 'element-plus/es/constants';
export declare const useSizeProp: {
    readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
    readonly required: false;
    readonly validator: ((val: unknown) => boolean) | undefined;
    __epPropKey: true;
};
export declare const useSizeProps: {
    size: {
        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "small" | "default" | "large", never>>;
        readonly required: false;
        readonly validator: ((val: unknown) => boolean) | undefined;
        __epPropKey: true;
    };
};
export interface SizeContext {
    size: Ref<ComponentSize>;
}
export declare const SIZE_INJECTION_KEY: InjectionKey<SizeContext>;
export declare const useGlobalSize: () => import("vue").ComputedRef<"" | "small" | "default" | "large">;


code:
import { inject, computed, unref } from 'vue';
import '../../utils/index.mjs';
import '../../constants/index.mjs';
import { buildProp } from '../../utils/vue/props/runtime.mjs';
import { componentSizes } from '../../constants/size.mjs';

const useSizeProp = buildProp({
  type: String,
  values: componentSizes,
  required: false
});
const useSizeProps = {
  size: useSizeProp
};
const SIZE_INJECTION_KEY = Symbol("size");
const useGlobalSize = () => {
  const injectedSize = inject(SIZE_INJECTION_KEY, {});
  return computed(() => {
    return unref(injectedSize.size) || "";
  });
};

export { SIZE_INJECTION_KEY, useGlobalSize, useSizeProp, useSizeProps };
//# sourceMappingURL=index.mjs.map


code:
import type { Ref, VNode } from 'vue';
export declare const useTeleport: (contentRenderer: () => VNode, appendToBody: Ref<boolean>) => {
    isTeleportVisible: Ref<boolean>;
    showTeleport: () => void;
    hideTeleport: () => void;
    renderTeleport: () => void;
};


code:
import { ref, h, Teleport, onUnmounted } from 'vue';
import '../../utils/index.mjs';
import { isClient } from '@vueuse/core';
import { NOOP } from '@vue/shared';
import { createGlobalNode, removeGlobalNode } from '../../utils/vue/global-node.mjs';

const useTeleport = (contentRenderer, appendToBody) => {
  const isTeleportVisible = ref(false);
  if (!isClient) {
    return {
      isTeleportVisible,
      showTeleport: NOOP,
      hideTeleport: NOOP,
      renderTeleport: NOOP
    };
  }
  let $el = null;
  const showTeleport = () => {
    isTeleportVisible.value = true;
    if ($el !== null)
      return;
    $el = createGlobalNode();
  };
  const hideTeleport = () => {
    isTeleportVisible.value = false;
    if ($el !== null) {
      removeGlobalNode($el);
      $el = null;
    }
  };
  const renderTeleport = () => {
    return appendToBody.value !== true ? contentRenderer() : isTeleportVisible.value ? [h(Teleport, { to: $el }, contentRenderer())] : void 0;
  };
  onUnmounted(hideTeleport);
  return {
    isTeleportVisible,
    showTeleport,
    hideTeleport,
    renderTeleport
  };
};

export { useTeleport };
//# sourceMappingURL=index.mjs.map


code:
import type { Ref } from 'vue';
export declare const useThrottleRender: (loading: Ref<boolean>, throttle?: number) => Ref<boolean>;


code:
import { ref, onMounted, watch } from 'vue';

const useThrottleRender = (loading, throttle = 0) => {
  if (throttle === 0)
    return loading;
  const throttled = ref(false);
  let timeoutHandle = null;
  const dispatchThrottling = () => {
    if (timeoutHandle) {
      clearTimeout(timeoutHandle);
    }
    timeoutHandle = setTimeout(() => {
      throttled.value = loading.value;
    }, throttle);
  };
  onMounted(dispatchThrottling);
  watch(() => loading.value, (val) => {
    if (val) {
      dispatchThrottling();
    } else {
      throttled.value = val;
    }
  });
  return throttled;
};

export { useThrottleRender };
//# sourceMappingURL=index.mjs.map


code:
export declare function useTimeout(): {
    registerTimeout: (fn: (...args: any[]) => any, delay: number) => void;
    cancelTimeout: () => void;
};


code:
import { tryOnScopeDispose } from '@vueuse/core';

function useTimeout() {
  let timeoutHandle;
  const registerTimeout = (fn, delay) => {
    cancelTimeout();
    timeoutHandle = window.setTimeout(fn, delay);
  };
  const cancelTimeout = () => window.clearTimeout(timeoutHandle);
  tryOnScopeDispose(() => cancelTimeout());
  return {
    registerTimeout,
    cancelTimeout
  };
}

export { useTimeout };
//# sourceMappingURL=index.mjs.map


sourcesContent:
import { tryOnScopeDispose } from '@vueuse/core'

export function useTimeout() {
  let timeoutHandle: number

  const registerTimeout = (fn: (...args: any[]) => any, delay: number) => {
    cancelTimeout()
    timeoutHandle = window.setTimeout(fn, delay)
  }
  const cancelTimeout = () => window.clearTimeout(timeoutHandle)

  tryOnScopeDispose(() => cancelTimeout())

  return {
    registerTimeout,
    cancelTimeout,
  }
}


code:
export declare const useTransitionFallthroughEmits: readonly ["after-appear", "after-enter", "after-leave", "appear", "appear-cancelled", "before-enter", "before-leave", "enter", "enter-cancelled", "leave", "leave-cancelled"];
/**
 * NOTE:
 * This is only a delegator for delegating transition callbacks.
 * Use this at your need.
 */
/**
 * Simple usage
 *
 * In your setups:
 *
 * setup() {
 *   const fallthroughMethods = useTransitionFallthrough()
 *   return fallthrough
 * }
 *
 * In your template:
 *
 * <template>
 *  <transition name="whatever" v-bind="fallthrough">
 *    <slot />
 *  </transition>
 * </template>
 *
 */
export declare const useTransitionFallthrough: () => {
    onAfterAppear: () => void;
    onAfterEnter: () => void;
    onAfterLeave: () => void;
    onAppearCancelled: () => void;
    onBeforeEnter: () => void;
    onBeforeLeave: () => void;
    onEnter: () => void;
    onEnterCancelled: () => void;
    onLeave: () => void;
    onLeaveCancelled: () => void;
};


code:
import { getCurrentInstance } from 'vue';

const AFTER_APPEAR = "after-appear";
const AFTER_ENTER = "after-enter";
const AFTER_LEAVE = "after-leave";
const APPEAR = "appear";
const APPEAR_CANCELLED = "appear-cancelled";
const BEFORE_ENTER = "before-enter";
const BEFORE_LEAVE = "before-leave";
const ENTER = "enter";
const ENTER_CANCELLED = "enter-cancelled";
const LEAVE = "leave";
const LEAVE_CANCELLED = "leave-cancelled";
const useTransitionFallthroughEmits = [
  AFTER_APPEAR,
  AFTER_ENTER,
  AFTER_LEAVE,
  APPEAR,
  APPEAR_CANCELLED,
  BEFORE_ENTER,
  BEFORE_LEAVE,
  ENTER,
  ENTER_CANCELLED,
  LEAVE,
  LEAVE_CANCELLED
];
const useTransitionFallthrough = () => {
  const { emit } = getCurrentInstance();
  return {
    onAfterAppear: () => {
      emit(AFTER_APPEAR);
    },
    onAfterEnter: () => {
      emit(AFTER_ENTER);
    },
    onAfterLeave: () => {
      emit(AFTER_LEAVE);
    },
    onAppearCancelled: () => {
      emit(APPEAR_CANCELLED);
    },
    onBeforeEnter: () => {
      emit(BEFORE_ENTER);
    },
    onBeforeLeave: () => {
      emit(BEFORE_LEAVE);
    },
    onEnter: () => {
      emit(ENTER);
    },
    onEnterCancelled: () => {
      emit(ENTER_CANCELLED);
    },
    onLeave: () => {
      emit(LEAVE);
    },
    onLeaveCancelled: () => {
      emit(LEAVE_CANCELLED);
    }
  };
};

export { useTransitionFallthrough, useTransitionFallthroughEmits };
//# sourceMappingURL=index.mjs.map


code:
import type { InjectionKey, Ref } from 'vue';
export interface ElZIndexInjectionContext {
    current: number;
}
export declare const defaultInitialZIndex = 2000;
export declare const ZINDEX_INJECTION_KEY: InjectionKey<ElZIndexInjectionContext>;
export declare const zIndexContextKey: InjectionKey<Ref<number | undefined>>;
export declare const useZIndex: (zIndexOverrides?: Ref<number>) => {
    initialZIndex: import("vue").ComputedRef<number>;
    currentZIndex: import("vue").ComputedRef<number>;
    nextZIndex: () => number;
};
export declare type UseZIndexReturn = ReturnType<typeof useZIndex>;


code:
import { ref, getCurrentInstance, inject, computed, unref } from 'vue';
import '../../utils/index.mjs';
import { isNumber } from '../../utils/types.mjs';
import { isClient } from '@vueuse/core';
import { debugWarn } from '../../utils/error.mjs';

const initial = {
  current: 0
};
const zIndex = ref(0);
const defaultInitialZIndex = 2e3;
const ZINDEX_INJECTION_KEY = Symbol("elZIndexContextKey");
const zIndexContextKey = Symbol("zIndexContextKey");
const useZIndex = (zIndexOverrides) => {
  const increasingInjection = getCurrentInstance() ? inject(ZINDEX_INJECTION_KEY, initial) : initial;
  const zIndexInjection = zIndexOverrides || (getCurrentInstance() ? inject(zIndexContextKey, void 0) : void 0);
  const initialZIndex = computed(() => {
    const zIndexFromInjection = unref(zIndexInjection);
    return isNumber(zIndexFromInjection) ? zIndexFromInjection : defaultInitialZIndex;
  });
  const currentZIndex = computed(() => initialZIndex.value + zIndex.value);
  const nextZIndex = () => {
    increasingInjection.current++;
    zIndex.value = increasingInjection.current;
    return currentZIndex.value;
  };
  if (!isClient && !inject(ZINDEX_INJECTION_KEY)) {
    debugWarn("ZIndexInjection", `Looks like you are using server rendering, you must provide a z-index provider to ensure the hydration process to be succeed
usage: app.provide(ZINDEX_INJECTION_KEY, { current: 0 })`);
  }
  return {
    initialZIndex,
    currentZIndex,
    nextZIndex
  };
};

export { ZINDEX_INJECTION_KEY, defaultInitialZIndex, useZIndex, zIndexContextKey };
//# sourceMappingURL=index.mjs.map


code:
import installer from './defaults';
export * from 'element-plus/es/components';
export * from 'element-plus/es/constants';
export * from 'element-plus/es/directives';
export * from 'element-plus/es/hooks';
export * from './make-installer';
export declare const install: (app: import("vue").App<any>, options?: Partial<import("element-plus/es/components").ConfigProviderProps> | undefined) => void;
export declare const version: string;
export default installer;
export { default as dayjs } from 'dayjs';


code:
import installer from './defaults.mjs';
export { default } from './defaults.mjs';
import './components/index.mjs';
import './constants/index.mjs';
import './directives/index.mjs';
import './hooks/index.mjs';
export { makeInstaller } from './make-installer.mjs';
export { default as dayjs } from 'dayjs';
export { affixEmits, affixProps } from './components/affix/src/affix.mjs';
export { ElAffix } from './components/affix/index.mjs';
export { alertEffects, alertEmits, alertProps } from './components/alert/src/alert.mjs';
export { ElAlert } from './components/alert/index.mjs';
export { autocompleteEmits, autocompleteProps } from './components/autocomplete/src/autocomplete.mjs';
export { ElAutocomplete } from './components/autocomplete/index.mjs';
export { avatarEmits, avatarProps } from './components/avatar/src/avatar.mjs';
export { ElAvatar } from './components/avatar/index.mjs';
export { backtopEmits, backtopProps } from './components/backtop/src/backtop2.mjs';
export { ElBacktop } from './components/backtop/index.mjs';
export { badgeProps } from './components/badge/src/badge.mjs';
export { ElBadge } from './components/badge/index.mjs';
export { breadcrumbProps } from './components/breadcrumb/src/breadcrumb.mjs';
export { breadcrumbItemProps } from './components/breadcrumb/src/breadcrumb-item.mjs';
export { breadcrumbKey } from './components/breadcrumb/src/constants.mjs';
export { ElBreadcrumb, ElBreadcrumbItem } from './components/breadcrumb/index.mjs';
export { buttonEmits, buttonNativeTypes, buttonProps, buttonTypes } from './components/button/src/button.mjs';
export { buttonGroupContextKey } from './components/button/src/constants.mjs';
export { ElButton, ElButtonGroup } from './components/button/index.mjs';
export { calendarEmits, calendarProps } from './components/calendar/src/calendar.mjs';
export { ElCalendar } from './components/calendar/index.mjs';
export { cardProps } from './components/card/src/card.mjs';
export { ElCard } from './components/card/index.mjs';
export { carouselEmits, carouselProps } from './components/carousel/src/carousel.mjs';
export { carouselItemProps } from './components/carousel/src/carousel-item.mjs';
export { CAROUSEL_ITEM_NAME, carouselContextKey } from './components/carousel/src/constants.mjs';
export { ElCarousel, ElCarouselItem } from './components/carousel/index.mjs';
export { cascaderEmits, cascaderProps } from './components/cascader/src/cascader.mjs';
export { ElCascader } from './components/cascader/index.mjs';
export { CASCADER_PANEL_INJECTION_KEY } from './components/cascader-panel/src/types.mjs';
export { CommonProps, DefaultProps, useCascaderConfig } from './components/cascader-panel/src/config.mjs';
export { ElCascaderPanel } from './components/cascader-panel/index.mjs';
export { checkTagEmits, checkTagProps } from './components/check-tag/src/check-tag.mjs';
export { ElCheckTag } from './components/check-tag/index.mjs';
export { checkboxGroupEmits, checkboxGroupProps } from './components/checkbox/src/checkbox-group.mjs';
export { checkboxEmits, checkboxProps } from './components/checkbox/src/checkbox.mjs';
export { checkboxGroupContextKey } from './components/checkbox/src/constants.mjs';
export { ElCheckbox, ElCheckboxButton, ElCheckboxGroup } from './components/checkbox/index.mjs';
export { colProps } from './components/col/src/col.mjs';
export { ElCol } from './components/col/index.mjs';
export { collapseEmits, collapseProps, emitChangeFn } from './components/collapse/src/collapse.mjs';
export { collapseItemProps } from './components/collapse/src/collapse-item.mjs';
export { collapseContextKey } from './components/collapse/src/constants.mjs';
export { ElCollapse, ElCollapseItem } from './components/collapse/index.mjs';
export { ElCollapseTransition } from './components/collapse-transition/index.mjs';
export { colorPickerContextKey, colorPickerEmits, colorPickerProps } from './components/color-picker/src/color-picker.mjs';
export { ElColorPicker } from './components/color-picker/index.mjs';
export { messageConfig } from './components/config-provider/src/config-provider.mjs';
export { configProviderProps } from './components/config-provider/src/config-provider-props.mjs';
export { configProviderContextKey } from './components/config-provider/src/constants.mjs';
export { provideGlobalConfig, useGlobalComponentSettings, useGlobalConfig } from './components/config-provider/src/hooks/use-global-config.mjs';
export { ElConfigProvider } from './components/config-provider/index.mjs';
export { ElAside, ElContainer, ElFooter, ElHeader, ElMain } from './components/container/index.mjs';
export { countdownEmits, countdownProps } from './components/countdown/src/countdown.mjs';
export { ElCountdown } from './components/countdown/index.mjs';
export { ROOT_PICKER_INJECTION_KEY } from './components/date-picker/src/constants.mjs';
export { datePickerProps } from './components/date-picker/src/props/date-picker.mjs';
export { ElDatePicker } from './components/date-picker/index.mjs';
export { descriptionProps } from './components/descriptions/src/description.mjs';
export { descriptionItemProps } from './components/descriptions/src/description-item.mjs';
export { ElDescriptions, ElDescriptionsItem } from './components/descriptions/index.mjs';
export { useDialog } from './components/dialog/src/use-dialog.mjs';
export { dialogEmits, dialogProps } from './components/dialog/src/dialog.mjs';
export { dialogInjectionKey } from './components/dialog/src/constants.mjs';
export { ElDialog } from './components/dialog/index.mjs';
export { dividerProps } from './components/divider/src/divider.mjs';
export { ElDivider } from './components/divider/index.mjs';
export { drawerEmits, drawerProps } from './components/drawer/src/drawer.mjs';
export { ElDrawer } from './components/drawer/index.mjs';
export { DROPDOWN_COLLECTION_INJECTION_KEY, DROPDOWN_COLLECTION_ITEM_INJECTION_KEY, ElCollection, ElCollectionItem, FIRST_KEYS, FIRST_LAST_KEYS, LAST_KEYS, dropdownItemProps, dropdownMenuProps, dropdownProps } from './components/dropdown/src/dropdown.mjs';
export { DROPDOWN_INJECTION_KEY } from './components/dropdown/src/tokens.mjs';
export { ElDropdown, ElDropdownItem, ElDropdownMenu } from './components/dropdown/index.mjs';
export { emptyProps } from './components/empty/src/empty.mjs';
export { ElEmpty } from './components/empty/index.mjs';
export { formEmits, formMetaProps, formProps } from './components/form/src/form.mjs';
export { formItemProps, formItemValidateStates } from './components/form/src/form-item.mjs';
export { formContextKey, formItemContextKey } from './components/form/src/constants.mjs';
export { useDisabled, useFormDisabled, useFormSize, useSize } from './components/form/src/hooks/use-form-common-props.mjs';
export { useFormItem, useFormItemInputId } from './components/form/src/hooks/use-form-item.mjs';
export { ElForm, ElFormItem } from './components/form/index.mjs';
export { iconProps } from './components/icon/src/icon.mjs';
export { ElIcon } from './components/icon/index.mjs';
export { imageEmits, imageProps } from './components/image/src/image2.mjs';
export { ElImage } from './components/image/index.mjs';
export { imageViewerEmits, imageViewerProps } from './components/image-viewer/src/image-viewer.mjs';
export { ElImageViewer } from './components/image-viewer/index.mjs';
export { inputEmits, inputProps } from './components/input/src/input.mjs';
export { ElInput } from './components/input/index.mjs';
export { inputNumberEmits, inputNumberProps } from './components/input-number/src/input-number.mjs';
export { ElInputNumber } from './components/input-number/index.mjs';
export { linkEmits, linkProps } from './components/link/src/link.mjs';
export { ElLink } from './components/link/index.mjs';
export { menuEmits, menuProps } from './components/menu/src/menu.mjs';
export { menuItemEmits, menuItemProps } from './components/menu/src/menu-item.mjs';
export { menuItemGroupProps } from './components/menu/src/menu-item-group.mjs';
export { subMenuProps } from './components/menu/src/sub-menu.mjs';
export { ElMenu, ElMenuItem, ElMenuItemGroup, ElSubMenu } from './components/menu/index.mjs';
export { overlayEmits, overlayProps } from './components/overlay/src/overlay.mjs';
export { ElOverlay } from './components/overlay/index.mjs';
export { pageHeaderEmits, pageHeaderProps } from './components/page-header/src/page-header.mjs';
export { ElPageHeader } from './components/page-header/index.mjs';
export { paginationEmits, paginationProps } from './components/pagination/src/pagination.mjs';
export { elPaginationKey } from './components/pagination/src/constants.mjs';
export { ElPagination } from './components/pagination/index.mjs';
export { popconfirmEmits, popconfirmProps } from './components/popconfirm/src/popconfirm.mjs';
export { ElPopconfirm } from './components/popconfirm/index.mjs';
export { Effect, popperProps, roleTypes, usePopperProps } from './components/popper/src/popper.mjs';
export { popperTriggerProps, usePopperTriggerProps } from './components/popper/src/trigger.mjs';
export { popperContentEmits, popperContentProps, popperCoreConfigProps, usePopperContentEmits, usePopperContentProps, usePopperCoreConfigProps } from './components/popper/src/content.mjs';
export { popperArrowProps, usePopperArrowProps } from './components/popper/src/arrow.mjs';
export { POPPER_CONTENT_INJECTION_KEY, POPPER_INJECTION_KEY } from './components/popper/src/constants.mjs';
export { default as ElPopperArrow } from './components/popper/src/arrow2.mjs';
export { default as ElPopperTrigger } from './components/popper/src/trigger2.mjs';
export { default as ElPopperContent } from './components/popper/src/content2.mjs';
export { ElPopper } from './components/popper/index.mjs';
export { progressProps } from './components/progress/src/progress.mjs';
export { ElProgress } from './components/progress/index.mjs';
export { radioEmits, radioProps, radioPropsBase } from './components/radio/src/radio.mjs';
export { radioGroupEmits, radioGroupProps } from './components/radio/src/radio-group.mjs';
export { radioButtonProps } from './components/radio/src/radio-button.mjs';
export { radioGroupKey } from './components/radio/src/constants.mjs';
export { ElRadio, ElRadioButton, ElRadioGroup } from './components/radio/index.mjs';
export { rateEmits, rateProps } from './components/rate/src/rate.mjs';
export { ElRate } from './components/rate/index.mjs';
export { IconComponentMap, IconMap, resultProps } from './components/result/src/result.mjs';
export { ElResult } from './components/result/index.mjs';
export { RowAlign, RowJustify, rowProps } from './components/row/src/row.mjs';
export { rowContextKey } from './components/row/src/constants.mjs';
export { ElRow } from './components/row/index.mjs';
export { BAR_MAP, GAP, renderThumbStyle } from './components/scrollbar/src/util.mjs';
export { scrollbarEmits, scrollbarProps } from './components/scrollbar/src/scrollbar.mjs';
export { thumbProps } from './components/scrollbar/src/thumb.mjs';
export { scrollbarContextKey } from './components/scrollbar/src/constants.mjs';
export { ElScrollbar } from './components/scrollbar/index.mjs';
export { selectGroupKey, selectKey } from './components/select/src/token.mjs';
export { ElOption, ElOptionGroup, ElSelect } from './components/select/index.mjs';
export { selectV2InjectionKey } from './components/select-v2/src/token.mjs';
export { ElSelectV2 } from './components/select-v2/index.mjs';
export { skeletonProps } from './components/skeleton/src/skeleton.mjs';
export { skeletonItemProps } from './components/skeleton/src/skeleton-item.mjs';
export { ElSkeleton, ElSkeletonItem } from './components/skeleton/index.mjs';
export { sliderEmits, sliderProps } from './components/slider/src/slider.mjs';
export { sliderContextKey } from './components/slider/src/constants.mjs';
export { ElSlider } from './components/slider/index.mjs';
export { spaceProps } from './components/space/src/space.mjs';
export { spaceItemProps } from './components/space/src/item.mjs';
export { useSpace } from './components/space/src/use-space.mjs';
export { ElSpace } from './components/space/index.mjs';
export { statisticProps } from './components/statistic/src/statistic.mjs';
export { ElStatistic } from './components/statistic/index.mjs';
export { stepProps } from './components/steps/src/item.mjs';
export { stepsEmits, stepsProps } from './components/steps/src/steps.mjs';
export { ElStep, ElSteps } from './components/steps/index.mjs';
export { switchEmits, switchProps } from './components/switch/src/switch.mjs';
export { ElSwitch } from './components/switch/index.mjs';
export { ElTable, ElTableColumn } from './components/table/index.mjs';
export { Alignment as TableV2Alignment, FixedDir as TableV2FixedDir, SortOrder as TableV2SortOrder } from './components/table-v2/src/constants.mjs';
export { default as TableV2 } from './components/table-v2/src/table-v2.mjs';
export { placeholderSign as TableV2Placeholder } from './components/table-v2/src/private.mjs';
export { autoResizerProps } from './components/table-v2/src/auto-resizer.mjs';
export { tableV2Props } from './components/table-v2/src/table.mjs';
export { tableV2RowProps } from './components/table-v2/src/row.mjs';
export { ElAutoResizer, ElTableV2 } from './components/table-v2/index.mjs';
export { tabsEmits, tabsProps } from './components/tabs/src/tabs.mjs';
export { tabBarProps } from './components/tabs/src/tab-bar.mjs';
export { tabNavEmits, tabNavProps } from './components/tabs/src/tab-nav.mjs';
export { tabPaneProps } from './components/tabs/src/tab-pane.mjs';
export { tabsRootContextKey } from './components/tabs/src/constants.mjs';
export { ElTabPane, ElTabs } from './components/tabs/index.mjs';
export { tagEmits, tagProps } from './components/tag/src/tag.mjs';
export { ElTag } from './components/tag/index.mjs';
export { textProps } from './components/text/src/text.mjs';
export { ElText } from './components/text/index.mjs';
export { buildTimeList, dateEquals, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, valueEquals } from './components/time-picker/src/utils.mjs';
export { DEFAULT_FORMATS_DATE, DEFAULT_FORMATS_DATEPICKER, DEFAULT_FORMATS_TIME, timeUnits } from './components/time-picker/src/constants.mjs';
export { timePickerDefaultProps } from './components/time-picker/src/common/props.mjs';
export { ElTimePicker } from './components/time-picker/index.mjs';
export { default as CommonPicker } from './components/time-picker/src/common/picker.mjs';
export { default as TimePickPanel } from './components/time-picker/src/time-picker-com/panel-time-pick.mjs';
export { timeSelectProps } from './components/time-select/src/time-select.mjs';
export { ElTimeSelect } from './components/time-select/index.mjs';
export { timelineItemProps } from './components/timeline/src/timeline-item.mjs';
export { ElTimeline, ElTimelineItem } from './components/timeline/index.mjs';
export { tooltipEmits, useTooltipModelToggle, useTooltipModelToggleEmits, useTooltipModelToggleProps, useTooltipProps } from './components/tooltip/src/tooltip.mjs';
export { useTooltipTriggerProps } from './components/tooltip/src/trigger.mjs';
export { useTooltipContentProps } from './components/tooltip/src/content.mjs';
export { TOOLTIP_INJECTION_KEY } from './components/tooltip/src/constants.mjs';
export { ElTooltip } from './components/tooltip/index.mjs';
export { LEFT_CHECK_CHANGE_EVENT, RIGHT_CHECK_CHANGE_EVENT, transferCheckedChangeFn, transferEmits, transferProps } from './components/transfer/src/transfer2.mjs';
export { ElTransfer } from './components/transfer/index.mjs';
export { ElTree } from './components/tree/index.mjs';
export { ElTreeSelect } from './components/tree-select/index.mjs';
export { ElTreeV2 } from './components/tree-v2/index.mjs';
export { genFileId, uploadBaseProps, uploadListTypes, uploadProps } from './components/upload/src/upload.mjs';
export { uploadContentProps } from './components/upload/src/upload-content2.mjs';
export { uploadListEmits, uploadListProps } from './components/upload/src/upload-list.mjs';
export { uploadDraggerEmits, uploadDraggerProps } from './components/upload/src/upload-dragger.mjs';
export { uploadContextKey } from './components/upload/src/constants.mjs';
export { ElUpload } from './components/upload/index.mjs';
export { default as FixedSizeList } from './components/virtual-list/src/components/fixed-size-list.mjs';
export { default as DynamicSizeList } from './components/virtual-list/src/components/dynamic-size-list.mjs';
export { default as FixedSizeGrid } from './components/virtual-list/src/components/fixed-size-grid.mjs';
export { default as DynamicSizeGrid } from './components/virtual-list/src/components/dynamic-size-grid.mjs';
export { virtualizedGridProps, virtualizedListProps, virtualizedProps, virtualizedScrollbarProps } from './components/virtual-list/src/props.mjs';
export { watermarkProps } from './components/watermark/src/watermark.mjs';
export { ElWatermark } from './components/watermark/index.mjs';
export { tourEmits, tourProps } from './components/tour/src/tour.mjs';
export { tourStepEmits, tourStepProps } from './components/tour/src/step.mjs';
export { tourContentEmits, tourContentProps, tourPlacements, tourStrategies } from './components/tour/src/content.mjs';
export { ElTour, ElTourStep } from './components/tour/index.mjs';
export { anchorEmits, anchorProps } from './components/anchor/src/anchor.mjs';
export { ElAnchor, ElAnchorLink } from './components/anchor/index.mjs';
export { segmentedEmits, segmentedProps } from './components/segmented/src/segmented.mjs';
export { ElSegmented } from './components/segmented/index.mjs';
export { mentionEmits, mentionProps } from './components/mention/src/mention.mjs';
export { ElMention } from './components/mention/index.mjs';
export { ElInfiniteScroll } from './components/infinite-scroll/index.mjs';
export { ElLoading } from './components/loading/index.mjs';
export { vLoading as ElLoadingDirective, vLoading } from './components/loading/src/directive.mjs';
export { Loading as ElLoadingService } from './components/loading/src/service.mjs';
export { messageDefaults, messageEmits, messageProps, messageTypes } from './components/message/src/message.mjs';
export { ElMessage } from './components/message/index.mjs';
export { ElMessageBox } from './components/message-box/index.mjs';
export { notificationEmits, notificationProps, notificationTypes } from './components/notification/src/notification.mjs';
export { ElNotification } from './components/notification/index.mjs';
export { popoverEmits, popoverProps } from './components/popover/src/popover.mjs';
export { ElPopover, ElPopoverDirective } from './components/popover/index.mjs';
export { EVENT_CODE } from './constants/aria.mjs';
export { WEEK_DAYS, datePickTypes } from './constants/date.mjs';
export { CHANGE_EVENT, INPUT_EVENT, UPDATE_MODEL_EVENT } from './constants/event.mjs';
export { INSTALLED_KEY } from './constants/key.mjs';
export { componentSizeMap, componentSizes } from './constants/size.mjs';
export { default as ClickOutside } from './directives/click-outside/index.mjs';
export { vRepeatClick } from './directives/repeat-click/index.mjs';
export { default as TrapFocus } from './directives/trap-focus/index.mjs';
export { default as Mousewheel } from './directives/mousewheel/index.mjs';
export { useAttrs } from './hooks/use-attrs/index.mjs';
export { useDeprecated } from './hooks/use-deprecated/index.mjs';
export { useDraggable } from './hooks/use-draggable/index.mjs';
export { useFocus } from './hooks/use-focus/index.mjs';
export { buildLocaleContext, buildTranslator, localeContextKey, translate, useLocale } from './hooks/use-locale/index.mjs';
export { useLockscreen } from './hooks/use-lockscreen/index.mjs';
export { useModal } from './hooks/use-modal/index.mjs';
export { createModelToggleComposable, useModelToggle, useModelToggleEmits, useModelToggleProps } from './hooks/use-model-toggle/index.mjs';
export { usePreventGlobal } from './hooks/use-prevent-global/index.mjs';
export { useProp } from './hooks/use-prop/index.mjs';
export { usePopper } from './hooks/use-popper/index.mjs';
export { useSameTarget } from './hooks/use-same-target/index.mjs';
export { useTeleport } from './hooks/use-teleport/index.mjs';
export { useThrottleRender } from './hooks/use-throttle-render/index.mjs';
export { useTimeout } from './hooks/use-timeout/index.mjs';
export { useTransitionFallthrough, useTransitionFallthroughEmits } from './hooks/use-transition-fallthrough/index.mjs';
export { ID_INJECTION_KEY, useId, useIdInjection } from './hooks/use-id/index.mjs';
export { useEscapeKeydown } from './hooks/use-escape-keydown/index.mjs';
export { usePopperContainer, usePopperContainerId } from './hooks/use-popper-container/index.mjs';
export { useDelayedRender } from './hooks/use-intermediate-render/index.mjs';
export { useDelayedToggle, useDelayedToggleProps } from './hooks/use-delayed-toggle/index.mjs';
export { FORWARD_REF_INJECTION_KEY, useForwardRef, useForwardRefDirective } from './hooks/use-forward-ref/index.mjs';
export { defaultNamespace, namespaceContextKey, useGetDerivedNamespace, useNamespace } from './hooks/use-namespace/index.mjs';
export { ZINDEX_INJECTION_KEY, defaultInitialZIndex, useZIndex, zIndexContextKey } from './hooks/use-z-index/index.mjs';
export { arrowMiddleware, getPositionDataWithUnit, useFloating, useFloatingProps } from './hooks/use-floating/index.mjs';
export { useCursor } from './hooks/use-cursor/index.mjs';
export { useOrderedChildren } from './hooks/use-ordered-children/index.mjs';
export { SIZE_INJECTION_KEY, useGlobalSize, useSizeProp, useSizeProps } from './hooks/use-size/index.mjs';
export { useFocusController } from './hooks/use-focus-controller/index.mjs';
export { useComposition } from './hooks/use-composition/index.mjs';
export { DEFAULT_EMPTY_VALUES, DEFAULT_VALUE_ON_CLEAR, SCOPE, emptyValuesContextKey, useEmptyValues, useEmptyValuesProps } from './hooks/use-empty-values/index.mjs';
export { ariaProps, useAriaProps } from './hooks/use-aria/index.mjs';

const install = installer.install;
const version = installer.version;

export { install, version };
//# sourceMappingURL=index.mjs.map


sourcesContent:
import installer from './defaults'
export * from '@element-plus/components'
export * from '@element-plus/constants'
export * from '@element-plus/directives'
export * from '@element-plus/hooks'
export * from './make-installer'

export const install = installer.install
export const version = installer.version
export default installer

export { default as dayjs } from 'dayjs'


code:
export { default as af } from './lang/af';
export { default as ar } from './lang/ar';
export { default as az } from './lang/az';
export { default as bg } from './lang/bg';
export { default as bn } from './lang/bn';
export { default as ca } from './lang/ca';
export { default as cs } from './lang/cs';
export { default as da } from './lang/da';
export { default as de } from './lang/de';
export { default as el } from './lang/el';
export { default as en } from './lang/en';
export { default as eo } from './lang/eo';
export { default as es } from './lang/es';
export { default as et } from './lang/et';
export { default as eu } from './lang/eu';
export { default as fa } from './lang/fa';
export { default as fi } from './lang/fi';
export { default as fr } from './lang/fr';
export { default as he } from './lang/he';
export { default as hr } from './lang/hr';
export { default as hu } from './lang/hu';
export { default as hyAm } from './lang/hy-am';
export { default as id } from './lang/id';
export { default as it } from './lang/it';
export { default as ja } from './lang/ja';
export { default as kk } from './lang/kk';
export { default as km } from './lang/km';
export { default as ko } from './lang/ko';
export { default as ku } from './lang/ku';
export { default as ky } from './lang/ky';
export { default as lt } from './lang/lt';
export { default as lv } from './lang/lv';
export { default as mn } from './lang/mn';
export { default as my } from './lang/my';
export { default as nbNo } from './lang/nb-no';
export { default as nl } from './lang/nl';
export { default as pa } from './lang/pa';
export { default as pl } from './lang/pl';
export { default as ptBr } from './lang/pt-br';
export { default as pt } from './lang/pt';
export { default as ro } from './lang/ro';
export { default as ru } from './lang/ru';
export { default as sk } from './lang/sk';
export { default as sl } from './lang/sl';
export { default as sr } from './lang/sr';
export { default as sv } from './lang/sv';
export { default as ta } from './lang/ta';
export { default as th } from './lang/th';
export { default as tk } from './lang/tk';
export { default as tr } from './lang/tr';
export { default as ugCn } from './lang/ug-cn';
export { default as uk } from './lang/uk';
export { default as uzUz } from './lang/uz-uz';
export { default as vi } from './lang/vi';
export { default as zhCn } from './lang/zh-cn';
export { default as zhTw } from './lang/zh-tw';
export declare type TranslatePair = {
    [key: string]: string | string[] | TranslatePair;
};
export declare type Language = {
    name: string;
    el: TranslatePair;
};


code:
export { default as af } from './lang/af.mjs';
export { default as ar } from './lang/ar.mjs';
export { default as az } from './lang/az.mjs';
export { default as bg } from './lang/bg.mjs';
export { default as bn } from './lang/bn.mjs';
export { default as ca } from './lang/ca.mjs';
export { default as cs } from './lang/cs.mjs';
export { default as da } from './lang/da.mjs';
export { default as de } from './lang/de.mjs';
export { default as el } from './lang/el.mjs';
export { default as en } from './lang/en.mjs';
export { default as eo } from './lang/eo.mjs';
export { default as es } from './lang/es.mjs';
export { default as et } from './lang/et.mjs';
export { default as eu } from './lang/eu.mjs';
export { default as fa } from './lang/fa.mjs';
export { default as fi } from './lang/fi.mjs';
export { default as fr } from './lang/fr.mjs';
export { default as he } from './lang/he.mjs';
export { default as hr } from './lang/hr.mjs';
export { default as hu } from './lang/hu.mjs';
export { default as hyAm } from './lang/hy-am.mjs';
export { default as id } from './lang/id.mjs';
export { default as it } from './lang/it.mjs';
export { default as ja } from './lang/ja.mjs';
export { default as kk } from './lang/kk.mjs';
export { default as km } from './lang/km.mjs';
export { default as ko } from './lang/ko.mjs';
export { default as ku } from './lang/ku.mjs';
export { default as ky } from './lang/ky.mjs';
export { default as lt } from './lang/lt.mjs';
export { default as lv } from './lang/lv.mjs';
export { default as mn } from './lang/mn.mjs';
export { default as my } from './lang/my.mjs';
export { default as nbNo } from './lang/nb-no.mjs';
export { default as nl } from './lang/nl.mjs';
export { default as pa } from './lang/pa.mjs';
export { default as pl } from './lang/pl.mjs';
export { default as ptBr } from './lang/pt-br.mjs';
export { default as pt } from './lang/pt.mjs';
export { default as ro } from './lang/ro.mjs';
export { default as ru } from './lang/ru.mjs';
export { default as sk } from './lang/sk.mjs';
export { default as sl } from './lang/sl.mjs';
export { default as sr } from './lang/sr.mjs';
export { default as sv } from './lang/sv.mjs';
export { default as ta } from './lang/ta.mjs';
export { default as th } from './lang/th.mjs';
export { default as tk } from './lang/tk.mjs';
export { default as tr } from './lang/tr.mjs';
export { default as ugCn } from './lang/ug-cn.mjs';
export { default as uk } from './lang/uk.mjs';
export { default as uzUz } from './lang/uz-uz.mjs';
export { default as vi } from './lang/vi.mjs';
export { default as zhCn } from './lang/zh-cn.mjs';
export { default as zhTw } from './lang/zh-tw.mjs';
//# sourceMappingURL=index.mjs.map


code:
declare const _default: {
    name: string;
    el: {
        breadcrumb: {
            label: string;
        };
        colorpicker: {
            confirm: string;
            clear: string;
        };
        datepicker: {
            now: string;
            today: string;
            cancel: string;
            clear: string;
            confirm: string;
            selectDate: string;
            selectTime: string;
            startDate: string;
            startTime: string;
            endDate: string;
            endTime: string;
            prevYear: string;
            nextYear: string;
            prevMonth: string;
            nextMonth: string;
            year: string;
            month1: string;
            month2: string;
            month3: string;
            month4: string;
            month5: string;
            month6: string;
            month7: string;
            month8: string;
            month9: string;
            month10: string;
            month11: string;
            month12: string;
            weeks: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            months: {
                jan: string;
                feb: string;
                mar: string;
                apr: string;
                may: string;
                jun: string;
                jul: string;
                aug: string;
                sep: string;
                oct: string;
                nov: string;
                dec: string;
            };
        };
        select: {
            loading: string;
            noMatch: string;
            noData: string;
            placeholder: string;
        };
        mention: {
            loading: string;
        };
        cascader: {
            noMatch: string;
            loading: string;
            placeholder: string;
            noData: string;
        };
        pagination: {
            goto: string;
            pagesize: string;
            total: string;
            pageClassifier: string;
            page: string;
            prev: string;
            next: string;
            currentPage: string;
            prevPages: string;
            nextPages: string;
        };
        messagebox: {
            title: string;
            confirm: string;
            cancel: string;
            error: string;
        };
        upload: {
            deleteTip: string;
            delete: string;
            preview: string;
            continue: string;
        };
        table: {
            emptyText: string;
            confirmFilter: string;
            resetFilter: string;
            clearFilter: string;
            sumText: string;
        };
        tree: {
            emptyText: string;
        };
        transfer: {
            noMatch: string;
            noData: string;
            titles: string[];
            filterPlaceholder: string;
            noCheckedFormat: string;
            hasCheckedFormat: string;
        };
        image: {
            error: string;
        };
        pageHeader: {
            title: string;
        };
        popconfirm: {
            confirmButtonText: string;
            cancelButtonText: string;
        };
        carousel: {
            leftArrow: string;
            rightArrow: string;
            indicator: string;
        };
    };
};
export default _default;


code:
var af = {
  name: "af",
  el: {
    breadcrumb: {
      label: "Breadcrumb"
    },
    colorpicker: {
      confirm: "Bevestig",
      clear: "Maak skoon"
    },
    datepicker: {
      now: "Nou",
      today: "Vandag",
      cancel: "Kanselleer",
      clear: "Maak skoon",
      confirm: "Bevestig",
      selectDate: "Kies datum",
      selectTime: "Kies tyd",
      startDate: "Begindatum",
      startTime: "Begintyd",
      endDate: "Einddatum",
      endTime: "Eindtyd",
      prevYear: "Previous Year",
      nextYear: "Next Year",
      prevMonth: "Previous Month",
      nextMonth: "Next Month",
      year: "Jaar",
      month1: "Jan",
      month2: "Feb",
      month3: "Mrt",
      month4: "Apr",
      month5: "Mei",
      month6: "Jun",
      month7: "Jul",
      month8: "Aug",
      month9: "Sep",
      month10: "Okt",
      month11: "Nov",
      month12: "Des",
      weeks: {
        sun: "So",
        mon: "Ma",
        tue: "Di",
        wed: "Wo",
        thu: "Do",
        fri: "Vr",
        sat: "Sa"
      },
      months: {
        jan: "Jan",
        feb: "Feb",
        mar: "Mrt",
        apr: "Apr",
        may: "Mei",
        jun: "Jun",
        jul: "Jul",
        aug: "Aug",
        sep: "Sep",
        oct: "Okt",
        nov: "Nov",
        dec: "Des"
      }
    },
    select: {
      loading: "Laai",
      noMatch: "Geen toepaslike data",
      noData: "Geen data",
      placeholder: "Kies"
    },
    mention: {
      loading: "Laai"
    },
    cascader: {
      noMatch: "Geen toepaslike data",
      loading: "Laai",
      placeholder: "Kies",
      noData: "Geen data"
    },
    pagination: {
      goto: "Gaan na",
      pagesize: "/page",
      total: "Totaal {total}",
      pageClassifier: "",
      page: "Page",
      prev: "Go to previous page",
      next: "Go to next page",
      currentPage: "page {pager}",
      prevPages: "Previous {pager} pages",
      nextPages: "Next {pager} pages"
    },
    messagebox: {
      title: "Boodskap",
      confirm: "Bevestig",
      cancel: "Kanselleer",
      error: "Ongeldige invoer"
    },
    upload: {
      deleteTip: "press delete to remove",
      delete: "Verwyder",
      preview: "Voorskou",
      continue: "Gaan voort"
    },
    table: {
      emptyText: "Geen Data",
      confirmFilter: "Bevestig",
      resetFilter: "Herstel",
      clearFilter: "Alles",
      sumText: "Som"
    },
    tree: {
      emptyText: "Geen Data"
    },
    transfer: {
      noMatch: "Geen toepaslike data",
      noData: "Geen data",
      titles: ["Lys 1", "Lys 2"],
      filterPlaceholder: "Voer sleutelwoord in",
      noCheckedFormat: "{total} items",
      hasCheckedFormat: "{checked}/{total} gekies"
    },
    image: {
      error: "FAILED"
    },
    pageHeader: {
      title: "Back"
    },
    popconfirm: {
      confirmButtonText: "Yes",
      cancelButtonText: "No"
    },
    carousel: {
      leftArrow: "Carousel arrow left",
      rightArrow: "Carousel arrow right",
      indicator: "Carousel switch to index {index}"
    }
  }
};

export { af as default };
//# sourceMappingURL=af.mjs.map


code:
declare const _default: {
    name: string;
    el: {
        breadcrumb: {
            label: string;
        };
        colorpicker: {
            confirm: string;
            clear: string;
            defaultLabel: string;
            description: string;
        };
        datepicker: {
            now: string;
            today: string;
            cancel: string;
            clear: string;
            confirm: string;
            dateTablePrompt: string;
            monthTablePrompt: string;
            yearTablePrompt: string;
            selectDate: string;
            selectTime: string;
            startDate: string;
            startTime: string;
            endDate: string;
            endTime: string;
            prevYear: string;
            nextYear: string;
            prevMonth: string;
            nextMonth: string;
            year: string;
            month1: string;
            month2: string;
            month3: string;
            month4: string;
            month5: string;
            month6: string;
            month7: string;
            month8: string;
            month9: string;
            month10: string;
            month11: string;
            month12: string;
            week: string;
            weeks: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            months: {
                jan: string;
                feb: string;
                mar: string;
                apr: string;
                may: string;
                jun: string;
                jul: string;
                aug: string;
                sep: string;
                oct: string;
                nov: string;
                dec: string;
            };
        };
        inputNumber: {
            decrease: string;
            increase: string;
        };
        select: {
            loading: string;
            noMatch: string;
            noData: string;
            placeholder: string;
        };
        mention: {
            loading: string;
        };
        dropdown: {
            toggleDropdown: string;
        };
        cascader: {
            noMatch: string;
            loading: string;
            placeholder: string;
            noData: string;
        };
        pagination: {
            goto: string;
            pagesize: string;
            total: string;
            pageClassifier: string;
            page: string;
            prev: string;
            next: string;
            currentPage: string;
            prevPages: string;
            nextPages: string;
        };
        dialog: {
            close: string;
        };
        drawer: {
            close: string;
        };
        messagebox: {
            title: string;
            confirm: string;
            cancel: string;
            error: string;
            close: string;
        };
        upload: {
            deleteTip: string;
            delete: string;
            preview: string;
            continue: string;
        };
        slider: {
            defaultLabel: string;
            defaultRangeStartLabel: string;
            defaultRangeEndLabel: string;
        };
        table: {
            emptyText: string;
            confirmFilter: string;
            resetFilter: string;
            clearFilter: string;
            sumText: string;
        };
        tree: {
            emptyText: string;
        };
        transfer: {
            noMatch: string;
            noData: string;
            titles: string[];
            filterPlaceholder: string;
            noCheckedFormat: string;
            hasCheckedFormat: string;
        };
        image: {
            error: string;
        };
        pageHeader: {
            title: string;
        };
        popconfirm: {
            confirmButtonText: string;
            cancelButtonText: string;
        };
        carousel: {
            leftArrow: string;
            rightArrow: string;
            indicator: string;
        };
    };
};
export default _default;


code:
declare const _default: {
    name: string;
    el: {
        breadcrumb: {
            label: string;
        };
        colorpicker: {
            confirm: string;
            clear: string;
            defaultLabel: string;
            description: string;
        };
        datepicker: {
            now: string;
            today: string;
            cancel: string;
            clear: string;
            confirm: string;
            dateTablePrompt: string;
            monthTablePrompt: string;
            yearTablePrompt: string;
            selectDate: string;
            selectTime: string;
            startDate: string;
            startTime: string;
            endDate: string;
            endTime: string;
            prevYear: string;
            nextYear: string;
            prevMonth: string;
            nextMonth: string;
            year: string;
            month1: string;
            month2: string;
            month3: string;
            month4: string;
            month5: string;
            month6: string;
            month7: string;
            month8: string;
            month9: string;
            month10: string;
            month11: string;
            month12: string;
            week: string;
            weeks: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            months: {
                jan: string;
                feb: string;
                mar: string;
                apr: string;
                may: string;
                jun: string;
                jul: string;
                aug: string;
                sep: string;
                oct: string;
                nov: string;
                dec: string;
            };
        };
        inputNumber: {
            decrease: string;
            increase: string;
        };
        select: {
            loading: string;
            noMatch: string;
            noData: string;
            placeholder: string;
        };
        mention: {
            loading: string;
        };
        dropdown: {
            toggleDropdown: string;
        };
        cascader: {
            noMatch: string;
            loading: string;
            placeholder: string;
            noData: string;
        };
        pagination: {
            goto: string;
            pagesize: string;
            total: string;
            pageClassifier: string;
            page: string;
            prev: string;
            next: string;
            currentPage: string;
            prevPages: string;
            nextPages: string;
        };
        dialog: {
            close: string;
        };
        drawer: {
            close: string;
        };
        messagebox: {
            title: string;
            confirm: string;
            cancel: string;
            error: string;
            close: string;
        };
        upload: {
            deleteTip: string;
            delete: string;
            preview: string;
            continue: string;
        };
        table: {
            emptyText: string;
            confirmFilter: string;
            resetFilter: string;
            clearFilter: string;
            sumText: string;
        };
        tree: {
            emptyText: string;
        };
        transfer: {
            noMatch: string;
            noData: string;
            titles: string[];
            filterPlaceholder: string;
            noCheckedFormat: string;
            hasCheckedFormat: string;
        };
        image: {
            error: string;
        };
        pageHeader: {
            title: string;
        };
        popconfirm: {
            confirmButtonText: string;
            cancelButtonText: string;
        };
        carousel: {
            leftArrow: string;
            rightArrow: string;
            indicator: string;
        };
    };
};
export default _default;


code:
declare const _default: {
    name: string;
    el: {
        breadcrumb: {
            label: string;
        };
        colorpicker: {
            confirm: string;
            clear: string;
        };
        datepicker: {
            now: string;
            today: string;
            cancel: string;
            clear: string;
            confirm: string;
            selectDate: string;
            selectTime: string;
            startDate: string;
            startTime: string;
            endDate: string;
            endTime: string;
            prevYear: string;
            nextYear: string;
            prevMonth: string;
            nextMonth: string;
            year: string;
            month1: string;
            month2: string;
            month3: string;
            month4: string;
            month5: string;
            month6: string;
            month7: string;
            month8: string;
            month9: string;
            month10: string;
            month11: string;
            month12: string;
            week: string;
            weeks: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            months: {
                jan: string;
                feb: string;
                mar: string;
                apr: string;
                may: string;
                jun: string;
                jul: string;
                aug: string;
                sep: string;
                oct: string;
                nov: string;
                dec: string;
            };
        };
        select: {
            loading: string;
            noMatch: string;
            noData: string;
            placeholder: string;
        };
        mention: {
            loading: string;
        };
        cascader: {
            noMatch: string;
            loading: string;
            placeholder: string;
            noData: string;
        };
        pagination: {
            goto: string;
            pagesize: string;
            total: string;
            pageClassifier: string;
            page: string;
            prev: string;
            next: string;
            currentPage: string;
            prevPages: string;
            nextPages: string;
        };
        messagebox: {
            title: string;
            confirm: string;
            cancel: string;
            error: string;
        };
        upload: {
            deleteTip: string;
            delete: string;
            preview: string;
            continue: string;
        };
        table: {
            emptyText: string;
            confirmFilter: string;
            resetFilter: string;
            clearFilter: string;
            sumText: string;
        };
        tree: {
            emptyText: string;
        };
        transfer: {
            noMatch: string;
            noData: string;
            titles: string[];
            filterPlaceholder: string;
            noCheckedFormat: string;
            hasCheckedFormat: string;
        };
        image: {
            error: string;
        };
        pageHeader: {
            title: string;
        };
        popconfirm: {
            confirmButtonText: string;
            cancelButtonText: string;
        };
        empty: {
            description: string;
        };
        carousel: {
            leftArrow: string;
            rightArrow: string;
            indicator: string;
        };
    };
};
export default _default;


code:
var az = {
  name: "az",
  el: {
    breadcrumb: {
      label: "Breadcrumb"
    },
    colorpicker: {
      confirm: "T\u0259sdiql\u0259",
      clear: "T\u0259mizl\u0259"
    },
    datepicker: {
      now: "\u0130ndi",
      today: "Bug\xFCn",
      cancel: "\u0130mtina",
      clear: "T\u0259mizl\u0259",
      confirm: "T\u0259sdiql\u0259",
      selectDate: "Tarix se\xE7",
      selectTime: "Saat se\xE7",
      startDate: "Ba\u015Flan\u011F\u0131c Tarixi",
      startTime: "Ba\u015Flan\u011F\u0131c Saat\u0131",
      endDate: "Bitm\u0259 Tarixi",
      endTime: "Bitm\u0259 Saat\u0131",
      prevYear: "\xD6nc\u0259ki il",
      nextYear: "Sonrak\u0131 il",
      prevMonth: "\xD6nc\u0259ki ay",
      nextMonth: "Sonrak\u0131 ay",
      year: "",
      month1: "Yanvar",
      month2: "Fevral",
      month3: "Mart",
      month4: "Aprel",
      month5: "May",
      month6: "\u0130yun",
      month7: "\u0130yul",
      month8: "Avqust",
      month9: "Sentyabr",
      month10: "Oktyabr",
      month11: "Noyabr",
      month12: "Dekabr",
      week: "h\u0259ft\u0259",
      weeks: {
        sun: "Baz",
        mon: "B.e",
        tue: "\xC7.a",
        wed: "\xC7\u0259r",
        thu: "C.a",
        fri: "C\xFCm",
        sat: "\u015E\u0259n"
      },
      months: {
        jan: "Yan",
        feb: "Fev",
        mar: "Mar",
        apr: "Apr",
        may: "May",
        jun: "\u0130yn",
        jul: "\u0130yl",
        aug: "Avq",
        sep: "Sen",
        oct: "Okt",
        nov: "Noy",
        dec: "Dek"
      }
    },
    select: {
      loading: "Y\xFCkl\u0259nir",
      noMatch: "N\u0259tic\u0259 tap\u0131lmad\u0131",
      noData: "M\u0259lumat yoxdur",
      placeholder: "Se\xE7"
    },
    mention: {
      loading: "Y\xFCkl\u0259nir"
    },
    cascader: {
      noMatch: "N\u0259tic\u0259 tap\u0131lmad\u0131",
      loading: "Y\xFCkl\u0259nir",
      placeholder: "Se\xE7",
      noData: "M\u0259lumat yoxdur"
    },
    pagination: {
      goto: "Get",
      pagesize: "/s\u0259hif\u0259",
      total: "Toplam {total}",
      pageClassifier: "",
      page: "Page",
      prev: "Go to previous page",
      next: "Go to next page",
      currentPage: "page {pager}",
      prevPages: "Previous {pager} pages",
      nextPages: "Next {pager} pages"
    },
    messagebox: {
      title: "Mesaj",
      confirm: "T\u0259sdiql\u0259",
      cancel: "\u0130mtina",
      error: "S\u0259hv"
    },
    upload: {
      deleteTip: "S\xFCr\xFC\u015Fd\xFCrm\u0259d\u0259n sonra sil",
      delete: "Sil",
      preview: "\xD6n izl\u0259",
      continue: "Davam et"
    },
    table: {
      emptyText: "M\u0259lumat yoxdur",
      confirmFilter: "T\u0259sdiql\u0259",
      resetFilter: "S\u0131f\u0131rla",
      clearFilter: "B\xFCt\xFCn",
      sumText: "C\u0259mi"
    },
    tree: {
      emptyText: "M\u0259lumat yoxdur"
    },
    transfer: {
      noMatch: "N\u0259tic\u0259 tap\u0131lmad\u0131",
      noData: "M\u0259lumat yoxdur",
      titles: ["Siyah\u0131 1", "Siyah\u0131 2"],
      filterPlaceholder: "K\u0259lim\u0259l\u0259ri daxil et",
      noCheckedFormat: "{total} \u0259d\u0259d",
      hasCheckedFormat: "{checked}/{total} se\xE7ildi"
    },
    image: {
      error: "S\u018FHV"
    },
    pageHeader: {
      title: "Geri"
    },
    popconfirm: {
      confirmButtonText: "B\u0259li",
      cancelButtonText: "Xeyr"
    },
    empty: {
      description: "M\u0259lumat yoxdur"
    },
    carousel: {
      leftArrow: "Carousel arrow left",
      rightArrow: "Carousel arrow right",
      indicator: "Carousel switch to index {index}"
    }
  }
};

export { az as default };
//# sourceMappingURL=az.mjs.map


code:
declare const _default: {
    name: string;
    el: {
        breadcrumb: {
            label: string;
        };
        colorpicker: {
            confirm: string;
            clear: string;
        };
        datepicker: {
            now: string;
            today: string;
            cancel: string;
            clear: string;
            confirm: string;
            selectDate: string;
            selectTime: string;
            startDate: string;
            startTime: string;
            endDate: string;
            endTime: string;
            prevYear: string;
            nextYear: string;
            prevMonth: string;
            nextMonth: string;
            year: string;
            month1: string;
            month2: string;
            month3: string;
            month4: string;
            month5: string;
            month6: string;
            month7: string;
            month8: string;
            month9: string;
            month10: string;
            month11: string;
            month12: string;
            week: string;
            weeks: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            months: {
                jan: string;
                feb: string;
                mar: string;
                apr: string;
                may: string;
                jun: string;
                jul: string;
                aug: string;
                sep: string;
                oct: string;
                nov: string;
                dec: string;
            };
        };
        select: {
            loading: string;
            noMatch: string;
            noData: string;
            placeholder: string;
        };
        mention: {
            loading: string;
        };
        cascader: {
            noMatch: string;
            loading: string;
            placeholder: string;
            noData: string;
        };
        pagination: {
            goto: string;
            pagesize: string;
            total: string;
            pageClassifier: string;
            page: string;
            prev: string;
            next: string;
            currentPage: string;
            prevPages: string;
            nextPages: string;
            deprecationWarning: string;
        };
        messagebox: {
            title: string;
            confirm: string;
            cancel: string;
            error: string;
        };
        upload: {
            deleteTip: string;
            delete: string;
            preview: string;
            continue: string;
        };
        table: {
            emptyText: string;
            confirmFilter: string;
            resetFilter: string;
            clearFilter: string;
            sumText: string;
        };
        tree: {
            emptyText: string;
        };
        transfer: {
            noMatch: string;
            noData: string;
            titles: string[];
            filterPlaceholder: string;
            noCheckedFormat: string;
            hasCheckedFormat: string;
        };
        image: {
            error: string;
        };
        pageHeader: {
            title: string;
        };
        popconfirm: {
            confirmButtonText: string;
            cancelButtonText: string;
        };
        carousel: {
            leftArrow: string;
            rightArrow: string;
            indicator: string;
        };
    };
};
export default _default;


code:
declare const _default: {
    name: string;
    el: {
        breadcrumb: {
            label: string;
        };
        colorpicker: {
            confirm: string;
            clear: string;
        };
        datepicker: {
            now: string;
            today: string;
            cancel: string;
            clear: string;
            confirm: string;
            selectDate: string;
            selectTime: string;
            startDate: string;
            startTime: string;
            endDate: string;
            endTime: string;
            prevYear: string;
            nextYear: string;
            prevMonth: string;
            nextMonth: string;
            year: string;
            month1: string;
            month2: string;
            month3: string;
            month4: string;
            month5: string;
            month6: string;
            month7: string;
            month8: string;
            month9: string;
            month10: string;
            month11: string;
            month12: string;
            weeks: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            months: {
                jan: string;
                feb: string;
                mar: string;
                apr: string;
                may: string;
                jun: string;
                jul: string;
                aug: string;
                sep: string;
                oct: string;
                nov: string;
                dec: string;
            };
        };
        select: {
            loading: string;
            noMatch: string;
            noData: string;
            placeholder: string;
        };
        mention: {
            loading: string;
        };
        cascader: {
            noMatch: string;
            loading: string;
            placeholder: string;
            noData: string;
        };
        pagination: {
            goto: string;
            pagesize: string;
            total: string;
            pageClassifier: string;
            page: string;
            prev: string;
            next: string;
            currentPage: string;
            prevPages: string;
            nextPages: string;
        };
        messagebox: {
            confirm: string;
            cancel: string;
            error: string;
        };
        upload: {
            deleteTip: string;
            delete: string;
            preview: string;
            continue: string;
        };
        table: {
            emptyText: string;
            confirmFilter: string;
            resetFilter: string;
            clearFilter: string;
            sumText: string;
        };
        tree: {
            emptyText: string;
        };
        transfer: {
            noMatch: string;
            noData: string;
            titles: string[];
            filterPlaceholder: string;
            noCheckedFormat: string;
            hasCheckedFormat: string;
        };
        image: {
            error: string;
        };
        pageHeader: {
            title: string;
        };
        popconfirm: {
            confirmButtonText: string;
            cancelButtonText: string;
        };
        carousel: {
            leftArrow: string;
            rightArrow: string;
            indicator: string;
        };
    };
};
export default _default;


code:
var ca = {
  name: "ca",
  el: {
    breadcrumb: {
      label: "Breadcrumb"
    },
    colorpicker: {
      confirm: "Confirmar",
      clear: "Netejar"
    },
    datepicker: {
      now: "Ara",
      today: "Avui",
      cancel: "Cancel\xB7lar",
      clear: "Netejar",
      confirm: "Confirmar",
      selectDate: "Seleccionar data",
      selectTime: "Seleccionar hora",
      startDate: "Data Inici",
      startTime: "Hora Inici",
      endDate: "Data Final",
      endTime: "Hora Final",
      prevYear: "Any anterior",
      nextYear: "Pr\xF2xim Any",
      prevMonth: "Mes anterior",
      nextMonth: "Pr\xF2xim Mes",
      year: "",
      month1: "Gener",
      month2: "Febrer",
      month3: "Mar\xE7",
      month4: "Abril",
      month5: "Maig",
      month6: "Juny",
      month7: "Juliol",
      month8: "Agost",
      month9: "Setembre",
      month10: "Octubre",
      month11: "Novembre",
      month12: "Desembre",
      weeks: {
        sun: "Dg",
        mon: "Dl",
        tue: "Dt",
        wed: "Dc",
        thu: "Dj",
        fri: "Dv",
        sat: "Ds"
      },
      months: {
        jan: "Gen",
        feb: "Febr",
        mar: "Mar\xE7",
        apr: "Abr",
        may: "Maig",
        jun: "Juny",
        jul: "Jul",
        aug: "Ag",
        sep: "Set",
        oct: "Oct",
        nov: "Nov",
        dec: "Des"
      }
    },
    select: {
      loading: "Carregant",
      noMatch: "No hi ha dades que coincideixin",
      noData: "Sense Dades",
      placeholder: "Seleccionar"
    },
    mention: {
      loading: "Carregant"
    },
    cascader: {
      noMatch: "No hi ha dades que coincideixin",
      loading: "Carregant",
      placeholder: "Seleccionar",
      noData: "Sense Dades"
    },
    pagination: {
      goto: "Anar a",
      pagesize: "/p\xE0gina",
      total: "Total {total}",
      pageClassifier: "",
      page: "Page",
      prev: "Go to previous page",
      next: "Go to next page",
      currentPage: "page {pager}",
      prevPages: "Previous {pager} pages",
      nextPages: "Next {pager} pages"
    },
    messagebox: {
      confirm: "Acceptar",
      cancel: "Cancel\xB7lar",
      error: "Entrada inv\xE0lida"
    },
    upload: {
      deleteTip: "premi eliminar per descartar",
      delete: "Eliminar",
      preview: "Vista Pr\xE8via",
      continue: "Continuar"
    },
    table: {
      emptyText: "Sense Dades",
      confirmFilter: "Confirmar",
      resetFilter: "Netejar",
      clearFilter: "Tot",
      sumText: "Tot"
    },
    tree: {
      emptyText: "Sense Dades"
    },
    transfer: {
      noMatch: "No hi ha dades que coincideixin",
      noData: "Sense Dades",
      titles: ["Llista 1", "Llista 2"],
      filterPlaceholder: "Introdueix la paraula clau",
      noCheckedFormat: "{total} \xEDtems",
      hasCheckedFormat: "{checked}/{total} seleccionats"
    },
    image: {
      error: "HA FALLAT"
    },
    pageHeader: {
      title: "Tornar"
    },
    popconfirm: {
      confirmButtonText: "S\xED",
      cancelButtonText: "No"
    },
    carousel: {
      leftArrow: "Carousel arrow left",
      rightArrow: "Carousel arrow right",
      indicator: "Carousel switch to index {index}"
    }
  }
};

export { ca as default };
//# sourceMappingURL=ca.mjs.map


code:
declare const _default: {
    name: string;
    el: {
        breadcrumb: {
            label: string;
        };
        colorpicker: {
            confirm: string;
            clear: string;
            defaultLabel: string;
            description: string;
        };
        datepicker: {
            now: string;
            today: string;
            cancel: string;
            clear: string;
            confirm: string;
            dateTablePrompt: string;
            monthTablePrompt: string;
            yearTablePrompt: string;
            selectedDate: string;
            selectDate: string;
            selectTime: string;
            startDate: string;
            startTime: string;
            endDate: string;
            endTime: string;
            prevYear: string;
            nextYear: string;
            prevMonth: string;
            nextMonth: string;
            year: string;
            month1: string;
            month2: string;
            month3: string;
            month4: string;
            month5: string;
            month6: string;
            month7: string;
            month8: string;
            month9: string;
            month10: string;
            month11: string;
            month12: string;
            week: string;
            weeks: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            weeksFull: {
                sun: string;
                mon: string;
                tue: string;
                wed: string;
                thu: string;
                fri: string;
                sat: string;
            };
            months: {
                jan: string;
                feb: string;
                mar: string;
                apr: string;
                may: string;
                jun: string;
                jul: string;
                aug: string;
                sep: string;
                oct: string;
                nov: string;
                dec: string;
            };
        };
        inputNumber: {
            decrease: string;
            increase: string;
        };
        select: {
            loading: string;
            noMatch: string;
            noData: string;
            placeholder: string;
        };
        mention: {
            loading: string;
        };
        dropdown: {
            toggleDropdown: string;
        };
        cascader: {
            noMatch: string;
            loading: string;
            placeholder: string;
            noData: string;
        };
        pagination: {
            goto: string;
            pagesize: string;
            total: string;
            pageClassifier: string;
            page: string;
            prev: string;
            next: string;
            currentPage: string;
            prevPages: string;
            nextPages: string;
            deprecationWarning: string;
        };
        dialog: {
            close: string;
        };
        drawer: {
            close: string;
        };
        messagebox: {
            title: string;
            confirm: string;
            cancel: string;
            error: string;
            close: string;
        };
        upload: {
            deleteTip: string;
            delete: string;
            preview: string;
            continue: string;
        };
        slider: {
            defaultLabel: string;
            defaultRangeStartLabel: string;
            defaultRangeEndLabel: string;
        };
        table: {
            emptyText: string;
            confirmFilter: string;
            resetFilter: string;
            clearFilter: string;
            sumText: string;
        };
        tree: {
            emptyText: string;
        };
        transfer: {
            noMatch: string;
            noData: string;
            titles: string[];
            filterPlaceholder: string;
            noCheckedFormat: string;
            hasCheckedFormat: string;
        };
        image: {
            error: string;
        };
        pageHeader: {
            title: string;
        };
        popconfirm: {
            confirmButtonText: string;
            cancelButtonText: string;
        };
        carousel: {
            leftArrow: string;
            rightArrow: string;
            indicator: string;
        };
    };
};
export default _default;