@fangzhongya/utils 0.0.11 → 0.0.16

package/dist/chunk-ETMYYVQJ.cjs

@@ -0,0 +1,432 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkQXK4IUBIcjs = require('./chunk-QXK4IUBI.cjs');
+
+
+var _chunkE4WBX6J5cjs = require('./chunk-E4WBX6J5.cjs');
+
+// 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: _nullishCoalesce(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 _chunkQXK4IUBIcjs.toFunction.call(void 0, 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 ? _chunkE4WBX6J5cjs.getObjValue.call(void 0, 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 ${_nullishCoalesce(_nullishCoalesce(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 };
+}
+
+
+
+
+
+
+exports.toJSONSStringify = toJSONSStringify; exports.toJSONSParse = toJSONSParse; exports.serializeFunctionRef = serializeFunctionRef; exports.serializeCodeBlock = serializeCodeBlock;

package/dist/{chunk-R5TH6GQE.js → chunk-FSIQKHKH.js}

@@ -1,12 +1,12 @@
-import {
-  object_exports
-} from "./chunk-JJLYV6GY.js";
 import {
   string_exports
-} from "./chunk-GIJMEVTJ.js";
+} from "./chunk-ZEMAXGD5.js";
+import {
+  object_exports
+} from "./chunk-IEQHKLEL.js";
 import {
   array_exports
-} from "./chunk-2KT66KQH.js";
+} from "./chunk-LU22MUUS.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";

package/dist/{chunk-QJVB3JIZ.js → chunk-HWR2FRME.js}

@@ -1,5 +1,5 @@
 // packages/node/getPort.ts
-import { createServer } from "node:net";
+import { createServer } from "net";
 function getPort(host, port = 5173, isLocal = true) {
   return new Promise((resolve, reject) => {
     isPortOccupied(port, host, isLocal).then((v) => {

package/dist/{chunk-JJLYV6GY.js → chunk-IEQHKLEL.js}

@@ -1,3 +1,10 @@
+import {
+  mergeObject
+} from "./chunk-RD4EP3M5.js";
+import {
+  getObjValue,
+  setObjValue
+} from "./chunk-754Z5VW6.js";
 import {
   reverseObj
 } from "./chunk-B3IGSYZT.js";
@@ -7,6 +14,9 @@ import {
 import {
   unmergeObject
 } from "./chunk-A6J46LQK.js";
+import {
+  attrValueSort
+} from "./chunk-T4BAVDTH.js";
 import {
   deepCopy
 } from "./chunk-PHKZER72.js";
@@ -19,12 +29,6 @@ import {
 import {
   hasOwn
 } from "./chunk-3IR2ABRO.js";
-import {
-  mergeObject
-} from "./chunk-RD4EP3M5.js";
-import {
-  attrValueSort
-} from "./chunk-T4BAVDTH.js";
 import {
   isObjectArray
 } from "./chunk-GYE23WAN.js";
@@ -41,12 +45,14 @@ __export(object_exports, {
   attrValueSort: () => attrValueSort,
   deepCopy: () => deepCopy,
   filterObject: () => filterObject,
+  getObjValue: () => getObjValue,
   getSort: () => getSort,
   hasOwn: () => hasOwn,
   isObject: () => isObject,
   isObjectArray: () => isObjectArray,
   mergeObject: () => mergeObject,
   reverseObj: () => reverseObj,
+  setObjValue: () => setObjValue,
   setSort: () => setSort,
   unmergeObject: () => unmergeObject
 });

package/dist/chunk-ILJLXJ5O.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// packages/basic/string/startsNum.ts
+function startsNum(str, substring) {
+  if (substring.length === 0) return 0;
+  let count = 0;
+  let index = 0;
+  while (str.startsWith(substring, index)) {
+    count++;
+    index += substring.length;
+  }
+  return count;
+}
+
+
+
+exports.startsNum = startsNum;

package/dist/chunk-JHV27P2Q.cjs

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkQXK4IUBIcjs = require('./chunk-QXK4IUBI.cjs');
+
+// 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 _chunkQXK4IUBIcjs.toFunction.call(void 0, value.value) || value;
+        case "undefined":
+          return void 0;
+        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;
+  });
+}
+
+
+
+
+exports.toJSONStringify = toJSONStringify; exports.toJSONParse = toJSONParse;

package/dist/{chunk-SNABGVNO.js → chunk-LPMR5W6M.js}

@@ -2,7 +2,7 @@
 function appearNum(str, t) {
   let reg = t;
   if (typeof t == "string") {
-    reg = new RegExp(t, "g");
+    reg = new RegExp(t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
   }
   let arr = str.match(reg);
   let c = arr ? arr.length : 0;

package/dist/{chunk-2KT66KQH.js → chunk-LU22MUUS.js}

@@ -1,9 +1,3 @@
-import {
-  duplicateRemoval
-} from "./chunk-ZVBCHJA5.js";
-import {
-  replaceAfter
-} from "./chunk-K33LOE73.js";
 import {
   toggleArray
 } from "./chunk-APKFW4LU.js";
@@ -13,6 +7,15 @@ import {
 import {
   deleteArray
 } from "./chunk-DBSRZCFK.js";
+import {
+  duplicateRemoval
+} from "./chunk-ZVBCHJA5.js";
+import {
+  replaceAfter
+} from "./chunk-K33LOE73.js";
+import {
+  sortObj
+} from "./chunk-O34QAOO7.js";
 import {
   isArray
 } from "./chunk-5PX3AFSC.js";
@@ -28,6 +31,7 @@ __export(array_exports, {
   duplicateRemoval: () => duplicateRemoval,
   isArray: () => isArray,
   replaceAfter: () => replaceAfter,
+  sortObj: () => sortObj,
   toggleArray: () => toggleArray
 });
 

package/dist/chunk-NESVPZNF.cjs

@@ -0,0 +1,29 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunk77SI5VSScjs = require('./chunk-77SI5VSS.cjs');
+
+
+var _chunk2H3KVSFAcjs = require('./chunk-2H3KVSFA.cjs');
+
+
+var _chunkILJLXJ5Ocjs = require('./chunk-ILJLXJ5O.cjs');
+
+// packages/urls/getReplaceCompleteUrl.ts
+function getReplaceCompleteUrl(url, imp) {
+  const obj = _chunk77SI5VSScjs.getUrlCatalogueObj.call(void 0, url);
+  if (!/[\\|\/]/.test(imp)) {
+    imp = "./" + imp;
+  }
+  const apart = _nullishCoalesce(obj.apart, () => ( "/"));
+  if (imp.startsWith("./")) {
+    return obj.catalogue + apart + imp.replace(/^\.\//, "").replace(/[\\|\/]/g, apart);
+  } else {
+    const v = _chunkILJLXJ5Ocjs.startsNum.call(void 0, imp, "../");
+    const m = obj.catalogue;
+    return m.substring(0, _chunk2H3KVSFAcjs.getStrNunPosit.call(void 0, m, "/", v)) + apart + imp.replace(RegExp("^(\\.\\.\\/){" + v + "}"), "");
+  }
+}
+
+
+
+exports.getReplaceCompleteUrl = getReplaceCompleteUrl;

package/dist/chunk-O34QAOO7.js

@@ -0,0 +1,16 @@
+// packages/basic/array/sortObj.ts
+function sortObj(arr, value) {
+  return arr.sort((a, b) => {
+    if (a[value] > b[value]) {
+      return 1;
+    } else if (a[value] < b[value]) {
+      return -1;
+    } else {
+      return 0;
+    }
+  });
+}
+
+export {
+  sortObj
+};

package/dist/{chunk-3HXQ7TGV.cjs → chunk-OJBZ7UUC.cjs}

@@ -2,7 +2,7 @@
 function appearNum(str, t) {
   let reg = t;
   if (typeof t == "string") {
-    reg = new RegExp(t, "g");
+    reg = new RegExp(t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
   }
   let arr = str.match(reg);
   let c = arr ? arr.length : 0;

package/dist/{chunk-YHLI3SF7.js → chunk-OVHYLUAS.js}

@@ -3,6 +3,11 @@ import {
   getTreeObj,
   treeToArray
 } from "./chunk-GVVJIN46.js";
+import {
+  splitGroup,
+  splitGroupDitto,
+  splitGroupExist
+} from "./chunk-XQOH3NGZ.js";
 import {
   __export
 } from "./chunk-MLKGABMK.js";
@@ -12,6 +17,9 @@ var tree_exports = {};
 __export(tree_exports, {
   arrayToTree: () => arrayToTree,
   getTreeObj: () => getTreeObj,
+  splitGroup: () => splitGroup,
+  splitGroupDitto: () => splitGroupDitto,
+  splitGroupExist: () => splitGroupExist,
   treeToArray: () => treeToArray
 });