@pantograph/vue 0.26.0 → 0.27.1

package/dist/Tabs/TabList.d.ts

@@ -0,0 +1,302 @@
+import { ClassValue } from 'class-variance-authority/types';
+import { TabsSlotProps } from './Tabs';
+export interface TabListProps {
+    class?: ClassValue;
+    indicatorCls?: ClassValue;
+    containerCls?: ClassValue;
+    fixedActionsCls?: ClassValue;
+    actionsCls?: ClassValue;
+    startScrollCls?: ClassValue;
+    endScrollCls?: ClassValue;
+}
+export interface TabListSlots {
+    fixedActions?: (data: TabsSlotProps) => never;
+    actions?: (data: TabsSlotProps) => never;
+    default?: (data?: object) => never;
+}
+export declare const tabsPrefix: string;
+export declare const tabsTriggerPrefix: string;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TabListProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TabListProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    scrollContainer: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly scrollDistance?: number | undefined;
+            readonly scrollHideDelay?: number | undefined;
+            readonly dir?: "rtl" | "ltr" | undefined;
+            readonly type?: import('..').ScrollContainerType | undefined;
+            readonly hasMask?: boolean | undefined;
+            readonly size?: import('..').ScrollContainerSize | undefined;
+            readonly scrollbarCls?: import('clsx').ClassValue;
+            readonly wrapCls?: import('clsx').ClassValue;
+            readonly areaCls?: import('clsx').ClassValue;
+            readonly rootCls?: import('clsx').ClassValue;
+            readonly thumbCls?: import('clsx').ClassValue;
+            readonly cornerCls?: import('clsx').ClassValue;
+            readonly rootProps?: object | undefined;
+            readonly wrapProps?: object | undefined;
+            readonly overlay?: boolean | undefined;
+            readonly hideVerticalScrollbar?: boolean | undefined;
+            readonly hideHorizontalScrollbar?: boolean | undefined;
+            readonly color?: string | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            root: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly type?: ("auto" | "scroll" | "hover" | "always") | undefined;
+                    readonly dir?: ("ltr" | "rtl") | undefined;
+                    readonly scrollHideDelay?: number | undefined;
+                    readonly asChild?: boolean | undefined;
+                    readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').ScrollAreaRootProps> & Readonly<{}>, {
+                    viewport: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                    scrollTop: () => void;
+                    scrollTopLeft: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+                    type: "auto" | "scroll" | "hover" | "always";
+                    scrollHideDelay: number;
+                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import('vue').nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+            } & Readonly<{
+                type: "auto" | "scroll" | "hover" | "always";
+                scrollHideDelay: number;
+            }> & Omit<Readonly<import('reka-ui').ScrollAreaRootProps> & Readonly<{}>, "type" | "scrollHideDelay" | "scrollTop" | "scrollTopLeft" | "viewport"> & import('vue').ShallowUnwrapRef<{
+                viewport: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                scrollTop: () => void;
+                scrollTopLeft: () => void;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            }) | null;
+            container: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly nonce?: string | undefined;
+                    readonly asChild?: boolean | undefined;
+                    readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').ScrollAreaViewportProps> & Readonly<{}>, {
+                    viewportElement: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import('vue').nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+            } & Readonly<{}> & Omit<Readonly<import('reka-ui').ScrollAreaViewportProps> & Readonly<{}>, "viewportElement"> & import('vue').ShallowUnwrapRef<{
+                viewportElement: import('vue').Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            }> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            }) | null;
+            wrap: HTMLDivElement;
+            top: HTMLDivElement;
+            right: HTMLDivElement;
+            left: HTMLDivElement;
+            bottom: HTMLDivElement;
+            corner: ({
+                $: import('vue').ComponentInternalInstance;
+                $data: {};
+                $props: {
+                    readonly asChild?: boolean | undefined;
+                    readonly as?: (import('reka-ui').AsTag | import('vue').Component) | undefined;
+                } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import('vue').Slot<any> | undefined;
+                }>;
+                $root: import('vue').ComponentPublicInstance | null;
+                $parent: import('vue').ComponentPublicInstance | null;
+                $host: Element | null;
+                $emit: (event: string, ...args: any[]) => void;
+                $el: any;
+                $options: import('vue').ComponentOptionsBase<Readonly<import('reka-ui').ScrollAreaCornerProps> & Readonly<{}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                    beforeCreate?: (() => void) | (() => void)[];
+                    created?: (() => void) | (() => void)[];
+                    beforeMount?: (() => void) | (() => void)[];
+                    mounted?: (() => void) | (() => void)[];
+                    beforeUpdate?: (() => void) | (() => void)[];
+                    updated?: (() => void) | (() => void)[];
+                    activated?: (() => void) | (() => void)[];
+                    deactivated?: (() => void) | (() => void)[];
+                    beforeDestroy?: (() => void) | (() => void)[];
+                    beforeUnmount?: (() => void) | (() => void)[];
+                    destroyed?: (() => void) | (() => void)[];
+                    unmounted?: (() => void) | (() => void)[];
+                    renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import('vue').nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+            } & Readonly<{}> & Omit<Readonly<import('reka-ui').ScrollAreaCornerProps> & Readonly<{}>, never> & import('vue').ShallowUnwrapRef<{}> & {} & import('vue').ComponentCustomProperties & {} & {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            }) | null;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('..').ScrollContainerProps> & Readonly<{}>, {
+            container: import('vue').Ref<any, any>;
+            wrap: import('vue').Ref<any, any>;
+            root: import('vue').Ref<any, any>;
+            isOverflowX: import('vue').ShallowRef<boolean, boolean>;
+            isOverflowY: import('vue').ShallowRef<boolean, boolean>;
+            topVisible: import('vue').ShallowRef<boolean, boolean>;
+            rightVisible: import('vue').ShallowRef<boolean, boolean>;
+            leftVisible: import('vue').ShallowRef<boolean, boolean>;
+            bottomVisible: import('vue').ShallowRef<boolean, boolean>;
+            getScroll: () => {
+                scrollTop: any;
+                scrollLeft: any;
+            };
+            scrollTop: () => any;
+            scrollTopLeft: () => any;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
+            size: import('..').ScrollContainerSize;
+            type: import('..').ScrollContainerType;
+            overlay: boolean;
+            scrollDistance: number;
+            scrollHideDelay: number;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{
+        size: import('..').ScrollContainerSize;
+        type: import('..').ScrollContainerType;
+        overlay: boolean;
+        scrollDistance: number;
+        scrollHideDelay: number;
+    }> & Omit<Readonly<import('..').ScrollContainerProps> & Readonly<{}>, "wrap" | "root" | "topVisible" | "bottomVisible" | "rightVisible" | "leftVisible" | "isOverflowX" | "isOverflowY" | "container" | "getScroll" | "scrollTop" | "scrollTopLeft" | ("size" | "type" | "overlay" | "scrollDistance" | "scrollHideDelay")> & import('vue').ShallowUnwrapRef<{
+        container: import('vue').Ref<any, any>;
+        wrap: import('vue').Ref<any, any>;
+        root: import('vue').Ref<any, any>;
+        isOverflowX: import('vue').ShallowRef<boolean, boolean>;
+        isOverflowY: import('vue').ShallowRef<boolean, boolean>;
+        topVisible: import('vue').ShallowRef<boolean, boolean>;
+        rightVisible: import('vue').ShallowRef<boolean, boolean>;
+        leftVisible: import('vue').ShallowRef<boolean, boolean>;
+        bottomVisible: import('vue').ShallowRef<boolean, boolean>;
+        getScroll: () => {
+            scrollTop: any;
+            scrollLeft: any;
+        };
+        scrollTop: () => any;
+        scrollTopLeft: () => any;
+    }> & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            root?(_: {}): any;
+            root?(_: {}): any;
+            area?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) | null;
+    container: HTMLDivElement;
+}, any>, Readonly<TabListSlots> & TabListSlots>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Tabs/TabTrigger.d.ts

@@ -0,0 +1,41 @@
+import { TabsTriggerProps } from 'reka-ui';
+import { TabsSlotProps } from './Tabs';
+import { ClassValue } from 'class-variance-authority/types';
+import { BadgeProps } from '../Badge';
+export interface TabTriggerProps extends Omit<TabsTriggerProps, 'as' | 'asChild'> {
+    text?: string | number;
+    loading?: boolean;
+    draggable?: boolean;
+    class?: ClassValue;
+    contentCls?: ClassValue;
+    textCls?: ClassValue;
+    trailingCls?: ClassValue;
+    actionCls?: ClassValue;
+    badgeProps?: BadgeProps;
+}
+export interface TabTriggerSlots {
+    leading?: (data: TabsSlotProps) => never;
+    trailing?: (data: TabsSlotProps) => never;
+    action?: (data: TabsSlotProps) => never;
+    text?: (data?: object) => never;
+    badge?: (data?: object) => never;
+    badgeIcon?: (data?: object) => never;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<TabTriggerSlots> & TabTriggerSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<TabTriggerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TabTriggerProps> & Readonly<{}>, {
+    loading: boolean;
+    draggable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Tabs/Tabs.d.ts

@@ -0,0 +1,53 @@
+import { TabsRootProps, TabsRootEmits } from 'reka-ui';
+import { TabsSize } from './Tabs.model';
+import { Direction } from '../ConfigProvider';
+import { ComputedRef } from 'vue';
+import { EmitFn } from '@vue/runtime-core';
+import { Sortable, SortableEvent, SortableOptions } from '@pantograph/sortable';
+export interface TabsProps extends TabsRootProps {
+    block?: boolean;
+    draggable?: boolean;
+    size?: TabsSize;
+    sortableProps?: SortableOptions;
+}
+export interface TabsEmits extends TabsRootEmits {
+    change: TabsRootEmits['update:modelValue'];
+    dragStart: [event: SortableEvent, sortable: Sortable];
+    dragEnd: [event: SortableEvent, sortable: Sortable];
+}
+export type TabsItem = Map<HTMLElement, {
+    ref: HTMLElement;
+    value?: any;
+}>;
+export interface TabsSlotProps {
+    iconSize: 'sm' | 'xsm';
+    size: 'md' | 'sm';
+}
+export interface TabsContext {
+    props: TabsProps;
+    emit: EmitFn<TabsEmits>;
+    dir: ComputedRef<Direction | undefined>;
+    slotProps: ComputedRef<TabsSlotProps>;
+}
+export declare const injectTabsContext: <T extends TabsContext | null | undefined = TabsContext>(fallback?: T | undefined) => T extends null ? TabsContext | null : TabsContext, provideTabsContext: (contextValue: TabsContext) => TabsContext;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<TabsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (payload: string | number) => any;
+    change: (payload: string | number) => any;
+    dragStart: (event: Sortable.SortableEvent, sortable: Sortable) => any;
+    dragEnd: (event: Sortable.SortableEvent, sortable: Sortable) => any;
+}, string, import('vue').PublicProps, Readonly<TabsProps> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
+    onChange?: ((payload: string | number) => any) | undefined;
+    onDragStart?: ((event: Sortable.SortableEvent, sortable: Sortable) => any) | undefined;
+    onDragEnd?: ((event: Sortable.SortableEvent, sortable: Sortable) => any) | undefined;
+}>, {
+    size: TabsSize;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/Tabs/index.d.ts

@@ -1 +1,5 @@
-export {};
+export { type TabsContext, type TabsEmits, type TabsItem, type TabsProps, injectTabsContext, provideTabsContext, default as Tabs, } from './Tabs';
+export { type TabListProps, type TabListSlots, tabsPrefix, default as TabList } from './TabList';
+export { type TabTriggerProps, type TabTriggerSlots, default as TabTrigger } from './TabTrigger';
+export { default as TabContent } from './TabContent';
+export * from './Tabs.model';

package/dist/Tabs/index.js

@@ -1 +1,11 @@
-
+import { c as t, a as b, b as e, _ as T, T as i, i as o, p as r, t as n } from "../TabContent.vue_vue_type_script_setup_true_lang-DUqgKpvl.js";
+export {
+  t as TabContent,
+  b as TabList,
+  e as TabTrigger,
+  T as Tabs,
+  i as TabsSizes,
+  o as injectTabsContext,
+  r as provideTabsContext,
+  n as tabsPrefix
+};

package/dist/Tabs/index.umd.cjs

@@ -1 +1 @@
-"use strict";
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../TabContent.vue_vue_type_script_setup_true_lang-B3v-gPTa.js");exports.TabContent=e._sfc_main$3;exports.TabList=e._sfc_main$1;exports.TabTrigger=e._sfc_main$2;exports.Tabs=e._sfc_main;exports.TabsSizes=e.TabsSizes;exports.injectTabsContext=e.injectTabsContext;exports.provideTabsContext=e.provideTabsContext;exports.tabsPrefix=e.tabsPrefix;