@vingy/vueltip 2.1.0 → 2.2.0

package/README.md

@@ -202,50 +202,67 @@ Define your own theme by setting CSS variables:
 
 ### Plugin Options
 
-The `vueltipPlugin` accepts the following options:
-
-| Option                     | Type                             | Default                    | Description                                                                                                            |
-| -------------------------- | -------------------------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| `component`                | `Component`                      | Required                   | The Vue component to render as the tooltip                                                                             |
-| `showDelay`                | `number`                         | `0`                        | Delay in milliseconds before the tooltip appears on hover                                                              |
-| `hideDelay`                | `number`                         | `200`                      | Delay in milliseconds before the tooltip disappears when the cursor leaves                                             |
-| `defaultPlacement`         | `Placement`                      | `'top'`                    | Default tooltip placement: `'top'`, `'bottom'`, `'left'`, `'right'`, etc.                                              |
-| `defaultTruncateDetection` | `'x' \| 'y' \| 'both' \| 'none'` | `'both'`                   | Direction(s) to check for text truncation (`'x'` for horizontal, `'y'` for vertical, `'both'`, or `'none'` to disable) |
-| `handleDialogModals`       | `boolean`                        | `false`                    | Whether to handle tooltips within HTML `<dialog>` elements with the `open` attribute (modal dialogs)                   |
-| `placementAttribute`       | `string`                         | `'data-vueltip-placement'` | HTML attribute name for tooltip placement overrides                                                                    |
-| `keyAttribute`             | `string`                         | `'data-vueltip-key'`       | HTML attribute name for tooltip identification                                                                         |
-| `truncateAttribute`        | `string`                         | `'data-vueltip-truncate'`  | HTML attribute name for truncate detection overrides                                                                   |
-
-### useVueltip Composable Options
-
-The `useVueltip` composable accepts the following options:
-
-| Option            | Type                       | Default  | Description                                                |
-| ----------------- | -------------------------- | -------- | ---------------------------------------------------------- |
-| `tooltipElement`  | `Ref<HTMLElement \| null>` | Required | Reference to the tooltip container element                 |
-| `arrowElement`    | `Ref<HTMLElement \| null>` | Optional | Reference to the arrow element for positioning             |
-| `offset`          | `number`                   | `0`      | Offset distance between the tooltip and the target element |
-| `padding`         | `number`                   | `0`      | Padding between the tooltip and the viewport edges         |
-| `arrowSize`       | `number`                   | `0`      | Size of the arrow element (used for proper positioning)    |
-| `floatingOptions` | `UseFloatingOptions`       | `{}`     | Advanced options for the underlying Floating UI library    |
+| Option                     | Type                             | Default                    | Description                                                        |
+| -------------------------- | -------------------------------- | -------------------------- | ------------------------------------------------------------------ |
+| `component`                | `Component`                      | Required                   | The Vue component to render as the tooltip                         |
+| `showDelay`                | `number`                         | `0`                        | Delay in ms before the tooltip appears                             |
+| `hideDelay`                | `number`                         | `200`                      | Delay in ms before the tooltip disappears                          |
+| `defaultPlacement`         | `Placement`                      | `'top'`                    | Default placement: `'top'`, `'bottom'`, `'left'`, `'right'`, etc.  |
+| `defaultTruncateDetection` | `'x' \| 'y' \| 'both' \| 'none'` | `'both'`                   | Axis to check for text truncation                                  |
+| `handleDialogModals`       | `boolean`                        | `false`                    | Move the tooltip inside `<dialog>` elements when they are modal    |
+| `placementAttribute`       | `string`                         | `'data-vueltip-placement'` | HTML attribute name for per-element placement overrides            |
+| `keyAttribute`             | `string`                         | `'data-vueltip-key'`       | HTML attribute name used to identify tooltip targets               |
+| `truncateAttribute`        | `string`                         | `'data-vueltip-truncate'`  | HTML attribute name for per-element truncation detection overrides |
+
+### useVueltip Options
+
+| Option            | Type                       | Default  | Description                                          |
+| ----------------- | -------------------------- | -------- | ---------------------------------------------------- |
+| `tooltipElement`  | `Ref<HTMLElement \| null>` | Required | Reference to the tooltip container element           |
+| `arrowElement`    | `Ref<HTMLElement \| null>` | —        | Reference to the arrow element for positioning       |
+| `offset`          | `number`                   | `0`      | Distance between the tooltip and the target element  |
+| `padding`         | `number`                   | `0`      | Minimum space between the tooltip and viewport edges |
+| `arrowSize`       | `number`                   | `0`      | Size of the arrow element                            |
+| `floatingOptions` | `UseFloatingOptions`       | `{}`     | Advanced options passed to Floating UI               |
 
 ### Directive Options
 
-The `v-tooltip` directive accepts bindings in two formats:
+The directive accepts a simple string or an object:
 
-**Simple string (text only):**
+```
+v-tooltip="'text'"
+v-tooltip="{ text, placement, custom }"
+```
+
+| Option      | Type        | Default | Description                                              |
+| ----------- | ----------- | ------- | -------------------------------------------------------- |
+| `text`      | `string`    | —       | Tooltip text                                             |
+| `placement` | `Placement` | `'top'` | Placement override for this element                      |
+| `custom`    | `object`    | —       | Arbitrary typed data accessible in the tooltip component |
+
+**Placement via directive arg:**
+
+Placement can also be set as a directive argument instead of inside the object:
 
-```ts
-v-tooltip="'Tooltip text'"
+```
+v-tooltip:right="'text'"
 ```
 
-**Object with options:**
+**Truncation detection modifiers:**
 
-```ts
-v-tooltip="{
-  text: 'Tooltip text',
-  placement: 'right'  // Placement: 'top', 'bottom', 'left', 'right', etc.
-}"
+Control which axis is checked for text overflow. When the element is not truncated and the tooltip text matches the element content, the tooltip is suppressed.
+
+| Modifier | Description                          |
+| -------- | ------------------------------------ |
+| `x`      | Check horizontal overflow only       |
+| `y`      | Check vertical overflow only         |
+| `both`   | Check both axes (default)            |
+| `none`   | Always show regardless of truncation |
+
+```
+v-tooltip.x="'text'"
+v-tooltip.y="'text'"
+v-tooltip.none="'Always visible'"
 ```
 
 ## Custom Data

package/dist/basicTooltip.component.d.ts

@@ -0,0 +1 @@
+export declare const BasicTooltip: import('vue').DefineSetupFnComponent<Record<string, any>, {}, {}, Record<string, any> & {}, import('vue').PublicProps>;

package/dist/basicTooltip.css

@@ -1,42 +1 @@
-.vueltip-theme {
-  isolation: isolate;
-
-  --vueltip-bg: rgb(241, 245, 249);
-  --vueltip-text: rgb(15, 23, 42);
-  --vueltip-shadow:
-    0 10px 15px -3px rgba(0, 0, 0, 0.1),
-    0 4px 6px -4px rgba(0, 0, 0, 0.1);
-  --vueltip-border-radius: 4px;
-  --vueltip-padding: 4px 8px;
-  --vueltip-font-size: 14px;
-  --vueltip-font-weight: 600;
-}
-
-@media (prefers-color-scheme: dark) {
-  .vueltip-theme {
-    --vueltip-bg: rgb(30, 41, 59);
-    --vueltip-text: rgb(248, 250, 252);
-    --vueltip-shadow:
-      0 10px 15px -3px rgba(0, 0, 0, 0.5),
-      0 4px 6px -4px rgba(0, 0, 0, 0.5);
-  }
-}
-
-.vueltip-arrow {
-  pointer-events: none;
-  position: absolute;
-  z-index: 0;
-  background: var(--vueltip-bg);
-}
-
-.vueltip-content {
-  position: relative;
-  z-index: 10;
-  border-radius: var(--vueltip-border-radius);
-  background: var(--vueltip-bg);
-  padding: var(--vueltip-padding);
-  font-size: var(--vueltip-font-size);
-  font-weight: var(--vueltip-font-weight);
-  color: var(--vueltip-text);
-  box-shadow: var(--vueltip-shadow);
-}
+.vueltip-theme{isolation:isolate;--vueltip-bg:#f1f5f9;--vueltip-text:#0f172a;--vueltip-shadow:0 10px 15px -3px #0000001a, 0 4px 6px -4px #0000001a;--vueltip-border-radius:4px;--vueltip-padding:4px 8px;--vueltip-font-size:14px;--vueltip-font-weight:600}@media (prefers-color-scheme:dark){.vueltip-theme{--vueltip-bg:#1e293b;--vueltip-text:#f8fafc;--vueltip-shadow:0 10px 15px -3px #00000080, 0 4px 6px -4px #00000080}}.vueltip-arrow{pointer-events:none;z-index:0;background:var(--vueltip-bg);position:absolute}.vueltip-content{z-index:10;border-radius:var(--vueltip-border-radius);background:var(--vueltip-bg);padding:var(--vueltip-padding);font-size:var(--vueltip-font-size);font-weight:var(--vueltip-font-weight);color:var(--vueltip-text);box-shadow:var(--vueltip-shadow);position:relative}

package/dist/composables.d.ts

@@ -0,0 +1,21 @@
+import { Maybe } from '@vingy/shared/types';
+import { StyleValue } from 'vue';
+import { UseTooltipOptions } from './types.ts';
+export declare const useVueltip: ({ tooltipElement, arrowElement, offset: _offset, padding, arrowSize, floatingOptions, }: UseTooltipOptions) => {
+    tooltipStyles: Readonly<import('vue').Ref<{
+        position: import('@floating-ui/vue').Strategy;
+        top: string;
+        left: string;
+        transform?: string;
+        willChange?: string;
+    }, {
+        position: import('@floating-ui/vue').Strategy;
+        top: string;
+        left: string;
+        transform?: string;
+        willChange?: string;
+    }>>;
+    arrowStyles: import('vue').ComputedRef<StyleValue>;
+    show: import('vue').ComputedRef<boolean>;
+    content: import('vue').Ref<Maybe<import('./types.ts').Content>, Maybe<import('./types.ts').Content>>;
+};

package/dist/directive.d.ts

@@ -0,0 +1,8 @@
+import { Placement } from '@floating-ui/vue';
+import { DirectiveBinding } from 'vue';
+import { Modifier, Value } from './types.ts';
+export declare const vueltipDirective: {
+    updated: (el: HTMLElement, binding: DirectiveBinding<Value, Modifier, Placement>) => void;
+    created: (el: HTMLElement, binding: DirectiveBinding<Value, Modifier, Placement>) => void;
+    beforeUnmount: (el: HTMLElement) => void;
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { BasicTooltip } from './basicTooltip.component';
+export { useVueltip } from './composables';
+export { vueltipDirective } from './directive';
+export { setOptions } from './options';
+export { vueltipPlugin } from './plugin';
+export type { Content, CustomVueltipData } from './types';

package/dist/index.js

@@ -0,0 +1,193 @@
+import { computed as e, createVNode as t, defineComponent as n, h as r, ref as i, render as a, useTemplateRef as o, watch as s } from "vue";
+import { arrow as c, autoUpdate as l, flip as u, offset as d, shift as f, useFloating as p } from "@floating-ui/vue";
+//#region src/options.ts
+var m = {
+	placementAttribute: "data-vueltip-placement",
+	keyAttribute: "data-vueltip-key",
+	truncateAttribute: "data-vueltip-truncate",
+	showDelay: 0,
+	hideDelay: 200,
+	handleDialogModals: !1,
+	defaultTruncateDetection: "both",
+	defaultPlacement: "top"
+}, h = (e) => {
+	m = {
+		...m,
+		...e
+	};
+}, g = (e) => m[e], _, v = i("top"), y = i("top"), b = i(), x = i(), S = (e) => {
+	e !== x.value && e !== b.value || (b.value = void 0, x.value = void 0, _ && clearTimeout(_));
+}, C = i(/* @__PURE__ */ new Map()), w = (e) => C.value.get(e), T = (e, t) => C.value.set(e, t), E = (e) => C.value.delete(e), D = () => crypto.randomUUID(), O = i(), k = i();
+s([
+	O,
+	b,
+	v,
+	() => w(O.value ?? "")
+], ([e, t, n]) => {
+	if (!e) return;
+	_ && clearTimeout(_);
+	let r = g(t ? "showDelay" : "hideDelay");
+	_ = setTimeout(() => {
+		k.value = w(e), x.value = t, y.value = n, _ = void 0;
+	}, r);
+});
+//#endregion
+//#region src/composables.ts
+var A = {
+	top: "bottom",
+	right: "left",
+	bottom: "top",
+	left: "right"
+}, j = ({ tooltipElement: t, arrowElement: n, offset: r, padding: i, arrowSize: a, floatingOptions: o }) => {
+	let m, h = e(() => !!x.value);
+	s(h, (e, n, r) => {
+		if (!e) return;
+		let i = t.value;
+		if (!i) return;
+		m = i.parentElement;
+		let a = () => b.value = x.value, o = () => b.value = void 0;
+		i.addEventListener("mouseenter", a), i.addEventListener("mouseleave", o), r(() => {
+			i.removeEventListener("mouseenter", a), i.removeEventListener("mouseleave", o);
+		});
+	}, { flush: "post" });
+	let _ = [
+		d(r),
+		u(),
+		f({ padding: i })
+	];
+	n && _.push(c({
+		element: n,
+		padding: 6
+	}));
+	let { floatingStyles: v, middlewareData: S, placement: C } = p(x, t, {
+		placement: y,
+		whileElementsMounted: l,
+		middleware: _,
+		...o
+	}), w = e(() => A[C.value.split("-")[0]]), T = a ?? 10, E = e(() => ({
+		width: `${T}px`,
+		height: `${T}px`,
+		rotate: "45deg",
+		position: "absolute",
+		left: S.value.arrow?.x == null ? "" : `${S.value.arrow.x}px`,
+		top: S.value.arrow?.y == null ? "" : `${S.value.arrow.y}px`,
+		[w.value]: `-${T / 2}px`
+	}));
+	return g("handleDialogModals") && s(h, (e) => {
+		if (!e || !t.value || !x.value || !m) return;
+		let n = x.value.closest("dialog");
+		if (!n) {
+			t.value.parentElement !== m && m.appendChild(t.value);
+			return;
+		}
+		globalThis.getComputedStyle(n, "::backdrop").display !== "none" && n.appendChild(t.value);
+	}), {
+		tooltipStyles: v,
+		arrowStyles: E,
+		show: h,
+		content: k
+	};
+}, M = n(() => {
+	let { tooltipStyles: e, arrowStyles: t, show: n, content: i } = j({
+		tooltipElement: o("tooltipElement"),
+		arrowElement: o("arrowElement"),
+		offset: 8,
+		padding: 8
+	});
+	return () => n.value ? r("div", {
+		ref: "tooltipElement",
+		class: "vueltip-theme",
+		style: e.value,
+		role: "tooltip"
+	}, [r("div", {
+		ref: "arrowElement",
+		class: "vueltip-arrow",
+		style: t.value
+	}), r("div", { class: "vueltip-content" }, [i.value?.text])]) : null;
+});
+//#endregion
+//#region src/utils.ts
+function N(e) {
+	let t = P(e), n = e.offsetWidth < e.scrollWidth - 1, r = e.offsetHeight < e.scrollHeight - 1;
+	switch (t) {
+		case "x": return n;
+		case "y": return r;
+		case "both": return n || r;
+		case "none": return !0;
+	}
+}
+function P(e) {
+	return e.getAttribute(g("truncateAttribute")) ?? g("defaultTruncateDetection");
+}
+function F(e, t) {
+	return L(e) || R(e) ? z(e).includes(t) : !!(e.innerText || e.textContent)?.includes(t);
+}
+function I(e) {
+	return e instanceof HTMLElement;
+}
+function L(e) {
+	return e instanceof HTMLInputElement;
+}
+function R(e) {
+	return e instanceof HTMLTextAreaElement;
+}
+function z(e) {
+	return e.value;
+}
+var B = (e, t) => {
+	let n = e.getAttribute(g("keyAttribute"));
+	if (n) return t(n);
+}, V = (e) => (t) => {
+	let { target: n } = t;
+	!n || !I(n) || e(n);
+}, H = V((e) => B(e, (t) => {
+	let n = w(t);
+	if (!n) return;
+	let { text: r } = n;
+	if (!r || F(e, r) && !N(e)) return;
+	let i = e.getAttribute(g("placementAttribute"));
+	O.value = t, b.value = e, v.value = i;
+})), U = V((e) => {
+	e === b.value && (b.value = void 0);
+}), W = (e) => {
+	if (e == null || typeof e == "string") return { text: e };
+	let { placement: t, ...n } = e;
+	return n;
+}, G = (e) => {
+	let { value: t, arg: n } = e;
+	return t && typeof t != "string" && "placement" in t && t.placement != null ? t.placement : n || g("defaultPlacement");
+}, K = (e) => e.none ? "none" : e.both || e.x && e.y ? "both" : e.x ? "x" : e.y ? "y" : g("defaultTruncateDetection"), q = {
+	updated: (e, t) => {
+		B(e, (n) => {
+			e.setAttribute(g("placementAttribute"), G(t)), e.setAttribute(g("truncateAttribute"), K(t.modifiers ?? {})), T(n, W(t.value));
+		});
+	},
+	created: (e, t) => {
+		let n = D();
+		T(n, W(t.value)), e.setAttribute(g("keyAttribute"), n), e.setAttribute(g("placementAttribute"), G(t)), e.setAttribute(g("truncateAttribute"), K(t.modifiers ?? {})), e.addEventListener("mouseenter", H), e.addEventListener("focus", H), e.addEventListener("mouseleave", U), e.addEventListener("blur", U);
+	},
+	beforeUnmount: (e) => {
+		B(e, (e) => E(e)), S(e), e.removeEventListener("mouseenter", H), e.removeEventListener("focus", H), e.removeEventListener("mouseleave", U), e.removeEventListener("blur", U);
+	}
+}, J = (e) => {
+	if (e.key !== "Escape") return;
+	let t = b.value ?? x.value;
+	t && S(t);
+}, Y = "__vueltip_root__", X = () => {
+	let e = document.getElementById(Y);
+	if (e) return e;
+	let t = document.createElement("div");
+	return t.id = Y, document.body.appendChild(t), t;
+}, Z = 0, Q = { install: (e, n) => {
+	let { component: r, ...i } = n;
+	if (h(i), !r || typeof window > "u") return;
+	Z === 0 && window.addEventListener("keydown", J), Z++;
+	let o = X(), s = t(r);
+	s.appContext = e._context, a(s, o);
+	let { unmount: c } = e;
+	e.unmount = () => {
+		Z--, Z <= 0 && (window.removeEventListener("keydown", J), Z = 0), c.call(e);
+	};
+} };
+//#endregion
+export { M as BasicTooltip, h as setOptions, j as useVueltip, q as vueltipDirective, Q as vueltipPlugin };

package/dist/keyboardListeners.d.ts

@@ -0,0 +1 @@
+export declare const onKeydown: (e: KeyboardEvent) => void;

package/dist/listeners.d.ts

@@ -0,0 +1,2 @@
+export declare const onMouseover: (event: MouseEvent | FocusEvent) => void;
+export declare const onMouseout: (event: MouseEvent | FocusEvent) => void;

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+import { Options } from './types';
+export declare const setOptions: (opts?: Partial<Options>) => void;
+export declare const getOption: <T extends keyof Options>(key: T) => Options[T];

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+import { App, Component } from 'vue';
+import { Options } from './types';
+export declare const vueltipPlugin: {
+    install: (app: App, options: Partial<Options & {
+        component: Component;
+    }>) => void;
+};

package/dist/state.d.ts

@@ -0,0 +1,20 @@
+import { Placement } from '@floating-ui/vue';
+import { Maybe } from '@vingy/shared/types';
+import { Content } from './types';
+export declare const tooltipPlacement: import('vue').Ref<Placement, Placement>;
+export declare const debouncedTooltipPlacement: import('vue').Ref<Placement, Placement>;
+export declare const hoveredElement: import('vue').Ref<Maybe<HTMLElement>, Maybe<HTMLElement>>;
+export declare const debouncedHoveredElement: import('vue').Ref<Maybe<HTMLElement>, Maybe<HTMLElement>>;
+export declare const forceClearHoveredElement: (el: HTMLElement) => void;
+export declare const getContent: (key: string) => {
+    text: Maybe<string>;
+    custom?: import('./types').CustomVueltipData | undefined;
+} | undefined;
+export declare const setContent: (key: string, value: Content) => Map<string, {
+    text: Maybe<string>;
+    custom?: import('./types').CustomVueltipData | undefined;
+}> & Omit<Map<string, Content>, keyof Map<any, any>>;
+export declare const deleteContent: (key: string) => boolean;
+export declare const generateKey: () => `${string}-${string}-${string}-${string}-${string}`;
+export declare const tooltipKey: import('vue').Ref<Maybe<string>, Maybe<string>>;
+export declare const tooltipContent: import('vue').Ref<Maybe<Content>, Maybe<Content>>;

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+import { Placement, UseFloatingOptions } from '@floating-ui/vue';
+import { Maybe } from '@vingy/shared/types';
+import { Directive, ShallowRef } from 'vue';
+export interface CustomVueltipData {
+}
+export interface Content {
+    text: Maybe<string>;
+    custom?: CustomVueltipData;
+}
+export type Value = Maybe<string> | (Content & {
+    placement?: Placement;
+});
+export type Modifier = 'x' | 'y' | 'none' | 'both';
+export type TooltipDirective = Directive<HTMLElement, Value, Modifier, Placement>;
+export type Options = {
+    /** @default 'data-vueltip-placement' */
+    placementAttribute: string;
+    /** @default 'data-vueltip-key' */
+    keyAttribute: string;
+    /** @default 'data-vueltip-truncate' */
+    truncateAttribute: string;
+    /** @default 0 */
+    showDelay: number;
+    /** @default 200 */
+    hideDelay: number;
+    /** @default false */
+    handleDialogModals: boolean;
+    /** @default 'both' */
+    defaultTruncateDetection: Modifier;
+    /** @default 'top' */
+    defaultPlacement: Placement;
+};
+export type UseTooltipOptions = {
+    tooltipElement: Readonly<ShallowRef<HTMLElement | null>>;
+    arrowElement?: Readonly<ShallowRef<HTMLElement | null>>;
+    offset?: number;
+    padding?: number;
+    arrowSize?: number;
+    floatingOptions?: UseFloatingOptions<HTMLElement>;
+};
+declare module 'vue' {
+    interface GlobalDirectives {
+        vTooltip: TooltipDirective;
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function isTruncated(el: HTMLElement): boolean;
+export declare function elementContainsText(el: HTMLElement, text: string): boolean;
+export declare function isHtmlElement(el: EventTarget): el is HTMLElement;
+export declare const ensureKey: <T>(el: HTMLElement, fn: (key: string) => T) => T | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vingy/vueltip",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Headless tooltip which only shows when necessary.",
   "keywords": [
     "composition-api",
@@ -21,12 +21,12 @@
   "sideEffects": [
     "./dist/basicTooltip.css"
   ],
-  "main": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./basicTooltip.css": "./dist/basicTooltip.css"
   },
@@ -34,14 +34,17 @@
     "access": "public"
   },
   "devDependencies": {
-    "@floating-ui/vue": "^1.1.10",
+    "@vitejs/plugin-vue": "^6.0.5",
+    "vite": "^8.0.3",
+    "vite-plugin-dts": "^4.5.4",
     "@vingy/shared": "^0.1.0"
   },
   "peerDependencies": {
+    "@floating-ui/vue": "^1.1.10",
     "vue": "^3.5.0"
   },
   "scripts": {
-    "build": "tsdown",
-    "dev": "tsdown -w"
+    "build": "vite build",
+    "dev": "vite build --watch"
   }
 }

package/dist/chunk-CtajNgzt.mjs

@@ -1,36 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-
-//#endregion
-export { __reExport as n, __exportAll as t };