@fangzhongya/utils 0.0.79 → 0.0.82

package/dist/basic/string/toFunctionParam.js

@@ -1,10 +1,136 @@
-import {
-  toFunctionParam,
-  toFunctionParamOptions
-} from "../../chunk-U6V3V5KH.js";
-import "../../chunk-Q6BNW3MO.js";
-import "../../chunk-MLKGABMK.js";
-export {
-  toFunctionParam,
-  toFunctionParamOptions
-};
+import { extractParams, getFunctionFormat } from "./toFunction.js";
+//#region packages/basic/string/toFunctionParam.ts
+/**
+* 构建函数字符串（优化版）
+*/
+function buildFunctionString(obj) {
+	const { isAsync, isGenerator, param, body } = obj;
+	const funcName = obj.name || "";
+	return `${`${isAsync ? "async " : ""}${isGenerator ? "*" : ""}function${funcName ? ` ${funcName}` : ""}`}(${param}) { ${body} }`;
+}
+/**
+* 快速创建没有外部参数的函数
+*/
+function createSimpleFunction(obj) {
+	return new Function(`return ${buildFunctionString(obj)}`)();
+}
+function getKeys(externalKeys, body) {
+	return externalKeys.filter((o) => body.includes(o));
+}
+/**
+* 使用闭包方式创建函数（推荐方式）- 修复版本
+*/
+function createFunctionWithClosure(obj, externalParams) {
+	const externalKeys = Object.keys(externalParams);
+	if (externalKeys.length === 0) return createSimpleFunction(obj);
+	try {
+		const keys = getKeys(externalKeys, obj.body);
+		return new Function(...keys, `return ${buildFunctionString(obj)};`)(...keys.map((k) => externalParams[k]));
+	} catch (error) {
+		const { param, body } = obj;
+		const keys = getKeys(externalKeys, body);
+		const funcParams = param ? extractParams(param) : [];
+		return (...args) => {
+			const currentExternalValues = keys.map((k) => externalParams[k]);
+			return new Function(...funcParams, ...keys, `'use strict'; ${body}`)(...currentExternalValues, ...args);
+		};
+	}
+}
+function createFunctionWithDynamicBinding(obj, externalParams, autoFirst = false) {
+	const { param, body } = obj;
+	const funcParams = param ? extractParams(param) : [];
+	const getExternalParams = typeof externalParams === "function" ? externalParams : () => externalParams;
+	if (autoFirst) {
+		const currentExternal = getExternalParams();
+		const keys = getKeys(Object.keys(currentExternal), body);
+		const externalValues = keys.map((k) => currentExternal[k]);
+		const func = new Function(...funcParams, ...keys, `'use strict'; ${body}`);
+		return function(...args) {
+			return func(...externalValues, ...args);
+		};
+	} else return function(...args) {
+		const currentExternal = getExternalParams();
+		const keys = getKeys(Object.keys(currentExternal), body);
+		const externalValues = keys.map((k) => currentExternal[k]);
+		return new Function(...keys, ...funcParams, `'use strict'; ${body}`)(...externalValues, ...args);
+	};
+}
+/**
+* 使用非闭包方式创建函数（安全模式）
+*/
+function createFunctionWithoutClosure(obj, externalParams) {
+	const funcParams = obj.param ? extractParams(obj.param) : [];
+	const keys = getKeys(Object.keys(externalParams), obj.body);
+	const baseFunc = createSimpleFunction(obj);
+	return function(...args) {
+		const context = {};
+		keys.forEach((k) => {
+			context[k] = externalParams[k];
+		});
+		funcParams.forEach((paramName, index) => {
+			const cleanParam = paramName.split("=")[0].trim();
+			context[cleanParam] = args[index];
+		});
+		return baseFunc.call(context, ...args);
+	};
+}
+/**
+* 优化的toFunctionParam函数 - 修复版本
+*/
+function toFunctionParam(str, externalParams) {
+	try {
+		const obj = getFunctionFormat(str);
+		if (!obj?.body) return void 0;
+		if (externalParams) {
+			if (typeof externalParams === "function") return createFunctionWithDynamicBinding(obj, externalParams, false);
+			else if (Object.keys(externalParams).length > 0) return createFunctionWithClosure(obj, externalParams);
+		}
+		return createSimpleFunction(obj);
+	} catch (error) {
+		console.error("Function creation failed:", error);
+		return;
+	}
+}
+/**
+* 增强版，支持更多选项（修复版本）
+*/
+function toFunctionParamOptions(str, externalParams, options) {
+	try {
+		const obj = getFunctionFormat(str);
+		if (!obj?.body) return void 0;
+		const opts = {
+			useClosure: true,
+			strictMode: true,
+			context: {},
+			paramDefaults: {},
+			bindThis: false,
+			autoRebind: true,
+			autoFirst: true,
+			useProxy: false,
+			...options
+		};
+		let functionBody = obj.body;
+		if (opts.paramDefaults && Object.keys(opts.paramDefaults).length > 0) functionBody = Object.entries(opts.paramDefaults).map(([name, value]) => `if (${name} === undefined) ${name} = ${JSON.stringify(value)};`).join(" ") + " " + functionBody;
+		if (opts.strictMode) functionBody = `'use strict'; ${functionBody}`;
+		const funcObj = {
+			...obj,
+			body: functionBody
+		};
+		if (opts.name && !funcObj.name) funcObj.name = opts.name;
+		let result;
+		if (externalParams) if (opts.useProxy && typeof externalParams === "object") result = createFunctionWithClosure(funcObj, new Proxy(externalParams, { get: (target, prop) => {
+			return target[prop];
+		} }));
+		else if (opts.autoRebind || typeof externalParams === "function") result = createFunctionWithDynamicBinding(funcObj, typeof externalParams === "function" ? externalParams : () => externalParams, opts.autoFirst);
+		else if (opts.useClosure) result = createFunctionWithClosure(funcObj, externalParams);
+		else result = createFunctionWithoutClosure(funcObj, externalParams);
+		else result = createSimpleFunction(funcObj);
+		if (opts.bindThis && opts.context && Object.keys(opts.context).length > 0) return result.bind(opts.context);
+		return result;
+	} catch (error) {
+		console.error("Enhanced function creation failed:", error);
+		return;
+	}
+}
+//#endregion
+export { toFunctionParam, toFunctionParamOptions };

package/dist/basic/string/toJson.cjs

@@ -1,10 +1,43 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-var _chunkK2XKKEE7cjs = require('../../chunk-K2XKKEE7.cjs');
-require('../../chunk-JJ37YIPJ.cjs');
-require('../../chunk-75ZPJI57.cjs');
-
-
-
-exports.toJSONParse = _chunkK2XKKEE7cjs.toJSONParse; exports.toJSONStringify = _chunkK2XKKEE7cjs.toJSONStringify;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_basic_string_toFunction = require("./toFunction.cjs");
+//#region packages/basic/string/toJson.ts
+function toJSONStringify(obj, space) {
+	return JSON.stringify(obj, (_, value) => {
+		if (typeof value === "symbol") return {
+			__type: "symbol",
+			value: value.description
+		};
+		else if (typeof value === "function") return {
+			__type: "function",
+			value: value.toString()
+		};
+		else if (value === void 0) return { __type: "undefined" };
+		else if (value instanceof Date) return {
+			__type: "Date",
+			value: value.toISOString()
+		};
+		else if (value instanceof RegExp) return {
+			__type: "RegExp",
+			value: value.toString()
+		};
+		return value;
+	}, space);
+}
+function toJSONParse(str, reviver) {
+	return JSON.parse(str, (key, value) => {
+		if (value && typeof value === "object") switch (value.__type) {
+			case "symbol": return Symbol(value.value);
+			case "function": return require_basic_string_toFunction.toFunction(value.value) || value;
+			case "undefined": return;
+			case "Date": return new Date(value.value);
+			case "RegExp": {
+				const match = value.value.match(/\/(.*)\/([gimuy]*)/);
+				return match ? new RegExp(match[1], match[2]) : value;
+			}
+		}
+		return reviver ? reviver(key, value) : value;
+	});
+}
+//#endregion
+exports.toJSONParse = toJSONParse;
+exports.toJSONStringify = toJSONStringify;

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

@@ -1,4 +1,2 @@
-declare function toJSONStringify(obj: any, space?: number | string): string;
-declare function toJSONParse<T = any>(str: string, reviver?: (this: any, key: string, value: any) => any): T;
-
-export { toJSONParse, toJSONStringify };
+import { n as toJSONStringify, t as toJSONParse } from "../../toJson-CCefKwtn.cjs";
+export { toJSONParse, toJSONStringify };

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

@@ -1,4 +1,2 @@
-declare function toJSONStringify(obj: any, space?: number | string): string;
-declare function toJSONParse<T = any>(str: string, reviver?: (this: any, key: string, value: any) => any): T;
-
-export { toJSONParse, toJSONStringify };
+import { n as toJSONStringify, t as toJSONParse } from "../../toJson-CCefKwtn.js";
+export { toJSONParse, toJSONStringify };

package/dist/basic/string/toJson.js

@@ -1,10 +1,41 @@
-import {
-  toJSONParse,
-  toJSONStringify
-} from "../../chunk-TIZFQBWC.js";
-import "../../chunk-Q6BNW3MO.js";
-import "../../chunk-MLKGABMK.js";
-export {
-  toJSONParse,
-  toJSONStringify
-};
+import { toFunction } from "./toFunction.js";
+//#region packages/basic/string/toJson.ts
+function toJSONStringify(obj, space) {
+	return JSON.stringify(obj, (_, value) => {
+		if (typeof value === "symbol") return {
+			__type: "symbol",
+			value: value.description
+		};
+		else if (typeof value === "function") return {
+			__type: "function",
+			value: value.toString()
+		};
+		else if (value === void 0) return { __type: "undefined" };
+		else if (value instanceof Date) return {
+			__type: "Date",
+			value: value.toISOString()
+		};
+		else if (value instanceof RegExp) return {
+			__type: "RegExp",
+			value: value.toString()
+		};
+		return value;
+	}, space);
+}
+function toJSONParse(str, reviver) {
+	return JSON.parse(str, (key, value) => {
+		if (value && typeof value === "object") switch (value.__type) {
+			case "symbol": return Symbol(value.value);
+			case "function": return toFunction(value.value) || value;
+			case "undefined": return;
+			case "Date": return new Date(value.value);
+			case "RegExp": {
+				const match = value.value.match(/\/(.*)\/([gimuy]*)/);
+				return match ? new RegExp(match[1], match[2]) : value;
+			}
+		}
+		return reviver ? reviver(key, value) : value;
+	});
+}
+//#endregion
+export { toJSONParse, toJSONStringify };

package/dist/basic/string/toJsons.cjs

@@ -1,15 +1,339 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-var _chunkTKE7IK2Mcjs = require('../../chunk-TKE7IK2M.cjs');
-require('../../chunk-JJ37YIPJ.cjs');
-require('../../chunk-A5UJF6LP.cjs');
-require('../../chunk-75ZPJI57.cjs');
-
-
-
-
-
-exports.serializeCodeBlock = _chunkTKE7IK2Mcjs.serializeCodeBlock; exports.serializeFunctionRef = _chunkTKE7IK2Mcjs.serializeFunctionRef; exports.toJSONSParse = _chunkTKE7IK2Mcjs.toJSONSParse; exports.toJSONSStringify = _chunkTKE7IK2Mcjs.toJSONSStringify;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_basic_object_objValue = require("../object/objValue.cjs");
+const require_basic_string_toFunction = require("./toFunction.cjs");
+//#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 require_basic_string_toFunction.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 ? require_basic_object_objValue.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
+exports.serializeCodeBlock = serializeCodeBlock;
+exports.serializeFunctionRef = serializeFunctionRef;
+exports.toJSONSParse = toJSONSParse;
+exports.toJSONSStringify = toJSONSStringify;

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

@@ -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.cjs";
+export { CodeBlock, serializeCodeBlock, serializeFunctionRef, toJSONSParse, toJSONSStringify };