@poveste/vendors 0.2.1 → 0.3.0

package/dist/client/b-vue.js

@@ -1 +1 @@
-export { aq as BaseTransition, ar as BaseTransitionPropsValidators, as as Comment, at as DeprecationTypes, bB as EffectScope, au as ErrorCodes, av as ErrorTypeStrings, F as Fragment, aw as KeepAlive, bC as ReactiveEffect, ax as Static, ay as Suspense, az as Teleport, aA as Text, bD as TrackOpTypes, a5 as Transition, a0 as TransitionGroup, bE as TriggerOpTypes, a6 as VueElement, aB as assertNumber, aC as callWithAsyncErrorHandling, aD as callWithErrorHandling, bO as camelize, bP as capitalize, aE as cloneVNode, aF as compatUtils, a4 as compile, L as computed, v as createApp, f as createBlock, l as createCommentVNode, c as createElementBlock, h as createElementVNode, aG as createHydrationRenderer, aH as createPropsRestProxy, aI as createRenderer, a7 as createSSRApp, aJ as createSlots, aK as createStaticVNode, aL as createTextVNode, s as createVNode, X as customRef, aM as defineAsyncComponent, d as defineComponent, a8 as defineCustomElement, aN as defineEmits, aO as defineExpose, aP as defineModel, aQ as defineOptions, aR as defineProps, a9 as defineSSRCustomElement, aS as defineSlots, aT as devtools, bF as effect, E as effectScope, O as getCurrentInstance, I as getCurrentScope, bG as getCurrentWatcher, aU as getTransitionRawChildren, g as guardReactiveProps, x as h, aV as handleError, y as hasInjectionContext, aa as hydrate, aW as hydrateOnIdle, aX as hydrateOnInteraction, aY as hydrateOnMediaQuery, aZ as hydrateOnVisible, a_ as initCustomFormatter, ab as initDirectivesForSSR, z as inject, a$ as isMemoSame, bH as isProxy, H as isReactive, a2 as isReadonly, G as isRef, b0 as isRuntimeOnly, bI as isShallow, b1 as isVNode, D as markRaw, b2 as mergeDefaults, b3 as mergeModels, m as mergeProps, b as nextTick, ac as nodeOps, n as normalizeClass, a as normalizeProps, k as normalizeStyle, R as onActivated, Z as onBeforeMount, _ as onBeforeUnmount, a3 as onBeforeUpdate, Q as onDeactivated, b4 as onErrorCaptured, $ as onMounted, b5 as onRenderTracked, b6 as onRenderTriggered, J as onScopeDispose, b7 as onServerPrefetch, P as onUnmounted, a1 as onUpdated, bJ as onWatcherCleanup, o as openBlock, ad as patchProp, e as popScopeId, T as provide, bK as proxyRefs, p as pushScopeId, b8 as queuePostFlushCb, M as reactive, W as readonly, u as ref, b9 as registerRuntimeCompiler, ae as render, ba as renderList, r as renderSlot, i as resolveComponent, bb as resolveDirective, bc as resolveDynamicComponent, bd as resolveFilter, be as resolveTransitionHooks, bf as setBlockTracking, bg as setDevtoolsHook, bh as setTransitionHooks, V as shallowReactive, bL as shallowReadonly, U as shallowRef, bi as ssrContextKey, bj as ssrUtils, bM as stop, t as toDisplayString, bQ as toHandlerKey, bk as toHandlers, A as toRaw, N as toRef, K as toRefs, Y as toValue, bl as transformVNodeArgs, bN as triggerRef, C as unref, bm as useAttrs, af as useCssModule, ag as useCssVars, ah as useHost, bn as useId, bo as useModel, bp as useSSRContext, ai as useShadowRoot, bq as useSlots, br as useTemplateRef, bs as useTransitionState, aj as vModelCheckbox, ak as vModelDynamic, al as vModelRadio, am as vModelSelect, an as vModelText, ao as vShow, bt as version, bu as warn, B as watch, S as watchEffect, bv as watchPostEffect, bw as watchSyncEffect, bx as withAsyncContext, q as withCtx, by as withDefaults, bz as withDirectives, j as withKeys, bA as withMemo, ap as withModifiers, w as withScopeId } from './vue.runtime.esm-bundler.js';
+export { a5 as BaseTransition, a6 as BaseTransitionPropsValidators, a7 as Comment, a8 as DeprecationTypes, a9 as EffectScope, aa as ErrorCodes, ab as ErrorTypeStrings, F as Fragment, ac as KeepAlive, ad as ReactiveEffect, ae as Static, af as Suspense, ag as Teleport, ah as Text, ai as TrackOpTypes, aj as Transition, a1 as TransitionGroup, ak as TriggerOpTypes, al as VueElement, am as assertNumber, an as callWithAsyncErrorHandling, ao as callWithErrorHandling, ap as camelize, aq as capitalize, ar as cloneVNode, as as compatUtils, at as compile, L as computed, v as createApp, f as createBlock, l as createCommentVNode, c as createElementBlock, h as createElementVNode, au as createHydrationRenderer, av as createPropsRestProxy, aw as createRenderer, ax as createSSRApp, ay as createSlots, az as createStaticVNode, aA as createTextVNode, s as createVNode, X as customRef, aB as defineAsyncComponent, d as defineComponent, aC as defineCustomElement, aD as defineEmits, aE as defineExpose, aF as defineModel, aG as defineOptions, aH as defineProps, aI as defineSSRCustomElement, aJ as defineSlots, aK as devtools, aL as effect, E as effectScope, O as getCurrentInstance, I as getCurrentScope, aM as getCurrentWatcher, aN as getTransitionRawChildren, g as guardReactiveProps, x as h, aO as handleError, y as hasInjectionContext, aP as hydrate, aQ as hydrateOnIdle, aR as hydrateOnInteraction, aS as hydrateOnMediaQuery, aT as hydrateOnVisible, aU as initCustomFormatter, aV as initDirectivesForSSR, z as inject, aW as isMemoSame, aX as isProxy, H as isReactive, a3 as isReadonly, G as isRef, aY as isRuntimeOnly, aZ as isShallow, a_ as isVNode, D as markRaw, a$ as mergeDefaults, b0 as mergeModels, m as mergeProps, b as nextTick, b1 as nodeOps, n as normalizeClass, a as normalizeProps, k as normalizeStyle, R as onActivated, _ as onBeforeMount, $ as onBeforeUnmount, a4 as onBeforeUpdate, Q as onDeactivated, b2 as onErrorCaptured, a0 as onMounted, b3 as onRenderTracked, b4 as onRenderTriggered, J as onScopeDispose, b5 as onServerPrefetch, P as onUnmounted, a2 as onUpdated, b6 as onWatcherCleanup, o as openBlock, b7 as patchProp, e as popScopeId, T as provide, b8 as proxyRefs, p as pushScopeId, b9 as queuePostFlushCb, M as reactive, W as readonly, u as ref, ba as registerRuntimeCompiler, bb as render, bc as renderList, r as renderSlot, i as resolveComponent, bd as resolveDirective, be as resolveDynamicComponent, bf as resolveFilter, bg as resolveTransitionHooks, bh as setBlockTracking, bi as setDevtoolsHook, bj as setTransitionHooks, V as shallowReactive, Z as shallowReadonly, U as shallowRef, bk as ssrContextKey, bl as ssrUtils, bm as stop, t as toDisplayString, bn as toHandlerKey, bo as toHandlers, A as toRaw, N as toRef, K as toRefs, Y as toValue, bp as transformVNodeArgs, bq as triggerRef, C as unref, br as useAttrs, bs as useCssModule, bt as useCssVars, bu as useHost, bv as useId, bw as useModel, bx as useSSRContext, by as useShadowRoot, bz as useSlots, bA as useTemplateRef, bB as useTransitionState, bC as vModelCheckbox, bD as vModelDynamic, bE as vModelRadio, bF as vModelSelect, bG as vModelText, bH as vShow, bI as version, bJ as warn, B as watch, S as watchEffect, bK as watchPostEffect, bL as watchSyncEffect, bM as withAsyncContext, q as withCtx, bN as withDefaults, bO as withDirectives, j as withKeys, bP as withMemo, bQ as withModifiers, w as withScopeId } from './vue.runtime.esm-bundler.js';

package/dist/client/node_modules/@vue/compiler-core/dist/compiler-core.d.ts

@@ -1,6 +1,6 @@
 import { PatchFlags } from '@vue/shared';
 export { generateCodeFrame } from '@vue/shared';
-import { Node as Node$1, Identifier, Function, BlockStatement as BlockStatement$1, SwitchCase, Program, ObjectProperty } from '@babel/types';
+import { Node as Node$1, Identifier, Function, ObjectProperty, BlockStatement as BlockStatement$1, SwitchCase, Program } from '@babel/types';
 import { ParserPlugin } from '@babel/parser';
 
 export declare const FRAGMENT: unique symbol;
@@ -122,6 +122,7 @@ export interface TransformContext extends Required<Omit<TransformOptions, keyof
     hoist(exp: string | JSChildNode | ArrayExpression): SimpleExpressionNode;
     cache(exp: JSChildNode, isVNode?: boolean, inVOnce?: boolean): CacheExpression;
     constantCache: WeakMap<TemplateChildNode, ConstantTypes>;
+    vForMemoKeyedNodes: WeakSet<ElementNode>;
     filters?: Set<string>;
 }
 export declare function createTransformContext(root: RootNode, { filename, prefixIdentifiers, hoistStatic, hmr, cacheHandlers, nodeTransforms, directiveTransforms, transformHoist, isBuiltInComponent, isCustomElement, expressionPlugins, scopeId, slotted, ssr, inSSR, ssrCssVars, bindingMetadata, inline, isTS, onError, onWarn, compatConfig, }: TransformOptions): TransformContext;
@@ -138,6 +139,8 @@ export declare function buildProps(node: ElementNode, context: TransformContext,
     patchFlag: number;
     dynamicPropNames: string[];
     shouldUseBlock: boolean;
+    needsPatch: boolean;
+    isBlockRequired: boolean;
 };
 export declare function buildDirectiveArgs(dir: DirectiveNode, context: TransformContext): ArrayExpression;
 
@@ -375,6 +378,10 @@ export interface VNodeCall extends Node {
     patchFlag: PatchFlags | undefined;
     dynamicProps: string | SimpleExpressionNode | undefined;
     directives: DirectiveArguments | undefined;
+    /** Whether this vnode must be patched if a later transform makes it non-block. */
+    needsPatch?: boolean;
+    /** Whether a later transform must preserve this vnode as a block. */
+    isBlockRequired?: boolean;
     isBlock: boolean;
     disableTracking: boolean;
     isComponent: boolean;
@@ -473,11 +480,24 @@ export interface DirectiveArgumentNode extends ArrayExpression {
 }
 export interface RenderSlotCall extends CallExpression {
     callee: typeof RENDER_SLOT;
-    arguments: [string, string | ExpressionNode] | [string, string | ExpressionNode, PropsExpression] | [
+    arguments: [string, string | ExpressionNode] | [string, string | ExpressionNode, PropsExpression | '{}'] | [
         string,
         string | ExpressionNode,
         PropsExpression | '{}',
-        TemplateChildNode[]
+        FunctionExpression | string
+    ] | [
+        string,
+        string | ExpressionNode,
+        PropsExpression | '{}',
+        FunctionExpression | string,
+        string
+    ] | [
+        string,
+        string | ExpressionNode,
+        PropsExpression | '{}',
+        FunctionExpression | string,
+        string,
+        JSChildNode
     ];
 }
 export type SlotsExpression = SlotsObjectExpression | DynamicSlotsExpression;
@@ -948,7 +968,7 @@ export type CompilerOptions = ParserOptions & TransformOptions & CodegenOptions;
  *
  * Since TS 5.3, dts generation starts to strangely include broken triple slash
  * references for source-map-js, so we are inlining all source map related types
- * here to to workaround that.
+ * here to workaround that.
  */
 export interface CodegenSourceMapGenerator {
     setSourceContent(sourceFile: string, sourceContent: string): void;

package/dist/client/node_modules/@vue/compiler-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-core",
-  "version": "3.5.26",
+  "version": "3.5.41",
   "description": "@vue/compiler-core",
   "main": "index.js",
   "module": "dist/compiler-core.esm-bundler.js",
@@ -46,13 +46,13 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-core#readme",
   "dependencies": {
-    "@babel/parser": "^7.28.5",
-    "entities": "^7.0.0",
+    "@babel/parser": "^7.29.8",
+    "entities": "^7.0.1",
     "estree-walker": "^2.0.2",
     "source-map-js": "^1.2.1",
-    "@vue/shared": "3.5.26"
+    "@vue/shared": "3.5.41"
   },
   "devDependencies": {
-    "@babel/types": "^7.28.5"
+    "@babel/types": "^7.29.8"
   }
 }

package/dist/client/node_modules/@vue/compiler-dom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-dom",
-  "version": "3.5.26",
+  "version": "3.5.41",
   "description": "@vue/compiler-dom",
   "main": "index.js",
   "module": "dist/compiler-dom.esm-bundler.js",
@@ -51,7 +51,7 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-dom#readme",
   "dependencies": {
-    "@vue/compiler-core": "3.5.26",
-    "@vue/shared": "3.5.26"
+    "@vue/shared": "3.5.41",
+    "@vue/compiler-core": "3.5.41"
   }
 }

package/dist/client/node_modules/@vue/compiler-sfc/dist/compiler-sfc.d.ts

@@ -415,11 +415,13 @@ export type SimpleTypeResolveOptions = Partial<Pick<SFCScriptCompileOptions, 'gl
  * }
  * ```
  */
-export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl' | 'isCE'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
+export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'warn' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl' | 'isCE'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
     ast: Statement[];
     options: SimpleTypeResolveOptions;
 };
-export type TypeResolveContext = ScriptCompileContext | SimpleTypeResolveContext;
+export type TypeResolveContext = (ScriptCompileContext | SimpleTypeResolveContext) & {
+    silentOnExtendsFailure?: boolean;
+};
 type Import = Pick<ImportBinding, 'source' | 'imported'>;
 interface WithScope {
     _ownerScope: TypeScope;

package/dist/client/node_modules/@vue/compiler-sfc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "3.5.26",
+  "version": "3.5.41",
   "description": "@vue/compiler-sfc",
   "main": "dist/compiler-sfc.cjs.js",
   "module": "dist/compiler-sfc.esm-browser.js",
@@ -42,26 +42,26 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-sfc#readme",
   "dependencies": {
-    "@babel/parser": "^7.28.5",
+    "@babel/parser": "^7.29.8",
     "estree-walker": "^2.0.2",
     "magic-string": "^0.30.21",
-    "postcss": "^8.5.6",
+    "postcss": "^8.5.19",
     "source-map-js": "^1.2.1",
-    "@vue/compiler-core": "3.5.26",
-    "@vue/compiler-dom": "3.5.26",
-    "@vue/compiler-ssr": "3.5.26",
-    "@vue/shared": "3.5.26"
+    "@vue/compiler-core": "3.5.41",
+    "@vue/shared": "3.5.41",
+    "@vue/compiler-dom": "3.5.41",
+    "@vue/compiler-ssr": "3.5.41"
   },
   "devDependencies": {
-    "@babel/types": "^7.28.5",
+    "@babel/types": "^7.29.8",
     "@vue/consolidate": "^1.0.0",
     "hash-sum": "^2.0.0",
     "lru-cache": "10.1.0",
     "merge-source-map": "^1.1.0",
-    "minimatch": "~10.1.1",
+    "minimatch": "~10.2.6",
     "postcss-modules": "^6.0.1",
-    "postcss-selector-parser": "^7.1.0",
-    "pug": "^3.0.3",
-    "sass": "^1.96.0"
+    "postcss-selector-parser": "^7.1.4",
+    "pug": "^3.0.4",
+    "sass": "^1.102.0"
   }
 }

package/dist/client/node_modules/@vue/compiler-ssr/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-ssr",
-  "version": "3.5.26",
+  "version": "3.5.41",
   "description": "@vue/compiler-ssr",
   "main": "dist/compiler-ssr.cjs.js",
   "types": "dist/compiler-ssr.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-ssr#readme",
   "dependencies": {
-    "@vue/shared": "3.5.26",
-    "@vue/compiler-dom": "3.5.26"
+    "@vue/shared": "3.5.41",
+    "@vue/compiler-dom": "3.5.41"
   }
 }

package/dist/client/node_modules/@vue/reactivity/dist/reactivity.d.ts

@@ -42,10 +42,11 @@ export type Reactive<T> = UnwrapNestedRefs<T> & (T extends readonly any[] ? Reac
  * @see {@link https://vuejs.org/api/reactivity-core.html#reactive}
  */
 export declare function reactive<T extends object>(target: T): Reactive<T>;
-declare const ShallowReactiveMarker: unique symbol;
-export type ShallowReactive<T> = T & {
-    [ShallowReactiveMarker]?: true;
-};
+declare class ShallowReactiveBrandClass {
+    private __shallowReactiveBrand?;
+}
+type ShallowReactiveBrand = ShallowReactiveBrandClass;
+export type ShallowReactive<T> = T & ShallowReactiveBrand;
 /**
  * Shallow version of {@link reactive}.
  *
@@ -533,9 +534,9 @@ export declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
  * that contains refs.
  */
 export declare function proxyRefs<T extends object>(objectWithRefs: T): ShallowUnwrapRef<T>;
-export type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
+export type CustomRefFactory<T, S = T> = (track: () => void, trigger: () => void) => {
     get: () => T;
-    set: (value: T) => void;
+    set: (value: S) => void;
 };
 /**
  * Creates a customized ref with explicit control over its dependency tracking
@@ -544,10 +545,13 @@ export type CustomRefFactory<T> = (track: () => void, trigger: () => void) => {
  * @param factory - The function that receives the `track` and `trigger` callbacks.
  * @see {@link https://vuejs.org/api/reactivity-advanced.html#customref}
  */
-export declare function customRef<T>(factory: CustomRefFactory<T>): Ref<T>;
+export declare function customRef<T, S = T>(factory: CustomRefFactory<T, S>): Ref<T, S>;
 export type ToRefs<T = any> = {
     [K in keyof T]: ToRef<T[K]>;
 };
+type ArrayStringKey<T> = T extends readonly any[] ? number extends T['length'] ? `${number}` : never : never;
+type ToRefKey<T> = keyof T | ArrayStringKey<T>;
+type ToRefValue<T extends object, K extends ToRefKey<T>> = K extends keyof T ? T[K] : T extends readonly (infer V)[] ? K extends ArrayStringKey<T> ? V : never : never;
 /**
  * Converts a reactive object to a plain object where each property of the
  * resulting object is a ref pointing to the corresponding property of the
@@ -602,8 +606,8 @@ export type ToRef<T> = IfAny<T, Ref<T>, [T] extends [Ref] ? T : Ref<T>>;
  * @see {@link https://vuejs.org/api/reactivity-utilities.html#toref}
  */
 export declare function toRef<T>(value: T): T extends () => infer R ? Readonly<Ref<R>> : T extends Ref ? T : Ref<UnwrapRef<T>>;
-export declare function toRef<T extends object, K extends keyof T>(object: T, key: K): ToRef<T[K]>;
-export declare function toRef<T extends object, K extends keyof T>(object: T, key: K, defaultValue: T[K]): ToRef<Exclude<T[K], undefined>>;
+export declare function toRef<T extends object, K extends ToRefKey<T>>(object: T, key: K): ToRef<ToRefValue<T, K>>;
+export declare function toRef<T extends object, K extends ToRefKey<T>>(object: T, key: K, defaultValue: ToRefValue<T, K>): ToRef<Exclude<ToRefValue<T, K>, undefined>>;
 /**
  * This is a special exported interface for other packages to declare
  * additional types that should bail out for ref unwrapping. For example
@@ -619,18 +623,16 @@ export declare function toRef<T extends object, K extends keyof T>(object: T, ke
  */
 export interface RefUnwrapBailTypes {
 }
-export type ShallowUnwrapRef<T> = {
+export type ShallowUnwrapRef<T> = T extends ShallowReactiveBrand ? T : {
     [K in keyof T]: DistributeRef<T[K]>;
 };
 type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
 export type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
 type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
     [RawSymbol]?: true;
-} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? {
+} ? T : T extends ShallowReactiveBrand ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? {
     [K in keyof T]: UnwrapRefSimple<T[K]>;
-} : T extends object & {
-    [ShallowReactiveMarker]?: never;
-} ? {
+} : T extends object ? {
     [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>;
 } : T;
 
@@ -661,6 +663,8 @@ export declare function trigger(target: object, type: TriggerOpTypes, key?: unkn
 export declare class EffectScope {
     detached: boolean;
     private _isPaused;
+    private _warnOnRun;
+    readonly __v_skip = true;
     constructor(detached?: boolean);
     get active(): boolean;
     pause(): void;

package/dist/client/node_modules/@vue/reactivity/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/reactivity",
-  "version": "3.5.26",
+  "version": "3.5.41",
   "description": "@vue/reactivity",
   "main": "index.js",
   "module": "dist/reactivity.esm-bundler.js",
@@ -50,6 +50,6 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/reactivity#readme",
   "dependencies": {
-    "@vue/shared": "3.5.26"
+    "@vue/shared": "3.5.41"
   }
 }

package/dist/client/node_modules/@vue/runtime-core/dist/runtime-core.d.ts

@@ -1,6 +1,6 @@
 import { computed as computed$1, Ref, OnCleanup, WatchStopHandle, ShallowUnwrapRef, UnwrapNestedRefs, DebuggerEvent, ComputedGetter, WritableComputedOptions, WatchCallback, ReactiveEffect, DebuggerOptions, WatchSource, WatchHandle, ReactiveMarker, WatchEffect, ShallowRef, WatchErrorCodes, reactive } from '@vue/reactivity';
 export { ComputedGetter, ComputedRef, ComputedSetter, CustomRefFactory, DebuggerEvent, DebuggerEventExtraInfo, DebuggerOptions, DeepReadonly, EffectScheduler, EffectScope, MaybeRef, MaybeRefOrGetter, Raw, Reactive, ReactiveEffect, ReactiveEffectOptions, ReactiveEffectRunner, ReactiveFlags, Ref, ShallowReactive, ShallowRef, ShallowUnwrapRef, ToRef, ToRefs, TrackOpTypes, TriggerOpTypes, UnwrapNestedRefs, UnwrapRef, WatchCallback, WatchEffect, WatchHandle, WatchSource, WatchStopHandle, WritableComputedOptions, WritableComputedRef, customRef, effect, effectScope, getCurrentScope, getCurrentWatcher, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, onWatcherCleanup, proxyRefs, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, toValue, triggerRef, unref } from '@vue/reactivity';
-import { IfAny, Prettify, LooseRequired, UnionToIntersection, OverloadParameters, IsKeyValues } from '@vue/shared';
+import { IfAny, Prettify, UnionToIntersection, LooseRequired, OverloadParameters, IsKeyValues } from '@vue/shared';
 export { camelize, capitalize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
 
 export declare const computed: typeof computed$1;
@@ -271,6 +271,22 @@ export declare function defineOptions<RawBindings = {}, D = {}, C extends Comput
      */
     slots?: never;
 }): void;
+/**
+ * Vue `<script setup>` compiler macro for providing type hints to IDEs for
+ * slot name and slot props type checking.
+ *
+ * Example usage:
+ * ```ts
+ * const slots = defineSlots<{
+ *   default(props: { msg: string }): any
+ * }>()
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ *
+ * @see {@link https://vuejs.org/api/sfc-script-setup.html#defineslots}
+ */
 export declare function defineSlots<S extends Record<string, any> = Record<string, any>>(): StrictUnwrapSlotsType<SlotsType<S>>;
 export type ModelRef<T, M extends PropertyKey = string, G = T, S = T> = Ref<G, S> & [
     ModelRef<T, M, G, S>,
@@ -280,6 +296,8 @@ type DefineModelOptions<T = any, G = T, S = T> = {
     get?: (v: T) => G;
     set?: (v: S) => any;
 };
+type DefineModelRuntimeOptions<T, G, S> = Omit<PropOptions<T>, 'default'> & DefineModelOptions<T, G, S>;
+type DefineModelDefault<T> = InferDefault<Data, T>;
 /**
  * Vue `<script setup>` compiler macro for declaring a
  * two-way binding prop that can be consumed via `v-model` from the parent
@@ -313,18 +331,18 @@ type DefineModelOptions<T = any, G = T, S = T> = {
  * const count = defineModel<number>('count', { default: 0 })
  * ```
  */
-export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options: ({
-    default: any;
+export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options: DefineModelRuntimeOptions<T, G, S> & ({
+    default: DefineModelDefault<T>;
 } | {
     required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
-export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options: ({
-    default: any;
+})): ModelRef<T, M, G, S>;
+export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(options?: DefineModelRuntimeOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options: DefineModelRuntimeOptions<T, G, S> & ({
+    default: DefineModelDefault<T>;
 } | {
     required: true;
-}) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
-export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
+})): ModelRef<T, M, G, S>;
+export declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: DefineModelRuntimeOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
 type NotUndefined<T> = T extends undefined ? never : T;
 type MappedOmit<T, K extends keyof any> = {
     [P in keyof T as P extends K ? never : P]: T[P];
@@ -363,12 +381,12 @@ export declare function withDefaults<T, BKeys extends keyof T, Defaults extends
 export declare function useSlots(): SetupContext['slots'];
 export declare function useAttrs(): SetupContext['attrs'];
 
-export type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
+export type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null | any[]>;
 export type EmitsOptions = ObjectEmitsOptions | string[];
 export type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? {
     [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any;
 } : T extends ObjectEmitsOptions ? {
-    [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends (...args: infer P) => any ? P : T[K] extends null ? any[] : never) => any;
+    [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends (...args: infer P) => any ? P : T[K] extends null ? any[] : T[K] extends any[] ? T[K] : never) => any;
 } : {};
 type TypeEmitsToOptions<T extends ComponentTypeEmits> = {
     [K in keyof T & string]: T[K] extends [...args: infer Args] ? (...args: Args) => any : () => any;
@@ -480,16 +498,16 @@ export type CreateComponentPublicInstance<P = {}, B = {}, D = {}, C extends Comp
  * inference everywhere internally, but it has to be a new type to avoid
  * breaking types that relies on previous arguments order (#10842)
  */
-export type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
+export type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data = {}, TypeEl = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
 type ExposedKeys<T, Exposed extends string & keyof T> = '' extends Exposed ? T : Pick<T, Exposed>;
 export type ComponentPublicInstance<P = {}, // props type extracted from props option
 B = {}, // raw bindings returned from setup()
 D = {}, // return from data()
-C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data = {}, TypeEl extends Element = any> = {
+C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data = {}, TypeEl = any> = {
     $: ComponentInternalInstance;
     $data: D;
     $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
-    $attrs: Data;
+    $attrs: Attrs;
     $refs: Data & TypeRefs;
     $slots: UnwrapSlotsType<S>;
     $root: ComponentPublicInstance | null;
@@ -524,6 +542,10 @@ export interface SuspenseProps {
     onResolve?: () => void;
     onPending?: () => void;
     onFallback?: () => void;
+    /**
+     * Switch to fallback content if it takes longer than `timeout` milliseconds to render the new default content.
+     * A `timeout` value of `0` will cause the fallback content to be displayed immediately when default content is replaced.
+     */
     timeout?: string | number;
     /**
      * Allow suspense to be captured by parent suspense
@@ -557,6 +579,7 @@ export interface SuspenseBoundary {
     container: RendererElement;
     hiddenContainer: RendererElement;
     activeBranch: VNode | null;
+    isFallbackMountPending: boolean;
     pendingBranch: VNode | null;
     deps: number;
     pendingId: number;
@@ -981,11 +1004,11 @@ export declare function hasInjectionContext(): boolean;
 
 export type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
 type ResolveProps<PropsOrPropOptions, E extends EmitsOptions> = Readonly<PropsOrPropOptions extends ComponentPropsOptions ? ExtractPropTypes<PropsOrPropOptions> : PropsOrPropOptions> & ({} extends E ? {} : EmitsToProps<E>);
-export type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
+export type DefineComponent<PropsOrPropOptions = {}, RawBindings = {}, D = {}, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, EE extends string = string, PP = PublicProps, Props = ResolveProps<PropsOrPropOptions, E>, Defaults = ExtractDefaultPropTypes<PropsOrPropOptions>, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, MakeDefaultsOptional extends boolean = true, TypeRefs extends Record<string, unknown> = {}, TypeEl = any> = ComponentPublicInstanceConstructor<CreateComponentPublicInstanceWithMixins<Props, RawBindings, D, C, M, Mixin, Extends, E, PP, Defaults, MakeDefaultsOptional, {}, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, TypeRefs, TypeEl>> & ComponentOptionsBase<Props, RawBindings, D, C, M, Mixin, Extends, E, EE, Defaults, {}, string, S, LC & GlobalComponents, Directives & GlobalDirectives, Exposed, Provide> & PP;
 export type DefineSetupFnComponent<P extends Record<string, any>, E extends EmitsOptions = {}, S extends SlotsType = SlotsType, Props = P & EmitsToProps<E>, PP = PublicProps> = new (props: Props & PP) => CreateComponentPublicInstanceWithMixins<Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, E, PP, {}, false, {}, S>;
 type ToResolvedProps<Props, Emits extends EmitsOptions> = Readonly<Props> & Readonly<EmitsToProps<Emits>>;
 export declare function defineComponent<Props extends Record<string, any>, E extends EmitsOptions = {}, EE extends string = string, S extends SlotsType = {}>(setup: (props: Props, ctx: SetupContext<E, S>) => RenderFunction | Promise<RenderFunction>, options?: Pick<ComponentOptions, 'name' | 'inheritAttrs'> & {
-    props?: (keyof Props)[];
+    props?: (keyof NoInfer<Props>)[];
     emits?: E | EE[];
     slots?: S;
 }): DefineSetupFnComponent<Props, E, S>;
@@ -996,7 +1019,7 @@ export declare function defineComponent<Props extends Record<string, any>, E ext
 }): DefineSetupFnComponent<Props, E, S>;
 export declare function defineComponent<TypeProps, RuntimePropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, RuntimePropsKeys extends string = string, TypeEmits extends ComponentTypeEmits = {}, RuntimeEmitsOptions extends EmitsOptions = {}, RuntimeEmitsKeys extends string = string, Data = {}, SetupBindings = {}, Computed extends ComputedOptions = {}, Methods extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, InjectOptions extends ComponentInjectOptions = {}, InjectKeys extends string = string, Slots extends SlotsType = {}, LocalComponents extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, Provide extends ComponentProvideOptions = ComponentProvideOptions, ResolvedEmits extends EmitsOptions = {} extends RuntimeEmitsOptions ? TypeEmitsToOptions<TypeEmits> : RuntimeEmitsOptions, InferredProps = IsKeyValues<TypeProps> extends true ? TypeProps : string extends RuntimePropsKeys ? ComponentObjectPropsOptions extends RuntimePropsOptions ? {} : ExtractPropTypes<RuntimePropsOptions> : {
     [key in RuntimePropsKeys]?: any;
-}, TypeRefs extends Record<string, unknown> = {}, TypeEl extends Element = any>(options: {
+}, TypeRefs extends Record<string, unknown> = {}, TypeEl = any>(options: {
     props?: (RuntimePropsOptions & ThisType<void>) | RuntimePropsKeys[];
     /**
      * @private for language-tools use only
@@ -1307,6 +1330,12 @@ export declare function createCommentVNode(text?: string, asBlock?: boolean): VN
 export declare function mergeProps(...args: (Data & VNodeProps)[]): Data;
 
 type Data = Record<string, unknown>;
+/**
+ * For extending allowed non-declared attrs on components in TSX
+ */
+export interface AllowedAttrs {
+}
+export type Attrs = Data & AllowedAttrs;
 /**
  * Public utility type for extracting the instance type of a component.
  * Works with all valid component definition types. This is intended to replace
@@ -1415,7 +1444,7 @@ export type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends
 export type Component<PropsOrInstance = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<PropsOrInstance, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<PropsOrInstance>;
 
 export type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
-    attrs: Data;
+    attrs: Attrs;
     slots: UnwrapSlotsType<S>;
     emit: EmitFn<E>;
     expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
@@ -1688,7 +1717,7 @@ export declare function toHandlers(obj: Record<string, any>, preserveCaseIfNeces
  * Compiler runtime helper for rendering `<slot/>`
  * @private
  */
-export declare function renderSlot(slots: Slots, name: string, props?: Data, fallback?: () => VNodeArrayChildren, noSlotted?: boolean): VNode;
+export declare function renderSlot(slots: Slots, name: string, props?: Data | null, fallback?: () => VNodeArrayChildren, noSlotted?: boolean, branchKey?: PropertyKey): VNode;
 
 type SSRSlot = (...args: any[]) => VNode[] | undefined;
 interface CompiledSlotDescriptor {

package/dist/client/node_modules/@vue/runtime-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/runtime-core",
-  "version": "3.5.26",
+  "version": "3.5.41",
   "description": "@vue/runtime-core",
   "main": "index.js",
   "module": "dist/runtime-core.esm-bundler.js",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/runtime-core#readme",
   "dependencies": {
-    "@vue/shared": "3.5.26",
-    "@vue/reactivity": "3.5.26"
+    "@vue/shared": "3.5.41",
+    "@vue/reactivity": "3.5.41"
   }
 }