pxd 0.1.2 → 0.1.3

package/dist/components/list/index.vue

@@ -1,12 +1,14 @@
 <script setup>
-import { computed, reactive, shallowRef } from "vue";
+import { computed, nextTick, onMounted, reactive, shallowRef, watch } from "vue";
 import { useListNavigation } from "../../composables/_internal/use-list-navigation.js";
-import { flattenListOptions, resolveNavigableOption, resolveRowIndexByNavIndex } from "../../composables/_internal/use-list-rows.js";
+import { flattenListOptions } from "../../composables/_internal/use-list-rows.js";
 import { resolveNextListValue } from "../../composables/_internal/use-list-selection.js";
 import { resolveOptionByValue } from "../../composables/_internal/use-selected-list-item.js";
 import { useVirtualList } from "../../composables/use-virtual-list.js";
 import { provideListContext } from "../../contexts/list.js";
 import { getElement } from "../../utils/dom.js";
+import { toArray } from "../../utils/format.js";
+import { isNil } from "../../utils/is.js";
 import PLoadingMask from "../_internal/loading-mask.vue";
 import PListGroup from "../list-group/index.vue";
 import PListItem from "../list-item/index.vue";
@@ -79,15 +81,13 @@ const emits = defineEmits(["change", "update:modelValue"]);
 const containerRef = shallowRef();
 const flattened = computed(() => flattenListOptions(props.options));
 const rows = computed(() => flattened.value.rows);
+const itemRows = computed(() => flattened.value.itemRows);
 const navigableCount = computed(() => flattened.value.navigableCount);
-function isNavDisabled(index) {
-	return resolveNavigableOption(rows.value, index)?.option.disabled === true;
-}
 const virtualOptions = reactive({
 	dataKey: "key",
 	enabled: () => props.virtual,
-	scrollPaddingStart: 16,
-	scrollPaddingEnd: 16,
+	scrollPaddingStart: props.itemSize / 2,
+	scrollPaddingEnd: props.itemSize / 2,
 	get items() {
 		return rows.value;
 	},
@@ -98,14 +98,51 @@ const virtualOptions = reactive({
 		return props.overScan;
 	}
 });
+const { activeIndex, dispatch, setActiveIndex, onPointerOver, setFirstAsActive } = useListNavigation({
+	loop: () => props.loop,
+	count: () => navigableCount.value,
+	defaultActiveIndex: () => props.defaultActiveIndex,
+	isDisabled: isNavDisabled,
+	onActivateItem,
+	scrollToIndex: scrollNavIndexIntoView
+});
 const { totalSize, virtualItems, scrollToIndex } = useVirtualList(containerRef, virtualOptions);
+const renderEntries = computed(() => {
+	if (props.virtual) {
+		return virtualItems.value.map((virtualItem) => {
+			const row = rows.value[virtualItem.index];
+			return {
+				key: virtualItem.key,
+				start: virtualItem.start,
+				row,
+				itemRow: row?.type === "item" ? row : undefined,
+				headerLabel: row?.type === "header" ? row.label : undefined
+			};
+		});
+	}
+	return rows.value.map((row) => ({
+		key: row.key,
+		row,
+		itemRow: row.type === "item" ? row : undefined,
+		headerLabel: row.type === "header" ? row.label : undefined
+	}));
+});
+const contentStyle = computed(() => {
+	if (!props.virtual) {
+		return undefined;
+	}
+	return { height: `${totalSize.value}px` };
+});
+function isNavDisabled(index) {
+	return itemRows.value[index]?.option.disabled === true;
+}
 function scrollNavIndexIntoView(navIndex) {
-	const rowIndex = resolveRowIndexByNavIndex(rows.value, navIndex);
-	if (rowIndex < 0) {
+	const row = itemRows.value[navIndex];
+	if (!row) {
 		return;
 	}
 	if (props.virtual) {
-		scrollToIndex(rowIndex, {
+		scrollToIndex(row.rowIndex, {
 			align: "auto",
 			behavior: "instant"
 		});
@@ -126,7 +163,7 @@ function onItemSelect(value) {
 		return;
 	}
 	const option = resolveOptionByValue(props.options, value);
-	if (!option) {
+	if (!option || option.disabled) {
 		return;
 	}
 	const nextValue = resolveNextListValue(props.modelValue, value, props.multiple);
@@ -139,59 +176,102 @@ function onActivateItem(navIndex) {
 		el.click();
 		return;
 	}
-	const row = resolveNavigableOption(rows.value, navIndex);
+	const row = itemRows.value[navIndex];
 	if (!row) {
 		return;
 	}
 	onItemSelect(row.option.value);
 }
-const { activeIndex, dispatch, setActiveIndex, onPointerOver, setFirstAsActive } = useListNavigation({
-	loop: () => props.loop,
-	count: () => navigableCount.value,
-	defaultActiveIndex: () => props.defaultActiveIndex,
-	isDisabled: isNavDisabled,
-	onActivateItem,
-	scrollToIndex: scrollNavIndexIntoView
-});
-function isItemActive(row) {
-	return activeIndex.value === row.navIndex;
-}
 function dispatchCommand(command) {
 	if (props.loading) {
 		return false;
 	}
 	return dispatch(command);
 }
-const renderEntries = computed(() => {
+function findItemElement(navIndex) {
+	return getElement(`[data-list-item][data-index="${navIndex}"]`, containerRef.value);
+}
+function syncActiveItem(next, previous) {
+	if (previous >= 0) {
+		findItemElement(previous)?.removeAttribute("data-active");
+	}
+	if (next >= 0) {
+		findItemElement(next)?.setAttribute("data-active", "true");
+	}
+}
+function refreshActiveItem() {
+	const container = containerRef.value;
+	if (!container) {
+		return;
+	}
+	container.querySelectorAll("[data-list-item][data-active]").forEach((el) => {
+		el.removeAttribute("data-active");
+	});
+	if (activeIndex.value >= 0) {
+		findItemElement(activeIndex.value)?.setAttribute("data-active", "true");
+	}
+}
+function scrollToFirstSelected() {
+	const firstValue = toArray(props.modelValue)[0];
+	if (isNil(firstValue)) {
+		return false;
+	}
+	const target = itemRows.value.find((row) => row.option.value === firstValue);
+	if (!target) {
+		return false;
+	}
 	if (props.virtual) {
-		return virtualItems.value.map((virtualItem) => {
-			const row = rows.value[virtualItem.index];
-			return {
-				key: virtualItem.key,
-				start: virtualItem.start,
-				row,
-				itemRow: row?.type === "item" ? row : undefined,
-				headerLabel: row?.type === "header" ? row.label : undefined
-			};
-		});
+		nextTick(() => scrollNavIndexIntoView(target.navIndex));
+		return true;
 	}
-	return rows.value.map((row) => ({
-		key: row.key,
-		row,
-		itemRow: row.type === "item" ? row : undefined,
-		headerLabel: row.type === "header" ? row.label : undefined
-	}));
-});
-const contentStyle = computed(() => {
-	if (!props.virtual) {
-		return undefined;
+	const container = containerRef.value;
+	const item = getElement(`[data-list-item][data-index="${target.navIndex}"]`, container);
+	if (!container || !item) {
+		return false;
 	}
-	return { height: `${totalSize.value}px` };
-});
+	const itemRect = item.getBoundingClientRect();
+	const containerRect = container.getBoundingClientRect();
+	if (itemRect.top < containerRect.top) {
+		// Keep one row between the selection and the top edge.
+		container.scrollTop -= containerRect.top - itemRect.top + itemRect.height;
+	} else if (itemRect.bottom > containerRect.bottom) {
+		// Keep one row between the selection and the bottom edge.
+		container.scrollTop += itemRect.bottom - containerRect.bottom + itemRect.height;
+	}
+	return true;
+}
+function scrollToFirstOption() {
+	if (props.virtual) {
+		if (rows.value.length > 0) {
+			scrollToIndex(0, {
+				align: "start",
+				behavior: "instant"
+			});
+		}
+		return;
+	}
+	if (containerRef.value) {
+		containerRef.value.scrollTop = 0;
+	}
+}
+watch(activeIndex, syncActiveItem, { flush: "post" });
+watch(renderEntries, refreshActiveItem, { flush: "post" });
 provideListContext({
 	value: computed(() => props.modelValue),
 	onItemSelect
 });
+watch(rows, async () => {
+	await nextTick();
+	if (!scrollToFirstSelected()) {
+		scrollToFirstOption();
+	}
+}, { flush: "post" });
+onMounted(() => {
+	refreshActiveItem();
+	if (!scrollToFirstSelected()) {
+		scrollToFirstOption();
+	}
+});
 defineExpose({
 	focus: () => containerRef.value?.focus(),
 	dispatch: dispatchCommand,
@@ -234,7 +314,6 @@ defineExpose({
           v-else-if="entry.itemRow"
           v-bind="entry.itemRow.option"
           :index="entry.itemRow.navIndex"
-          :active="isItemActive(entry.itemRow)"
           :class="itemClass"
         >
           <template v-if="$slots.item">

package/dist/components/list/types.d.ts

@@ -3,7 +3,7 @@ import type {
   ComponentClass,
   ComponentLabel,
   ComponentValue,
-} from '../../types/shared'
+} from '../../types/shared/props'
 
 export interface ListOption {
   as?: ComponentAs

package/dist/components/list-group/types.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentLabel } from '../../types/shared'
+import type { ComponentLabel } from '../../types/shared/props'
 
 export interface ListGroupProps {
   label?: string

package/dist/components/list-item/index.d.vue.ts

@@ -1,7 +1,7 @@
 import type { ListItemProps } from './types';
-declare var __VLS_10: {};
+declare var __VLS_9: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_10) => any;
+    default?: (props: typeof __VLS_9) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<ListItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     click: (args_0: import("../../types/shared/props.js").ComponentValue, args_1: MouseEvent) => any;

package/dist/components/list-item/index.vue

@@ -48,21 +48,36 @@ const props = defineProps({
 	}
 });
 const emits = defineEmits(["click"]);
+const NATIVE_DISABLED_TAGS = new Set([
+	"button",
+	"input",
+	"select",
+	"textarea",
+	"option",
+	"optgroup",
+	"fieldset"
+]);
+const nativeDisabled = computed(() => {
+	if (!props.disabled || typeof props.as !== "string") {
+		return undefined;
+	}
+	return NATIVE_DISABLED_TAGS.has(props.as.toLowerCase()) ? true : undefined;
+});
 const { value: selectedValue, onItemSelect } = useListContext();
+const isChecked = computed(() => {
+	return !isNil(props.value) && toArray(selectedValue.value).includes(props.value);
+});
 const { attrs, classes } = useTailwindVariant({
 	base: "pxd-list-item min-h-9 p-2 text-sm pe-8 gap-2 flex w-full max-w-full cursor-pointer items-center rounded-md outline-none content-visibility-auto data-[disabled=true]:pointer-events-none data-[disabled=true]:text-gray-700",
 	variants: { variant: {
-		error: "text-red-900 active:bg-red-100 pointer-fine:aria-selected:bg-red-100",
-		warning: "text-amber-900 active:bg-amber-100 pointer-fine:aria-selected:bg-amber-100",
-		default: "text-foreground active:bg-gray-alpha-100 pointer-fine:aria-selected:bg-gray-alpha-100"
+		error: "text-red-900 active:bg-red-100 pointer-fine:data-[active=true]:bg-red-100",
+		warning: "text-amber-900 active:bg-amber-100 pointer-fine:data-[active=true]:bg-amber-100",
+		default: "text-foreground active:bg-gray-alpha-100 pointer-fine:data-[active=true]:bg-gray-alpha-100"
 	} }
 }, { selection: () => ({ variant: props.variant }) });
-const isChecked = computed(() => {
-	return !isNil(props.value) && toArray(selectedValue.value).includes(props.value);
-});
 function onItemClick(ev) {
 	const value = props.value;
-	if (isNil(value)) {
+	if (props.disabled || isNil(value)) {
 		return;
 	}
 	emits("click", value, ev);
@@ -80,7 +95,10 @@ function onItemClick(ev) {
     :data-variant="variant"
     :data-checked="isChecked"
     :data-disabled="disabled"
-    :aria-selected="active"
+    :data-active="active"
+    :aria-selected="isChecked"
+    :aria-disabled="disabled"
+    :disabled="nativeDisabled"
     :class="classes"
     v-bind="attrs"
     @click.stop="onItemClick"

package/dist/components/loading-bar/index.vue

@@ -42,6 +42,11 @@ const props = defineProps({
 		default: 300
 	}
 });
+let prevTimestamp = 0;
+let prevAnimationKey = 0;
+let hiddenBarTimeout;
+let enableTransitionTimeout;
+const ENABLE_TRANSITION_DELAY = 0;
 const status = shallowRef("finish");
 const hiddenBar = shallowRef(false);
 const progressValue = shallowRef(0);
@@ -64,11 +69,6 @@ const { classes: innerClasses } = useTailwindVariant({
 	mergeAttrsClass: false,
 	selection: () => ({ status: status.value })
 });
-let prevTimestamp = 0;
-let prevAnimationKey = 0;
-let hiddenBarTimeout;
-let enableTransitionTimeout;
-const ENABLE_TRANSITION_DELAY = 0;
 function getIncreaseDelta(n) {
 	if (n >= 0 && n < .2) {
 		return .1;

package/dist/components/marching-ants/index.d.vue.ts

@@ -1,9 +1,9 @@
 import type { MarchingAntsProps } from './types';
 declare function select(): void;
 declare function deselect(): void;
-declare var __VLS_11: {};
+declare var __VLS_9: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_11) => any;
+    default?: (props: typeof __VLS_9) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<MarchingAntsProps, {
     select: typeof select;

package/dist/components/marching-ants/index.vue

@@ -2,6 +2,62 @@
 import { computed, shallowRef } from "vue";
 import { getElement } from "../../utils/dom.js";
 import { getCssUnitValue } from "../../utils/format.js";
+defineOptions({
+	name: "PMarchingAnts",
+	inheritAttrs: false
+});
+const props = defineProps({
+	as: {
+		type: [String, Object],
+		required: false,
+		default: "div"
+	},
+	color: {
+		type: String,
+		required: false,
+		default: "#00ff88"
+	},
+	lineSize: {
+		type: [String, Number],
+		required: false,
+		default: 2
+	},
+	dashSize: {
+		type: [String, Number],
+		required: false,
+		default: 8
+	},
+	gap: {
+		type: [String, Number],
+		required: false,
+		default: 4
+	}
+});
+const targetRef = shallowRef();
+const outline = shallowRef();
+const dashArray = computed(() => {
+	const dash = parseFloat(getCssUnitValue(props.dashSize, "8") || "8");
+	const gap = parseFloat(getCssUnitValue(props.gap, "4") || "4");
+	return {
+		value: `${dash} ${gap}`,
+		offset: `-${dash + gap}`
+	};
+});
+const strokeStyle = computed(() => ({
+	"--marching-ants-color": props.color,
+	"--marching-ants-stroke-width": getCssUnitValue(props.lineSize, "2px"),
+	"--marching-ants-dash-array": dashArray.value.value,
+	"--marching-ants-dash-offset": dashArray.value.offset
+}));
+const circleOutline = computed(() => {
+	const value = outline.value;
+	return value?.type === "ellipse" && Math.abs(value.rx - value.ry) < .5 ? value : undefined;
+});
+const ellipseOutline = computed(() => {
+	const value = outline.value;
+	return value?.type === "ellipse" && !circleOutline.value ? value : undefined;
+});
+const pathOutline = computed(() => outline.value?.type === "path" ? outline.value : undefined);
 const resolveLength = (value, reference) => value.endsWith("%") ? parseFloat(value) / 100 * reference : parseFloat(value);
 const getElementRect = (element) => ({
 	style: getComputedStyle(element),
@@ -364,62 +420,6 @@ function getOutline(element) {
 	}
 	return createRectangleOutline(elementRect.width, elementRect.height);
 }
-defineOptions({
-	name: "PMarchingAnts",
-	inheritAttrs: false
-});
-const props = defineProps({
-	as: {
-		type: [String, Object],
-		required: false,
-		default: "div"
-	},
-	color: {
-		type: String,
-		required: false,
-		default: "#00ff88"
-	},
-	lineSize: {
-		type: [String, Number],
-		required: false,
-		default: 2
-	},
-	dashSize: {
-		type: [String, Number],
-		required: false,
-		default: 8
-	},
-	gap: {
-		type: [String, Number],
-		required: false,
-		default: 4
-	}
-});
-const targetRef = shallowRef();
-const outline = shallowRef();
-const dashArray = computed(() => {
-	const dash = parseFloat(getCssUnitValue(props.dashSize, "8") || "8");
-	const gap = parseFloat(getCssUnitValue(props.gap, "4") || "4");
-	return {
-		value: `${dash} ${gap}`,
-		offset: `-${dash + gap}`
-	};
-});
-const strokeStyle = computed(() => ({
-	"--marching-ants-color": props.color,
-	"--marching-ants-stroke-width": getCssUnitValue(props.lineSize, "2px"),
-	"--marching-ants-dash-array": dashArray.value.value,
-	"--marching-ants-dash-offset": dashArray.value.offset
-}));
-const circleOutline = computed(() => {
-	const value = outline.value;
-	return value?.type === "ellipse" && Math.abs(value.rx - value.ry) < .5 ? value : undefined;
-});
-const ellipseOutline = computed(() => {
-	const value = outline.value;
-	return value?.type === "ellipse" && !circleOutline.value ? value : undefined;
-});
-const pathOutline = computed(() => outline.value?.type === "path" ? outline.value : undefined);
 function select() {
 	const target = getElement(targetRef.value);
 	if (!target) {

package/dist/components/marching-ants/types.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentAs } from '../../types/shared'
+import type { ComponentAs } from '../../types/shared/props'
 
 export interface MarchingAntsProps {
   as?: ComponentAs

package/dist/components/marquee/index.d.vue.ts

@@ -1,12 +1,12 @@
 import type { MarqueeProps } from './types';
 declare function reset(): void;
-declare var __VLS_10: {}, __VLS_12: {}, __VLS_14: {};
+declare var __VLS_9: {}, __VLS_11: {}, __VLS_13: {};
 type __VLS_Slots = {} & {
-    prefix?: (props: typeof __VLS_10) => any;
+    prefix?: (props: typeof __VLS_9) => any;
 } & {
-    default?: (props: typeof __VLS_12) => any;
+    default?: (props: typeof __VLS_11) => any;
 } & {
-    suffix?: (props: typeof __VLS_14) => any;
+    suffix?: (props: typeof __VLS_13) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<MarqueeProps, {
     reset: typeof reset;
@@ -17,13 +17,13 @@ declare const __VLS_base: import("vue").DefineComponent<MarqueeProps, {
     onClick?: ((args_0: MouseEvent) => any) | undefined;
     onReplay?: (() => any) | undefined;
 }>, {
-    delay: number | string;
+    delay: string | number;
     text: string;
     background: string;
     color: string;
     as: import("../../types/shared/props.js").ComponentAs;
     pauseOnHover: boolean;
-    speed: number | string;
+    speed: string | number;
     scrollable: boolean;
     wrapable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/components/marquee/index.vue

@@ -55,23 +55,18 @@ const props = defineProps({
 	}
 });
 const emits = defineEmits(["click", "replay"]);
-const wrapRef = shallowRef();
-const contentRef = shallowRef();
-const phase = shallowRef("idle");
-const contentStyle = shallowRef();
 let wrapWidth = 0;
 let contentWidth = 0;
 let appliedSpeed = 0;
 let appliedDelay = 0;
 let restartRafId = 0;
-function toDelay(value) {
-	const n = Number(value);
-	return Number.isFinite(n) && n >= 0 ? n : 1;
-}
-function toSpeed(value) {
-	const n = Number(value);
-	return Number.isFinite(n) && n > 0 ? n : 60;
-}
+const scheduleSync = throttleByRaf(() => {
+	syncScroll(false);
+});
+const wrapRef = shallowRef();
+const contentRef = shallowRef();
+const phase = shallowRef("idle");
+const contentStyle = shallowRef();
 const delaySec = computed(() => toDelay(props.delay));
 const speed = computed(() => toSpeed(props.speed));
 const isWrapMode = computed(() => props.wrapable && props.scrollable === false);
@@ -89,6 +84,15 @@ const contentClass = computed(() => {
 	}
 	return "block max-w-full truncate";
 });
+useResizeObserver(wrapRef, scheduleSync);
+function toDelay(value) {
+	const n = Number(value);
+	return Number.isFinite(n) && n >= 0 ? n : 1;
+}
+function toSpeed(value) {
+	const n = Number(value);
+	return Number.isFinite(n) && n > 0 ? n : 60;
+}
 function clearRestart() {
 	if (restartRafId) {
 		caf(restartRafId);
@@ -162,9 +166,6 @@ function syncScroll(force = false) {
 	}
 	armFirst();
 }
-const scheduleSync = throttleByRaf(() => {
-	syncScroll(false);
-});
 function reset() {
 	if (isServer()) {
 		return;
@@ -193,7 +194,6 @@ watch(() => [
 	delaySec.value,
 	speed.value
 ], reset);
-useResizeObserver(wrapRef, scheduleSync);
 onMounted(reset);
 onBeforeUnmount(() => {
 	scheduleSync.cancel();

package/dist/components/marquee/types.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentAs } from '../../types/shared'
+import type { ComponentAs } from '../../types/shared/props'
 
 export interface MarqueeProps {
   as?: ComponentAs

package/dist/components/material/index.d.vue.ts

@@ -1,10 +1,10 @@
 import type { MaterialProps } from './types';
-declare var __VLS_8: {};
+declare var __VLS_7: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_7) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<MaterialProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MaterialProps> & Readonly<{}>, {
-    variant: "default" | "small" | "medium" | "large" | "tooltip" | "menu" | "modal" | "fullscreen";
+    variant: "default" | "menu" | "small" | "tooltip" | "medium" | "large" | "modal" | "fullscreen";
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/mention/index.d.vue.ts

@@ -1,15 +1,15 @@
 import type { ListOptions } from '../list/types';
 import type { MentionClickPayload, MentionProps } from './types';
-declare var __VLS_33: {
+declare var __VLS_28: {
     item: import("../list/types").ListOption;
     index: number;
     group: import("../list/types").ListOptionGroup | undefined;
     groupIndex: number | undefined;
-}, __VLS_36: {};
+}, __VLS_31: {};
 type __VLS_Slots = {} & {
-    item?: (props: typeof __VLS_33) => any;
+    item?: (props: typeof __VLS_28) => any;
 } & {
-    empty?: (props: typeof __VLS_36) => any;
+    empty?: (props: typeof __VLS_31) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<MentionProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     change: (args_0: string) => any;
@@ -20,11 +20,11 @@ declare const __VLS_base: import("vue").DefineComponent<MentionProps, {}, {}, {}
     "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
     "onMention-click"?: ((args_0: MentionClickPayload) => any) | undefined;
 }>, {
-    placeholder: string;
     disabled: boolean;
     modelValue: string;
     options: ListOptions | import("./types").MentionOptionsResolver;
     closeOnPressEscape: boolean;
+    placeholder: string;
     triggers: string[];
     searchPlaceholder: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;