@fluixi/utils 1.0.0-alpha.100

package/dist/lib/object/reconcile.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/object/reconcile.ts
+var reconcile_exports = {};
+__export(reconcile_exports, {
+  reconcile: () => reconcile
+});
+module.exports = __toCommonJS(reconcile_exports);
+function isPlain(v) {
+  if (v == null || typeof v !== "object") return false;
+  const p = Object.getPrototypeOf(v);
+  return p === Object.prototype || p === null;
+}
+function reconcileValue(next, current, opts) {
+  if (next === current) return current;
+  if (Array.isArray(next)) return reconcileArr(next, Array.isArray(current) ? current : [], opts);
+  if (isPlain(next)) return reconcileObj(next, isPlain(current) ? current : {}, opts);
+  return next;
+}
+function reconcileArr(next, current, opts) {
+  const { key, keepRef } = opts;
+  const curLen = current.length;
+  const nextLen = next.length;
+  const curItems = new Array(curLen);
+  for (let i = 0; i < curLen; i++) curItems[i] = current[i];
+  if (key === false) {
+    if (keepRef) {
+      for (let i = 0; i < nextLen; i++) {
+        const rv = reconcileValue(next[i], curItems[i], opts);
+        if (rv !== curItems[i]) current[i] = rv;
+      }
+      if (curLen > nextLen) current.splice(nextLen);
+      return current;
+    }
+    let changed2 = nextLen !== curLen;
+    const out = new Array(nextLen);
+    for (let i = 0; i < nextLen; i++) {
+      out[i] = reconcileValue(next[i], curItems[i], opts);
+      if (out[i] !== curItems[i]) changed2 = true;
+    }
+    return changed2 ? out : current;
+  }
+  const currentMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < curLen; i++) {
+    const item = curItems[i];
+    if (item != null && typeof item === "object" && key in item) {
+      currentMap.set(item[key], item);
+    }
+  }
+  const resolved = new Array(nextLen);
+  for (let i = 0; i < nextLen; i++) {
+    const n = next[i];
+    if (n != null && typeof n === "object" && key in n) {
+      resolved[i] = reconcileValue(n, currentMap.get(n[key]), opts);
+    } else {
+      resolved[i] = reconcileValue(n, curItems[i], opts);
+    }
+  }
+  if (keepRef) {
+    for (let i = 0; i < nextLen; i++) {
+      if (resolved[i] !== curItems[i]) current[i] = resolved[i];
+    }
+    if (curLen > nextLen) current.splice(nextLen);
+    return current;
+  }
+  let changed = nextLen !== curLen;
+  for (let i = 0; !changed && i < nextLen; i++) {
+    if (resolved[i] !== curItems[i]) changed = true;
+  }
+  return changed ? resolved : current;
+}
+function reconcileObj(next, current, opts) {
+  const { merge, keepRef } = opts;
+  const nextKeys = Object.keys(next);
+  const currentKeys = Object.keys(current);
+  const curValues = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < currentKeys.length; i++) {
+    curValues[currentKeys[i]] = current[currentKeys[i]];
+  }
+  let out = null;
+  const getOut = () => {
+    if (!out) out = keepRef ? current : { ...curValues };
+    return out;
+  };
+  if (!merge) {
+    for (let i = 0; i < currentKeys.length; i++) {
+      const k = currentKeys[i];
+      if (!(k in next)) delete getOut()[k];
+    }
+  }
+  for (let i = 0; i < nextKeys.length; i++) {
+    const k = nextKeys[i];
+    const cv = curValues[k];
+    const rv = reconcileValue(next[k], cv, opts);
+    if (rv !== cv || !(k in curValues)) getOut()[k] = rv;
+  }
+  return out ?? current;
+}
+function reconcile(next, options) {
+  const opts = {
+    key: options?.key !== void 0 ? options.key : "id",
+    merge: options?.merge ?? false,
+    keepRef: options?.keepRef ?? false
+  };
+  return (current) => {
+    if (current === void 0 || current === null) return next;
+    return reconcileValue(next, current, opts);
+  };
+}

package/dist/lib/object/reconcile.d.ts

@@ -0,0 +1,7 @@
+export interface ReconcileOptions {
+    key?: string | false;
+    merge?: boolean;
+    keepRef?: boolean;
+}
+export declare function reconcile<T>(next: T, options?: ReconcileOptions): (current: T | undefined) => T;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/lib/object/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../../src/lib/object/reconcile.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAqHD,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,SAAS,KAAK,CAAC,CAU/F"}

package/dist/lib/object/reconcile.js

@@ -0,0 +1,122 @@
+function isPlain(v) {
+    if (v == null || typeof v !== 'object')
+        return false;
+    const p = Object.getPrototypeOf(v);
+    return p === Object.prototype || p === null;
+}
+function reconcileValue(next, current, opts) {
+    if (next === current)
+        return current;
+    if (Array.isArray(next))
+        return reconcileArr(next, Array.isArray(current) ? current : [], opts);
+    if (isPlain(next))
+        return reconcileObj(next, isPlain(current) ? current : {}, opts);
+    return next;
+}
+function reconcileArr(next, current, opts) {
+    const { key, keepRef } = opts;
+    const curLen = current.length;
+    const nextLen = next.length;
+    // Snapshot once: avoids repeated proxy reads returning different references
+    const curItems = new Array(curLen);
+    for (let i = 0; i < curLen; i++)
+        curItems[i] = current[i];
+    if (key === false) {
+        // Index-based
+        if (keepRef) {
+            for (let i = 0; i < nextLen; i++) {
+                const rv = reconcileValue(next[i], curItems[i], opts);
+                if (rv !== curItems[i])
+                    current[i] = rv;
+            }
+            if (curLen > nextLen)
+                current.splice(nextLen);
+            return current;
+        }
+        let changed = nextLen !== curLen;
+        const out = new Array(nextLen);
+        for (let i = 0; i < nextLen; i++) {
+            out[i] = reconcileValue(next[i], curItems[i], opts);
+            if (out[i] !== curItems[i])
+                changed = true;
+        }
+        return changed ? out : current;
+    }
+    // Key-based: build lookup from snapshot
+    const currentMap = new Map();
+    for (let i = 0; i < curLen; i++) {
+        const item = curItems[i];
+        if (item != null && typeof item === 'object' && key in item) {
+            currentMap.set(item[key], item);
+        }
+    }
+    const resolved = new Array(nextLen);
+    for (let i = 0; i < nextLen; i++) {
+        const n = next[i];
+        if (n != null && typeof n === 'object' && key in n) {
+            resolved[i] = reconcileValue(n, currentMap.get(n[key]), opts);
+        }
+        else {
+            resolved[i] = reconcileValue(n, curItems[i], opts);
+        }
+    }
+    if (keepRef) {
+        for (let i = 0; i < nextLen; i++) {
+            if (resolved[i] !== curItems[i])
+                current[i] = resolved[i];
+        }
+        if (curLen > nextLen)
+            current.splice(nextLen);
+        return current;
+    }
+    // Immutable: compare resolved positions against snapshotted positions
+    let changed = nextLen !== curLen;
+    for (let i = 0; !changed && i < nextLen; i++) {
+        if (resolved[i] !== curItems[i])
+            changed = true;
+    }
+    return changed ? resolved : current;
+}
+function reconcileObj(next, current, opts) {
+    const { merge, keepRef } = opts;
+    const nextKeys = Object.keys(next);
+    const currentKeys = Object.keys(current);
+    // Snapshot current values once to avoid repeated proxy reads
+    const curValues = Object.create(null);
+    for (let i = 0; i < currentKeys.length; i++) {
+        curValues[currentKeys[i]] = current[currentKeys[i]];
+    }
+    let out = null;
+    const getOut = () => {
+        if (!out)
+            out = keepRef ? current : { ...curValues };
+        return out;
+    };
+    if (!merge) {
+        for (let i = 0; i < currentKeys.length; i++) {
+            const k = currentKeys[i];
+            if (!(k in next))
+                delete getOut()[k];
+        }
+    }
+    for (let i = 0; i < nextKeys.length; i++) {
+        const k = nextKeys[i];
+        const cv = curValues[k];
+        const rv = reconcileValue(next[k], cv, opts);
+        if (rv !== cv || !(k in curValues))
+            getOut()[k] = rv;
+    }
+    return out ?? current;
+}
+export function reconcile(next, options) {
+    const opts = {
+        key: options?.key !== undefined ? options.key : 'id',
+        merge: options?.merge ?? false,
+        keepRef: options?.keepRef ?? false,
+    };
+    return (current) => {
+        if (current === undefined || current === null)
+            return next;
+        return reconcileValue(next, current, opts);
+    };
+}

package/dist/lib/object/reconcile.mjs

@@ -0,0 +1,105 @@
+// src/lib/object/reconcile.ts
+function isPlain(v) {
+  if (v == null || typeof v !== "object") return false;
+  const p = Object.getPrototypeOf(v);
+  return p === Object.prototype || p === null;
+}
+function reconcileValue(next, current, opts) {
+  if (next === current) return current;
+  if (Array.isArray(next)) return reconcileArr(next, Array.isArray(current) ? current : [], opts);
+  if (isPlain(next)) return reconcileObj(next, isPlain(current) ? current : {}, opts);
+  return next;
+}
+function reconcileArr(next, current, opts) {
+  const { key, keepRef } = opts;
+  const curLen = current.length;
+  const nextLen = next.length;
+  const curItems = new Array(curLen);
+  for (let i = 0; i < curLen; i++) curItems[i] = current[i];
+  if (key === false) {
+    if (keepRef) {
+      for (let i = 0; i < nextLen; i++) {
+        const rv = reconcileValue(next[i], curItems[i], opts);
+        if (rv !== curItems[i]) current[i] = rv;
+      }
+      if (curLen > nextLen) current.splice(nextLen);
+      return current;
+    }
+    let changed2 = nextLen !== curLen;
+    const out = new Array(nextLen);
+    for (let i = 0; i < nextLen; i++) {
+      out[i] = reconcileValue(next[i], curItems[i], opts);
+      if (out[i] !== curItems[i]) changed2 = true;
+    }
+    return changed2 ? out : current;
+  }
+  const currentMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < curLen; i++) {
+    const item = curItems[i];
+    if (item != null && typeof item === "object" && key in item) {
+      currentMap.set(item[key], item);
+    }
+  }
+  const resolved = new Array(nextLen);
+  for (let i = 0; i < nextLen; i++) {
+    const n = next[i];
+    if (n != null && typeof n === "object" && key in n) {
+      resolved[i] = reconcileValue(n, currentMap.get(n[key]), opts);
+    } else {
+      resolved[i] = reconcileValue(n, curItems[i], opts);
+    }
+  }
+  if (keepRef) {
+    for (let i = 0; i < nextLen; i++) {
+      if (resolved[i] !== curItems[i]) current[i] = resolved[i];
+    }
+    if (curLen > nextLen) current.splice(nextLen);
+    return current;
+  }
+  let changed = nextLen !== curLen;
+  for (let i = 0; !changed && i < nextLen; i++) {
+    if (resolved[i] !== curItems[i]) changed = true;
+  }
+  return changed ? resolved : current;
+}
+function reconcileObj(next, current, opts) {
+  const { merge, keepRef } = opts;
+  const nextKeys = Object.keys(next);
+  const currentKeys = Object.keys(current);
+  const curValues = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < currentKeys.length; i++) {
+    curValues[currentKeys[i]] = current[currentKeys[i]];
+  }
+  let out = null;
+  const getOut = () => {
+    if (!out) out = keepRef ? current : { ...curValues };
+    return out;
+  };
+  if (!merge) {
+    for (let i = 0; i < currentKeys.length; i++) {
+      const k = currentKeys[i];
+      if (!(k in next)) delete getOut()[k];
+    }
+  }
+  for (let i = 0; i < nextKeys.length; i++) {
+    const k = nextKeys[i];
+    const cv = curValues[k];
+    const rv = reconcileValue(next[k], cv, opts);
+    if (rv !== cv || !(k in curValues)) getOut()[k] = rv;
+  }
+  return out ?? current;
+}
+function reconcile(next, options) {
+  const opts = {
+    key: options?.key !== void 0 ? options.key : "id",
+    merge: options?.merge ?? false,
+    keepRef: options?.keepRef ?? false
+  };
+  return (current) => {
+    if (current === void 0 || current === null) return next;
+    return reconcileValue(next, current, opts);
+  };
+}
+export {
+  reconcile
+};

package/dist/lib/object/selector.cjs

@@ -0,0 +1,303 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/object/selector.ts
+var selector_exports = {};
+__export(selector_exports, {
+  createFilterFunction: () => createFilterFunction,
+  createSelector: () => createSelector,
+  detectSelectorType: () => detectSelectorType,
+  parseSelector: () => parseSelector,
+  stringifySelector: () => stringifySelector,
+  validateSelector: () => validateSelector
+});
+module.exports = __toCommonJS(selector_exports);
+var parseSelector = (selector, options = {}) => {
+  const { type = "auto", throwOnError = false } = options;
+  if (!selector || typeof selector !== "string") {
+    return [];
+  }
+  const segments = [];
+  let current = "";
+  let inBrackets = false;
+  let inQuotes = false;
+  let quoteChar = "";
+  let bracketContent = "";
+  let bracketDepth = 0;
+  const detectType = (str) => {
+    if (str.includes("..")) return "descendant";
+    if (str.includes("[?(")) return "filter";
+    if (str.includes("[:") || str.includes("[0:")) return "slice";
+    if (str.includes("[,") || str.includes("[0,1]")) return "union";
+    if (str.includes("[*]") || str.includes(".*.")) return "wildcard";
+    if (str.includes("[]")) return "array-wildcard";
+    if (str.includes("[") && str.includes("]")) return "bracket";
+    return "dot";
+  };
+  const actualType = type === "auto" ? detectType(selector) : type;
+  const parseBracketContent = (content) => {
+    const trimmed = content.trim();
+    if (trimmed === "*" || trimmed === "") {
+      return {
+        type: "wildcard",
+        value: trimmed === "" ? "[]" : "*",
+        raw: trimmed === "" ? "[]" : content
+      };
+    }
+    if (trimmed === "[]") {
+      return { type: "wildcard", value: "[]", raw: content };
+    }
+    if (/^-?\d+$/.test(trimmed)) {
+      return { type: "index", value: parseInt(trimmed, 10), raw: content };
+    }
+    if (trimmed.includes(":")) {
+      const parts = trimmed.split(":").map((p) => p.trim());
+      const start = parts[0] === "" ? 0 : parseInt(parts[0], 10);
+      const end = parts[1] === "" ? Infinity : parseInt(parts[1], 10);
+      if (isNaN(start) || isNaN(end)) {
+        if (throwOnError) throw new Error(`Invalid slice notation: ${content}`);
+        return { type: "wildcard", value: "*", raw: content };
+      }
+      return { type: "slice", value: [start, end], raw: content };
+    }
+    if (trimmed.includes(",")) {
+      const indices = trimmed.split(",").map((p) => {
+        const num = parseInt(p.trim(), 10);
+        return isNaN(num) ? -1 : num;
+      }).filter((n) => n >= 0);
+      if (indices.length === 0) {
+        if (throwOnError) throw new Error(`Invalid union notation: ${content}`);
+        return { type: "wildcard", value: "*", raw: content };
+      }
+      return { type: "union", value: indices, raw: content };
+    }
+    if (trimmed.startsWith("?(") && trimmed.endsWith(")")) {
+      const expr = trimmed.slice(2, -1);
+      try {
+        const filterFn = createFilterFunction(expr);
+        return { type: "filter", value: filterFn, raw: content };
+      } catch (error) {
+        if (throwOnError) throw error;
+        return { type: "wildcard", value: "*", raw: content };
+      }
+    }
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+      return { type: "property", value: trimmed.slice(1, -1), raw: content };
+    }
+    return { type: "property", value: trimmed, raw: content };
+  };
+  for (let i = 0; i < selector.length; i++) {
+    const char = selector[i];
+    const nextChar = selector[i + 1];
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+      continue;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = "";
+      if (!(char === '"' || char === "'")) {
+        if (inBrackets) {
+          bracketContent += char;
+        } else {
+          current += char;
+        }
+      }
+      continue;
+    }
+    if (inQuotes) {
+      if (inBrackets) {
+        bracketContent += char;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "[" && !inBrackets) {
+      if (current) {
+        segments.push({ type: "property", value: current, raw: current });
+        current = "";
+      }
+      inBrackets = true;
+      bracketContent = "";
+      continue;
+    }
+    if (char === "]" && inBrackets && !inQuotes) {
+      inBrackets = false;
+      const segment = parseBracketContent(bracketContent);
+      segments.push(segment);
+      continue;
+    }
+    let lastDot = segments.length > 0 ? segments[segments.length - 1] : null;
+    if (char === "." && !inBrackets && !inQuotes) {
+      if (nextChar === ".") {
+        const l = selector.split("..")[0];
+        segments.push({ type: "property", value: l, raw: l });
+        segments.push({ type: "descendant", value: "..", raw: ".." });
+        i++;
+      } else if (current) {
+        if (current === "*") {
+          segments.push({ type: "wildcard", value: current, raw: current });
+        } else {
+          segments.push({ type: "property", value: current, raw: current });
+        }
+        current = "";
+      }
+      continue;
+    }
+    if (inBrackets) {
+      bracketContent += char;
+    } else {
+      if (lastDot && lastDot.type !== "descendant") {
+        current += char;
+      } else {
+        const l = selector.split(lastDot?.raw)[1];
+        if (l !== void 0) {
+          current = l;
+        } else {
+          current += char;
+        }
+      }
+    }
+  }
+  if (current) {
+    segments.push({ type: "property", value: current, raw: current });
+  }
+  return segments.map((segment) => {
+    if (segment.type === "property" && typeof segment.value === "string") {
+      if (/^-?\d+$/.test(segment.value)) {
+        const num = parseInt(segment.value, 10);
+        if (!isNaN(num)) {
+          return { ...segment, type: "index", value: num };
+        }
+      }
+    }
+    return segment;
+  });
+};
+var createFilterFunction = (expr) => {
+  const safeExpr = expr.replace(/@\.([a-zA-Z_$][\w$]*)/g, (_, prop) => `item.${prop}`).replace(/@/g, "item");
+  try {
+    return new Function("item", `return ${safeExpr}`);
+  } catch (error) {
+    throw new Error(`Invalid filter expression: ${expr}`);
+  }
+};
+var stringifySelector = (segments) => {
+  const parts = [];
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const prevSegment = i > 0 ? segments[i - 1] : null;
+    switch (segment.type) {
+      case "property":
+        const needsQuotes = /[\.\[\]\s]/.test(String(segment.value));
+        if (needsQuotes) {
+          parts.push(`["${segment.value}"]`);
+        } else {
+          if (prevSegment && prevSegment.type !== "descendant") {
+            parts.push(".");
+          }
+          parts.push(String(segment.value));
+        }
+        break;
+      case "index":
+        parts.push(`[${segment.value}]`);
+        break;
+      case "wildcard":
+        if (segment.value === "[]") {
+          parts.push("[]");
+        } else {
+          parts.push("[*]");
+        }
+        break;
+      case "slice":
+        const [start, end] = segment.value;
+        parts.push(`[${start}:${end === Infinity ? "" : end}]`);
+        break;
+      case "union":
+        const indices = segment.value;
+        parts.push(`[${indices.join(",")}]`);
+        break;
+      case "filter":
+        parts.push(`[?(${segment.raw?.slice(2, -1) || ""})]`);
+        break;
+      case "descendant":
+        parts.push("..");
+        break;
+    }
+  }
+  return parts.join("").replace(/\.\[/g, "[");
+};
+var validateSelector = (selector, options = {}) => {
+  if (Array.isArray(selector)) {
+    return selector.map(
+      (sel) => validateSelector(sel, options)
+    );
+  }
+  if (!/^[a-zA-Z]/.test(selector)) {
+    return {
+      valid: false,
+      error: `Selector starts with '.'`,
+      type: detectSelectorType(selector)
+    };
+  }
+  if (!/[a-zA-Z]$/.test(selector)) {
+    return {
+      valid: false,
+      error: `Selector end with '.'`,
+      type: detectSelectorType(selector)
+    };
+  }
+  try {
+    const segments = parseSelector(selector, { throwOnError: true });
+    const type = detectSelectorType(selector);
+    if (options.allowedTypes) {
+      if (!options.allowedTypes.includes(type)) {
+        return {
+          valid: false,
+          error: `Selector type ${type} not allowed. Allowed: ${options.allowedTypes.join(
+            ", "
+          )}`,
+          type
+        };
+      }
+    }
+    return { valid: true, type: detectSelectorType(selector) };
+  } catch (error) {
+    return { valid: false, error: error.message };
+  }
+};
+var detectSelectorType = (selector) => {
+  if (selector.includes("..")) return "descendant";
+  if (selector.includes("[?(")) return "filter";
+  if (selector.includes("[:") || selector.includes("[0:")) return "slice";
+  if (/\[[^\]]*,[^\]]*\]/.test(selector)) return "union";
+  if (selector.includes("[*]") || selector.includes(".*.")) return "wildcard";
+  if (selector.includes("[]")) return "array-wildcard";
+  if (selector.includes("[") && selector.includes("]")) return "bracket";
+  return "dot";
+};
+var createSelector = (template, replacements) => {
+  return template.replace(/\{(\w+)\}/g, (_, key) => {
+    if (key in replacements) {
+      return String(replacements[key]);
+    }
+    return `{${key}}`;
+  });
+};