@fangzhongya/utils 0.0.11 → 0.0.15

package/dist/basic/string/toJson.js

@@ -1,8 +1,8 @@
 import {
   toJSONParse,
   toJSONStringify
-} from "../../chunk-AFKJQ4QP.js";
-import "../../chunk-6YI3CDEW.js";
+} from "../../chunk-U3PZBQ6G.js";
+import "../../chunk-7O4MJOHM.js";
 import "../../chunk-MLKGABMK.js";
 export {
   toJSONParse,

package/dist/basic/string/toJsons.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkETMYYVQJcjs = require('../../chunk-ETMYYVQJ.cjs');
+require('../../chunk-QXK4IUBI.cjs');
+require('../../chunk-E4WBX6J5.cjs');
+require('../../chunk-75ZPJI57.cjs');
+
+
+
+
+
+exports.serializeCodeBlock = _chunkETMYYVQJcjs.serializeCodeBlock; exports.serializeFunctionRef = _chunkETMYYVQJcjs.serializeFunctionRef; exports.toJSONSParse = _chunkETMYYVQJcjs.toJSONSParse; exports.toJSONSStringify = _chunkETMYYVQJcjs.toJSONSStringify;

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

@@ -0,0 +1,60 @@
+type ObjAny<T = any> = Record<string | number | symbol, T>;
+declare const TYPE_MARKERS: {
+    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): 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 };

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

@@ -0,0 +1,60 @@
+type ObjAny<T = any> = Record<string | number | symbol, T>;
+declare const TYPE_MARKERS: {
+    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): 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 };

package/dist/basic/string/toJsons.js

@@ -0,0 +1,15 @@
+import {
+  serializeCodeBlock,
+  serializeFunctionRef,
+  toJSONSParse,
+  toJSONSStringify
+} from "../../chunk-5HC662VK.js";
+import "../../chunk-7O4MJOHM.js";
+import "../../chunk-754Z5VW6.js";
+import "../../chunk-MLKGABMK.js";
+export {
+  serializeCodeBlock,
+  serializeFunctionRef,
+  toJSONSParse,
+  toJSONSStringify
+};

package/dist/{chunk-45M6CPWK.cjs → chunk-4VLLDFBC.cjs}

@@ -7,11 +7,17 @@ var _chunkL7FSHU27cjs = require('./chunk-L7FSHU27.cjs');
 
 
 
-var _chunkJYPJ5QJ5cjs = require('./chunk-JYPJ5QJ5.cjs');
+var _chunkJHV27P2Qcjs = require('./chunk-JHV27P2Q.cjs');
 
 
 
-var _chunkZJIRJ4YJcjs = require('./chunk-ZJIRJ4YJ.cjs');
+
+
+var _chunkETMYYVQJcjs = require('./chunk-ETMYYVQJ.cjs');
+
+
+
+var _chunkQXK4IUBIcjs = require('./chunk-QXK4IUBI.cjs');
 
 
 var _chunk3HXQ7TGVcjs = require('./chunk-3HXQ7TGV.cjs');
@@ -38,13 +44,17 @@ _chunk75ZPJI57cjs.__export.call(void 0, string_exports, {
   appearNumSeat: () => _chunkJR6ZN6QDcjs.appearNumSeat,
   firstLower: () => _chunkUEVMS6QDcjs.firstLower,
   firstUpper: () => _chunkOQL4GIEJcjs.firstUpper,
-  getFunctionFormat: () => _chunkZJIRJ4YJcjs.getFunctionFormat,
+  getFunctionFormat: () => _chunkQXK4IUBIcjs.getFunctionFormat,
   getStartSame: () => _chunkJ7S3KBHLcjs.getStartSame,
   getStartSames: () => _chunkPW7RP73Jcjs.getStartSames,
+  serializeCodeBlock: () => _chunkETMYYVQJcjs.serializeCodeBlock,
+  serializeFunctionRef: () => _chunkETMYYVQJcjs.serializeFunctionRef,
   splitUpper: () => _chunkL7FSHU27cjs.splitUpper,
-  toFunction: () => _chunkZJIRJ4YJcjs.toFunction,
-  toJSONParse: () => _chunkJYPJ5QJ5cjs.toJSONParse,
-  toJSONStringify: () => _chunkJYPJ5QJ5cjs.toJSONStringify
+  toFunction: () => _chunkQXK4IUBIcjs.toFunction,
+  toJSONParse: () => _chunkJHV27P2Qcjs.toJSONParse,
+  toJSONSParse: () => _chunkETMYYVQJcjs.toJSONSParse,
+  toJSONSStringify: () => _chunkETMYYVQJcjs.toJSONSStringify,
+  toJSONStringify: () => _chunkJHV27P2Qcjs.toJSONStringify
 });
 
 

package/dist/chunk-5HC662VK.js

@@ -0,0 +1,432 @@
+import {
+  toFunction
+} from "./chunk-7O4MJOHM.js";
+import {
+  getObjValue
+} from "./chunk-754Z5VW6.js";
+
+// packages/basic/string/toJsons.ts
+var TYPE_MARKERS = {
+  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_"
+};
+var arrayBufferUtils = {
+  // 将ArrayBuffer编码为Base64字符串
+  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"
+    );
+  },
+  // 将Base64字符串解码为ArrayBuffer
+  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"
+    );
+  },
+  // 获取ArrayBuffer的字节数组表示
+  toByteArray: (buffer) => {
+    return Array.from(new Uint8Array(buffer));
+  },
+  // 从字节数组创建ArrayBuffer
+  fromByteArray: (array) => {
+    const buffer = new ArrayBuffer(array.length);
+    const view = new Uint8Array(buffer);
+    array.forEach((value, index) => view[index] = value);
+    return buffer;
+  }
+};
+function toJSONSStringify(obj, space) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    obj,
+    function(key, value) {
+      if (value === null) {
+        return null;
+      }
+      if (typeof value === "object") {
+        if (seen.has(value)) return "[Circular]";
+        seen.add(value);
+      }
+      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);
+  } catch (error) {
+    console.error("JSON parse error:", {
+      str: str.slice(0, 200) + "...",
+      error
+    });
+    return {};
+  }
+}
+function restoreSpecialValues(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(item);
+      if (converted !== item) {
+        return converted;
+      }
+      return restoreSpecialValues(item, depth + 1);
+    });
+  }
+  const result = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      let value = obj[key];
+      const converted = convertSpecialValue(value);
+      if (converted !== value) {
+        value = converted;
+      } else {
+        value = restoreSpecialValues(value, depth + 1);
+      }
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function convertSpecialValue(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 void 0;
+        case TYPE_MARKERS.DATE:
+          return new Date(markerValue);
+        // 从时间戳恢复Date
+        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);
+        // 处理所有TypedArray类型
+        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);
+        }
+      }
+    }
+  }
+  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 };
+}
+
+export {
+  toJSONSStringify,
+  toJSONSParse,
+  serializeFunctionRef,
+  serializeCodeBlock
+};

package/dist/{chunk-VQKOHGV5.cjs → chunk-5WOFUMZG.cjs}

@@ -1,5 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
+var _chunkTCMJPIRMcjs = require('./chunk-TCMJPIRM.cjs');
+
+
+var _chunkXSQOJWXLcjs = require('./chunk-XSQOJWXL.cjs');
+
+
 var _chunkGD3OA7GUcjs = require('./chunk-GD3OA7GU.cjs');
 
 
@@ -9,10 +15,7 @@ var _chunkMHHMXDHDcjs = require('./chunk-MHHMXDHD.cjs');
 var _chunkSOAKYJIGcjs = require('./chunk-SOAKYJIG.cjs');
 
 
-var _chunkTCMJPIRMcjs = require('./chunk-TCMJPIRM.cjs');
-
-
-var _chunkXSQOJWXLcjs = require('./chunk-XSQOJWXL.cjs');
+var _chunkXW3XIK3Dcjs = require('./chunk-XW3XIK3D.cjs');
 
 
 var _chunkISHLY7WMcjs = require('./chunk-ISHLY7WM.cjs');
@@ -28,6 +31,7 @@ _chunk75ZPJI57cjs.__export.call(void 0, array_exports, {
   duplicateRemoval: () => _chunkGD3OA7GUcjs.duplicateRemoval,
   isArray: () => _chunkISHLY7WMcjs.isArray,
   replaceAfter: () => _chunkMHHMXDHDcjs.replaceAfter,
+  sortObj: () => _chunkXW3XIK3Dcjs.sortObj,
   toggleArray: () => _chunkSOAKYJIGcjs.toggleArray
 });
 

package/dist/chunk-754Z5VW6.js

@@ -0,0 +1,29 @@
+// packages/basic/object/objValue.ts
+function getObjValue(key, locale) {
+  if (!key) return locale;
+  const path = key.split(".");
+  let result = locale;
+  for (const prop of path) {
+    if (result == null || typeof result !== "object") return void 0;
+    result = result[prop];
+  }
+  return result;
+}
+function setObjValue(locale, key, value) {
+  if (!key) return Object.assign(locale, value);
+  const path = key.split(".");
+  const lastKey = path.pop();
+  let current = locale;
+  for (const prop of path) {
+    if (!current[prop] || typeof current[prop] !== "object") {
+      current[prop] = {};
+    }
+    current = current[prop];
+  }
+  current[lastKey] = value;
+}
+
+export {
+  getObjValue,
+  setObjValue
+};