@pawover/kit 0.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 猫爪在上
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# pawover-kit

package/dist/enums/index.js

@@ -0,0 +1,20 @@
+/** 屏幕响应断点 token 配置 */
+export const BREAK_POINT_TOKENS = {
+    XS: 576,
+    XSMin: 576,
+    XSMax: 767,
+    SM: 768,
+    SMMin: 768,
+    SMMax: 991,
+    MD: 992,
+    MDMin: 992,
+    MDMax: 1199,
+    LG: 1200,
+    LGMin: 1200,
+    LGMax: 1599,
+    XL: 1600,
+    XLMin: 1600,
+    XLMax: 1919,
+    XXL: 1920,
+    XXLMin: 1920,
+};

package/dist/hooks/react/index.js

@@ -0,0 +1,5 @@
+export * from "./useCreation";
+export * from "./useLatest";
+export * from "./useMount";
+export * from "./useResponsive";
+export * from "./useUnmount";

package/dist/hooks/react/useCreation.js

@@ -0,0 +1,11 @@
+import { isEqual } from "radashi";
+import { useRef } from "react";
+export function useCreation(factory, deps) {
+    const { current } = useRef({ deps, result: undefined, isInitialized: false });
+    if (current.isInitialized === false || !isEqual(current.deps, deps)) {
+        current.deps = deps;
+        current.result = factory();
+        current.isInitialized = true;
+    }
+    return current.result;
+}

package/dist/hooks/react/useLatest.js

@@ -0,0 +1,6 @@
+import { useRef } from "react";
+export function useLatest(value) {
+    const ref = useRef(value);
+    ref.current = value;
+    return ref;
+}

package/dist/hooks/react/useMount.js

@@ -0,0 +1,29 @@
+import { useEffect, useRef } from "react";
+import { isFunction, isPromiseLike } from "src/utils";
+import { useLatest } from "./useLatest";
+/**
+ * 在组件初始化时执行的 Hook
+ * - 即使在严格模式下也只执行一次
+ * @reference https://ahooks.js.org/hooks/use-mount
+ *
+ * @param {MountCallback} effect 副作用函数
+ */
+export function useMount(effect) {
+    if (!isFunction(effect)) {
+        console.error(`useMount expected parameter is a function, but got ${typeof effect}`);
+    }
+    const isMountedRef = useRef(false);
+    const effectRef = useLatest(effect);
+    useEffect(() => {
+        if (isMountedRef.current) {
+            return;
+        }
+        isMountedRef.current = true;
+        const result = effectRef.current?.();
+        // If fn returns a Promise, don't return it as cleanup function
+        if (isPromiseLike(result)) {
+            return;
+        }
+        return result;
+    }, []);
+}

package/dist/hooks/react/useResponsive.js

@@ -0,0 +1,59 @@
+import { useEffect, useState } from "react";
+import { BREAK_POINT_TOKENS } from "src/enums";
+import { objectKeys } from "src/utils";
+const subscriberList = new Set();
+const { XS, SM, MD, LG, XL, XXL } = BREAK_POINT_TOKENS;
+const defaultResponsiveValues = { xxl: false, xl: false, lg: false, md: false, sm: false, xs: false };
+const responsiveConfig = Object.freeze({ xs: XS, sm: SM, md: MD, lg: LG, xl: XL, xxl: XXL });
+let responsiveValues = { ...defaultResponsiveValues };
+export function useResponsive(options) {
+    const { compactBreakPoint = "xl" } = options || {};
+    calculate();
+    const [responsive, setResponsive] = useState(responsiveValues);
+    const isCompact = !responsive[compactBreakPoint];
+    const current = objectKeys(defaultResponsiveValues).find((key) => responsive[key] === true) || "xs";
+    useEffect(() => {
+        addListener();
+        const subscriber = () => {
+            setResponsive(responsiveValues);
+        };
+        subscriberList.add(subscriber);
+        return () => {
+            subscriberList.delete(subscriber);
+            if (subscriberList.size === 0) {
+                removeListener();
+            }
+        };
+    }, []);
+    return { responsive, current, isCompact };
+}
+function resizeListener() {
+    const oldInfo = responsiveValues;
+    calculate();
+    if (oldInfo === responsiveValues) {
+        return;
+    }
+    for (const subscriber of subscriberList) {
+        subscriber();
+    }
+}
+function addListener() {
+    window.addEventListener("resize", resizeListener);
+}
+function removeListener() {
+    window.removeEventListener("resize", resizeListener);
+}
+function calculate() {
+    const width = window.innerWidth;
+    const newValues = { ...defaultResponsiveValues };
+    let shouldUpdate = false;
+    for (const key of objectKeys(responsiveConfig)) {
+        newValues[key] = width >= responsiveConfig[key];
+        if (newValues[key] !== responsiveValues[key]) {
+            shouldUpdate = true;
+        }
+    }
+    if (shouldUpdate) {
+        responsiveValues = newValues;
+    }
+}

package/dist/hooks/react/useUnmount.js

@@ -0,0 +1,17 @@
+import { useEffect } from "react";
+import { isFunction } from "src/utils";
+import { useLatest } from "./useLatest";
+/**
+ * 在组件卸载时执行的 Hook
+ *
+ * @param {Func} effect 副作用函数
+ */
+export function useUnmount(effect) {
+    if (!isFunction(effect)) {
+        console.error(`useUnmount expected parameter is a function, got ${typeof effect}`);
+    }
+    const effectRef = useLatest(effect);
+    useEffect(() => () => {
+        effectRef.current?.();
+    }, []);
+}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./enums";
+export * from "./utils";

package/dist/types/enums/index.d.ts

@@ -0,0 +1,20 @@
+/** 屏幕响应断点 token 配置 */
+export declare const BREAK_POINT_TOKENS: {
+    readonly XS: 576;
+    readonly XSMin: 576;
+    readonly XSMax: 767;
+    readonly SM: 768;
+    readonly SMMin: 768;
+    readonly SMMax: 991;
+    readonly MD: 992;
+    readonly MDMin: 992;
+    readonly MDMax: 1199;
+    readonly LG: 1200;
+    readonly LGMin: 1200;
+    readonly LGMax: 1599;
+    readonly XL: 1600;
+    readonly XLMin: 1600;
+    readonly XLMax: 1919;
+    readonly XXL: 1920;
+    readonly XXLMin: 1920;
+};

package/dist/types/hooks/react/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./useCreation";
+export * from "./useLatest";
+export * from "./useMount";
+export * from "./useResponsive";
+export * from "./useUnmount";

package/dist/types/hooks/react/useCreation.d.ts

@@ -0,0 +1,2 @@
+import { type DependencyList } from "react";
+export declare function useCreation<T>(factory: () => T, deps: DependencyList): T;

package/dist/types/hooks/react/useLatest.d.ts

@@ -0,0 +1 @@
+export declare function useLatest<T>(value: T): import("react").RefObject<T>;

package/dist/types/hooks/react/useMount.d.ts

@@ -0,0 +1,11 @@
+import { type EffectCallback } from "react";
+type MountCallback = EffectCallback | AsyncFunc;
+/**
+ * 在组件初始化时执行的 Hook
+ * - 即使在严格模式下也只执行一次
+ * @reference https://ahooks.js.org/hooks/use-mount
+ *
+ * @param {MountCallback} effect 副作用函数
+ */
+export declare function useMount(effect: MountCallback): void;
+export {};

package/dist/types/hooks/react/useResponsive.d.ts

@@ -0,0 +1,16 @@
+import type { Breakpoint } from "@pawover/types";
+type ResponsiveValues = Record<Breakpoint, boolean>;
+interface ResponsiveHookOptions {
+    /**
+     * 紧凑布局断点
+     * - 低于此断点时使用紧凑布局
+     * @default "xl"
+     */
+    compactBreakPoint?: Breakpoint;
+}
+export declare function useResponsive(options?: ResponsiveHookOptions): {
+    responsive: ResponsiveValues;
+    current: Breakpoint;
+    isCompact: boolean;
+};
+export {};

package/dist/types/hooks/react/useUnmount.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 在组件卸载时执行的 Hook
+ *
+ * @param {Func} effect 副作用函数
+ */
+export declare function useUnmount(effect: Func): void;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./enums";
+export * from "./utils";

package/dist/types/utils/array.d.ts

@@ -0,0 +1,76 @@
+export declare function toArray<T>(candidate?: T | T[] | false): T[];
+/**
+ * 获取数组第一项
+ *
+ * @param initialList 初始数组
+ * @param saveValue 安全值
+ */
+export declare function arrayFirst<T>(initialList: readonly T[], saveValue?: T): T | undefined;
+/**
+ * 获取数组最后一项
+ *
+ * @param initialList 初始数组
+ * @param saveValue 安全值
+ */
+export declare function arrayLast<T>(initialList: readonly T[], saveValue?: T): T | undefined;
+export declare function arrayDiff<T>(initialList: readonly T[], diffList: readonly T[], match: (row: T) => PropertyKey): T[];
+/**
+ * 数组竞争
+ * - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
+ *
+ * @param initialList 数组
+ * @param match 匹配函数
+ */
+export declare function arrayCompete<T>(initialList: readonly T[], match: (a: T, b: T) => T): T | null;
+/**
+ * 统计数组的项目出现次数
+ * - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
+ *
+ * @param initialList 初始数组
+ * @param match 标识符匹配函数
+ */
+export declare function arrayCounting<T, K extends PropertyKey>(initialList: readonly T[], match: (row: T) => K): Record<string, number>;
+/**
+ * 数组项替换
+ * - 在给定的数组中，替换符合匹配函数结果的项目。只替换第一个匹配项。始终返回原始数组的副本。
+ *
+ * @param initialList 初始数组
+ * @param newItem 替换项
+ * @param match 匹配函数
+ */
+export declare function arrayReplace<T>(initialList: readonly T[], newItem: T, match: (row: T, index: number) => boolean): T[];
+/**
+ * 数组选择
+ * - 一次性应用 `filter` 和 `map` 操作
+ *
+ * @param initialList 初始数组
+ * @param filter filter 函数
+ * @param mapper map 函数
+ */
+export declare function arrayPick<T, K = T>(initialList: readonly T[], filter: (row: T, index: number) => boolean, mapper?: ((row: T, index: number) => K) | undefined): (readonly T[] & unknown[]) | K[];
+/**
+ * 数组切分
+ * - 将数组以指定的长度切分后，组合在高维数组中
+ *
+ * @param initialList 初始数组
+ * @param size 分割尺寸，默认 `10`
+ */
+export declare function arraySplit<T>(initialList: readonly T[], size?: number): T[][];
+/**
+ * 数组迭代
+ * - 运行一个函数 n 次以生成一个值，迭代函数将作为还原器运行无数次，然后返回累积值
+ *
+ * @param count 迭代次数
+ * @param iterate 迭代函数
+ * @param initialValue 初始值
+ */
+export declare function arrayIterate<T>(count: number, iterate: (currentValue: T, iteration: number) => T, initialValue: T): T;
+/**
+ * 数组合并
+ * - 通过给定的标识符匹配函数，用第二个数组中的匹配项替换第一个数组中匹配项的所有内容
+ *
+ * @param initialList 初始数组
+ * @param mergeList 待合并数组
+ * @param match 标识符匹配函数
+ */
+export declare function arrayMerge<T>(initialList: readonly T[], mergeList: readonly T[], match: (item: T) => unknown): readonly T[] & unknown[];

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

@@ -0,0 +1,6 @@
+export * from "./array";
+export * from "./object";
+export * from "./string";
+export * from "./to";
+export * from "./tree";
+export * from "./typeof";

package/dist/types/utils/object.d.ts

@@ -0,0 +1,53 @@
+import type { NonEmptyObject, UnionToTuple, ValueOf } from "type-fest";
+/**
+ * 返回对象的可枚举属性和方法的名称
+ * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+ *
+ * @param obj 对象
+ * @returns 对象所有可枚举的属性的键名
+ */
+export declare function objectKeys<O extends AnyObject>(obj: O): (keyof O)[];
+/**
+ * 返回对象的可枚举属性的值数组
+ *
+ * @param obj 对象
+ */
+export declare function objectValues<O extends AnyObject>(obj: O): UnionToTuple<ValueOf<O>>;
+/**
+ * 返回对象的可枚举属性的键/值数组
+ *
+ * @param obj 对象
+ */
+export declare function objectEntries<O extends AnyObject>(obj: O): [string & keyof O, O[keyof O]][];
+/**
+ * 对象反转
+ * - 返回交换了对象的可枚举属性的值/键对象
+ *
+ * @param obj 对象
+ */
+export declare function objectSwitch<O extends AnyObject>(obj: NonEmptyObject<O>): Record<O[keyof O], keyof O>;
+/**
+ * 对象合并
+ * - 将两个对象递归合并为一个新对象，从右到左依次使用数值
+ * - 递归只适用于子对象属性
+ */
+export declare function objectAssign<O extends AnyObject>(obj: O, overrideObj: O): O;
+export declare function objectPick<O extends AnyObject, K extends keyof O>(obj: O, keys: readonly K[]): Pick<O, K>;
+/**
+ * 获取枚举所有属性的键
+ *
+ * @param enumeration 枚举
+ */
+export declare function enumKeys<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, ...(keyof E)[]];
+/**
+ * 获取枚举所有属性的值
+ *
+ * @param enumeration 枚举
+ */
+export declare function enumValues<E extends AnyObject>(enumeration: NonEmptyObject<E>): UnionToTuple<ValueOf<E>>;
+/**
+ * 返回枚举的属性的键/值数组
+ *
+ * @param enumeration 枚举
+ */
+export declare function enumEntries<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, E[keyof E]][];

package/dist/types/utils/string.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 转义特殊字符
+ *
+ * @link https://github.com/sindresorhus/escape-string-regexp
+ * @param value 字符串
+ */
+export declare function escapeStringRegexp(value: string): string;
+/**
+ * 首字母大小写
+ */
+export declare function stringInitialCase(value: string, type: "lower" | "upper"): string;
+export declare function stringToJson<R extends AnyObject = AnyObject, D extends R = R>(data: string | null | undefined, safeValue: D): R;
+export declare function stringToValues<T extends number | string = number>(data: string | null | undefined, valueType?: "number" | "string"): T[];

package/dist/types/utils/to.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param promise
+ * @param errorExt - 可以传递给err对象的其他信息
+ */
+export declare function to<T, U = Error>(promise: Readonly<Promise<T>>, errorExt?: UnknownObject): Promise<[U, undefined] | [null, T]>;

package/dist/types/utils/tree/index.d.ts

@@ -0,0 +1,6 @@
+export { treeFilter } from "./treeFilter";
+export { treeFind } from "./treeFind";
+export { treeForEach } from "./treeForEach";
+export { treeMap } from "./treeMap";
+export { rowsToTree } from "./rowsToTree";
+export { treeToRows } from "./treeToRows";

package/dist/types/utils/tree/rowsToTree.d.ts

@@ -0,0 +1,10 @@
+import type { ChildrenKey, ParentIdKey, RowKey } from "./types";
+export interface RowsToTreeOptions<RK extends string = RowKey, PK extends string = ParentIdKey, CK extends string = ChildrenKey> {
+    rowKey?: RK;
+    parentIdKey?: PK;
+    childrenKey?: CK;
+}
+/**
+ * 行结构 转 树结构
+ */
+export declare function rowsToTree<T extends AnyObject = AnyObject, CK extends string = ChildrenKey, R = TreeLike<T, CK>, RK extends string = RowKey, PK extends string = ParentIdKey>(rows: T[], options?: RowsToTreeOptions<RK, PK, CK> | undefined): R[];

package/dist/types/utils/tree/treeFilter.d.ts

@@ -0,0 +1,6 @@
+import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
+export type TreeFilterOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
+export type TreeFilterInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;
+export type TreeFilterCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
+export declare function treeFilter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T[];
+export declare function treeFilter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T;

package/dist/types/utils/tree/treeFind.d.ts

@@ -0,0 +1,8 @@
+import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
+export type TreeFindOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
+export type TreeFindInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;
+export type TreeFindCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
+/**
+ * 查找树节点，找到第一个返回非空值的节点
+ */
+export declare function treeFind<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeFindCallback<T>, options?: TreeFindOptions<T, CK>): T | undefined;

package/dist/types/utils/tree/treeForEach.d.ts

@@ -0,0 +1,5 @@
+import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
+export type TreeForeachOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
+export type TreeForeachInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;
+export type TreeForeachCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => void;
+export declare function treeForEach<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeForeachCallback<T>, options?: TreeForeachOptions<T, CK>): void;

package/dist/types/utils/tree/treeMap.d.ts

@@ -0,0 +1,6 @@
+import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
+export type TreeMapOptions<T extends AnyObject, CK extends string> = BaseOptions<T, CK>;
+export type TreeMapInnerOption<T extends AnyObject, CK extends string> = BaseInnerOptions<T, CK>;
+export type TreeMapCallback<R extends AnyObject, T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => R;
+export declare function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>[];
+export declare function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>;

package/dist/types/utils/tree/treeToRows.d.ts

@@ -0,0 +1,9 @@
+import type { SetOptional } from "type-fest";
+import { type TreeForeachOptions } from "./treeForEach";
+import type { ChildrenKey } from "./types";
+type TreeToRowsOptions<T extends AnyObject, CK extends string = ChildrenKey> = TreeForeachOptions<T, CK>;
+/**
+ * 树结构 转 行结构
+ */
+export declare function treeToRows<T extends AnyObject, CK extends string = ChildrenKey, R extends AnyObject = SetOptional<T, CK>>(tree: T | T[], options?: TreeToRowsOptions<T, CK>): R[];
+export {};

package/dist/types/utils/tree/types.d.ts

@@ -0,0 +1,24 @@
+export type RowKey = "id";
+export type ParentIdKey = "parentId";
+export type ChildrenKey = "children";
+export type Strategy = "pre" | "post" | "breadth";
+export interface BaseCallbackMeta<T> {
+    depth: number;
+    parents?: T[];
+}
+export interface BaseOptions<T, CK extends string> {
+    childrenKey?: CK;
+    strategy?: Strategy;
+    getChildrenKey?: (row: T, meta: BaseCallbackMeta<T>) => CK | undefined;
+}
+export interface BaseInnerOptions<T, CK extends string> {
+    childrenKey: CK;
+    parents: T[];
+    depth: number;
+    getChildrenKey?: (row: T, meta: BaseCallbackMeta<T>) => CK | undefined;
+}
+export interface QueueItem<T, CK extends string> {
+    queueRow: T;
+    queueOptions: BaseInnerOptions<T, CK>;
+}
+export declare function getFinalChildrenKey<T, CK extends string>(tree: T, meta: BaseCallbackMeta<T>, options: BaseInnerOptions<T, CK>): CK;

package/dist/types/utils/typeof.d.ts

@@ -0,0 +1,29 @@
+import type { Class } from "type-fest";
+export declare function isString<T extends string>(value: unknown): value is T;
+export declare function isNumber<T extends number>(value: unknown): value is T;
+export declare function isBoolean<T extends boolean>(value: unknown): value is T;
+export declare function isObject<T extends Record<PropertyKey, unknown>>(value: unknown): value is T;
+export declare function isArray<T extends unknown[]>(value: unknown): value is T;
+export declare function isBigInt<T extends bigint>(value: unknown): value is T;
+export declare function isSymbol<T extends symbol>(value: unknown): value is T;
+export declare function isFunction<T extends Func>(value: unknown): value is T;
+export declare function isGeneratorFunction<T extends Func>(value: unknown): value is T;
+export declare function isAsyncFunction<T extends AsyncFunc>(value: unknown): value is T;
+export declare function isPromise<T extends Promise<unknown>>(value: unknown): value is T;
+export declare function isPromiseLike<T extends PromiseLike<unknown>>(value: unknown): value is T;
+export declare function isNull<T extends null>(value: unknown): value is T;
+export declare function isUndefined<T extends undefined>(value: unknown): value is T;
+export declare function isDate<T extends Date>(value: unknown): value is T;
+export declare function isRegExp<T extends RegExp>(value: unknown): value is T;
+export declare function isError<T extends Error>(value: unknown): value is T;
+export declare function isFile<T extends File>(value: unknown): value is T;
+export declare function isMap<T extends Map<unknown, unknown>>(value: unknown): value is T;
+export declare function isWeakMap<T extends WeakMap<AnyObject, unknown>>(value: unknown): value is T;
+export declare function isSet<T extends Set<unknown>>(value: unknown): value is T;
+export declare function isWeakSet<T extends WeakSet<AnyObject>>(value: unknown): value is T;
+export declare function isWindow<T extends Window>(value: unknown): value is T;
+export declare function isWebSocket<T extends WebSocket>(value: unknown): value is T;
+export declare function isURLSearchParams<T extends Window>(value: unknown): value is T;
+export declare function isClass<T extends Class<AnyObject>>(value: unknown): value is T;
+export declare function isInteger<T extends number>(value: unknown): value is T;
+export declare function isIterable<T extends Iterable<unknown>>(value: unknown): value is T;