@blokkli/editor 2.0.0-alpha.35 → 2.0.0-alpha.37

package/dist/modules/table-of-contents/index.d.mts

@@ -0,0 +1,11 @@
+import { B as BlokkliModule } from '../../shared/editor.BdBm1Z7C.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
+import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
+
+declare const _default: (options?: object) => BlokkliModule<object>;
+
+export { _default as default };

package/dist/modules/table-of-contents/index.mjs

@@ -0,0 +1,24 @@
+import { createResolver, addComponent } from '@nuxt/kit';
+import { d as defineBlokkliModule } from '../../shared/editor.CGf7C_0M.mjs';
+import { fileURLToPath } from 'node:url';
+
+const index = defineBlokkliModule({
+  setup(ctx) {
+    const moduleResolver = createResolver(
+      fileURLToPath(new URL("./", import.meta.url))
+    );
+    ctx.helper.addAlias(
+      "#blokkli/table-of-contents",
+      moduleResolver.resolve("./runtime/types")
+    );
+    addComponent({
+      filePath: moduleResolver.resolve(
+        "./runtime/components/BlokkliTableOfContents/index.vue"
+      ),
+      name: "BlokkliTableOfContents",
+      global: true
+    });
+  }
+});
+
+export { index as default };

package/dist/modules/table-of-contents/runtime/components/BlokkliTableOfContents/index.d.vue.ts

@@ -0,0 +1,44 @@
+import type { fromLibraryBlockBundle } from '#blokkli-build/config';
+import type { FieldListItemTyped } from '#blokkli-build/generated-types';
+import type { BlokkliTableOfContentsLink } from './../../types/index.js';
+type BundleWithoutLibrary = Exclude<FieldListItemTyped['bundle'], typeof fromLibraryBlockBundle>;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends BundleWithoutLibrary>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        /**
+         * Which bundles to include. This will also match reusable blocks of this bundle.
+         */
+        bundles: T[];
+        /**
+         * The name of the defineBlokkli option used to toggle if a block should be
+         * added to the table of contents.
+         *
+         * If not provided, all blocks are included.
+         */
+        optionName?: string;
+        /**
+         * Map a block item to a link.
+         */
+        mapItem: (item: Extract<FieldListItemTyped, {
+            bundle: T;
+        }>) => BlokkliTableOfContentsLink | null;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default(props: {
+            links: BlokkliTableOfContentsLink[];
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/modules/table-of-contents/runtime/components/BlokkliTableOfContents/index.vue

@@ -0,0 +1,43 @@
+<template>
+  <slot :links />
+</template>
+
+<script>
+
+</script>
+
+<script setup>
+import { falsy } from "#blokkli/helpers";
+import { getRuntimeOptions } from "#blokkli/helpers/runtimeHelpers";
+import { computed, useBlokkliHelper } from "#imports";
+import { BK_HIDDEN_GLOBALLY } from "./../../../../../global/constants";
+const props = defineProps({
+  bundles: { type: Array, required: true },
+  optionName: { type: String, required: false },
+  mapItem: { type: Function, required: true }
+});
+defineSlots();
+const { queryBlocks } = useBlokkliHelper();
+const items = queryBlocks(props.bundles);
+const links = computed(() => {
+  return items.value.filter((item) => {
+    if ("bundle" in item) {
+      const options = getRuntimeOptions(item);
+      if (!options) {
+        return null;
+      }
+      if (props.optionName) {
+        const shouldShow = options[props.optionName];
+        if (!shouldShow) {
+          return false;
+        }
+      }
+      const hiddenGlobally = options[BK_HIDDEN_GLOBALLY];
+      if (hiddenGlobally) {
+        return false;
+      }
+      return true;
+    }
+  }).map(props.mapItem).filter(falsy);
+});
+</script>

package/dist/modules/table-of-contents/runtime/components/BlokkliTableOfContents/index.vue.d.ts

@@ -0,0 +1,44 @@
+import type { fromLibraryBlockBundle } from '#blokkli-build/config';
+import type { FieldListItemTyped } from '#blokkli-build/generated-types';
+import type { BlokkliTableOfContentsLink } from './../../types/index.js';
+type BundleWithoutLibrary = Exclude<FieldListItemTyped['bundle'], typeof fromLibraryBlockBundle>;
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: <T extends BundleWithoutLibrary>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        /**
+         * Which bundles to include. This will also match reusable blocks of this bundle.
+         */
+        bundles: T[];
+        /**
+         * The name of the defineBlokkli option used to toggle if a block should be
+         * added to the table of contents.
+         *
+         * If not provided, all blocks are included.
+         */
+        optionName?: string;
+        /**
+         * Map a block item to a link.
+         */
+        mapItem: (item: Extract<FieldListItemTyped, {
+            bundle: T;
+        }>) => BlokkliTableOfContentsLink | null;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default(props: {
+            links: BlokkliTableOfContentsLink[];
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/modules/table-of-contents/runtime/types/index.d.ts

@@ -0,0 +1,4 @@
+export type BlokkliTableOfContentsLink = {
+    id: string;
+    label: string;
+};

package/dist/runtime/components/Blocks/Fragment/index.vue

@@ -19,12 +19,16 @@ const ctx = defineBlokkli({
     disableEdit: true
   }
 });
+const providerType = ctx.provider.value?.providerType;
 const allComponentsChunk = inject(INJECT_ALL_COMPONENTS_CHUNK, null);
 const component = getComponent(
   "fragment",
   componentProps.name,
-  void 0,
-  void 0,
+  {
+    fieldListType: void 0,
+    parentBundle: void 0,
+    providerType
+  },
   allComponentsChunk
 );
 provide(INJECT_FRAGMENT_CONTEXT, ctx);

package/dist/runtime/components/BlokkliItem.vue

@@ -33,7 +33,8 @@ import {
   INJECT_FIELD_PROXY_MODE,
   INJECT_FIELD_USES_PROXY,
   INJECT_GLOBAL_PROXY_MODE,
-  INJECT_ITEM_PROPS_OVERRIDE
+  INJECT_ITEM_PROPS_OVERRIDE,
+  INJECT_PROVIDER_TYPE
 } from "../helpers/injections";
 import { fragmentBlockBundle, itemEntityType } from "#blokkli-build/config";
 const componentProps = defineProps({
@@ -53,8 +54,9 @@ const allComponentsChunk = inject(INJECT_ALL_COMPONENTS_CHUNK, null);
 const fieldUsesProxy = inject(INJECT_FIELD_USES_PROXY, false);
 const isGlobalProxyMode = inject(INJECT_GLOBAL_PROXY_MODE, null);
 const fieldListType = inject(INJECT_FIELD_LIST_TYPE, void 0);
+const providerType = inject(INJECT_PROVIDER_TYPE, void 0);
 const itemProps = computed(() => {
-  if (mutatedItemProps) {
+  if (mutatedItemProps && componentProps.isEditing) {
     const mutatedProps = mutatedItemProps[componentProps.uuid];
     if (mutatedProps) {
       return {
@@ -70,8 +72,11 @@ const component = isProxyMode || isGlobalProxyMode?.value ? defineAsyncComponent
 ) : getComponent(
   "block",
   componentProps.bundle,
-  fieldListType?.value || "default",
-  componentProps.parentType,
+  {
+    fieldListType: fieldListType?.value || "default",
+    parentBundle: componentProps.parentType,
+    providerType
+  },
   allComponentsChunk
 );
 const blockNotImplemented = componentProps.isEditing ? defineAsyncComponent(() => import("./Blocks/NotImplemented/index.vue")) : null;

package/dist/runtime/components/BlokkliProvider.d.vue.ts

@@ -1,4 +1,5 @@
 import type { EditPermission } from '#blokkli/types/provider';
+import type { ValidProviderTypes } from '#blokkli-build/generated-types';
 declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         /**
@@ -41,6 +42,12 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
          * Whether to isolate the provider element during editing.
          */
         isolate?: boolean;
+        /**
+         * The provider type.
+         *
+         * @default "default"
+         */
+        providerType?: ValidProviderTypes;
     } & ({
         /**
          * The entity data. Will be merged with the mutatedEntity data during editing.

package/dist/runtime/components/BlokkliProvider.vue

@@ -15,6 +15,7 @@
         :entity-uuid
         :entity-bundle
         :language
+        :provider-type
       >
         <slot
           :entity="mutatedEntity"
@@ -34,6 +35,7 @@
         :language
         :isolate
         :permissions
+        :provider-type
       >
         <slot
           :is-editing
@@ -78,7 +80,8 @@ import {
 } from "#imports";
 import {
   INJECT_ENTITY_CONTEXT,
-  INJECT_PROVIDER_CONTEXT
+  INJECT_PROVIDER_CONTEXT,
+  INJECT_PROVIDER_TYPE
 } from "../helpers/injections";
 const props = defineProps({
   entityType: { type: String, required: true },
@@ -91,6 +94,7 @@ const props = defineProps({
   hostOptions: { type: Object, required: false, default: void 0 },
   permissions: { type: Array, required: false, default: () => [] },
   isolate: { type: Boolean, required: false },
+  providerType: { type: null, required: false, default: "default" },
   entity: { type: null, required: false, default: void 0 }
 });
 defineSlots();
@@ -136,6 +140,7 @@ function edit() {
 const blokkliProviderEntityContext = computed(
   () => {
     return {
+      providerType: props.providerType,
       uuid: props.entityUuid,
       type: props.entityType,
       bundle: props.entityBundle,
@@ -152,6 +157,7 @@ const entityContext = computed(() => {
 });
 provide(INJECT_PROVIDER_CONTEXT, blokkliProviderEntityContext);
 provide(INJECT_ENTITY_CONTEXT, entityContext.value);
+provide(INJECT_PROVIDER_TYPE, props.providerType);
 onMounted(() => {
   shouldRender.value = true;
 });

package/dist/runtime/components/BlokkliProvider.vue.d.ts

@@ -1,4 +1,5 @@
 import type { EditPermission } from '#blokkli/types/provider';
+import type { ValidProviderTypes } from '#blokkli-build/generated-types';
 declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
     props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         /**
@@ -41,6 +42,12 @@ declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
          * Whether to isolate the provider element during editing.
          */
         isolate?: boolean;
+        /**
+         * The provider type.
+         *
+         * @default "default"
+         */
+        providerType?: ValidProviderTypes;
     } & ({
         /**
          * The entity data. Will be merged with the mutatedEntity data during editing.

package/dist/runtime/composables/defineBlokkli.js

@@ -92,7 +92,7 @@ export function defineBlokkli(arg) {
   }
   if (editContext?.useBlockRegistration && editContext.dom && bundle !== fromLibraryBlockBundle && bundle !== fragmentBlockBundle) {
     const isProxyMode = inject(INJECT_FIELD_USES_PROXY, false);
-    if (!isProxyMode) {
+    if (!isProxyMode && isEditing) {
       editContext.useBlockRegistration(editContext.dom, reusableUuid ?? uuid);
     }
   }

package/dist/runtime/composables/useBlokkliHelper.js

@@ -32,8 +32,10 @@ function walkBlocks(matches, callback, mutatedOptions, mutatedFieldsMap, list) {
     if (!("props" in mappedItem) || !mappedItem.props) continue;
     const propNames = Object.keys(nestedFieldMapping);
     for (const propName of propNames) {
-      const fieldName = nestedFieldMapping[propName];
-      const key = mappedItem.uuid + ":" + fieldName;
+      const mapping = nestedFieldMapping[propName];
+      if (!mapping) continue;
+      if (mapping[0] !== "field") continue;
+      const key = mappedItem.uuid + ":" + mapping[1];
       const value = mutatedFieldsMap ? mutatedFieldsMap[key]?.list : mappedItem.props?.[propName];
       if (!value) continue;
       const valueAsArray = Array.isArray(value) ? value : [value];

package/dist/runtime/editor/components/AnimationCanvas/index.vue

@@ -43,7 +43,8 @@ const {
   animation,
   state,
   directive,
-  blocks
+  blocks,
+  fields
 } = useBlokkli();
 function onCanvasFocus() {
   ui.setCanvasFocused(true);
@@ -78,22 +79,12 @@ let pointerDownElement = null;
 let mouseStartCoordinates = null;
 let pointerDownTimestamp = 0;
 let pointerUpTimestamp = 0;
-function getFieldZIndex(uuid) {
-  const fieldKey = state.getFieldKeyForUuid(uuid);
-  if (!fieldKey) {
-    return 0;
-  }
-  const separatorIndex = fieldKey.indexOf(":");
-  const entityUuid = fieldKey.substring(0, separatorIndex);
-  const fieldName = fieldKey.substring(separatorIndex + 1);
-  return dom.getRegisteredField(entityUuid, fieldName)?.zIndex ?? 0;
-}
+let pointerDownOnCanvas = false;
 function getInteractedElement(e) {
   const { x, y } = getInteractionCoordinates(e);
   const visibleUuids = dom.getVisibleBlocks();
   let deepestUuid = "";
   let deepestLevel = -1;
-  let deepestZIndex = 0;
   for (let i = 0; i < visibleUuids.length; i++) {
     const uuid = visibleUuids[i];
     if (!uuid) {
@@ -114,13 +105,8 @@ function getInteractedElement(e) {
     if (level > deepestLevel) {
       deepestUuid = uuid;
       deepestLevel = level;
-      deepestZIndex = getFieldZIndex(uuid);
-    } else {
-      const zIndex = getFieldZIndex(uuid);
-      if (zIndex > deepestZIndex) {
-        deepestUuid = uuid;
-        deepestZIndex = zIndex;
-      }
+    } else if (fields.compareFieldPriority(uuid, deepestUuid) > 0) {
+      deepestUuid = uuid;
     }
   }
   const editableField = directive.getEditableAtPoint(x, y);
@@ -159,7 +145,7 @@ function onPointerMove(e) {
   if (!handlePointerMove) {
     return;
   }
-  if (keyboard.isPressingSpace.value || e.buttons === MOUSE_BUTTONS.AUXILIARY) {
+  if (keyboard.isPressingSpace.value || e.buttons & MOUSE_BUTTONS.AUXILIARY) {
     return;
   }
   e.preventDefault();
@@ -216,9 +202,10 @@ function onPointerMove(e) {
   }
 }
 function onPointerDown(e) {
-  if (e.buttons === MOUSE_BUTTONS.AUXILIARY) {
+  if (e.buttons & MOUSE_BUTTONS.AUXILIARY) {
     return;
   }
+  pointerDownOnCanvas = true;
   if (canvasEl.value) {
     canvasEl.value.focus();
   }
@@ -266,15 +253,15 @@ function isClickInArtboard(coords) {
   return isInsideRect(coords.x, coords.y, rect);
 }
 function onPointerUp(e) {
-  handlePointerMove = false;
   if (e.button === MOUSE_BUTTON.AUXILIARY) {
     e.preventDefault();
     return;
   }
+  handlePointerMove = false;
   e.preventDefault();
   e.stopPropagation();
   e.stopImmediatePropagation();
-  if (ui.openTooltip.value) {
+  if (ui.openTooltip.value && !selection.activeEditableLabel.value) {
     ui.openTooltip.value = "";
     return;
   }
@@ -304,8 +291,11 @@ function onPointerUp(e) {
     return;
   }
   if (selection.activeEditableLabel.value) {
-    eventBus.emit("window:clickAway");
-    lastInteractedElement = null;
+    if (pointerDownOnCanvas) {
+      eventBus.emit("window:clickAway");
+      lastInteractedElement = null;
+    }
+    pointerDownOnCanvas = false;
     return;
   }
   if (animation.handleClick(e.clientX, e.clientY)) {
@@ -318,6 +308,7 @@ function onPointerUp(e) {
     const deltaY = Math.abs(lastInteractedElement.y - e.clientY);
     if (deltaTime < 400 && deltaX < 3 && deltaY < 3) {
       if (clicked.editableFieldName) {
+        pointerDownOnCanvas = false;
         eventBus.emit("editable:focus", {
           fieldName: clicked.editableFieldName,
           uuid: clicked.uuid
@@ -342,7 +333,6 @@ function onPointerUp(e) {
     } else if (keyboard.isPressingShift.value) {
       eventBus.emit("select:shiftToggle", clicked.uuid);
     } else {
-      console.log("asdfasdf");
       eventBus.emit("select", clicked.uuid);
     }
     return;
@@ -464,7 +454,7 @@ function onClick(e) {
   e.preventDefault();
   e.stopImmediatePropagation();
   e.stopPropagation();
-  if (canvasEl.value) {
+  if (canvasEl.value && !selection.activeEditableLabel.value) {
     canvasEl.value.focus();
   }
 }

package/dist/runtime/editor/components/Banner/index.d.vue.ts

@@ -3,17 +3,28 @@ import type { ThemeColorName } from './../../../../global/types/theme.js';
 type __VLS_Props = {
     id: string;
     icon: BlokkliIcon;
-    text: string;
+    text?: string;
     button?: string;
     scheme?: ThemeColorName;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     click: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: (() => any) | undefined;
 }>, {
+    text: string;
     button: string;
     scheme: ThemeColorName;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/editor/components/Banner/index.vue

@@ -5,7 +5,9 @@
     :class="scheme ? 'bk-scheme-' + scheme : void 0"
   >
     <Icon :name="icon" />
-    <p v-html="text" />
+    <slot>
+      <p v-if="text" v-html="text" />
+    </slot>
     <button v-if="button" class="bk-banner-close" @click="$emit('click')">
       {{ button }}
       <Icon name="bk_mdi_close" />
@@ -24,7 +26,7 @@ import {
 const props = defineProps({
   id: { type: String, required: true },
   icon: { type: null, required: true },
-  text: { type: String, required: true },
+  text: { type: String, required: false, default: void 0 },
   button: { type: String, required: false, default: void 0 },
   scheme: { type: String, required: false, default: "accent" }
 });

package/dist/runtime/editor/components/Banner/index.vue.d.ts

@@ -3,17 +3,28 @@ import type { ThemeColorName } from './../../../../global/types/theme.js';
 type __VLS_Props = {
     id: string;
     icon: BlokkliIcon;
-    text: string;
+    text?: string;
     button?: string;
     scheme?: ThemeColorName;
 };
-declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     click: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: (() => any) | undefined;
 }>, {
+    text: string;
     button: string;
     scheme: ThemeColorName;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/editor/components/Dropdown/index.d.vue.ts

@@ -0,0 +1,27 @@
+type __VLS_Props = {
+    position?: 'bottom-left' | 'top-left' | 'top-right';
+    disabled?: boolean;
+};
+declare function close(): void;
+declare var __VLS_1: {}, __VLS_9: {
+    close: typeof close;
+};
+type __VLS_Slots = {} & {
+    button?: (props: typeof __VLS_1) => any;
+} & {
+    default?: (props: typeof __VLS_9) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    close: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    disabled: boolean;
+    position: "bottom-left" | "top-left" | "top-right";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};