@barzhsieh/nuxt-content-mermaid 2.1.2 → 2.2.0

package/dist/runtime/components/icons/IconPlus.vue

@@ -0,0 +1,57 @@
+<script setup>
+defineProps({
+  size: { type: [Number, String], required: false, default: 20 }
+});
+</script>
+
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    :width="size"
+    :height="size"
+    viewBox="0 0 24 24"
+    class="ncm-icon-animate"
+  ><g
+    fill="none"
+    stroke="currentColor"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    stroke-width="2"
+  ><path
+    class="ncm-icon-ring"
+    stroke-dasharray="64"
+    stroke-dashoffset="64"
+    d="M3 12c0 -4.97 4.03 -9 9 -9c4.97 0 9 4.03 9 9c0 4.97 -4.03 9 -9 9c-4.97 0 -9 -4.03 -9 -9Z"
+  ><animate
+    fill="freeze"
+    attributeName="stroke-dashoffset"
+    dur="0.6s"
+    values="64;0"
+  /></path><path
+    class="ncm-icon-line"
+    stroke-dasharray="12"
+    stroke-dashoffset="12"
+    d="M7 12h10"
+  ><animate
+    fill="freeze"
+    attributeName="stroke-dashoffset"
+    begin="0.6s"
+    dur="0.2s"
+    values="12;0"
+  /></path><path
+    class="ncm-icon-line"
+    stroke-dasharray="12"
+    stroke-dashoffset="12"
+    d="M12 7v10"
+  ><animate
+    fill="freeze"
+    attributeName="stroke-dashoffset"
+    begin="0.8s"
+    dur="0.2s"
+    values="12;0"
+  /></path></g></svg>
+</template>
+
+<style scoped>
+@media (prefers-reduced-motion:reduce){.ncm-icon-animate .ncm-icon-line,.ncm-icon-animate .ncm-icon-ring{stroke-dashoffset:0}.ncm-icon-animate animate{display:none}}
+</style>

package/dist/runtime/components/icons/IconPlus.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    size?: number | string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: number | string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/icons/iconFullScreen.d.vue.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    size?: number | string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: number | string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/icons/iconFullScreen.vue

@@ -0,0 +1,26 @@
+<script setup>
+defineProps({
+  size: { type: [Number, String], required: false, default: 20 }
+});
+</script>
+
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    :width="size"
+    :height="size"
+    viewBox="0 0 24 24"
+  ><g
+    fill="none"
+    stroke="currentColor"
+    stroke-width="1.5"
+  ><path
+    stroke-linecap="round"
+    d="M13 22c4.055-.008 6.178-.107 7.535-1.465C22 19.072 22 16.714 22 12s0-7.071-1.465-8.536C19.071 2 16.714 2 12 2S4.929 2 3.464 3.464C2.107 4.822 2.008 6.944 2 11"
+    opacity="0.5"
+  /><path
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    d="m12 12l5-5m0 0h-3.75M17 7v3.75"
+  /><path d="M2 18c0-1.886 0-2.828.586-3.414S4.114 14 6 14s2.828 0 3.414.586S10 16.114 10 18s0 2.828-.586 3.414S7.886 22 6 22s-2.828 0-3.414-.586S2 19.886 2 18Z" /></g></svg>
+</template>

package/dist/runtime/components/icons/iconFullScreen.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    size?: number | string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: number | string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/icons/iconFullScreenExit.d.vue.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    size?: number | string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: number | string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/icons/iconFullScreenExit.vue

@@ -0,0 +1,26 @@
+<script setup>
+defineProps({
+  size: { type: [Number, String], required: false, default: 20 }
+});
+</script>
+
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    :width="size"
+    :height="size"
+    viewBox="0 0 24 24"
+  ><g
+    fill="none"
+    stroke="currentColor"
+    stroke-width="1.5"
+  ><path
+    stroke-linecap="round"
+    d="M13 22c4.055-.008 6.178-.107 7.535-1.465C22 19.072 22 16.714 22 12s0-7.071-1.465-8.536C19.071 2 16.714 2 12 2S4.929 2 3.464 3.464C2.107 4.822 2.008 6.944 2 11"
+    opacity="0.5"
+  /><path
+    stroke-linecap="round"
+    stroke-linejoin="round"
+    d="m17 7l-5 5m0 0h3.75M12 12V8.25"
+  /><path d="M2 18c0-1.886 0-2.828.586-3.414S4.114 14 6 14s2.828 0 3.414.586S10 16.114 10 18s0 2.828-.586 3.414S7.886 22 6 22s-2.828 0-3.414-.586S2 19.886 2 18Z" /></g></svg>
+</template>

package/dist/runtime/components/icons/iconFullScreenExit.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    size?: number | string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: number | string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/composables/_configurable.d.ts

@@ -0,0 +1,27 @@
+export interface ConfigurableWindow {
+    window?: Window;
+}
+export interface ConfigurableDocument {
+    document?: Document;
+}
+export interface ConfigurableDocumentOrShadowRoot {
+    document?: DocumentOrShadowRoot;
+}
+export interface ConfigurableNavigator {
+    navigator?: Navigator;
+}
+export interface ConfigurableLocation {
+    location?: Location;
+}
+export declare const defaultWindow: (Window & typeof globalThis) | undefined;
+export declare const defaultDocument: Document | undefined;
+export declare const defaultNavigator: Navigator | undefined;
+export declare const defaultLocation: Location | undefined;
+export interface ConfigurableDeepRefs<D extends boolean> {
+    /**
+     * Return deep refs instead of shallow refs.
+     *
+     * @default true - will be changed to `false` by default in the next major
+     */
+    deepRefs?: D;
+}

package/dist/runtime/composables/_configurable.js

@@ -0,0 +1,5 @@
+import { isClient } from "../utils/index.js";
+export const defaultWindow = isClient ? window : void 0;
+export const defaultDocument = isClient ? window.document : void 0;
+export const defaultNavigator = isClient ? window.navigator : void 0;
+export const defaultLocation = isClient ? window.location : void 0;

package/dist/runtime/composables/shared/index.d.ts

@@ -0,0 +1,5 @@
+export { tryOnMounted } from './tryOnMounted.js';
+export { tryOnScopeDispose } from './tryOnScopeDispose.js';
+export { watchImmediate } from './watchImmediate.js';
+export { isObject, isClient } from '../../utils/index.js';
+export { toArray } from '../../utils/index.js';

package/dist/runtime/composables/shared/index.js

@@ -0,0 +1,5 @@
+export { tryOnMounted } from "./tryOnMounted.js";
+export { tryOnScopeDispose } from "./tryOnScopeDispose.js";
+export { watchImmediate } from "./watchImmediate.js";
+export { isObject, isClient } from "../../utils/index.js";
+export { toArray } from "../../utils/index.js";

package/dist/runtime/composables/shared/tryOnMounted.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentInternalInstance } from 'vue';
+import type { Fn } from '../../types/utils.js';
+/**
+ * Call onMounted() if it's inside a component lifecycle, if not, just call the function
+ *
+ * @param fn
+ * @param sync if set to false, it will run in the nextTick() of Vue
+ * @param target
+ */
+export declare function tryOnMounted(fn: Fn, sync?: boolean, target?: ComponentInternalInstance | null): void;

package/dist/runtime/composables/shared/tryOnMounted.js

@@ -0,0 +1,11 @@
+import { nextTick, onMounted } from "vue";
+import { getLifeCycleTarget } from "../../utils/index.js";
+export function tryOnMounted(fn, sync = true, target) {
+  const instance = getLifeCycleTarget(target);
+  if (instance)
+    onMounted(fn, target);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}

package/dist/runtime/composables/shared/tryOnScopeDispose.d.ts

@@ -0,0 +1,7 @@
+import type { Fn } from '../../types/utils.js';
+/**
+ * Call onScopeDispose() if it's inside an effect scope lifecycle, if not, do nothing
+ *
+ * @param fn
+ */
+export declare function tryOnScopeDispose(fn: Fn, failSilently?: boolean): boolean;

package/dist/runtime/composables/shared/tryOnScopeDispose.js

@@ -0,0 +1,8 @@
+import { getCurrentScope, onScopeDispose } from "vue";
+export function tryOnScopeDispose(fn, failSilently) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn, failSilently);
+    return true;
+  }
+  return false;
+}

package/dist/runtime/composables/shared/watchImmediate.d.ts

@@ -0,0 +1,5 @@
+import type { MultiWatchSources, WatchCallback, WatchHandle, WatchOptions, WatchSource } from 'vue';
+import type { MapOldSources, MapSources } from '../../types/utils.js';
+export declare function watchImmediate<T extends Readonly<MultiWatchSources>>(source: [...T], cb: WatchCallback<MapSources<T>, MapOldSources<T, true>>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+export declare function watchImmediate<T>(source: WatchSource<T>, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;
+export declare function watchImmediate<T extends object>(source: T, cb: WatchCallback<T, T | undefined>, options?: Omit<WatchOptions<true>, 'immediate'>): WatchHandle;

package/dist/runtime/composables/shared/watchImmediate.js

@@ -0,0 +1,11 @@
+import { watch } from "vue";
+export function watchImmediate(source, cb, options) {
+  return watch(
+    source,
+    cb,
+    {
+      ...options,
+      immediate: true
+    }
+  );
+}

package/dist/runtime/composables/unrefElement.d.ts

@@ -0,0 +1,12 @@
+import type { ComponentPublicInstance, MaybeRef, MaybeRefOrGetter } from 'vue';
+export type VueInstance = ComponentPublicInstance;
+export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
+export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;
+export type MaybeElement = HTMLElement | SVGElement | VueInstance | undefined | null;
+export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends VueInstance ? Exclude<MaybeElement, VueInstance> : T | undefined;
+/**
+ * Get the dom element of a ref of element or Vue component instance
+ *
+ * @param elRef
+ */
+export declare function unrefElement<T extends MaybeElement>(elRef: MaybeComputedElementRef<T>): UnRefElementReturn<T>;

package/dist/runtime/composables/unrefElement.js

@@ -0,0 +1,5 @@
+import { toValue } from "vue";
+export function unrefElement(elRef) {
+  const plain = toValue(elRef);
+  return plain?.$el ?? plain;
+}

package/dist/runtime/composables/useEventListener.d.ts

@@ -0,0 +1,73 @@
+import type { Arrayable, Fn } from '../types/utils.js';
+import type { MaybeRef, MaybeRefOrGetter } from 'vue';
+interface InferEventTarget<Events> {
+    addEventListener: (event: Events, fn?: any, options?: any) => any;
+    removeEventListener: (event: Events, fn?: any, options?: any) => any;
+}
+export type WindowEventName = keyof WindowEventMap;
+export type DocumentEventName = keyof DocumentEventMap;
+export type ShadowRootEventName = keyof ShadowRootEventMap;
+export interface GeneralEventListener<E = Event> {
+    (evt: E): void;
+}
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 1: Omitted Window target
+ *
+ * @see https://vueuse.org/useEventListener
+ */
+export declare function useEventListener<E extends keyof WindowEventMap>(event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 2: Explicitly Window target
+ *
+ * @see https://vueuse.org/useEventListener
+ * @param target
+ * @param event
+ * @param listener
+ * @param options
+ */
+export declare function useEventListener<E extends keyof WindowEventMap>(target: Window, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Window, ev: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 3: Explicitly Document target
+ *
+ * @see https://vueuse.org/useEventListener
+ */
+export declare function useEventListener<E extends keyof DocumentEventMap>(target: Document, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: Document, ev: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 4: Explicitly ShadowRoot target
+ *
+ * @see https://vueuse.org/useEventListener
+ */
+export declare function useEventListener<E extends keyof ShadowRootEventMap>(target: MaybeRefOrGetter<Arrayable<ShadowRoot> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<Arrayable<(this: ShadowRoot, ev: ShadowRootEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 5: Explicitly HTMLElement target
+ *
+ * @see https://vueuse.org/useEventListener
+ */
+export declare function useEventListener<E extends keyof HTMLElementEventMap>(target: MaybeRefOrGetter<Arrayable<HTMLElement> | null | undefined>, event: MaybeRefOrGetter<Arrayable<E>>, listener: MaybeRef<(this: HTMLElement, ev: HTMLElementEventMap[E]) => any>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 6: Custom event target with event type infer
+ *
+ * @see https://vueuse.org/useEventListener
+ */
+export declare function useEventListener<Names extends string, EventType = Event>(target: MaybeRefOrGetter<Arrayable<InferEventTarget<Names>> | null | undefined>, event: MaybeRefOrGetter<Arrayable<Names>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+/**
+ * Register using addEventListener on mounted, and removeEventListener automatically on unmounted.
+ *
+ * Overload 7: Custom event target fallback
+ *
+ * @see https://vueuse.org/useEventListener
+ */
+export declare function useEventListener<EventType = Event>(target: MaybeRefOrGetter<Arrayable<EventTarget> | null | undefined>, event: MaybeRefOrGetter<Arrayable<string>>, listener: MaybeRef<Arrayable<GeneralEventListener<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): Fn;
+export {};

package/dist/runtime/composables/useEventListener.js

@@ -0,0 +1,40 @@
+import { isObject, toArray, watchImmediate } from "./shared/index.js";
+import { computed, toValue, unref } from "vue";
+import { defaultWindow } from "./_configurable.js";
+import { unrefElement } from "./unrefElement.js";
+export function useEventListener(...args) {
+  const register = (el, event, listener, options) => {
+    el.addEventListener(event, listener, options);
+    return () => el.removeEventListener(event, listener, options);
+  };
+  const firstParamTargets = computed(() => {
+    const test = toArray(toValue(args[0])).filter((e) => e != null);
+    return test.every((e) => typeof e !== "string") ? test : void 0;
+  });
+  return watchImmediate(
+    () => [
+      firstParamTargets.value?.map((e) => unrefElement(e)) ?? [defaultWindow].filter((e) => e != null),
+      toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+      toArray(unref(firstParamTargets.value ? args[2] : args[1])),
+      // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
+      toValue(firstParamTargets.value ? args[3] : args[2])
+    ],
+    ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
+      if (!raw_targets?.length || !raw_events?.length || !raw_listeners?.length)
+        return;
+      const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+      const cleanups = raw_targets.flatMap(
+        (el) => raw_events.flatMap(
+          (event) => raw_listeners.map(
+            (listener) => register(el, event, listener, optionsClone)
+          )
+        )
+      );
+      onCleanup(() => {
+        cleanups.forEach((fn) => fn());
+      });
+    },
+    { flush: "post" }
+  );
+}

package/dist/runtime/composables/useFullscreen.d.ts

@@ -0,0 +1,25 @@
+import type { ConfigurableDocument } from './_configurable.js';
+import type { MaybeElementRef } from './unrefElement.js';
+export interface UseFullscreenOptions extends ConfigurableDocument {
+    /**
+     * Automatically exit fullscreen when component is unmounted
+     *
+     * @default false
+     */
+    autoExit?: boolean;
+}
+/**
+ * Reactive Fullscreen API.
+ *
+ * @see https://vueuse.org/useFullscreen
+ * @param target
+ * @param options
+ */
+export declare function useFullscreen(target?: MaybeElementRef, options?: UseFullscreenOptions): {
+    isSupported: import("vue").ComputedRef<boolean>;
+    isFullscreen: import("vue").ShallowRef<boolean, boolean>;
+    enter: () => Promise<void>;
+    exit: () => Promise<void>;
+    toggle: () => Promise<void>;
+};
+export type UseFullscreenReturn = ReturnType<typeof useFullscreen>;

package/dist/runtime/composables/useFullscreen.js

@@ -0,0 +1,122 @@
+import { tryOnMounted, tryOnScopeDispose } from "./shared/index.js";
+import { computed, shallowRef } from "vue";
+import { defaultDocument } from "./_configurable.js";
+import { unrefElement } from "./unrefElement.js";
+import { useEventListener } from "./useEventListener.js";
+import { useSupported } from "./useSupported.js";
+const eventHandlers = [
+  "fullscreenchange",
+  "webkitfullscreenchange",
+  "webkitendfullscreen",
+  "mozfullscreenchange",
+  "MSFullscreenChange"
+];
+export function useFullscreen(target, options = {}) {
+  const {
+    document = defaultDocument,
+    autoExit = false
+  } = options;
+  const targetRef = computed(() => unrefElement(target) ?? document?.documentElement);
+  const isFullscreen = shallowRef(false);
+  const requestMethod = computed(() => {
+    return [
+      "requestFullscreen",
+      "webkitRequestFullscreen",
+      "webkitEnterFullscreen",
+      "webkitEnterFullScreen",
+      "webkitRequestFullScreen",
+      "mozRequestFullScreen",
+      "msRequestFullscreen"
+    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+  });
+  const exitMethod = computed(() => {
+    return [
+      "exitFullscreen",
+      "webkitExitFullscreen",
+      "webkitExitFullScreen",
+      "webkitCancelFullScreen",
+      "mozCancelFullScreen",
+      "msExitFullscreen"
+    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+  });
+  const fullscreenEnabled = computed(() => {
+    return [
+      "fullScreen",
+      "webkitIsFullScreen",
+      "webkitDisplayingFullscreen",
+      "mozFullScreen",
+      "msFullscreenElement"
+    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);
+  });
+  const fullscreenElementMethod = [
+    "fullscreenElement",
+    "webkitFullscreenElement",
+    "mozFullScreenElement",
+    "msFullscreenElement"
+  ].find((m) => document && m in document);
+  const isSupported = useSupported(() => targetRef.value && document && requestMethod.value !== void 0 && exitMethod.value !== void 0 && fullscreenEnabled.value !== void 0);
+  const isCurrentElementFullScreen = () => {
+    if (fullscreenElementMethod)
+      return document?.[fullscreenElementMethod] === targetRef.value;
+    return false;
+  };
+  const isElementFullScreen = () => {
+    if (fullscreenEnabled.value) {
+      if (document && document[fullscreenEnabled.value] != null) {
+        return document[fullscreenEnabled.value];
+      } else {
+        const target2 = targetRef.value;
+        if (target2?.[fullscreenEnabled.value] != null) {
+          return Boolean(target2[fullscreenEnabled.value]);
+        }
+      }
+    }
+    return false;
+  };
+  async function exit() {
+    if (!isSupported.value || !isFullscreen.value)
+      return;
+    if (exitMethod.value) {
+      if (document?.[exitMethod.value] != null) {
+        await document[exitMethod.value]();
+      } else {
+        const target2 = targetRef.value;
+        if (target2?.[exitMethod.value] != null)
+          await target2[exitMethod.value]();
+      }
+    }
+    isFullscreen.value = false;
+  }
+  async function enter() {
+    if (!isSupported.value || isFullscreen.value)
+      return;
+    if (isElementFullScreen())
+      await exit();
+    const target2 = targetRef.value;
+    if (requestMethod.value && target2?.[requestMethod.value] != null) {
+      await target2[requestMethod.value]();
+      isFullscreen.value = true;
+    }
+  }
+  async function toggle() {
+    await (isFullscreen.value ? exit() : enter());
+  }
+  const handlerCallback = () => {
+    const isElementFullScreenValue = isElementFullScreen();
+    if (!isElementFullScreenValue || isElementFullScreenValue && isCurrentElementFullScreen())
+      isFullscreen.value = isElementFullScreenValue;
+  };
+  const listenerOptions = { capture: false, passive: true };
+  useEventListener(document, eventHandlers, handlerCallback, listenerOptions);
+  useEventListener(() => unrefElement(targetRef), eventHandlers, handlerCallback, listenerOptions);
+  tryOnMounted(handlerCallback, false);
+  if (autoExit)
+    tryOnScopeDispose(exit);
+  return {
+    isSupported,
+    isFullscreen,
+    enter,
+    exit,
+    toggle
+  };
+}

package/dist/runtime/composables/useMermaidCursors.d.ts

@@ -0,0 +1,12 @@
+import { type Ref, type MaybeRef } from 'vue';
+export declare function useMermaidCursors(iconSize: Ref<number>, enabled: MaybeRef<boolean>): {
+    cursorVariables: import("vue").ComputedRef<{
+        '--ncm-cursor-expand'?: undefined;
+        '--ncm-cursor-collapse'?: undefined;
+    } | {
+        '--ncm-cursor-expand': string;
+        '--ncm-cursor-collapse': string;
+    }>;
+    cursorExpandUri: import("vue").ComputedRef<string>;
+    cursorCollapseUri: import("vue").ComputedRef<string>;
+};

package/dist/runtime/composables/useMermaidCursors.js

@@ -0,0 +1,41 @@
+import { computed, toValue } from "vue";
+export function useMermaidCursors(iconSize, enabled) {
+  const buildCursorSvg = (size, paths) => {
+    const outerWidth = Math.max(2, Math.round(size / 8));
+    const innerWidth = Math.max(1, outerWidth - 1);
+    return `<svg xmlns='http://www.w3.org/2000/svg' width='${size}' height='${size}' viewBox='0 0 24 24' fill='none' stroke-linecap='round' stroke-linejoin='round'><g stroke='black' stroke-width='${outerWidth}'>${paths}</g><g stroke='white' stroke-width='${innerWidth}'>${paths}</g></svg>`;
+  };
+  const cursorExpandUri = computed(() => {
+    const size = iconSize.value;
+    const svg = buildCursorSvg(
+      size,
+      "<polyline points='15 3 21 3 21 9'/><polyline points='9 21 3 21 3 15'/><line x1='21' y1='3' x2='14' y2='10'/><line x1='3' y1='21' x2='10' y2='14'/>"
+    );
+    const encoded = encodeURIComponent(svg);
+    const hotspot = Math.round(size / 2);
+    return `url("data:image/svg+xml,${encoded}") ${hotspot} ${hotspot}, zoom-in`;
+  });
+  const cursorCollapseUri = computed(() => {
+    const size = iconSize.value;
+    const svg = buildCursorSvg(
+      size,
+      "<polyline points='4 14 10 14 10 20'/><polyline points='20 10 14 10 14 4'/><line x1='14' y1='10' x2='21' y2='3'/><line x1='3' y1='21' x2='10' y2='14'/>"
+    );
+    const encoded = encodeURIComponent(svg);
+    const hotspot = Math.round(size / 2);
+    return `url("data:image/svg+xml,${encoded}") ${hotspot} ${hotspot}, zoom-out`;
+  });
+  const cursorVariables = computed(() => {
+    const isEnabled = toValue(enabled);
+    if (!isEnabled) return {};
+    return {
+      "--ncm-cursor-expand": cursorExpandUri.value,
+      "--ncm-cursor-collapse": cursorCollapseUri.value
+    };
+  });
+  return {
+    cursorVariables,
+    cursorExpandUri,
+    cursorCollapseUri
+  };
+}