freewind-ts-utils 0.18.2

package/eslint-config/layers/testLayer.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const testLayer: Linter.Config;

package/eslint-config/layers/testLayer.js

@@ -0,0 +1,46 @@
+import { doExpr as e } from "../../common/doExpr.js";
+import "../../common/index.js";
+import { tsLayer as t } from "./tsLayer.js";
+import { withRuleOverrides as n } from "../utils/withRuleOverrides.js";
+import r from "@factory/eslint-plugin";
+import i from "@vitest/eslint-plugin";
+//#region src/eslint-config/layers/testLayer.ts
+var a = {
+	...t,
+	plugins: {
+		...t.plugins,
+		"@factory": r,
+		vitest: i
+	},
+	rules: n(t.rules, {
+		"@typescript-eslint/no-explicit-any": "off",
+		"@typescript-eslint/no-empty-object-type": "off",
+		"@typescript-eslint/no-unsafe-function-type": "off",
+		"@typescript-eslint/no-wrapper-object-types": "off",
+		"@typescript-eslint/no-restricted-types": "off",
+		"@typescript-eslint/require-await": "off",
+		"@factory/test-file-location": "error",
+		"vitest/no-restricted-matchers": ["error", e(() => {
+			let e = "Use toMatchInlineSnapshot() or toThrowErrorMatchingInlineSnapshot() instead if possible";
+			return {
+				toMatchSnapshot: "Use toMatchInlineSnapshot() instead if possible",
+				toThrowErrorMatchingSnapshot: "Use toThrowErrorMatchingInlineSnapshot() instead if possible",
+				toBe: e,
+				toEqual: e,
+				toStrictEqual: e,
+				toMatchObject: e,
+				toContain: e,
+				toContainEqual: e,
+				toBeNull: e,
+				toBeUndefined: e,
+				toBeTruthy: e,
+				toBeFalsy: e,
+				toHaveProperty: e,
+				toThrow: e,
+				toThrowError: e
+			};
+		})]
+	})
+};
+//#endregion
+export { a as testLayer };

package/eslint-config/layers/tsLayer.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare const tsLayer: Linter.Config;

package/eslint-config/layers/tsLayer.js

@@ -0,0 +1,70 @@
+import { freewindSingleExportPlugin as e } from "../plugins/freewindSingleExportPlugin.js";
+import t from "typescript-eslint";
+import n from "eslint-plugin-filename-match-export";
+import r from "eslint-plugin-no-default-export";
+import i from "eslint-plugin-react";
+import a from "eslint-plugin-require-react-fc";
+//#region src/eslint-config/layers/tsLayer.ts
+var o = (e) => `应尽力收窄类型：${e}；确属必要/合理 → 向用户确认后方可使用eslint-disable-next-line`, s = o("Record value 写具体类型，别用 unknown"), c = {
+	...t.configs.base,
+	languageOptions: {
+		parser: t.parser,
+		parserOptions: { projectService: !0 }
+	},
+	settings: { react: { version: "detect" } },
+	plugins: {
+		"@typescript-eslint": t.plugin,
+		react: i,
+		"single-export": e,
+		"filename-match-export": n,
+		"no-default-export": r,
+		"require-react-fc": a
+	},
+	rules: {
+		"single-export/single-export": "error",
+		"no-default-export/no-default-export": "error",
+		"@typescript-eslint/prefer-destructuring": [
+			"error",
+			{
+				array: !1,
+				object: !1
+			},
+			{
+				enforceForRenamedProperties: !0,
+				enforceForDeclarationWithTypeAnnotation: !1
+			}
+		],
+		"@typescript-eslint/no-empty-function": ["error", { allow: ["arrowFunctions"] }],
+		eqeqeq: [
+			"error",
+			"always",
+			{ null: "ignore" }
+		],
+		"@typescript-eslint/require-await": "error",
+		"@typescript-eslint/no-explicit-any": "error",
+		"@typescript-eslint/no-empty-object-type": "error",
+		"@typescript-eslint/no-unsafe-function-type": "error",
+		"@typescript-eslint/no-wrapper-object-types": "error",
+		"@typescript-eslint/no-restricted-types": ["error", { types: {
+			object: o("object → interface 或具体 shape"),
+			"Record<string,unknown>": s,
+			"Record<number,unknown>": s,
+			unknown: o("unknown → 具体类型")
+		} }],
+		"@typescript-eslint/explicit-module-boundary-types": ["error", {
+			allowArgumentsExplicitlyTypedAsAny: !1,
+			allowDirectConstAssertionInArrowFunctions: !0,
+			allowHigherOrderFunctions: !0,
+			allowTypedFunctionExpressions: !0,
+			allowOverloadFunctions: !0
+		}],
+		"react/function-component-definition": ["error", {
+			namedComponents: "arrow-function",
+			unnamedComponents: "arrow-function"
+		}],
+		"react/no-deprecated": "error",
+		"require-react-fc/require-react-fc": "error"
+	}
+};
+//#endregion
+export { c as tsLayer };

package/eslint-config/plugins/freewindSingleExportPlugin.d.ts

@@ -0,0 +1,2 @@
+import { ESLint } from 'eslint';
+export declare const freewindSingleExportPlugin: ESLint.Plugin;

package/eslint-config/plugins/freewindSingleExportPlugin.js

@@ -0,0 +1,47 @@
+//#region src/eslint-config/plugins/freewindSingleExportPlugin.ts
+function e(e) {
+	if (e.type === "FunctionDeclaration") return !0;
+	if (e.type !== "VariableDeclarator") return !1;
+	let t = e.init?.type;
+	return t === "FunctionExpression" || t === "ArrowFunctionExpression";
+}
+function t(t, n, r) {
+	let i = n.sourceCode.getScope(r);
+	for (; i !== null;) {
+		let n = i.variables.find((e) => e.name === t);
+		if (n) return n.defs.some((t) => e(t.node));
+		i = i.upper;
+	}
+	return !1;
+}
+function n(n, r) {
+	if (n.type !== "ExportNamedDeclaration") return !1;
+	let i = n;
+	return i.declaration?.type === "FunctionDeclaration" ? !0 : i.declaration?.type === "VariableDeclaration" ? i.declaration.declarations?.some((t) => e(t)) ?? !1 : !i.specifiers?.length || i.declaration ? !1 : i.specifiers.some((e) => e.exportKind !== "type" && e.local?.type === "Identifier" && e.local.name !== void 0 && t(e.local.name, r, i));
+}
+var r = { rules: { "single-export": {
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce a single function export per file" },
+		schema: [],
+		messages: { multipleExports: "Only one export is allowed per file. Found {{count}} exports. Split functionality across multiple files following domain boundaries." }
+	},
+	create(e) {
+		let t = [];
+		return {
+			ExportNamedDeclaration(e) {
+				(e.declaration || e.specifiers?.length) && !e.source && t.push(e);
+			},
+			"Program:exit"() {
+				let r = t.filter((t) => n(t, e)), i = r.length;
+				if (!(i <= 1)) for (let [t, n] of r.entries()) t > 0 && e.report({
+					node: n,
+					messageId: "multipleExports",
+					data: { count: String(i) }
+				});
+			}
+		};
+	}
+} } };
+//#endregion
+export { r as freewindSingleExportPlugin };

package/eslint-config/utils/withRuleOverrides.d.ts

@@ -0,0 +1,2 @@
+import { Linter } from 'eslint';
+export declare function withRuleOverrides(rules?: Partial<Linter.RulesRecord>, overrides?: Partial<Linter.RulesRecord>): Linter.RulesRecord;

package/eslint-config/utils/withRuleOverrides.js

@@ -0,0 +1,9 @@
+//#region src/eslint-config/utils/withRuleOverrides.ts
+function e(e = {}, t = {}) {
+	return {
+		...e,
+		...t
+	};
+}
+//#endregion
+export { e as withRuleOverrides };

package/index.d.ts

@@ -0,0 +1 @@
+export * from './common/index.js';

package/index.js

@@ -0,0 +1,49 @@
+import { fuzzyMatchPath as e } from "./common/fuzzy/fuzzyMatchPath.js";
+import { fuzzyMatch as t } from "./common/fuzzy/fuzzyMatch.js";
+import { formatSize as n } from "./common/formatSize.js";
+import { truncateString as r } from "./common/truncateString.js";
+import { anyToString as i } from "./common/anyToString/anyToString.js";
+import { assertsType as a } from "./common/assertsType.js";
+import { buildSequence as o } from "./common/buildSequence.js";
+import { deepClone as s } from "./common/deepClone.js";
+import { deepEqual as c } from "./common/deepEqual.js";
+import { deepParseJsonStrings as l } from "./common/deepParseJsonStrings.js";
+import { dependsOn as u } from "./common/dependsOn.js";
+import { doExpr as d } from "./common/doExpr.js";
+import { flatChildren as f } from "./common/flatChildren.js";
+import { formatDecimal as p } from "./common/formatDecimal.js";
+import { formatFriendlyTime as m } from "./common/formatFriendlyTime.js";
+import { isNonNil as h } from "./common/isNonNil.js";
+import { buildTree as g } from "./common/tree/buildTree.js";
+import { isRecord as _ } from "./common/isRecord.js";
+import { isJsonRecord as v } from "./common/jsonRecord/isJsonRecord.js";
+import { filterJsonRecord as y } from "./common/jsonRecord/filterJsonRecord.js";
+import { flatTree as b } from "./common/tree/flatTree.js";
+import { isEmptyRecord as x } from "./common/isEmptyRecord.js";
+import { isNil as S } from "./common/isNil.js";
+import { isSimpleInt as C } from "./common/simpleInt/isSimpleInt.js";
+import { isSimpleIntInputing as w } from "./common/simpleInt/isSimpleIntInputing.js";
+import { isSimpleNumber as T } from "./common/simpleInt/isSimpleNumber.js";
+import { isSimpleNumberInputing as E } from "./common/simpleInt/isSimpleNumberInputing.js";
+import { mapJsonRecord as D } from "./common/jsonRecord/mapJsonRecord.js";
+import { mapTree as O } from "./common/tree/mapTree.js";
+import { modifyJsonRecord as k } from "./common/jsonRecord/modifyJsonRecord.js";
+import { onlyUnique as A } from "./common/onlyUnique.js";
+import { parseSimpleIntOrNil as j } from "./common/simpleInt/parseSimpleIntOrNil.js";
+import { parseSimpleInt as M } from "./common/simpleInt/parseSimpleInt.js";
+import { parseSimpleNumberOrNil as N } from "./common/simpleInt/parseSimpleNumberOrNil.js";
+import { parseSimpleNumber as P } from "./common/simpleInt/parseSimpleNumber.js";
+import { pipe as F } from "./common/pipe.js";
+import { pipeNonNil as I } from "./common/pipeNonNil.js";
+import { jsonRecordDiff as L } from "./common/jsonRecord/jsonRecordDiff.js";
+import { pruneTree as R } from "./common/tree/pruneTree.js";
+import { sortTree as z } from "./common/tree/sortTree.js";
+import { tap as B } from "./common/tap.js";
+import { treeToArray as V } from "./common/tree/treeToArray.js";
+import { treeToRows as H } from "./common/tree/treeToRows.js";
+import { truncateJsonStrings as U } from "./common/truncateJsonStrings.js";
+import { tryParsePartialJson as W } from "./common/tryParsePartialJson.js";
+import { walkJsonRecord as G } from "./common/jsonRecord/walkJsonRecord.js";
+import { walkTree as K } from "./common/tree/walkTree.js";
+import "./common/index.js";
+export { i as anyToString, a as assertsType, o as buildSequence, g as buildTree, s as deepClone, c as deepEqual, l as deepParseJsonStrings, u as dependsOn, d as doExpr, y as filterJsonRecord, f as flatChildren, b as flatTree, p as formatDecimal, m as formatFriendlyTime, n as formatSize, t as fuzzyMatch, e as fuzzyMatchPath, x as isEmptyRecord, v as isJsonRecord, S as isNil, h as isNonNil, _ as isRecord, C as isSimpleInt, w as isSimpleIntInputing, T as isSimpleNumber, E as isSimpleNumberInputing, L as jsonRecordDiff, D as mapJsonRecord, O as mapTree, k as modifyJsonRecord, A as onlyUnique, M as parseSimpleInt, j as parseSimpleIntOrNil, P as parseSimpleNumber, N as parseSimpleNumberOrNil, F as pipe, I as pipeNonNil, R as pruneTree, z as sortTree, B as tap, V as treeToArray, H as treeToRows, U as truncateJsonStrings, r as truncateString, W as tryParsePartialJson, G as walkJsonRecord, K as walkTree };

package/node/index.d.ts

@@ -0,0 +1,2 @@
+export * from './md5.js';
+export * from './uuid.js';

package/node/index.js

@@ -0,0 +1,3 @@
+import { md5 as e } from "./md5.js";
+import { uuid as t } from "./uuid.js";
+export { e as md5, t as uuid };

package/node/md5.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns the MD5 hex digest of a UTF-8 string.
+ *
+ * Node.js only. MD5 is unsuitable for passwords, signatures, or other security-sensitive use.
+ *
+ * @example
+ * ```ts
+ * md5('hello') // '5d41402abc4b2a76b9719d911017c592'
+ * ```
+ */
+export declare function md5(value: string): string;

package/node/md5.js

@@ -0,0 +1,7 @@
+import { createHash as e } from "node:crypto";
+//#region src/node/md5.ts
+function t(t) {
+	return e("md5").update(t, "utf8").digest("hex");
+}
+//#endregion
+export { t as md5 };

package/node/uuid.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns an RFC 4122 version 4 UUID string.
+ *
+ * Node.js only.
+ *
+ * @example
+ * ```ts
+ * uuid() // '36b8f84d-df4e-4d49-b662-bcde71a8764f'
+ * ```
+ */
+export declare function uuid(): string;

package/node/uuid.js

@@ -0,0 +1,7 @@
+import { randomUUID as e } from "node:crypto";
+//#region src/node/uuid.ts
+function t() {
+	return e();
+}
+//#endregion
+export { t as uuid };

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "freewind-ts-utils",
+  "version": "0.18.2",
+  "description": "TypeScript utils for common, node, and browser usage",
+  "license": "MIT",
+  "type": "module",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./common": {
+      "types": "./common/index.d.ts",
+      "default": "./common/index.js"
+    },
+    "./common/*": {
+      "types": "./common/*.d.ts",
+      "default": "./common/*.js"
+    },
+    "./node": {
+      "types": "./node/index.d.ts",
+      "default": "./node/index.js"
+    },
+    "./node/*": {
+      "types": "./node/*.d.ts",
+      "default": "./node/*.js"
+    },
+    "./react": {
+      "types": "./react/index.d.ts",
+      "default": "./react/index.js"
+    },
+    "./react/*": {
+      "types": "./react/hooks/*.d.ts",
+      "default": "./react/hooks/*.js"
+    },
+    "./react/useInputEvent": {
+      "types": "./react/hooks/useInputEvent/index.d.ts",
+      "default": "./react/hooks/useInputEvent/index.js"
+    },
+    "./react/useOverlayStack": {
+      "types": "./react/hooks/useOverlayStack/index.d.ts",
+      "default": "./react/hooks/useOverlayStack/index.js"
+    },
+    "./react/ink-components": {
+      "types": "./react/ink-components/index.d.ts",
+      "default": "./react/ink-components/index.js"
+    },
+    "./react/ink-components/*": {
+      "types": "./react/ink-components/*/index.d.ts",
+      "default": "./react/ink-components/*/index.js"
+    },
+    "./antd": {
+      "types": "./antd/index.d.ts",
+      "default": "./antd/index.js"
+    },
+    "./antd/*": {
+      "types": "./antd/*/index.d.ts",
+      "default": "./antd/*/index.js"
+    },
+    "./vite-plugins": {
+      "types": "./vite-plugins/index.d.ts",
+      "default": "./vite-plugins/index.js"
+    },
+    "./vite-plugins/*": {
+      "types": "./vite-plugins/*.d.ts",
+      "default": "./vite-plugins/*.js"
+    },
+    "./eslint-config": {
+      "types": "./eslint-config/index.d.ts",
+      "default": "./eslint-config/index.js"
+    },
+    "./prettier-config": {
+      "types": "./prettier-config/index.d.ts",
+      "default": "./prettier-config/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.{json,css,md}": "prettier --write"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@factory/eslint-plugin": "0.1.0",
+    "@vitest/eslint-plugin": "1.6.19",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-filename-match-export": "1.4.0",
+    "eslint-plugin-no-default-export": "1.0.0",
+    "eslint-plugin-react": "7.37.5",
+    "eslint-plugin-require-react-fc": "1.0.1",
+    "globals": "^17.6.0",
+    "magic-string": "^0.30.21",
+    "typescript-eslint": "^8.60.1"
+  },
+  "peerDependencies": {
+    "ahooks": "^3",
+    "antd": "^6",
+    "ink": "^7",
+    "react": ">=19.2.0",
+    "react-dom": ">=19.2.0",
+    "react-json-view-lite": "^2.5.0",
+    "vite": "^6 || ^8"
+  }
+}

package/prettier-config/freewindPrettierPreset.d.ts

@@ -0,0 +1,2 @@
+import { Config } from 'prettier';
+export declare const freewindPrettierPreset: Config;

package/prettier-config/freewindPrettierPreset.js

@@ -0,0 +1,4 @@
+//#region src/prettier-config/freewindPrettierPreset.ts
+var e = { printWidth: 160 };
+//#endregion
+export { e as freewindPrettierPreset };

package/prettier-config/index.d.ts

@@ -0,0 +1 @@
+export { freewindPrettierPreset } from './freewindPrettierPreset.js';

package/prettier-config/index.js

@@ -0,0 +1,2 @@
+import { freewindPrettierPreset as e } from "./freewindPrettierPreset.js";
+export { e as freewindPrettierPreset };

package/react/hooks/useCopyToClipboard.d.ts

@@ -0,0 +1,10 @@
+type Options = {
+    onError?: (error: unknown) => void;
+};
+export declare function useCopyToClipboard(options?: Options): {
+    copied: boolean;
+    copying: boolean;
+    copy: (this: unknown, value: string) => Promise<boolean>;
+    reset: (this: unknown) => void;
+};
+export {};

package/react/hooks/useCopyToClipboard.js

@@ -0,0 +1,28 @@
+import { useState as e } from "react";
+import { useMemoizedFn as t } from "ahooks";
+//#region src/react/hooks/useCopyToClipboard.ts
+var n = () => void 0;
+function r(r = {}) {
+	let i = r.onError ?? n, [a, o] = e(!1), [s, c] = e(!1);
+	return {
+		copied: a,
+		copying: s,
+		copy: t(async (e) => {
+			if (s) return !1;
+			if (!navigator.clipboard?.writeText) throw Error("Clipboard API is unavailable");
+			c(!0), o(!1);
+			try {
+				return await navigator.clipboard.writeText(e), o(!0), !0;
+			} catch (e) {
+				throw i(e), e;
+			} finally {
+				c(!1);
+			}
+		}),
+		reset: t(() => {
+			o(!1);
+		})
+	};
+}
+//#endregion
+export { r as useCopyToClipboard };

package/react/hooks/useDeepCompareSelector.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns a stable selector that reuses the previous result when `deepEqual` says
+ * the next selected value is unchanged. Pair it with `useContextSelector` to
+ * avoid rerenders from freshly created object or array slices.
+ *
+ * @example
+ * ```tsx
+ * export const useStore = <T,>(selector: (store: CliStore) => T) => {
+ *   const deepSelector = useDeepCompareSelector(selector)
+ *
+ *   return useContextSelector(CliStoreContext, (store) => {
+ *     if (!store) throw new Error('CliStoreProvider is missing')
+ *     return deepSelector(store)
+ *   })
+ * }
+ *
+ * const { name1, name2 } = useStore((store) => ({
+ *   name1: store.name1,
+ *   name2: store.name2,
+ * }))
+ * ```
+ */
+export declare function useDeepCompareSelector<T, S>(selector: (value: T) => S): (value: T) => S;

package/react/hooks/useDeepCompareSelector.js

@@ -0,0 +1,14 @@
+import { deepEqual as e } from "../../common/deepEqual.js";
+import { useCallback as t, useRef as n } from "react";
+//#region src/react/hooks/useDeepCompareSelector.ts
+function r(r) {
+	let i = n(r);
+	i.current = r;
+	let a = n(void 0);
+	return t((t) => {
+		let n = i.current(t);
+		return a.current !== void 0 && e(a.current, n) ? a.current : (a.current = n, n);
+	}, []);
+}
+//#endregion
+export { r as useDeepCompareSelector };

package/react/hooks/useInputEvent/_internal/ink-input/index.d.ts

@@ -0,0 +1,2 @@
+export { default as parseKeypress, nonAlphanumericKeys } from './parse-keypress.js';
+export { createInputParser } from './input-parser.js';

package/react/hooks/useInputEvent/_internal/ink-input/index.js

@@ -0,0 +1,3 @@
+import e, { nonAlphanumericKeys as t } from "./parse-keypress.js";
+import { createInputParser as n } from "./input-parser.js";
+export { n as createInputParser, t as nonAlphanumericKeys, e as parseKeypress };

package/react/hooks/useInputEvent/_internal/ink-input/input-parser.d.ts

@@ -0,0 +1,6 @@
+export function createInputParser(): {
+    push(chunk: any): any[];
+    hasPendingEscape(): boolean;
+    flushPendingEscape(): string | undefined;
+    reset(): void;
+};

package/react/hooks/useInputEvent/_internal/ink-input/input-parser.js

@@ -0,0 +1,98 @@
+//#region src/react/hooks/useInputEvent/_internal/ink-input/input-parser.js
+var e = "\x1B", t = "\x1B[200~", n = "\x1B[201~", r = (e) => e >= 48 && e <= 63, i = (e) => e >= 32 && e <= 47, a = (e) => e >= 64 && e <= 126, o = (e, t, n) => {
+	let o = t + n + 1, s = o;
+	for (; s < e.length; s++) {
+		let n = e.codePointAt(s);
+		if (n === void 0) return "pending";
+		if (!(r(n) || i(n)) && !(n === 91 && s === o)) return a(n) ? {
+			sequence: e.slice(t, s + 1),
+			nextIndex: s + 1
+		} : void 0;
+	}
+	return "pending";
+}, s = (e, t, n) => {
+	let r = t + n + 2;
+	if (r > e.length) return "pending";
+	let i = e.codePointAt(r - 1);
+	if (!(i === void 0 || !a(i))) return {
+		sequence: e.slice(t, r),
+		nextIndex: r
+	};
+}, c = (e, t, n) => {
+	let r = e[t + n];
+	if (r === void 0) return "pending";
+	if (r === "[") return o(e, t, n);
+	if (r === "O") return s(e, t, n);
+}, l = (e, t) => {
+	let n = e.codePointAt(t + 1), r = n !== void 0 && n > 65535 ? 2 : 1, i = t + 1 + r;
+	return {
+		sequence: e.slice(t, i),
+		nextIndex: i
+	};
+}, u = (t, n) => {
+	if (n === t.length - 1) return "pending";
+	if (t[n + 1] === e) {
+		if (n + 2 >= t.length) return "pending";
+		let e = c(t, n, 2);
+		return e === "pending" ? "pending" : e || {
+			sequence: t.slice(n, n + 2),
+			nextIndex: n + 2
+		};
+	}
+	let r = c(t, n, 1);
+	return r === "pending" ? "pending" : r || l(t, n);
+}, d = (e, t) => {
+	let n = 0;
+	for (let r = 0; r < e.length; r++) {
+		let i = e[r];
+		(i === "" || i === "\b") && (r > n && t.push(e.slice(n, r)), t.push(i), n = r + 1);
+	}
+	n < e.length && t.push(e.slice(n));
+}, f = (r) => {
+	let i = [], a = 0, o = (e) => ({
+		events: i,
+		pending: r.slice(e)
+	});
+	for (; a < r.length;) {
+		let s = r.indexOf(e, a);
+		if (s === -1) return d(r.slice(a), i), {
+			events: i,
+			pending: ""
+		};
+		s > a && d(r.slice(a, s), i);
+		let c = u(r, s);
+		if (c === "pending") return o(s);
+		if (c.sequence === t) {
+			let e = c.nextIndex, t = r.indexOf(n, e);
+			if (t === -1) return o(s);
+			i.push({ paste: r.slice(e, t) }), a = t + 6;
+			continue;
+		}
+		i.push(c.sequence), a = c.nextIndex;
+	}
+	return {
+		events: i,
+		pending: ""
+	};
+}, p = () => {
+	let n = "";
+	return {
+		push(e) {
+			let t = f(n + e);
+			return n = t.pending, t.events;
+		},
+		hasPendingEscape() {
+			return n.startsWith(e) && !n.startsWith(t) && n !== "\x1B[200";
+		},
+		flushPendingEscape() {
+			if (!n.startsWith(e)) return;
+			let t = n;
+			return n = "", t;
+		},
+		reset() {
+			n = "";
+		}
+	};
+};
+//#endregion
+export { p as createInputParser };

package/react/hooks/useInputEvent/_internal/ink-input/kitty-keyboard.d.ts

@@ -0,0 +1,19 @@
+export function resolveFlags(flags: any): number;
+export namespace kittyFlags {
+    let disambiguateEscapeCodes: number;
+    let reportEventTypes: number;
+    let reportAlternateKeys: number;
+    let reportAllKeysAsEscapeCodes: number;
+    let reportAssociatedText: number;
+}
+export namespace kittyModifiers {
+    export let shift: number;
+    export let alt: number;
+    export let ctrl: number;
+    let _super: number;
+    export { _super as super };
+    export let hyper: number;
+    export let meta: number;
+    export let capsLock: number;
+    export let numLock: number;
+}

package/react/hooks/useInputEvent/_internal/ink-input/kitty-keyboard.js

@@ -0,0 +1,13 @@
+//#region src/react/hooks/useInputEvent/_internal/ink-input/kitty-keyboard.js
+var e = {
+	shift: 1,
+	alt: 2,
+	ctrl: 4,
+	super: 8,
+	hyper: 16,
+	meta: 32,
+	capsLock: 64,
+	numLock: 128
+};
+//#endregion
+export { e as kittyModifiers };