v-float 0.1.0

package/dist/composables/use-floating-tree.d.ts

@@ -0,0 +1,48 @@
+import { FloatingContext } from './use-floating';
+import { TreeNode, TreeOptions } from './use-tree';
+/**
+ * Configuration options for the floating tree
+ */
+export interface FloatingTreeOptions extends TreeOptions {
+}
+export interface UseFloatingTreeReturn {
+    readonly nodeMap: Readonly<Map<string, TreeNode<FloatingContext>>>;
+    readonly root: Readonly<TreeNode<FloatingContext>>;
+    findNodeById: (nodeId: string) => TreeNode<FloatingContext> | null;
+    moveNode: (nodeId: string, newParentId: string | null) => boolean;
+    dispose: () => void;
+    addNode: (data: FloatingContext, parentId?: string | null) => TreeNode<FloatingContext> | null;
+    removeNode: (nodeId: string, deleteStrategy?: "orphan" | "recursive") => boolean;
+    traverse: (mode: "dfs" | "bfs", startNode?: TreeNode<FloatingContext>) => TreeNode<FloatingContext>[];
+    /**
+     * Checks if a given node is the topmost open node in the tree hierarchy.
+     * A node is considered topmost if it's open and none of its ancestors are open.
+     *
+     * @param nodeId - The ID of the node to check.
+     * @returns True if the node is open and no ancestors are open, false otherwise.
+     */
+    isTopmost: (nodeId: string) => boolean;
+    getAllOpenNodes: () => TreeNode<FloatingContext>[];
+    /**
+     * Executes a provided function once for each tree node that matches the specified relationship.
+     * This is a flexible iteration method that can target nodes based on their relationship to a target node.
+     *
+     * @param nodeId - The ID of the target node used as a reference point for the relationship
+     * @param callback - A function to execute for each matching node
+     * @param options - Configuration options for the iteration behavior
+     */
+    forEach: (nodeId: string, callback: (node: TreeNode<FloatingContext>) => void, options?: {
+        relationship?: NodeRelationship;
+        applyToMatching?: boolean;
+    }) => void;
+}
+/**
+ * Predefined node relationship strategies used for filtering nodes.
+ */
+type NodeRelationship = "ancestors-only" | "siblings-only" | "descendants-only" | "children-only" | "self-and-ancestors" | "self-and-children" | "self-and-descendants" | "self-and-siblings" | "self-ancestors-and-children" | "full-branch" | "all-except-branch";
+/**
+ * Manages a hierarchical tree of floating elements.
+ */
+export declare function useFloatingTree(rootNodeData: FloatingContext, options?: FloatingTreeOptions): UseFloatingTreeReturn;
+export {};
+//# sourceMappingURL=use-floating-tree.d.ts.map

package/dist/composables/use-floating-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-floating-tree.d.ts","sourceRoot":"","sources":["../../src/composables/use-floating-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,OAAO,EAAQ,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAA;AAMlE;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,WAAW;CAAG;AAE3D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAA;IAClE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAA;IAClD,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,QAAQ,CAAC,eAAe,CAAC,GAAG,IAAI,CAAA;IAClE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAA;IACjE,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,OAAO,EAAE,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,KAAK,QAAQ,CAAC,eAAe,CAAC,GAAG,IAAI,CAAA;IAC9F,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,QAAQ,GAAG,WAAW,KAAK,OAAO,CAAA;IAChF,QAAQ,EAAE,CACR,IAAI,EAAE,KAAK,GAAG,KAAK,EACnB,SAAS,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,KAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAA;IAChC;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAA;IACtC,eAAe,EAAE,MAAM,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAA;IAClD;;;;;;;OAOG;IACH,OAAO,EAAE,CACP,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,eAAe,CAAC,KAAK,IAAI,EACnD,OAAO,CAAC,EAAE;QACR,YAAY,CAAC,EAAE,gBAAgB,CAAA;QAC/B,eAAe,CAAC,EAAE,OAAO,CAAA;KAC1B,KACE,IAAI,CAAA;CACV;AAED;;GAEG;AACH,KAAK,gBAAgB,GACjB,gBAAgB,GAChB,eAAe,GACf,kBAAkB,GAClB,eAAe,GACf,oBAAoB,GACpB,mBAAmB,GACnB,sBAAsB,GACtB,mBAAmB,GACnB,6BAA6B,GAC7B,aAAa,GACb,mBAAmB,CAAA;AAqBvB;;GAEG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,eAAe,EAC7B,OAAO,GAAE,mBAAwB,GAChC,qBAAqB,CA+JvB"}

package/dist/composables/use-floating.d.ts

@@ -0,0 +1,161 @@
+import { AutoUpdateOptions, Middleware, MiddlewareData, Placement, Strategy, VirtualElement } from '@floating-ui/dom';
+import { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+/**
+ * Type for anchor element in floating UI
+ */
+export type AnchorElement = HTMLElement | VirtualElement | null;
+/**
+ * Type for floating element in floating UI
+ */
+export type FloatingElement = HTMLElement | null;
+/**
+ * CSS styles for positioning floating elements
+ */
+export type FloatingStyles = {
+    /**
+     * CSS position property
+     */
+    position: Strategy;
+    /**
+     * CSS top property
+     */
+    top: string;
+    /**
+     * CSS left property
+     */
+    left: string;
+    /**
+     * CSS transform property
+     */
+    transform?: string;
+    /**
+     * CSS will-change property
+     */
+    "will-change"?: string;
+} & {
+    [key: `--${string}`]: any;
+};
+/**
+ * Options for configuring floating element behavior
+ */
+export interface UseFloatingOptions {
+    /**
+     * Where to place the floating element relative to its anchor element.
+     * @default 'bottom'
+     */
+    placement?: MaybeRefOrGetter<Placement | undefined>;
+    /**
+     * The type of CSS positioning to use.
+     * @default 'absolute'
+     */
+    strategy?: MaybeRefOrGetter<Strategy | undefined>;
+    /**
+     * Whether to use CSS transform instead of top/left positioning.
+     * @default true
+     */
+    transform?: MaybeRefOrGetter<boolean | undefined>;
+    /**
+     * Middlewares modify the positioning coordinates in some fashion, or provide useful data for the consumer to use.
+     */
+    middlewares?: Middleware[];
+    /**
+     * Function called when both the anchor and floating elements are mounted.
+     */
+    whileElementsMounted?: (anchorEl: NonNullable<AnchorElement>, floatingEl: NonNullable<FloatingElement>, update: () => void) => undefined | (() => void);
+    /**
+     * Whether the floating element is open.
+     * @default false
+     */
+    open?: Ref<boolean>;
+    /**
+     * Function to control the open state of the floating element. If not provided, a default function is used that updates the `open` ref.
+     */
+    setOpen?: (open: boolean) => void;
+}
+/**
+ * Context object returned by useFloating containing all necessary data and methods
+ */
+export interface FloatingContext {
+    /**
+     * The x-coordinate of the floating element
+     */
+    x: Readonly<Ref<number>>;
+    /**
+     * The y-coordinate of the floating element
+     */
+    y: Readonly<Ref<number>>;
+    /**
+     * The strategy used for positioning
+     */
+    strategy: Readonly<Ref<Strategy>>;
+    /**
+     * The placement of the floating element
+     */
+    placement: Readonly<Ref<Placement>>;
+    /**
+     * Data from middleware for additional customization
+     */
+    middlewareData: Readonly<Ref<MiddlewareData>>;
+    /**
+     * Whether the floating element has been positioned
+     */
+    isPositioned: Readonly<Ref<boolean>>;
+    /**
+     * Computed styles to apply to the floating element
+     */
+    floatingStyles: ComputedRef<FloatingStyles>;
+    /**
+     * Function to manually update the position
+     */
+    update: () => void;
+    /**
+     * The refs object containing references to anchor and floating elements
+     */
+    refs: {
+        anchorEl: Ref<AnchorElement>;
+        floatingEl: Ref<FloatingElement>;
+    };
+    /**
+     * Whether the floating element is open
+     */
+    open: Readonly<Ref<boolean>>;
+    /**
+     * Function to explicitly set the open state of the floating element.
+     */
+    setOpen: (open: boolean) => void;
+}
+/**
+ * Composable function that provides positioning for a floating element relative to an anchor element
+ *
+ * This composable handles the positioning logic for floating elements (like tooltips, popovers, etc.)
+ * relative to their anchor elements. It uses Floating UI under the hood and provides reactive
+ * positioning data and styles.
+ *
+ * @param anchorEl - The anchor element or a reactive reference to it
+ * @param floatingEl - The floating element or a reactive reference to it
+ * @param options - Additional options for the floating behavior
+ * @returns A FloatingContext object containing positioning data and methods
+ *
+ * @example
+ * ```ts
+ * const { floatingStyles, refs } = useFloating(anchorEl, floatingEl, {
+ *   placement: 'bottom',
+ *   strategy: 'absolute'
+ * })
+ * ```
+ */
+export declare function useFloating(anchorEl: Ref<AnchorElement>, floatingEl: Ref<FloatingElement>, options?: UseFloatingOptions): FloatingContext;
+/**
+ * Auto-update function to use with `whileElementsMounted` option
+ *
+ * This function provides automatic position updates for floating elements.
+ * It's a wrapper around Floating UI's autoUpdate function.
+ *
+ * @param anchorEl - The anchor element
+ * @param floatingEl - The floating element
+ * @param update - The update function to call
+ * @param options - Additional options for auto-updating
+ * @returns A cleanup function to stop auto-updating
+ */
+export declare function autoUpdate(anchorEl: HTMLElement, floatingEl: HTMLElement, update: () => void, options?: AutoUpdateOptions): () => void;
+//# sourceMappingURL=use-floating.d.ts.map

package/dist/composables/use-floating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-floating.d.ts","sourceRoot":"","sources":["../../src/composables/use-floating.ts"],"names":[],"mappings":"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"}

package/dist/composables/use-tree.d.ts

@@ -0,0 +1,151 @@
+import { Ref } from 'vue';
+/**
+ * Options for creating a TreeNode
+ */
+export interface TreeNodeOptions {
+    /** Optional ID for the node. If not provided, one will be generated. */
+    id?: string;
+}
+/**
+ * Options for configuring tree behavior
+ */
+export interface TreeOptions {
+    /** Strategy for deleting child nodes when a parent is deleted.
+     * - 'orphan': Children are detached from the tree (parent becomes null).
+     * - 'recursive': Children are also deleted recursively.
+     * @default 'recursive'
+     */
+    deleteStrategy?: "orphan" | "recursive";
+}
+/**
+ * Represents a node in a reactive tree structure.
+ * Each node contains data, parent reference, and children references.
+ */
+export declare class TreeNode<T> {
+    #private;
+    readonly id: string;
+    data: T;
+    parent: Ref<TreeNode<T> | null>;
+    children: Ref<TreeNode<T>[]>;
+    constructor(data: T, parent?: TreeNode<T> | null, options?: TreeNodeOptions, isRoot?: boolean);
+    /**
+     * Adds an existing node instance to this node's children array.
+     * @internal
+     * @param childNode The TreeNode instance to add.
+     */
+    addChild(childNode: TreeNode<T>): void;
+    /**
+     * Removes a specific child node instance from this node's children.
+     * @internal
+     * Note: This only removes the direct child link. Use the Tree's `removeNode` method for full removal including map updates and recursive deletion.
+     * @param childNode The child node instance to remove.
+     * @returns True if the child was found and removed, false otherwise.
+     */
+    _removeChildInstance(childNode: TreeNode<T>): boolean;
+    /**
+     * Updates the node's data.
+     * If T is an object, performs a shallow merge using Object.assign.
+     * If T is a primitive, replaces the value.
+     * @param newData Partial data for objects, or the new value for primitives.
+     */
+    updateData(newData: Partial<T> | T): void;
+    /**
+     * Finds the first direct child matching the predicate.
+     * @param predicate Function to test each child node.
+     * @returns The matching child node or null if not found.
+     */
+    findChild(predicate: (node: TreeNode<T>) => boolean): TreeNode<T> | null;
+    /**
+     * Finds the first descendant node (including self) matching the predicate using DFS.
+     * @param predicate Function to test each node.
+     * @returns The matching descendant node or null if not found.
+     */
+    findDescendant(predicate: (node: TreeNode<T>) => boolean): TreeNode<T> | null;
+    /**
+     * Checks if this node is a descendant of the potential ancestor.
+     * @param potentialAncestor The node to check against.
+     * @returns True if this node is a descendant, false otherwise.
+     */
+    isDescendantOf(potentialAncestor: TreeNode<T>): boolean;
+    /**
+     * Gets the path of nodes from the root to this node.
+     * @returns An array of nodes starting with the root and ending with this node.
+     */
+    getPath(): TreeNode<T>[];
+    /** Checks if the node is the true root of the tree, distinct from an orphaned node. */
+    get isRoot(): boolean;
+    /** Checks if the node is a leaf node (has no children). */
+    get isLeaf(): boolean;
+}
+/**
+ * Manages a reactive tree structure.
+ *
+ * This class provides a complete tree data structure with reactive nodes,
+ * supporting operations like adding, removing, and moving nodes, as well as
+ * traversal and search functionality.
+ *
+ * @template T The type of data stored in the tree nodes.
+ */
+export declare class Tree<T> {
+    #private;
+    /** The root node of the tree. */
+    readonly root: TreeNode<T>;
+    /** Readonly reactive map of node IDs to TreeNode instances for quick lookups. */
+    readonly nodeMap: Readonly<Map<string, TreeNode<T>>>;
+    /**
+     * Creates a new Tree instance.
+     * @param initialRootData Data for the root node.
+     * @param options Configuration options for the tree behavior.
+     *
+     * @example
+     * ```ts
+     * const myTree = new Tree({ name: 'Root' });
+     * const childNode = myTree.addNode({ name: 'Child' }, myTree.root.id);
+     * ```
+     */
+    constructor(initialRootData: T, options?: TreeOptions);
+    /**
+     * Finds a node anywhere in the tree by its ID.
+     * @param id The ID of the node to find.
+     * @returns The node if found, otherwise null.
+     */
+    findNodeById(id: string): TreeNode<T> | null;
+    /**
+     * Adds a new node to the tree.
+     * @param data The data for the new node.
+     * @param parentId The ID of the parent node. If null or undefined, adds to the root.
+     * @param nodeOptions Optional configuration for the new node (e.g., custom ID).
+     * @returns The newly created TreeNode, or null if the parent was not found.
+     */
+    addNode(data: T, parentId?: string | null, nodeOptions?: TreeNodeOptions): TreeNode<T> | null;
+    /**
+     * Removes a node from the tree by its ID.
+     * Handles deletion of descendants based on the provided strategy or the tree's default.
+     * @param nodeId The ID of the node to remove.
+     * @param deleteStrategy Optional strategy override. If not provided, uses the tree's default strategy.
+     * @returns True if the node was successfully removed, false otherwise.
+     */
+    removeNode(nodeId: string, deleteStrategy?: "orphan" | "recursive"): boolean;
+    /**
+     * Moves a node to become a child of a new parent.
+     * @param nodeId The ID of the node to move.
+     * @param newParentId The ID of the new parent node. Set to null to move to the root level.
+     * @returns True if the node was successfully moved, false otherwise.
+     */
+    moveNode(nodeId: string, newParentId: string | null): boolean;
+    /**
+     * Traverses the tree using either Depth-First Search (DFS) or Breadth-First Search (BFS).
+     * @param strategy The traversal strategy ('dfs' or 'bfs'). Defaults to 'dfs'.
+     * @param startNode The node to start traversal from. Defaults to the root node.
+     * @returns An array of nodes in the order they were visited.
+     */
+    traverse(strategy?: "dfs" | "bfs", startNode?: TreeNode<T> | null): TreeNode<T>[];
+    /**
+     * Clears the internal node map. This is crucial for allowing garbage collection
+     * when the Tree instance is no longer needed, especially in scenarios like
+     * Vue components where the instance might be tied to the component lifecycle.
+     * Call this method when you are finished with the Tree instance (e.g., in `onScopeDispose`).
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=use-tree.d.ts.map

package/dist/composables/use-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-tree.d.ts","sourceRoot":"","sources":["../../src/composables/use-tree.ts"],"names":[],"mappings":"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"}

package/dist/composables/utils/dom.d.ts

@@ -0,0 +1,11 @@
+export declare function normalizeProp(normalizable?: boolean | {
+    escapeKey?: boolean;
+    outsidePress?: boolean;
+}): {
+    escapeKey: boolean;
+    outsidePress: boolean;
+};
+export declare function isHTMLElement(node: unknown | null): node is HTMLElement;
+export declare function isEventTargetWithin(event: Event, element: Element | null | undefined): boolean;
+export declare function isClickOnScrollbar(event: MouseEvent, target: HTMLElement): boolean;
+//# sourceMappingURL=dom.d.ts.map

package/dist/composables/utils/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../../src/composables/utils/dom.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAC3B,YAAY,CAAC,EAAE,OAAO,GAAG;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE;;;EAQzE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,IAAI,WAAW,CAEvE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAU9F;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAalF"}

package/dist/composables/utils/use-composition.d.ts

@@ -0,0 +1,4 @@
+export declare function useComposition(): {
+    isComposing: () => boolean;
+};
+//# sourceMappingURL=use-composition.d.ts.map

package/dist/composables/utils/use-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-composition.d.ts","sourceRoot":"","sources":["../../../src/composables/utils/use-composition.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc;;EAc7B"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './composables';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+export type AnyFn<T extends unknown[] = unknown[], U = unknown> = (...args: T) => U;
+export type Fn = () => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,CAAA;AACnF,MAAM,MAAM,EAAE,GAAG,MAAM,IAAI,CAAA"}

package/dist/utils/dom.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rounds a value based on the device pixel ratio
+ */
+export declare function roundByDPR(el: HTMLElement, value: number): number;
+/**
+ * Gets the device pixel ratio for an element
+ */
+export declare function getDPR(el: HTMLElement): number;
+//# sourceMappingURL=dom.d.ts.map

package/dist/utils/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/utils/dom.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,UAGxD;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,WAAW,UAIrC"}

package/dist/utils/id.d.ts

@@ -0,0 +1,2 @@
+export declare function useId(): string;
+//# sourceMappingURL=id.d.ts.map

package/dist/utils/id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../src/utils/id.ts"],"names":[],"mappings":"AAEA,wBAAgB,KAAK,IAAI,MAAM,CAE9B"}

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './dom';
+export * from './reactivity';
+export * from './type-guards';
+export * from './id';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,MAAM,CAAA"}

package/dist/utils/reactivity.d.ts

@@ -0,0 +1,2 @@
+export declare function isWatchable(source: unknown): boolean;
+//# sourceMappingURL=reactivity.d.ts.map

package/dist/utils/reactivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactivity.d.ts","sourceRoot":"","sources":["../../src/utils/reactivity.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAEpD"}

package/dist/utils/type-guards.d.ts

@@ -0,0 +1,8 @@
+import { AnyFn } from '../types';
+/**
+ * Checks if a value is a function
+ * @param value - The value to check
+ * @returns True if the value is a function, false otherwise
+ */
+export declare function isFunction(value: unknown): value is AnyFn;
+//# sourceMappingURL=type-guards.d.ts.map

package/dist/utils/type-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.d.ts","sourceRoot":"","sources":["../../src/utils/type-guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CAEzD"}