@fangzhongya/utils 0.0.80 → 0.0.82

package/dist/basic/string/toJsons.d.ts

@@ -1,61 +1,2 @@
-type ObjAny<T = any> = Record<string | number | symbol, T>;
-declare const TYPE_MARKERS: {
-    CIRCULAR_REF: string;
-    FUNCTION_REF: string;
-    CODE_BLOCK: string;
-    /**内置对象*/
-    SYMBOL: string;
-    FUNCTION: string;
-    UNDEFINED: string;
-    DATE: string;
-    REGEXP: string;
-    NAN: string;
-    BIGINT: string;
-    MAP: string;
-    SET: string;
-    ARRAY_BUFFER: string;
-    TYPED_ARRAY: string;
-    DATA_VIEW: string;
-    ERROR: string;
-    URL: string;
-    INFINITY: string;
-    NEGATIVE_INFINITY: string;
-    INT8_ARRAY: string;
-    UINT8_ARRAY: string;
-    UINT8_CLAMPED_ARRAY: string;
-    INT16_ARRAY: string;
-    UINT16_ARRAY: string;
-    INT32_ARRAY: string;
-    UINT32_ARRAY: string;
-    FLOAT32_ARRAY: string;
-    FLOAT64_ARRAY: string;
-    BIGINT64_ARRAY: string;
-    BIGUINT64_ARRAY: string;
-};
-/**
- * 安全序列化函数（支持更多内置对象）
- */
-declare function toJSONSStringify(obj: any, space?: number | string, filtrat?: string): string;
-/**
- * 安全反序列化函数（完整支持更多内置对象）
- */
-declare function toJSONSParse<T = any>(str: string, context?: ObjAny): T;
-type CodeBlock = {
-    params: string[];
-    body: string;
-    name?: string;
-};
-/**
- * 序列化函数引用
- */
-declare function serializeFunctionRef(key: string): {
-    [TYPE_MARKERS.FUNCTION_REF]: string;
-};
-/**
- * 序列化代码块
- */
-declare function serializeCodeBlock(value: CodeBlock): {
-    [TYPE_MARKERS.CODE_BLOCK]: CodeBlock;
-};
-
-export { type CodeBlock, serializeCodeBlock, serializeFunctionRef, toJSONSParse, toJSONSStringify };
+import { a as toJSONSStringify, i as toJSONSParse, n as serializeCodeBlock, r as serializeFunctionRef, t as CodeBlock } from "../../toJsons-CcWSsCUX.js";
+export { CodeBlock, serializeCodeBlock, serializeFunctionRef, toJSONSParse, toJSONSStringify };

package/dist/basic/string/toJsons.js

@@ -1,15 +1,335 @@
-import {
-  serializeCodeBlock,
-  serializeFunctionRef,
-  toJSONSParse,
-  toJSONSStringify
-} from "../../chunk-ZADO6V3Z.js";
-import "../../chunk-Q6BNW3MO.js";
-import "../../chunk-SHNH5OEU.js";
-import "../../chunk-MLKGABMK.js";
-export {
-  serializeCodeBlock,
-  serializeFunctionRef,
-  toJSONSParse,
-  toJSONSStringify
+import { getObjValue } from "../object/objValue.js";
+import { toFunction } from "./toFunction.js";
+//#region packages/basic/string/toJsons.ts
+const TYPE_MARKERS = {
+	CIRCULAR_REF: "_CR_",
+	FUNCTION_REF: "_FR_",
+	CODE_BLOCK: "_CB_",
+	/**内置对象*/
+	SYMBOL: "_Sy_",
+	FUNCTION: "_F_",
+	UNDEFINED: "_UN_",
+	DATE: "_D_",
+	REGEXP: "_R_",
+	NAN: "_N_",
+	BIGINT: "_BI_",
+	MAP: "_M_",
+	SET: "_S_",
+	ARRAY_BUFFER: "_AB_",
+	TYPED_ARRAY: "_TA_",
+	DATA_VIEW: "_DV_",
+	ERROR: "_E_",
+	URL: "_U_",
+	INFINITY: "_I_",
+	NEGATIVE_INFINITY: "_NI_",
+	INT8_ARRAY: "_I8_",
+	UINT8_ARRAY: "_U8_",
+	UINT8_CLAMPED_ARRAY: "_U8C_",
+	INT16_ARRAY: "_I1_",
+	UINT16_ARRAY: "_U1_",
+	INT32_ARRAY: "_I3_",
+	UINT32_ARRAY: "_U3_",
+	FLOAT32_ARRAY: "_F3_",
+	FLOAT64_ARRAY: "_F6_",
+	BIGINT64_ARRAY: "_BI6_",
+	BIGUINT64_ARRAY: "_BU6_"
 };
+const arrayBufferUtils = {
+	encode: (buffer) => {
+		if (typeof Buffer !== "undefined") {
+			const bytes = new Uint8Array(buffer);
+			let binary = "";
+			bytes.forEach((byte) => binary += String.fromCharCode(byte));
+			return btoa(binary);
+		}
+		if (typeof btoa === "function") {
+			const bytes = new Uint8Array(buffer);
+			let binary = "";
+			for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+			return btoa(binary);
+		}
+		throw new Error("ArrayBuffer encoding not supported in this environment");
+	},
+	decode: (base64Str) => {
+		if (typeof Buffer !== "undefined") {
+			const binaryString = atob(base64Str);
+			const bytes = new Uint8Array(binaryString.length);
+			for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+			return bytes.buffer;
+		}
+		if (typeof atob === "function") {
+			const binaryString = atob(base64Str);
+			const bytes = new Uint8Array(binaryString.length);
+			for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+			return bytes.buffer;
+		}
+		throw new Error("ArrayBuffer decoding not supported in this environment");
+	},
+	toByteArray: (buffer) => {
+		return Array.from(new Uint8Array(buffer));
+	},
+	fromByteArray: (array) => {
+		const buffer = new ArrayBuffer(array.length);
+		const view = new Uint8Array(buffer);
+		array.forEach((value, index) => view[index] = value);
+		return buffer;
+	}
+};
+/**
+* 获取对象的完整路径
+*/
+function getObjectPath(obj, key, seen) {
+	if (obj === null || obj === void 0) return String(key);
+	if (!Object.prototype.hasOwnProperty.call(obj, key)) return String(key);
+	const objPath = seen.get(obj);
+	if (objPath) return Array.isArray(obj) ? `${objPath}[${key}]` : `${objPath}.${key}`;
+	const path = `root${key}`;
+	if (typeof obj === "object" && obj !== null && !seen.has(obj)) seen.set(obj, path);
+	return path;
+}
+/**
+* 获取对象的完整路径的数据
+* @param obj 原始对象
+* @param key getObjectPath 返回的路径
+* @returns 对应路径的值
+*/
+/**
+* 获取对象的完整路径的数据
+* @param obj 原始对象
+* @param key getObjectPath 返回的路径
+* @returns 对应路径的值
+*/
+function getObjectPathValue(obj, key) {
+	if (key === "root") return obj;
+	let path = key;
+	if (path.startsWith("root")) path = path.slice(4);
+	if (!path) return obj;
+	const parts = [];
+	let current = "";
+	let inArray = false;
+	let bracketDepth = 0;
+	for (let i = 0; i < path.length; i++) {
+		const char = path[i];
+		if (char === "[") {
+			if (current) {
+				parts.push(current);
+				current = "";
+			}
+			inArray = true;
+			current += char;
+			bracketDepth++;
+		} else if (char === "]") {
+			current += char;
+			bracketDepth--;
+			if (bracketDepth === 0) {
+				const arrayIndex = current.slice(1, -1);
+				parts.push(arrayIndex);
+				current = "";
+				inArray = false;
+			}
+		} else if (char === "." && !inArray) {
+			if (current) {
+				parts.push(current);
+				current = "";
+			}
+		} else current += char;
+	}
+	if (current) parts.push(current);
+	let result = obj;
+	for (const part of parts) {
+		if (result === null || result === void 0) return;
+		const num = Number(part);
+		const index = !isNaN(num) && part.trim() !== "" ? num : part;
+		result = result[index];
+	}
+	return result;
+}
+/**
+* 安全序列化函数（支持更多内置对象）
+*/
+function toJSONSStringify(obj, space, filtrat = "__") {
+	const seen = /* @__PURE__ */ new WeakMap();
+	return JSON.stringify(obj, function(key, value) {
+		const fullPath = this === null || this === void 0 ? key : getObjectPath(this, key, seen);
+		if (filtrat && key.startsWith(filtrat)) return;
+		if (value === null) return null;
+		if (typeof value === "object" && value !== null) {
+			const existingPath = seen.get(value);
+			if (existingPath && existingPath !== fullPath) return { [TYPE_MARKERS.CIRCULAR_REF]: existingPath };
+			if (!seen.has(value)) seen.set(value, fullPath);
+		}
+		if (this[key] instanceof Date) return { [TYPE_MARKERS.DATE]: this[key].getTime() };
+		if (this[key] instanceof URL) return { [TYPE_MARKERS.URL]: this[key].href };
+		if (value === Infinity) return { [TYPE_MARKERS.INFINITY]: 1 };
+		if (value === -Infinity) return { [TYPE_MARKERS.NEGATIVE_INFINITY]: 1 };
+		if (value === void 0) return { [TYPE_MARKERS.UNDEFINED]: 1 };
+		if (Object.is(value, NaN)) return { [TYPE_MARKERS.NAN]: 1 };
+		switch (typeof value) {
+			case "bigint": return { [TYPE_MARKERS.BIGINT]: value.toString() };
+			case "symbol": return { [TYPE_MARKERS.SYMBOL]: {
+				k: Symbol.keyFor(value) ?? 0,
+				d: value.description || ""
+			} };
+			case "function": return { [TYPE_MARKERS.FUNCTION]: value.toString() };
+			case "object":
+				if (value instanceof RegExp) return { [TYPE_MARKERS.REGEXP]: {
+					s: value.source,
+					f: value.flags
+				} };
+				if (value instanceof Map) return { [TYPE_MARKERS.MAP]: Array.from(value.entries()) };
+				if (value instanceof Set) return { [TYPE_MARKERS.SET]: Array.from(value.values()) };
+				if (value instanceof ArrayBuffer) return { [TYPE_MARKERS.ARRAY_BUFFER]: arrayBufferUtils.encode(value) };
+				if (value instanceof Int8Array) return { [TYPE_MARKERS.INT8_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Uint8Array) return { [TYPE_MARKERS.UINT8_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Uint8ClampedArray) return { [TYPE_MARKERS.UINT8_CLAMPED_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Int16Array) return { [TYPE_MARKERS.INT16_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Uint16Array) return { [TYPE_MARKERS.UINT16_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Int32Array) return { [TYPE_MARKERS.INT32_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Uint32Array) return { [TYPE_MARKERS.UINT32_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Float32Array) return { [TYPE_MARKERS.FLOAT32_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof Float64Array) return { [TYPE_MARKERS.FLOAT64_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof BigInt64Array) return { [TYPE_MARKERS.BIGINT64_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof BigUint64Array) return { [TYPE_MARKERS.BIGUINT64_ARRAY]: arrayBufferUtils.toByteArray(value.buffer) };
+				if (value instanceof DataView) return { [TYPE_MARKERS.DATA_VIEW]: {
+					b: arrayBufferUtils.encode(value.buffer),
+					o: value.byteOffset,
+					l: value.byteLength
+				} };
+				if (value instanceof Error) return { [TYPE_MARKERS.ERROR]: {
+					n: value.name,
+					m: value.message,
+					s: value.stack
+				} };
+		}
+		return value;
+	}, space);
+}
+/**
+* 安全反序列化函数（完整支持更多内置对象）
+*/
+function toJSONSParse(str, context) {
+	try {
+		const parsed = JSON.parse(str, (key, value) => {
+			if (value && typeof value === "object") {
+				const markers = Object.keys(value);
+				if (markers.length === 1) {
+					const marker = markers[0];
+					const markerValue = value[marker];
+					switch (marker) {
+						case TYPE_MARKERS.BIGINT: return BigInt(markerValue);
+						case TYPE_MARKERS.SYMBOL: return markerValue.k ? Symbol.for(markerValue.k) : Symbol(markerValue.d);
+						case TYPE_MARKERS.FUNCTION: return toFunction(markerValue, key) || function() {};
+						case TYPE_MARKERS.NAN: return NaN;
+						case TYPE_MARKERS.INFINITY: return Infinity;
+						case TYPE_MARKERS.NEGATIVE_INFINITY: return -Infinity;
+						case TYPE_MARKERS.FUNCTION_REF: return context ? getObjValue(markerValue, context) : void 0;
+						case TYPE_MARKERS.CODE_BLOCK: return getCodeBlock(markerValue, key);
+					}
+				}
+			}
+			return value;
+		});
+		return restoreSpecialValues(parsed, parsed);
+	} catch (error) {
+		console.error("JSON parse error:", {
+			str: str.slice(0, 200) + "...",
+			error
+		});
+		return {};
+	}
+}
+/**
+* 递归恢复所有特殊类型的值（支持数组和对象）
+*/
+function restoreSpecialValues(original, obj, depth = 0) {
+	if (depth > 100) throw new Error("Recursion limit exceeded");
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => {
+		const converted = convertSpecialValue(original, item);
+		if (converted !== item) return converted;
+		return restoreSpecialValues(original, item, depth + 1);
+	});
+	const result = {};
+	for (const key in obj) if (Object.prototype.hasOwnProperty.call(obj, key)) {
+		let value = obj[key];
+		const converted = convertSpecialValue(original, value);
+		if (converted !== value) value = converted;
+		else value = restoreSpecialValues(original, value, depth + 1);
+		result[key] = value;
+	}
+	return result;
+}
+/**
+* 转换特殊标记值为实际值（支持更多内置对象）
+*/
+function convertSpecialValue(original, value) {
+	if (value && typeof value === "object") {
+		const keys = Object.keys(value);
+		if (keys.length === 1) {
+			const [marker] = keys;
+			const markerValue = value[marker];
+			switch (marker) {
+				case TYPE_MARKERS.UNDEFINED: return;
+				case TYPE_MARKERS.DATE: return new Date(markerValue);
+				case TYPE_MARKERS.REGEXP: return new RegExp(markerValue.s, markerValue.f);
+				case TYPE_MARKERS.MAP: return new Map(markerValue);
+				case TYPE_MARKERS.SET: return new Set(markerValue);
+				case TYPE_MARKERS.ARRAY_BUFFER: return arrayBufferUtils.decode(markerValue);
+				case TYPE_MARKERS.ERROR: {
+					const { n, m, s } = markerValue;
+					const error = new Error(m);
+					error.name = n;
+					error.stack = s;
+					return error;
+				}
+				case TYPE_MARKERS.URL: return new URL(markerValue);
+				case TYPE_MARKERS.INT8_ARRAY: return new Int8Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.UINT8_ARRAY: return new Uint8Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.UINT8_CLAMPED_ARRAY: return new Uint8ClampedArray(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.INT16_ARRAY: return new Int16Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.UINT16_ARRAY: return new Uint16Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.INT32_ARRAY: return new Int32Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.UINT32_ARRAY: return new Uint32Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.FLOAT32_ARRAY: return new Float32Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.FLOAT64_ARRAY: return new Float64Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.BIGINT64_ARRAY: return new BigInt64Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.BIGUINT64_ARRAY: return new BigUint64Array(arrayBufferUtils.fromByteArray(markerValue));
+				case TYPE_MARKERS.DATA_VIEW: {
+					const buffer = arrayBufferUtils.decode(markerValue.b);
+					return new DataView(buffer, markerValue.o, markerValue.l);
+				}
+				case TYPE_MARKERS.CIRCULAR_REF: return getObjectPathValue(original, markerValue);
+			}
+		}
+	}
+	return value;
+}
+function getCodeBlock(value, key) {
+	try {
+		try {
+			const fullFunction = `function ${value.name ?? key ?? ""}(${value.params.join(",")}) { ${value.body} }`;
+			return new Function(`"use strict";
+				 return (${fullFunction})`)();
+		} catch (error) {
+			return new Function(...value.params, `"use strict";
+				 ${value.body}`);
+		}
+	} catch (error) {
+		console.error("Code block execution failed", error);
+		return value;
+	}
+}
+/**
+* 序列化函数引用
+*/
+function serializeFunctionRef(key) {
+	return { [TYPE_MARKERS.FUNCTION_REF]: key };
+}
+/**
+* 序列化代码块
+*/
+function serializeCodeBlock(value) {
+	return { [TYPE_MARKERS.CODE_BLOCK]: value };
+}
+//#endregion
+export { serializeCodeBlock, serializeFunctionRef, toJSONSParse, toJSONSStringify };

package/dist/basic/string/toStringParse.cjs

@@ -1,8 +1,151 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkHLKHFBMFcjs = require('../../chunk-HLKHFBMF.cjs');
-require('../../chunk-JJ37YIPJ.cjs');
-require('../../chunk-75ZPJI57.cjs');
-
-
-exports.toStringParse = _chunkHLKHFBMFcjs.toStringParse;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_basic_string_toFunction = require("./toFunction.cjs");
+//#region packages/basic/string/toStringParse.ts
+const arrayBufferUtils = {
+	encode: (buffer) => {
+		if (typeof Buffer !== "undefined") {
+			const bytes = new Uint8Array(buffer);
+			let binary = "";
+			bytes.forEach((byte) => binary += String.fromCharCode(byte));
+			return btoa(binary);
+		}
+		if (typeof btoa === "function") {
+			const bytes = new Uint8Array(buffer);
+			let binary = "";
+			for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+			return btoa(binary);
+		}
+		throw new Error("ArrayBuffer encoding not supported in this environment");
+	},
+	decode: (base64Str) => {
+		if (typeof Buffer !== "undefined") {
+			const binaryString = atob(base64Str);
+			const bytes = new Uint8Array(binaryString.length);
+			for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+			return bytes.buffer;
+		}
+		if (typeof atob === "function") {
+			const binaryString = atob(base64Str);
+			const bytes = new Uint8Array(binaryString.length);
+			for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+			return bytes.buffer;
+		}
+		throw new Error("ArrayBuffer decoding not supported in this environment");
+	},
+	toByteArray: (buffer) => {
+		return Array.from(new Uint8Array(buffer));
+	},
+	fromByteArray: (array) => {
+		const buffer = new ArrayBuffer(array.length);
+		const view = new Uint8Array(buffer);
+		array.forEach((value, index) => view[index] = value);
+		return buffer;
+	}
+};
+/**
+* 安全反序列化函数（完整支持更多内置对象）
+*/
+function toStringParse(str, type, split = ",") {
+	try {
+		type = type.toLowerCase();
+		switch (type) {
+			case "string": return str;
+			case "number": return Number(str);
+			case "null": return null;
+			case "boolean": return Boolean(str);
+			case "function": return require_basic_string_toFunction.toFunction(str) || function() {};
+			case "undefined": return;
+			case "array": return JSON.parse(str);
+			case "map": {
+				const v = JSON.parse(str);
+				const map = /* @__PURE__ */ new Map();
+				if (v instanceof Array) for (let value of v) map.set(value[0], value[1]);
+				else Object.keys(v).forEach((k) => {
+					map.set(k, v[k]);
+				});
+				return map;
+			}
+			case "set": {
+				const v = JSON.parse(str);
+				return new Set(...v);
+			}
+			case "object": return JSON.parse(str);
+			case "symbol": return Symbol(str);
+			case "nan": return NaN;
+			case "date": return new Date(str);
+			case "regexp": {
+				const e = str.split(split);
+				return new RegExp(e[0], e[1]);
+			}
+			case "infinity": return Infinity;
+			case "-infinity": return -Infinity;
+			case "bigint": return BigInt(str);
+			case "arraybuffer": return arrayBufferUtils.decode(str);
+			case "error": {
+				const e = str.split(split);
+				const error = new Error(e[0]);
+				error.name = e[1];
+				error.stack = e[2];
+				return error;
+			}
+			case "url": return new URL(str);
+			case "int8array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Int8Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "uint8array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Uint8Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "uint8clampedarray": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Uint8ClampedArray(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "int16array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Int16Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "bigint64array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new BigInt64Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "biguint64array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new BigUint64Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "float64array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Float64Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "float32array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Float32Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "uint32array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Uint32Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "int32array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Int32Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "uint16array": {
+				const arr = str.split(split).map((o) => Number(o));
+				return new Uint16Array(arrayBufferUtils.fromByteArray(arr));
+			}
+			case "dataview": {
+				const d = str.split(split);
+				const buffer = arrayBufferUtils.decode(d[0]);
+				return new DataView(buffer, Number(d[1]), Number(d[2]));
+			}
+		}
+	} catch (error) {
+		console.error("JSON parse error:", {
+			str: str.slice(0, 200) + "...",
+			error
+		});
+		return str;
+	}
+}
+//#endregion
+exports.toStringParse = toStringParse;

package/dist/basic/string/toStringParse.d.cts

@@ -1,6 +1,2 @@
-/**
- * 安全反序列化函数（完整支持更多内置对象）
- */
-declare function toStringParse(str: string, type: string, split?: string | RegExp): any;
-
-export { toStringParse };
+import { t as toStringParse } from "../../toStringParse-hkcBrKV-.cjs";
+export { toStringParse };

package/dist/basic/string/toStringParse.d.ts

@@ -1,6 +1,2 @@
-/**
- * 安全反序列化函数（完整支持更多内置对象）
- */
-declare function toStringParse(str: string, type: string, split?: string | RegExp): any;
-
-export { toStringParse };
+import { t as toStringParse } from "../../toStringParse-hkcBrKV-.js";
+export { toStringParse };