@abraca/nuxt 2.0.0 → 2.0.3

package/dist/runtime/composables/useEmailVerification.js

@@ -1,58 +1,110 @@
 import { ref } from "vue";
-import { useAbracadabra } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
 const verified = ref(false);
-const isRequesting = ref(false);
-const isConfirming = ref(false);
-const error = ref(null);
 const lastSentAt = ref(null);
-async function request() {
-  const abra = useAbracadabra();
-  const client = abra.client.value;
-  if (!client) throw new Error("Not connected");
-  isRequesting.value = true;
-  error.value = null;
-  try {
-    await client.requestEmailVerification();
-    lastSentAt.value = Date.now();
-  } catch (e) {
-    error.value = e instanceof Error ? e.message : "Failed to send verification email";
-    throw e;
-  } finally {
-    isRequesting.value = false;
-  }
+const busy = ref(null);
+const error = ref(null);
+const lastSuccess = ref(null);
+function extractServerMessage(raw) {
+  const trailing = raw.replace(/ \(\d+\)$/, "").trim();
+  const colon = trailing.indexOf(": ");
+  if (colon === -1) return trailing;
+  const head = trailing.slice(0, colon);
+  if (/^[A-Z]+ \//.test(head)) return trailing.slice(colon + 2).trim();
+  return trailing;
 }
-async function confirm(token) {
-  const abra = useAbracadabra();
-  const client = abra.client.value;
-  if (!client) throw new Error("Not connected");
-  isConfirming.value = true;
-  error.value = null;
-  try {
-    await client.confirmEmailVerification(token);
-    verified.value = true;
-  } catch (e) {
-    error.value = e instanceof Error ? e.message : "Verification failed";
-    verified.value = false;
-    throw e;
-  } finally {
-    isConfirming.value = false;
+function classifyError(err) {
+  if (err instanceof TypeError && /fetch|network/i.test(err.message)) {
+    return { code: "network_error", message: err.message };
+  }
+  if (!(err instanceof Error)) {
+    return { code: "unknown", message: String(err) };
+  }
+  const status = err.status;
+  const serverMsg = extractServerMessage(err.message);
+  const lower = serverMsg.toLowerCase();
+  const retryMatch = lower.match(/retry(?:[-\s]?after)?[:\s]+(\d+)/);
+  const retryAfterSeconds = retryMatch ? Number(retryMatch[1]) : void 0;
+  if (status === 429) {
+    return { code: "rate_limited", message: serverMsg, status, retryAfterSeconds };
+  }
+  if (status === 410 || /token (?:expired|invalid)/.test(lower)) {
+    return {
+      code: lower.includes("expired") ? "token_expired" : "token_invalid",
+      message: serverMsg,
+      status
+    };
+  }
+  if (status === 404 || /verification (?:is )?disabled/.test(lower)) {
+    return { code: "verification_disabled", message: serverMsg, status };
+  }
+  if (lower.includes("already verified") || lower.includes("already_verified")) {
+    return { code: "already_verified", message: serverMsg, status };
   }
+  if (lower.includes("no email") || lower.includes("email not set") || lower.includes("email_not_set")) {
+    return { code: "email_not_set", message: serverMsg, status };
+  }
+  if (status === 401) return { code: "unauthorized", message: serverMsg, status };
+  if (status === 403) return { code: "forbidden", message: serverMsg, status };
+  if (typeof status === "number" && status >= 500) {
+    return { code: "server_error", message: serverMsg, status };
+  }
+  return { code: "unknown", message: serverMsg, status };
 }
 export function useEmailVerification() {
+  const abra = useAbracadabra();
+  function clearError() {
+    error.value = null;
+  }
+  async function run(action, fn) {
+    const client = abra.client.value;
+    if (!client) {
+      const err = { code: "network_error", message: "Not connected" };
+      error.value = err;
+      return { ok: false, error: err };
+    }
+    busy.value = action;
+    error.value = null;
+    try {
+      await fn(client);
+      lastSuccess.value = action;
+      return { ok: true };
+    } catch (e) {
+      const err = classifyError(e);
+      error.value = err;
+      return { ok: false, error: err };
+    } finally {
+      busy.value = null;
+    }
+  }
+  async function request() {
+    const res = await run("request", (client) => client.requestEmailVerification());
+    if (res.ok) lastSentAt.value = Date.now();
+    return res;
+  }
+  async function confirm(opts) {
+    const res = await run("confirm", (client) => client.confirmEmailVerification(opts.token));
+    if (res.ok) verified.value = true;
+    return res;
+  }
   return {
-    /** True after a successful `confirm()` in the current session. */
+    /** True after a successful `confirm()` in this session. */
     verified,
-    /** Whether a `request()` is in flight. */
-    isRequesting,
-    /** Whether a `confirm()` is in flight. */
-    isConfirming,
-    /** Last error message, or null. */
-    error,
     /** Epoch ms of the last successful `request()`, or null. */
     lastSentAt,
-    /** Send a verification email to the current user. Requires auth. */
+    /** Currently-running action, or null. */
+    busy,
+    /** Most recent typed error, or null. Cleared at the start of every action. */
+    error,
+    /** Most recent successful action, or null. */
+    lastSuccess,
+    /** Wipe `error` without re-running anything. */
+    clearError,
+    /** Send a verification email to the current user. Auth required. */
     request,
     /** Confirm a verification token from the email link. No auth required. */
-    confirm
+    confirm,
+    /** Internal helper exposed for testing. */
+    _classifyError: classifyError
   };
 }

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

@@ -0,0 +1,64 @@
+/** Known error codes raised by `usePasswordAuth()` actions. */
+export type PasswordAuthErrorCode = 'rate_limited' | 'locked_out' | 'password_too_short' | 'invalid_credentials' | 'token_expired' | 'token_invalid' | 'password_already_set' | 'email_taken' | 'username_taken' | 'password_login_disabled' | 'password_reset_disabled' | 'invite_required' | 'invite_invalid' | 'network_error' | 'forbidden' | 'unauthorized' | 'server_error' | 'unknown';
+export interface PasswordAuthError {
+    code: PasswordAuthErrorCode;
+    message: string;
+    /** HTTP status code, when the error came from the REST API. */
+    status?: number;
+    /** Seconds the caller should wait before retrying — only set for `rate_limited` / `locked_out`. */
+    retryAfterSeconds?: number;
+}
+export type PasswordAuthAction = 'login' | 'register' | 'reset-request' | 'reset-confirm' | 'change' | 'set';
+export interface PasswordAuthResult {
+    ok: boolean;
+    error?: PasswordAuthError;
+}
+declare function classifyError(err: unknown): PasswordAuthError;
+export declare function usePasswordAuth(): {
+    busy: import("vue").Ref<PasswordAuthAction | null, PasswordAuthAction | null>;
+    error: import("vue").Ref<{
+        code: PasswordAuthErrorCode;
+        message: string;
+        status?: number
+        /** Seconds the caller should wait before retrying — only set for `rate_limited` / `locked_out`. */
+         | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null, PasswordAuthError | {
+        code: PasswordAuthErrorCode;
+        message: string;
+        status?: number
+        /** Seconds the caller should wait before retrying — only set for `rate_limited` / `locked_out`. */
+         | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null>;
+    lastSuccess: import("vue").Ref<PasswordAuthAction | null, PasswordAuthAction | null>;
+    clearError: () => void;
+    login: (opts: {
+        username: string;
+        password: string;
+    }) => Promise<PasswordAuthResult>;
+    register: (opts: {
+        username: string;
+        password: string;
+        email?: string;
+        displayName?: string;
+        inviteCode?: string;
+    }) => Promise<PasswordAuthResult>;
+    requestReset: (opts: {
+        identifier: string;
+    }) => Promise<PasswordAuthResult>;
+    confirmReset: (opts: {
+        token: string;
+        newPassword: string;
+    }) => Promise<PasswordAuthResult>;
+    changePassword: (opts: {
+        currentPassword: string;
+        newPassword: string;
+    }) => Promise<PasswordAuthResult>;
+    setPassword: (opts: {
+        password: string;
+    }) => Promise<PasswordAuthResult>;
+    /** Internal helper exposed for testing — classify any error to its code. */
+    _classifyError: typeof classifyError;
+};
+export {};

package/dist/runtime/composables/usePasswordAuth.js

@@ -0,0 +1,126 @@
+import { ref } from "vue";
+import { useAbracadabraAuth } from "./useAbracadabraAuth.js";
+function extractServerMessage(raw) {
+  const trailing = raw.replace(/ \(\d+\)$/, "").trim();
+  const colon = trailing.indexOf(": ");
+  if (colon === -1) return trailing;
+  const head = trailing.slice(0, colon);
+  if (/^[A-Z]+ \//.test(head)) return trailing.slice(colon + 2).trim();
+  return trailing;
+}
+function classifyError(err) {
+  if (err instanceof TypeError && /fetch|network/i.test(err.message)) {
+    return { code: "network_error", message: err.message };
+  }
+  if (!(err instanceof Error)) {
+    return { code: "unknown", message: String(err) };
+  }
+  const status = err.status;
+  const serverMsg = extractServerMessage(err.message);
+  const lower = serverMsg.toLowerCase();
+  const retryMatch = lower.match(/retry(?:[-\s]?after)?[:\s]+(\d+)/);
+  const retryAfterSeconds = retryMatch ? Number(retryMatch[1]) : void 0;
+  if (status === 423) {
+    return { code: "locked_out", message: serverMsg, status, retryAfterSeconds };
+  }
+  if (status === 429) {
+    return { code: "rate_limited", message: serverMsg, status, retryAfterSeconds };
+  }
+  if (status === 410 || /token (?:expired|invalid)/.test(lower)) {
+    return {
+      code: lower.includes("expired") ? "token_expired" : "token_invalid",
+      message: serverMsg,
+      status
+    };
+  }
+  if (lower.includes("password too short")) {
+    return { code: "password_too_short", message: serverMsg, status };
+  }
+  if (lower.includes("password_already_set")) {
+    return { code: "password_already_set", message: serverMsg, status };
+  }
+  if (lower.includes("password login is disabled")) {
+    return { code: "password_login_disabled", message: serverMsg, status };
+  }
+  if (lower.includes("password reset disabled") || lower.includes("password reset is disabled")) {
+    return { code: "password_reset_disabled", message: serverMsg, status };
+  }
+  if (lower.includes("username") && (lower.includes("taken") || lower.includes("exists") || lower.includes("in use"))) {
+    return { code: "username_taken", message: serverMsg, status };
+  }
+  if (lower.includes("email") && (lower.includes("taken") || lower.includes("exists") || lower.includes("in use"))) {
+    return { code: "email_taken", message: serverMsg, status };
+  }
+  if (lower.includes("invite required") || lower.includes("invite is required")) {
+    return { code: "invite_required", message: serverMsg, status };
+  }
+  if (lower.includes("invite") && (lower.includes("invalid") || lower.includes("expired") || lower.includes("used"))) {
+    return { code: "invite_invalid", message: serverMsg, status };
+  }
+  if (status === 401 || lower.includes("unauthorized") || lower.includes("invalid credentials") || lower.includes("bad password")) {
+    return { code: status === 401 ? "unauthorized" : "invalid_credentials", message: serverMsg, status };
+  }
+  if (status === 403) {
+    return { code: "forbidden", message: serverMsg, status };
+  }
+  if (typeof status === "number" && status >= 500) {
+    return { code: "server_error", message: serverMsg, status };
+  }
+  return { code: "unknown", message: serverMsg, status };
+}
+export function usePasswordAuth() {
+  const auth = useAbracadabraAuth();
+  const busy = ref(null);
+  const error = ref(null);
+  const lastSuccess = ref(null);
+  function clearError() {
+    error.value = null;
+  }
+  async function run(action, fn) {
+    busy.value = action;
+    error.value = null;
+    try {
+      await fn();
+      lastSuccess.value = action;
+      return { ok: true };
+    } catch (e) {
+      const err = classifyError(e);
+      error.value = err;
+      return { ok: false, error: err };
+    } finally {
+      busy.value = null;
+    }
+  }
+  async function login(opts) {
+    return run("login", () => auth.loginWithPassword(opts));
+  }
+  async function register(opts) {
+    return run("register", () => auth.registerWithPassword(opts));
+  }
+  async function requestReset(opts) {
+    return run("reset-request", () => auth.requestPasswordReset(opts));
+  }
+  async function confirmReset(opts) {
+    return run("reset-confirm", () => auth.confirmPasswordReset(opts));
+  }
+  async function changePassword(opts) {
+    return run("change", () => auth.changePassword(opts));
+  }
+  async function setPassword(opts) {
+    return run("set", () => auth.setPassword(opts.password));
+  }
+  return {
+    busy,
+    error,
+    lastSuccess,
+    clearError,
+    login,
+    register,
+    requestReset,
+    confirmReset,
+    changePassword,
+    setPassword,
+    /** Internal helper exposed for testing — classify any error to its code. */
+    _classifyError: classifyError
+  };
+}

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

@@ -12,9 +12,9 @@
  *   const history = useTiptapHistory(editorRef)
  *   <UButton :disabled="!history.canUndo.value" @click="history.undo" />
  */
-import { type MaybeRef } from 'vue';
+import { type MaybeRefOrGetter } from 'vue';
 import type { Editor } from '@tiptap/vue-3';
-export declare function useTiptapHistory(editor: MaybeRef<Editor | null | undefined>): {
+export declare function useTiptapHistory(editor: MaybeRefOrGetter<Editor | null | undefined>): {
     canUndo: import("vue").ComputedRef<boolean>;
     canRedo: import("vue").ComputedRef<boolean>;
     undo: () => void;

package/dist/runtime/composables/useTiptapHistory.js

@@ -1,12 +1,12 @@
-import { computed, unref } from "vue";
+import { computed, toValue } from "vue";
 export function useTiptapHistory(editor) {
-  const canUndo = computed(() => !!unref(editor)?.can?.().undo?.());
-  const canRedo = computed(() => !!unref(editor)?.can?.().redo?.());
+  const canUndo = computed(() => !!toValue(editor)?.can?.().undo?.());
+  const canRedo = computed(() => !!toValue(editor)?.can?.().redo?.());
   function undo() {
-    unref(editor)?.commands?.undo?.();
+    toValue(editor)?.commands?.undo?.();
   }
   function redo() {
-    unref(editor)?.commands?.redo?.();
+    toValue(editor)?.commands?.redo?.();
   }
   return { canUndo, canRedo, undo, redo };
 }

package/dist/runtime/extensions/svg-embed.d.ts

@@ -0,0 +1,23 @@
+import { Node } from '@tiptap/core';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        svgEmbed: {
+            insertSvgEmbed: (attrs: {
+                svg?: string;
+                title?: string;
+                width?: string | null;
+                height?: string | null;
+            }) => ReturnType;
+        };
+    }
+}
+/**
+ * SVG embed extension.
+ *
+ * The extension itself has no peer dep. Sanitization happens inside the
+ * NodeView via `runtime/utils/sanitizeSvg.ts`, which try-imports DOMPurify
+ * and falls back to a strict built-in allowlist when DOMPurify isn't
+ * installed. Apps that need richer SVG features (animations, CSS) should
+ * `pnpm add dompurify`.
+ */
+export declare const SvgEmbed: Node<any, any>;

package/dist/runtime/extensions/svg-embed.js

@@ -0,0 +1,33 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import SvgEmbedView from "./views/SvgEmbedView.vue";
+export const SvgEmbed = Node.create({
+  name: "svgEmbed",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      svg: { default: "" },
+      title: { default: "" },
+      width: { default: null },
+      height: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="svg-embed"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "svg-embed" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(SvgEmbedView);
+  },
+  addCommands() {
+    return {
+      insertSvgEmbed: (attrs) => ({ commands }) => {
+        return commands.insertContent({ type: this.name, attrs });
+      }
+    };
+  }
+});

package/dist/runtime/extensions/views/MetaFieldView.vue

@@ -140,12 +140,23 @@ function onDateTimeRange(range) {
     [endKey.value]: `${dvToIso(range.end)}T${et}:00.000Z`
   });
 }
-function onStartTime(t2) {
+function asSingleTime(t2) {
+  if (t2 && typeof t2 === "object" && "hour" in t2 && "minute" in t2) {
+    const v = t2;
+    if (typeof v.hour === "number" && typeof v.minute === "number") {
+      return { hour: v.hour, minute: v.minute };
+    }
+  }
+  return null;
+}
+function onStartTime(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   const date = getStr(startKey.value).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   patch({ [startKey.value]: `${date}T${timeToHHMM(t2)}:00.000Z` });
 }
-function onEndTime(t2) {
+function onEndTime(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   const date = getStr(endKey.value).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   patch({ [endKey.value]: `${date}T${timeToHHMM(t2)}:00.000Z` });
@@ -257,15 +268,18 @@ function onSingleDatetimeDate(d) {
   const time = getStr(metaKey.value).slice(11, 16) || "00:00";
   patch({ [metaKey.value]: `${date}T${time}:00.000Z` });
 }
-function onSingleTime(t2) {
+function onSingleTime(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   patch({ [metaKey.value]: timeToHHMM(t2) });
 }
-function onTimeRangeStart(t2) {
+function onTimeRangeStart(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   patch({ [startKey.value]: timeToHHMM(t2) });
 }
-function onTimeRangeEnd(t2) {
+function onTimeRangeEnd(raw) {
+  const t2 = asSingleTime(raw);
   if (!t2) return;
   patch({ [endKey.value]: timeToHHMM(t2) });
 }
@@ -1089,7 +1103,10 @@ function removeOption(opt) {
             <UInputTime
               size="sm"
               :model-value="isoToTime(getStr(metaKey).slice(11, 16) || '00:00')"
-              @update:model-value="(t2) => t2 && patch({ [metaKey]: `${getStr(metaKey).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}T${timeToHHMM(t2)}:00.000Z` })"
+              @update:model-value="(raw) => {
+  const t2 = asSingleTime(raw);
+  if (t2) patch({ [metaKey]: `${getStr(metaKey).slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}T${timeToHHMM(t2)}:00.000Z` });
+}"
             />
           </div>
         </template>

package/dist/runtime/extensions/views/SvgEmbedView.d.vue.ts

@@ -0,0 +1,4 @@
+import type { NodeViewProps } from '@tiptap/vue-3';
+declare const __VLS_export: import("vue").DefineComponent<NodeViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NodeViewProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/extensions/views/SvgEmbedView.vue

@@ -0,0 +1,120 @@
+<script setup>
+import { ref, computed, watch, watchEffect } from "vue";
+import { NodeViewWrapper } from "@tiptap/vue-3";
+import { sanitizeSvg } from "../../utils/sanitizeSvg";
+const props = defineProps({
+  decorations: { type: Array, required: true },
+  selected: { type: Boolean, required: true },
+  updateAttributes: { type: Function, required: true },
+  deleteNode: { type: Function, required: true },
+  node: { type: null, required: true },
+  view: { type: null, required: true },
+  getPos: { type: null, required: true },
+  innerDecorations: { type: null, required: true },
+  editor: { type: Object, required: true },
+  extension: { type: Object, required: true },
+  HTMLAttributes: { type: Object, required: true }
+});
+const rawSvg = computed(() => props.node.attrs.svg || "");
+const title = computed(() => props.node.attrs.title || "");
+const hasSvg = computed(() => !!rawSvg.value);
+const sanitized = ref("");
+const isDragOver = ref(false);
+watchEffect(async () => {
+  sanitized.value = await sanitizeSvg(rawSvg.value);
+});
+const containerStyle = computed(() => {
+  const s = {};
+  if (props.node.attrs.width) s.width = String(props.node.attrs.width);
+  if (props.node.attrs.height) s.height = String(props.node.attrs.height);
+  return s;
+});
+function isSvgFile(file) {
+  return file.type === "image/svg+xml" || file.name.toLowerCase().endsWith(".svg");
+}
+async function loadSvgFile(file) {
+  const text = await file.text();
+  if (!text.includes("<svg")) return;
+  props.updateAttributes({
+    svg: text,
+    title: props.node.attrs.title || file.name.replace(/\.svg$/i, "")
+  });
+}
+function pickSvgFile() {
+  const input = document.createElement("input");
+  input.type = "file";
+  input.accept = ".svg,image/svg+xml";
+  input.onchange = () => {
+    const file = input.files?.[0];
+    if (file) loadSvgFile(file);
+  };
+  input.click();
+}
+function onDrop(e) {
+  e.preventDefault();
+  e.stopPropagation();
+  isDragOver.value = false;
+  const file = Array.from(e.dataTransfer?.files ?? []).find(isSvgFile);
+  if (file) loadSvgFile(file);
+}
+function onDragOver(e) {
+  e.preventDefault();
+  e.stopPropagation();
+  isDragOver.value = true;
+}
+function onDragLeave() {
+  isDragOver.value = false;
+}
+const placeholderText = computed(() => {
+  if (isDragOver.value) return "Drop SVG file here";
+  if (hasSvg.value && !sanitized.value) return "SVG removed by sanitizer";
+  return "Click or drop an SVG file";
+});
+</script>
+
+<template>
+  <NodeViewWrapper
+    class="svg-embed-wrapper my-3"
+    data-type="svg-embed"
+  >
+    <div
+      contenteditable="false"
+      data-drag-handle
+      class="border border-(--ui-border) rounded-md overflow-hidden transition-colors"
+      :class="{
+  'border-(--ui-primary) bg-(--ui-primary)/5': isDragOver,
+  'border-(--ui-primary)': props.selected && !isDragOver
+}"
+      @drop="onDrop"
+      @dragover="onDragOver"
+      @dragleave="onDragLeave"
+    >
+      <div
+        v-if="title && sanitized"
+        class="px-3 py-1.5 text-xs font-medium text-(--ui-text-dimmed) border-b border-(--ui-border) bg-(--ui-bg-elevated)"
+      >
+        {{ title }}
+      </div>
+      <div
+        v-if="sanitized"
+        class="flex items-center justify-center p-2 [&_svg]:max-w-full [&_svg]:h-auto"
+        :style="containerStyle"
+        v-html="sanitized"
+      />
+      <div
+        v-else
+        class="flex flex-col items-center justify-center gap-2 px-6 py-10 cursor-pointer text-(--ui-text-dimmed) hover:bg-(--ui-bg-elevated)/40 transition-colors"
+        role="button"
+        tabindex="0"
+        @click="pickSvgFile"
+        @keydown.enter="pickSvgFile"
+      >
+        <UIcon
+          name="i-lucide-image"
+          class="size-6"
+        />
+        <span class="text-sm">{{ placeholderText }}</span>
+      </div>
+    </div>
+  </NodeViewWrapper>
+</template>

package/dist/runtime/extensions/views/SvgEmbedView.vue.d.ts

@@ -0,0 +1,4 @@
+import type { NodeViewProps } from '@tiptap/vue-3';
+declare const __VLS_export: import("vue").DefineComponent<NodeViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<NodeViewProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;