@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/object/merge.cjs

@@ -1 +1,1029 @@
-"use strict";var E=Object.defineProperty;var F=Object.getOwnPropertyDescriptor;var N=Object.getOwnPropertyNames;var W=Object.prototype.hasOwnProperty;var q=(e,r)=>{for(var i in r)E(e,i,{get:r[i],enumerable:!0})},U=(e,r,i,f)=>{if(r&&typeof r=="object"||typeof r=="function")for(let t of N(r))!W.call(e,t)&&t!==i&&E(e,t,{get:()=>r[t],enumerable:!(f=F(r,t))||f.enumerable});return e};var L=e=>U(E({},"__esModule",{value:!0}),e);var G={};q(G,{deepMerge:()=>K,deepMergeKeepReference:()=>K,deepMergeStrict:()=>Q,deepMergeWithOptions:()=>R,merge:()=>D,mergeArrays:()=>B,mergeIntoStructure:()=>Z,mergeStrict:()=>Q,mergeWithOptions:()=>R});module.exports=L(G);var b=e=>e==null||Array.isArray(e)||typeof e=="function"||e instanceof Date||e instanceof RegExp||e instanceof Map||e instanceof Set||e instanceof Error?!1:typeof e=="object";function $(e){if(typeof e!="object"||e===null)return!1;let r=Object.getPrototypeOf(e);return r===Object.prototype||r===null}var w=(e,r)=>{if(e==null||typeof e!="object")return e;if(e instanceof Date)return new Date(e.getTime());if(e instanceof RegExp)return new RegExp(e.source,e.flags);if(e instanceof Map){let i=new Map;return e.forEach((f,t)=>{(!r||!r.some(s=>s.toString()===t.toString()))&&i.set(t,w(f))}),i}if(e instanceof Set){let i=new Set;return e.forEach(f=>{i.add(w(f))}),i}if(Array.isArray(e))return Array.from(e).map(i=>w(i));if(b(e)){let i={};for(let t in e)Object.prototype.hasOwnProperty.call(e,t)&&(!r||!r.some(s=>s.toString()===t.toString()))&&(i[t]=w(e[t]));let f=Object.getOwnPropertySymbols(e);for(let t of f)(!r||!r.some(s=>s.toString()===t.toString()))&&(i[t]=w(e[t]));return i}return e};var P=(e,r)=>e===r,O=(e,r)=>{if(e.length!==r.length)return!1;for(let i=0;i<e.length;i++)if(Array.isArray(e[i])&&Array.isArray(r[i])){if(!O(e[i],r[i]))return!1}else if(b(e[i])&&b(r[i])){if(!j(e[i],r[i]))return!1}else if(e[i]!==r[i])return!1;return!0},j=(e,r)=>{let i=Object.keys(e),f=Object.keys(r);if(i.length!==f.length)return!1;for(let t of i){if(!(t in r))return!1;let s=e[t],d=r[t];if(Array.isArray(s)&&Array.isArray(d)){if(!O(s,d))return!1}else if(b(s)&&b(d)){if(!j(s,d))return!1}else if(s!==d)return!1}return!0},M=(e,r,i={})=>{let{includeDeleted:f=!1,includeAdded:t=!0,deepArrayComparison:s=!0,equalityFn:d=P,preserveStructure:m=!1}=i;if(e==null&&r==null)return{};if(e==null)return t?{...r}:{};if(r==null){if(f){let c={};for(let A in e)c[A]=void 0;return c}return{}}if(!b(e)||!b(r))return d(e,r)?{}:r;let u={},l=new Set;for(let c in r){l.add(c);let A=e[c],S=r[c];if(!(c in e)){t&&(u[c]=S);continue}if(Array.isArray(A)&&Array.isArray(S)){s?O(A,S)?m&&(u[c]=void 0):u[c]=S:A!==S?u[c]=S:m&&(u[c]=void 0);continue}if(b(A)&&b(S)){let h=M(A,S,i);Object.keys(h).length>0?u[c]=h:m&&(u[c]=void 0);continue}d(A,S)?m&&(u[c]=void 0):u[c]=S}if(f)for(let c in e)l.has(c)||(u[c]=void 0);return u},C=(e,r,i={})=>{let f=[],t=[],s=[],d={},{includeDeleted:m=!1,includeAdded:u=!0,deepArrayComparison:l=!0,equalityFn:c=P}=i;if(Array.isArray(e)&&Array.isArray(r)){let h=Math.max(e.length,r.length),o=[],a=!1;for(let n=0;n<h;n++){let y=`[${n}]`;if(n>=e.length)f.push(y),o[n]=r[n],a=!0;else if(n>=r.length)t.push(y),a=!0;else{let p=e[n],g=r[n];b(p)&&b(g)||Array.isArray(p)&&Array.isArray(g)?C(p,g,i).hasChanges?(s.push(y),o[n]=g,a=!0):o[n]=p:c(p,g)?o[n]=p:(s.push(y),o[n]=g,a=!0)}}return{changes:a?o:{},added:f,deleted:t,modified:s,hasChanges:a||t.length>0}}let A=(h,o,a="")=>{let n={added:[],deleted:[],modified:[]};if(Array.isArray(h)&&Array.isArray(o)){let y=Math.max(h.length,o.length);for(let p=0;p<y;p++){let g=a?`${a}[${p}]`:`[${p}]`;if(p>=h.length)n.added.push(g);else if(p>=o.length)n.deleted.push(g);else{let T=h[p],x=o[p];if(b(T)&&b(x)){let k=A(T,x,g);n.added.push(...k.added),n.deleted.push(...k.deleted),n.modified.push(...k.modified)}else if(Array.isArray(T)&&Array.isArray(x)){let k=A(T,x,g);n.added.push(...k.added),n.deleted.push(...k.deleted),n.modified.push(...k.modified)}else T!==x&&n.modified.push(g)}}return n}if(b(h)&&b(o)){let y=new Set([...Object.keys(h||{}),...Object.keys(o||{})]);for(let p of y){let g=h?.[p],T=o?.[p],x=a?`${a}.${p}`:p;if(!(p in(h||{})))n.added.push(x);else if(!(p in(o||{})))n.deleted.push(x);else if(Array.isArray(g)&&Array.isArray(T)){if(!O(g,T)){let k=A(g,T,x);n.added.push(...k.added),n.deleted.push(...k.deleted),n.modified.push(...k.modified)}}else if(b(g)&&b(T)){let k=A(g,T,x);n.added.push(...k.added),n.deleted.push(...k.deleted),n.modified.push(...k.modified)}else g!==T&&n.modified.push(x)}}return n};if(e==null&&r==null)return{changes:{},added:f,deleted:t,modified:s,hasChanges:!1};if(e==null){if(u&&r)for(let h in r)f.push(h),d[h]=r[h];return{changes:d,added:f,deleted:t,modified:s,hasChanges:f.length>0}}if(r==null){if(m)for(let h in e)t.push(h),d[h]=void 0;return{changes:d,added:f,deleted:t,modified:s,hasChanges:t.length>0}}let S=new Set;for(let h in r){S.add(h);let o=e[h],a=r[h];if(!(h in e)){u&&(f.push(h),d[h]=a);continue}let n=!1;if(Array.isArray(o)&&Array.isArray(a)){if(n=l?!O(o,a):o!==a,n){let y=A(o,a,h);f.push(...y.added),t.push(...y.deleted),s.push(...y.modified),d[h]=a}}else if(b(o)&&b(a)){let y=M(o,a,i);if(n=Object.keys(y).length>0,n){let p=A(o,a,h);f.push(...p.added),t.push(...p.deleted),s.push(...p.modified),d[h]=y}}else n=!c(o,a),n&&(s.push(h),d[h]=a)}for(let h in e)S.has(h)||(t.push(h),d[h]=void 0);return{changes:d,added:f,deleted:t,modified:s,hasChanges:f.length>0||t.length>0||s.length>0}};function _(e){return!!(e&&(e.diff||e.changes)&&(e.modified||e.deleted||e.hasChanges))}var v=(e,r,i)=>{if(!_(r)){let n=r,y=i||!1;if(Array.isArray(e)&&Array.isArray(n)){let g=y?e:[...e];n.length<g.length&&(g.length=n.length);for(let T=0;T<n.length;T++){let x=n[T];x!==void 0&&(b(g[T])&&b(x)||Array.isArray(g[T])&&Array.isArray(x)?g[T]=v(g[T],x,y):g[T]=x)}return g}if(!b(e))return n;if(!b(n))return e;let p=y?e:{...e};for(let g in n){let T=n[g];T===void 0?delete p[g]:Array.isArray(p[g])&&Array.isArray(T)||b(p[g])&&b(T)?p[g]=v(p[g],T,y):p[g]=T}return p}let{diff:f,added:t=[],deleted:s=[],modified:d=[],changes:m,keepRef:u}=r,l=i!==void 0?i:u,c=m||f;if(!c)return e;let A=new Set(t),S=new Set(s),h=new Set(d),o=n=>{if(t.length===0&&s.length===0&&d.length===0)return!0;let y=n.split(/[.\[\]]+/).filter(Boolean);for(let p=0;p<=y.length;p++){let g=y.slice(0,p).join("."),T=y.slice(0,p).map((x,k)=>/^\d+$/.test(x)?`[${x}]`:k>0?`.${x}`:x).join("");if(A.has(g)||A.has(T)||S.has(g)||S.has(T)||h.has(g)||h.has(T))return!0}return!1};if(Array.isArray(e)&&Array.isArray(c)){let n=l?e:[...e];n.length=c.length;for(let y=0;y<c.length;y++){let p=`[${y}]`,g=c[y];g!==void 0&&o(p)&&(b(n[y])&&b(g)||Array.isArray(n[y])&&Array.isArray(g)?n[y]=v(n[y],g,l):n[y]=g)}return n}if(!b(e))return c;if(!b(c))return e;let a=l?e:{...e};for(let n of s)n.includes(".")||n.includes("[")||o(n)&&delete a[n];for(let n in c){let y=c[n];o(n)&&(y===void 0?delete a[n]:Array.isArray(a[n])&&Array.isArray(y)||b(a[n])&&b(y)?a[n]=v(a[n],y,l):a[n]=y)}return a};var I=(e,r={})=>{let{type:i="auto",throwOnError:f=!1}=r;if(!e||typeof e!="string")return[];let t=[],s="",d=!1,m=!1,u="",l="",c=0,S=i==="auto"?(o=>o.includes("..")?"descendant":o.includes("[?(")?"filter":o.includes("[:")||o.includes("[0:")?"slice":o.includes("[,")||o.includes("[0,1]")?"union":o.includes("[*]")||o.includes(".*.")?"wildcard":o.includes("[]")?"array-wildcard":o.includes("[")&&o.includes("]")?"bracket":"dot")(e):i,h=o=>{let a=o.trim();if(a==="*"||a==="")return{type:"wildcard",value:a===""?"[]":"*",raw:a===""?"[]":o};if(a==="[]")return{type:"wildcard",value:"[]",raw:o};if(/^-?\d+$/.test(a))return{type:"index",value:parseInt(a,10),raw:o};if(a.includes(":")){let n=a.split(":").map(g=>g.trim()),y=n[0]===""?0:parseInt(n[0],10),p=n[1]===""?1/0:parseInt(n[1],10);if(isNaN(y)||isNaN(p)){if(f)throw new Error(`Invalid slice notation: ${o}`);return{type:"wildcard",value:"*",raw:o}}return{type:"slice",value:[y,p],raw:o}}if(a.includes(",")){let n=a.split(",").map(y=>{let p=parseInt(y.trim(),10);return isNaN(p)?-1:p}).filter(y=>y>=0);if(n.length===0){if(f)throw new Error(`Invalid union notation: ${o}`);return{type:"wildcard",value:"*",raw:o}}return{type:"union",value:n,raw:o}}if(a.startsWith("?(")&&a.endsWith(")")){let n=a.slice(2,-1);try{return{type:"filter",value:z(n),raw:o}}catch(y){if(f)throw y;return{type:"wildcard",value:"*",raw:o}}}return a.startsWith('"')&&a.endsWith('"')||a.startsWith("'")&&a.endsWith("'")?{type:"property",value:a.slice(1,-1),raw:o}:{type:"property",value:a,raw:o}};for(let o=0;o<e.length;o++){let a=e[o],n=e[o+1];if((a==='"'||a==="'")&&!m){m=!0,u=a;continue}else if(a===u&&m){m=!1,u="",a==='"'||a==="'"||(d?l+=a:s+=a);continue}if(m){d?l+=a:s+=a;continue}if(a==="["&&!d){s&&(t.push({type:"property",value:s,raw:s}),s=""),d=!0,l="";continue}if(a==="]"&&d&&!m){d=!1;let p=h(l);t.push(p);continue}let y=t.length>0?t[t.length-1]:null;if(a==="."&&!d&&!m){if(n==="."){let p=e.split("..")[0];t.push({type:"property",value:p,raw:p}),t.push({type:"descendant",value:"..",raw:".."}),o++}else s&&(s==="*"?t.push({type:"wildcard",value:s,raw:s}):t.push({type:"property",value:s,raw:s}),s="");continue}if(d)l+=a;else if(y&&y.type!=="descendant")s+=a;else{let p=e.split(y?.raw)[1];p!==void 0?s=p:s+=a}}return s&&t.push({type:"property",value:s,raw:s}),t.map(o=>{if(o.type==="property"&&typeof o.value=="string"&&/^-?\d+$/.test(o.value)){let a=parseInt(o.value,10);if(!isNaN(a))return{...o,type:"index",value:a}}return o})},z=e=>{let r=e.replace(/@\.([a-zA-Z_$][\w$]*)/g,(i,f)=>`item.${f}`).replace(/@/g,"item");try{return new Function("item",`return ${r}`)}catch{throw new Error(`Invalid filter expression: ${e}`)}};function D(...e){if(e.length===0)return{};let r=e[0],i=Array.isArray(r);for(let t of e)if(t&&Array.isArray(t)!==i)throw new Error("Cannot mix arrays and objects in deepMerge");let f=i?[]:{};for(let t of e)if(t!=null)if(i){let s=f,d=t;for(let m of d)s.push(w(m))}else{if(!$(t))continue;let s=f,d=t;for(let u in d)if(Object.prototype.hasOwnProperty.call(d,u)){let l=d[u],c=s[u];c===void 0?s[u]=w(l):Array.isArray(l)&&Array.isArray(c)?s[u]=[...c,...l.map(A=>w(A))]:$(l)&&$(c)?s[u]=D(c,l):s[u]=w(l)}let m=Object.getOwnPropertySymbols(d);for(let u of m){let l=d[u],c=s[u];c===void 0?s[u]=w(l):Array.isArray(l)&&Array.isArray(c)?s[u]=[...c,...l.map(A=>w(A))]:$(l)&&$(c)?s[u]=D(c,l):s[u]=w(l)}}return f}function B(e,r,i){let{key:f,override:t=!0}=i||{};if(!f)return Array.from(new Set([...e,...r]));let s=new Map;for(let d of e)s.set(d[f],d);for(let d of r){let m=s.get(d[f]);m?s.set(d[f],t?{...m,...d}:{...d,...m}):s.set(d[f],d)}return Array.from(s.values())}function J(e,r){for(let i in r){let f=e[i],t=r[i],s=C(f,t);Array.isArray(f)&&Array.isArray(t)?(f.length=0,f.push(...t)):typeof f=="object"&&typeof t=="object"&&f&&t&&s.hasChanges?v(f,t):e[i]=t}}function R(e,...r){if(r.length===0)return w(e);let i={preserveTarget:!1,strict:!1},f=r,t=r[r.length-1];t&&typeof t=="object"&&("preserveTarget"in t||"strict"in t)&&(i={...i,...t},f=r.slice(0,-1));let s=i.preserveTarget?e:w(e),d=Array.isArray(s);for(let m of f)if(m&&Array.isArray(m)!==d)throw new Error("Cannot mix arrays and objects in deepMergeWithOptions");for(let m of f)if(m!=null)if(d){let u=s,l=m;if(i.strict)for(let c=0;c<u.length&&c<l.length;c++)$(u[c])&&$(l[c])?u[c]=R(u[c],l[c],i):typeof u[c]==typeof l[c]&&(u[c]=w(l[c]));else J(u,l)}else{if(!$(m))continue;let u=s,l=m;for(let A in l){if(!Object.prototype.hasOwnProperty.call(l,A))continue;let S=l[A];if(i.strict&&!(A in u))continue;let h=u[A];h===void 0?u[A]=w(S):Array.isArray(S)&&Array.isArray(h)?i.strict?u[A]=R(h,S,i):u[A]=[...h,...S.map(o=>w(o))]:$(S)&&$(h)?u[A]=R(h,S,i):u[A]=w(S)}let c=Object.getOwnPropertySymbols(l);for(let A of c){if(i.strict&&!(A in u))continue;let S=l[A],h=u[A];h===void 0?u[A]=w(S):Array.isArray(S)&&Array.isArray(h)?i.strict?u[A]=R(h,S,i):u[A]=[...h,...S.map(o=>w(o))]:$(S)&&$(h)?u[A]=R(h,S,i):u[A]=w(S)}}return s}function K(e,...r){return R(e,...r,{preserveTarget:!0})}function Q(e,...r){let i=!1,f=r;return r.length>0&&typeof r[r.length-1]=="boolean"&&(i=r[r.length-1],f=r.slice(0,-1)),R(e,...f,{preserveTarget:i,strict:!0})}var Z=(e,r,i)=>{let f=I(r),t=e;for(let s=0;s<f.length;s++){let d=f[s],m=s===f.length-1;switch(d.type){case"property":if(m)t[String(d.value)]=i;else{if(!t[String(d.value)]){let l=f[s+1];t[String(d.value)]=l.type==="index"||l.type==="slice"||l.type==="union"||l.type==="wildcard"?[]:{}}t=t[String(d.value)]}break;case"index":Array.isArray(t)||(t=[]);let u=d.value;if(m){if(u>=t.length)for(let l=t.length;l<=u;l++)t.push(void 0);t[u]=i}else{if(!t[u]){let l=f[s+1];t[u]=l.type==="index"||l.type==="slice"||l.type==="union"||l.type==="wildcard"?[]:{}}t=t[u]}break;case"wildcard":if(Array.isArray(t))if(m)for(let l=0;l<t.length;l++)t[l]=i;else{let l=f[s+1];for(let c=0;c<t.length;c++)t[c]||(t[c]=l.type==="index"||l.type==="slice"||l.type==="union"||l.type==="wildcard"?[]:{});t.length>0&&(t=t[0])}break}}};
+"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/merge.ts
+var merge_exports = {};
+__export(merge_exports, {
+  deepMerge: () => deepMergeKeepReference,
+  deepMergeKeepReference: () => deepMergeKeepReference,
+  deepMergeStrict: () => deepMergeStrict,
+  deepMergeWithOptions: () => deepMergeWithOptions,
+  merge: () => merge,
+  mergeArrays: () => mergeArrays,
+  mergeIntoStructure: () => mergeIntoStructure,
+  mergeStrict: () => deepMergeStrict,
+  mergeWithOptions: () => deepMergeWithOptions
+});
+module.exports = __toCommonJS(merge_exports);
+
+// src/lib/object/utils.ts
+var isObject = (value) => {
+  if (value == null) return false;
+  if (Array.isArray(value)) return false;
+  if (typeof value === "function") return false;
+  if (value instanceof Date) return false;
+  if (value instanceof RegExp) return false;
+  if (value instanceof Map) return false;
+  if (value instanceof Set) return false;
+  if (value instanceof Error) return false;
+  return typeof value === "object";
+};
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/lib/object/clone.ts
+var deepClone = (obj, skipKeys) => {
+  if (obj == null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Map) {
+    const clone = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      if (!skipKeys || !skipKeys.some((k) => k.toString() === key.toString())) {
+        clone.set(key, deepClone(value));
+      }
+    });
+    return clone;
+  }
+  if (obj instanceof Set) {
+    const clone = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clone.add(deepClone(value));
+    });
+    return clone;
+  }
+  if (Array.isArray(obj)) {
+    return Array.from(obj).map((item) => deepClone(item));
+  }
+  if (isObject(obj)) {
+    const clone = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        if (!skipKeys || !skipKeys.some((k) => k.toString() === key.toString())) {
+          clone[key] = deepClone(obj[key]);
+        }
+      }
+    }
+    const symbols = Object.getOwnPropertySymbols(obj);
+    for (const symbol of symbols) {
+      if (!skipKeys || !skipKeys.some((s) => s.toString() === symbol.toString())) {
+        clone[symbol] = deepClone(obj[symbol]);
+      }
+    }
+    return clone;
+  }
+  return obj;
+};
+
+// src/lib/object/diff.ts
+var defaultEqualityFn = (a, b) => a === b;
+var deepArrayEqual = (arr1, arr2) => {
+  if (arr1.length !== arr2.length) return false;
+  for (let i = 0; i < arr1.length; i++) {
+    if (Array.isArray(arr1[i]) && Array.isArray(arr2[i])) {
+      if (!deepArrayEqual(arr1[i], arr2[i])) return false;
+    } else if (isObject(arr1[i]) && isObject(arr2[i])) {
+      if (!deepObjectEqual(arr1[i], arr2[i])) return false;
+    } else if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+var deepObjectEqual = (obj1, obj2) => {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!(key in obj2)) return false;
+    const val1 = obj1[key];
+    const val2 = obj2[key];
+    if (Array.isArray(val1) && Array.isArray(val2)) {
+      if (!deepArrayEqual(val1, val2)) return false;
+    } else if (isObject(val1) && isObject(val2)) {
+      if (!deepObjectEqual(val1, val2)) return false;
+    } else if (val1 !== val2) {
+      return false;
+    }
+  }
+  return true;
+};
+var diffObject = (oldObj, newObj, options = {}) => {
+  const {
+    includeDeleted = false,
+    includeAdded = true,
+    deepArrayComparison = true,
+    equalityFn = defaultEqualityFn,
+    preserveStructure = false
+  } = options;
+  if (oldObj == null && newObj == null) {
+    return {};
+  }
+  if (oldObj == null) {
+    return includeAdded ? { ...newObj } : {};
+  }
+  if (newObj == null) {
+    if (includeDeleted) {
+      const result2 = {};
+      for (const key in oldObj) {
+        result2[key] = void 0;
+      }
+      return result2;
+    }
+    return {};
+  }
+  if (!isObject(oldObj) || !isObject(newObj)) {
+    return equalityFn(oldObj, newObj) ? {} : newObj;
+  }
+  const result = {};
+  const processedKeys = /* @__PURE__ */ new Set();
+  for (const key in newObj) {
+    processedKeys.add(key);
+    const oldValue = oldObj[key];
+    const newValue = newObj[key];
+    if (!(key in oldObj)) {
+      if (includeAdded) {
+        result[key] = newValue;
+      }
+      continue;
+    }
+    if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+      if (deepArrayComparison) {
+        if (!deepArrayEqual(oldValue, newValue)) {
+          result[key] = newValue;
+        } else if (preserveStructure) {
+          result[key] = void 0;
+        }
+      } else {
+        if (oldValue !== newValue) {
+          result[key] = newValue;
+        } else if (preserveStructure) {
+          result[key] = void 0;
+        }
+      }
+      continue;
+    }
+    if (isObject(oldValue) && isObject(newValue)) {
+      const nestedDiff = diffObject(oldValue, newValue, options);
+      if (Object.keys(nestedDiff).length > 0) {
+        result[key] = nestedDiff;
+      } else if (preserveStructure) {
+        result[key] = void 0;
+      }
+      continue;
+    }
+    if (!equalityFn(oldValue, newValue)) {
+      result[key] = newValue;
+    } else if (preserveStructure) {
+      result[key] = void 0;
+    }
+  }
+  if (includeDeleted) {
+    for (const key in oldObj) {
+      if (!processedKeys.has(key)) {
+        result[key] = void 0;
+      }
+    }
+  }
+  return result;
+};
+var diffObjectDetailed = (oldObj, newObj, options = {}) => {
+  const added = [];
+  const deleted = [];
+  const modified = [];
+  const changes = {};
+  const {
+    includeDeleted = false,
+    includeAdded = true,
+    deepArrayComparison = true,
+    equalityFn = defaultEqualityFn
+  } = options;
+  if (Array.isArray(oldObj) && Array.isArray(newObj)) {
+    const maxLength = Math.max(oldObj.length, newObj.length);
+    const arrayChanges = [];
+    let hasArrayChanges = false;
+    for (let i = 0; i < maxLength; i++) {
+      const indexPath = `[${i}]`;
+      if (i >= oldObj.length) {
+        added.push(indexPath);
+        arrayChanges[i] = newObj[i];
+        hasArrayChanges = true;
+      } else if (i >= newObj.length) {
+        deleted.push(indexPath);
+        hasArrayChanges = true;
+      } else {
+        const oldElement = oldObj[i];
+        const newElement = newObj[i];
+        if (isObject(oldElement) && isObject(newElement)) {
+          const nestedDiff = diffObjectDetailed(
+            oldElement,
+            newElement,
+            options
+          );
+          if (nestedDiff.hasChanges) {
+            modified.push(indexPath);
+            arrayChanges[i] = newElement;
+            hasArrayChanges = true;
+          } else {
+            arrayChanges[i] = oldElement;
+          }
+        } else if (Array.isArray(oldElement) && Array.isArray(newElement)) {
+          const nestedDiff = diffObjectDetailed(
+            oldElement,
+            newElement,
+            options
+          );
+          if (nestedDiff.hasChanges) {
+            modified.push(indexPath);
+            arrayChanges[i] = newElement;
+            hasArrayChanges = true;
+          } else {
+            arrayChanges[i] = oldElement;
+          }
+        } else if (!equalityFn(oldElement, newElement)) {
+          modified.push(indexPath);
+          arrayChanges[i] = newElement;
+          hasArrayChanges = true;
+        } else {
+          arrayChanges[i] = oldElement;
+        }
+      }
+    }
+    return {
+      changes: hasArrayChanges ? arrayChanges : {},
+      added,
+      deleted,
+      modified,
+      hasChanges: hasArrayChanges || deleted.length > 0
+    };
+  }
+  const collectDetailedPaths = (old, newVal, currentPath = "") => {
+    const result = {
+      added: [],
+      deleted: [],
+      modified: []
+    };
+    if (Array.isArray(old) && Array.isArray(newVal)) {
+      const maxLength = Math.max(old.length, newVal.length);
+      for (let i = 0; i < maxLength; i++) {
+        const indexPath = currentPath ? `${currentPath}[${i}]` : `[${i}]`;
+        if (i >= old.length) {
+          result.added.push(indexPath);
+        } else if (i >= newVal.length) {
+          result.deleted.push(indexPath);
+        } else {
+          const oldElement = old[i];
+          const newElement = newVal[i];
+          if (isObject(oldElement) && isObject(newElement)) {
+            const nested = collectDetailedPaths(
+              oldElement,
+              newElement,
+              indexPath
+            );
+            result.added.push(...nested.added);
+            result.deleted.push(...nested.deleted);
+            result.modified.push(...nested.modified);
+          } else if (Array.isArray(oldElement) && Array.isArray(newElement)) {
+            const nested = collectDetailedPaths(
+              oldElement,
+              newElement,
+              indexPath
+            );
+            result.added.push(...nested.added);
+            result.deleted.push(...nested.deleted);
+            result.modified.push(...nested.modified);
+          } else if (oldElement !== newElement) {
+            result.modified.push(indexPath);
+          }
+        }
+      }
+      return result;
+    }
+    if (isObject(old) && isObject(newVal)) {
+      const allKeys = /* @__PURE__ */ new Set([
+        ...Object.keys(old || {}),
+        ...Object.keys(newVal || {})
+      ]);
+      for (const key of allKeys) {
+        const oldValue = old?.[key];
+        const newValue = newVal?.[key];
+        const path = currentPath ? `${currentPath}.${key}` : key;
+        if (!(key in (old || {}))) {
+          result.added.push(path);
+        } else if (!(key in (newVal || {}))) {
+          result.deleted.push(path);
+        } else if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+          if (!deepArrayEqual(oldValue, newValue)) {
+            const nested = collectDetailedPaths(oldValue, newValue, path);
+            result.added.push(...nested.added);
+            result.deleted.push(...nested.deleted);
+            result.modified.push(...nested.modified);
+          }
+        } else if (isObject(oldValue) && isObject(newValue)) {
+          const nested = collectDetailedPaths(oldValue, newValue, path);
+          result.added.push(...nested.added);
+          result.deleted.push(...nested.deleted);
+          result.modified.push(...nested.modified);
+        } else if (oldValue !== newValue) {
+          result.modified.push(path);
+        }
+      }
+    }
+    return result;
+  };
+  if (oldObj == null && newObj == null) {
+    return { changes: {}, added, deleted, modified, hasChanges: false };
+  }
+  if (oldObj == null) {
+    if (includeAdded && newObj) {
+      for (const key in newObj) {
+        added.push(key);
+        changes[key] = newObj[key];
+      }
+    }
+    return {
+      changes,
+      added,
+      deleted,
+      modified,
+      hasChanges: added.length > 0
+    };
+  }
+  if (newObj == null) {
+    if (includeDeleted) {
+      for (const key in oldObj) {
+        deleted.push(key);
+        changes[key] = void 0;
+      }
+    }
+    return {
+      changes,
+      added,
+      deleted,
+      modified,
+      hasChanges: deleted.length > 0
+    };
+  }
+  const processedKeys = /* @__PURE__ */ new Set();
+  for (const key in newObj) {
+    processedKeys.add(key);
+    const oldValue = oldObj[key];
+    const newValue = newObj[key];
+    if (!(key in oldObj)) {
+      if (includeAdded) {
+        added.push(key);
+        changes[key] = newValue;
+      }
+      continue;
+    }
+    let isDifferent = false;
+    if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+      isDifferent = deepArrayComparison ? !deepArrayEqual(oldValue, newValue) : oldValue !== newValue;
+      if (isDifferent) {
+        const paths = collectDetailedPaths(oldValue, newValue, key);
+        added.push(...paths.added);
+        deleted.push(...paths.deleted);
+        modified.push(...paths.modified);
+        changes[key] = newValue;
+      }
+    } else if (isObject(oldValue) && isObject(newValue)) {
+      const nestedDiff = diffObject(oldValue, newValue, options);
+      isDifferent = Object.keys(nestedDiff).length > 0;
+      if (isDifferent) {
+        const paths = collectDetailedPaths(oldValue, newValue, key);
+        added.push(...paths.added);
+        deleted.push(...paths.deleted);
+        modified.push(...paths.modified);
+        changes[key] = nestedDiff;
+      }
+    } else {
+      isDifferent = !equalityFn(oldValue, newValue);
+      if (isDifferent) {
+        modified.push(key);
+        changes[key] = newValue;
+      }
+    }
+  }
+  for (const key in oldObj) {
+    if (!processedKeys.has(key)) {
+      deleted.push(key);
+      changes[key] = void 0;
+    }
+  }
+  return {
+    changes,
+    added,
+    deleted,
+    modified,
+    hasChanges: added.length > 0 || deleted.length > 0 || modified.length > 0
+  };
+};
+function isApplyDiff(value) {
+  if (value && (value.diff || value.changes) && (value.modified || value.deleted || value.hasChanges)) {
+    return true;
+  }
+  return false;
+}
+var applyDiff = (baseObj, option, keepRefParam) => {
+  if (!isApplyDiff(option)) {
+    const diff2 = option;
+    const shouldKeepRef2 = keepRefParam || false;
+    if (Array.isArray(baseObj) && Array.isArray(diff2)) {
+      const result3 = shouldKeepRef2 ? baseObj : [...baseObj];
+      if (diff2.length < result3.length) {
+        result3.length = diff2.length;
+      }
+      for (let i = 0; i < diff2.length; i++) {
+        const diffValue = diff2[i];
+        if (diffValue === void 0) {
+          continue;
+        }
+        if (isObject(result3[i]) && isObject(diffValue)) {
+          result3[i] = applyDiff(result3[i], diffValue, shouldKeepRef2);
+        } else if (Array.isArray(result3[i]) && Array.isArray(diffValue)) {
+          result3[i] = applyDiff(
+            result3[i],
+            diffValue,
+            shouldKeepRef2
+          );
+        } else {
+          result3[i] = diffValue;
+        }
+      }
+      return result3;
+    }
+    if (!isObject(baseObj)) return diff2;
+    if (!isObject(diff2)) return baseObj;
+    const result2 = shouldKeepRef2 ? baseObj : { ...baseObj };
+    for (const key in diff2) {
+      const diffValue = diff2[key];
+      if (diffValue === void 0) {
+        delete result2[key];
+      } else if (Array.isArray(result2[key]) && Array.isArray(diffValue)) {
+        result2[key] = applyDiff(result2[key], diffValue, shouldKeepRef2);
+      } else if (isObject(result2[key]) && isObject(diffValue)) {
+        result2[key] = applyDiff(result2[key], diffValue, shouldKeepRef2);
+      } else {
+        result2[key] = diffValue;
+      }
+    }
+    return result2;
+  }
+  const {
+    diff,
+    added = [],
+    deleted = [],
+    modified = [],
+    changes,
+    keepRef: keepRefOption
+  } = option;
+  const shouldKeepRef = keepRefParam !== void 0 ? keepRefParam : keepRefOption;
+  const diffToApply = changes || diff;
+  if (!diffToApply) return baseObj;
+  const addedSet = new Set(added);
+  const deletedSet = new Set(deleted);
+  const modifiedSet = new Set(modified);
+  const shouldApplyPath = (path) => {
+    if (added.length === 0 && deleted.length === 0 && modified.length === 0) {
+      return true;
+    }
+    const pathParts = path.split(/[.\[\]]+/).filter(Boolean);
+    for (let i = 0; i <= pathParts.length; i++) {
+      const partialPath = pathParts.slice(0, i).join(".");
+      const bracketPath = pathParts.slice(0, i).map((p, idx) => /^\d+$/.test(p) ? `[${p}]` : idx > 0 ? `.${p}` : p).join("");
+      if (addedSet.has(partialPath) || addedSet.has(bracketPath) || deletedSet.has(partialPath) || deletedSet.has(bracketPath) || modifiedSet.has(partialPath) || modifiedSet.has(bracketPath)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  if (Array.isArray(baseObj) && Array.isArray(diffToApply)) {
+    const result2 = shouldKeepRef ? baseObj : [...baseObj];
+    result2.length = diffToApply.length;
+    for (let i = 0; i < diffToApply.length; i++) {
+      const indexPath = `[${i}]`;
+      const diffValue = diffToApply[i];
+      if (diffValue === void 0) {
+        continue;
+      }
+      if (!shouldApplyPath(indexPath)) {
+        continue;
+      }
+      if (isObject(result2[i]) && isObject(diffValue)) {
+        result2[i] = applyDiff(result2[i], diffValue, shouldKeepRef);
+      } else if (Array.isArray(result2[i]) && Array.isArray(diffValue)) {
+        result2[i] = applyDiff(
+          result2[i],
+          diffValue,
+          shouldKeepRef
+        );
+      } else {
+        result2[i] = diffValue;
+      }
+    }
+    return result2;
+  }
+  if (!isObject(baseObj)) return diffToApply;
+  if (!isObject(diffToApply)) return baseObj;
+  const result = shouldKeepRef ? baseObj : { ...baseObj };
+  for (const path of deleted) {
+    if (path.includes(".") || path.includes("[")) continue;
+    if (shouldApplyPath(path)) {
+      delete result[path];
+    }
+  }
+  for (const key in diffToApply) {
+    const diffValue = diffToApply[key];
+    if (!shouldApplyPath(key)) {
+      continue;
+    }
+    if (diffValue === void 0) {
+      delete result[key];
+    } else if (Array.isArray(result[key]) && Array.isArray(diffValue)) {
+      result[key] = applyDiff(result[key], diffValue, shouldKeepRef);
+    } else if (isObject(result[key]) && isObject(diffValue)) {
+      result[key] = applyDiff(result[key], diffValue, shouldKeepRef);
+    } else {
+      result[key] = diffValue;
+    }
+  }
+  return result;
+};
+
+// src/lib/object/selector.ts
+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}`);
+  }
+};
+
+// src/lib/object/merge.ts
+function merge(...sources) {
+  if (sources.length === 0) return {};
+  const firstItem = sources[0];
+  const isArrayMerge = Array.isArray(firstItem);
+  for (const source of sources) {
+    if (source && Array.isArray(source) !== isArrayMerge) {
+      throw new Error("Cannot mix arrays and objects in deepMerge");
+    }
+  }
+  let result = isArrayMerge ? [] : {};
+  for (const source of sources) {
+    if (source == null) continue;
+    if (isArrayMerge) {
+      const resultArray = result;
+      const sourceArray = source;
+      for (const item of sourceArray) {
+        resultArray.push(deepClone(item));
+      }
+    } else {
+      if (!isPlainObject(source)) continue;
+      const resultObj = result;
+      const sourceObj = source;
+      for (const key in sourceObj) {
+        if (Object.prototype.hasOwnProperty.call(sourceObj, key)) {
+          const value = sourceObj[key];
+          const existing = resultObj[key];
+          if (existing === void 0) {
+            resultObj[key] = deepClone(value);
+          } else if (Array.isArray(value) && Array.isArray(existing)) {
+            resultObj[key] = [
+              ...existing,
+              ...value.map((item) => deepClone(item))
+            ];
+          } else if (isPlainObject(value) && isPlainObject(existing)) {
+            resultObj[key] = merge(existing, value);
+          } else {
+            resultObj[key] = deepClone(value);
+          }
+        }
+      }
+      const symbols = Object.getOwnPropertySymbols(sourceObj);
+      for (const symbol of symbols) {
+        const value = sourceObj[symbol];
+        const existing = resultObj[symbol];
+        if (existing === void 0) {
+          resultObj[symbol] = deepClone(value);
+        } else if (Array.isArray(value) && Array.isArray(existing)) {
+          resultObj[symbol] = [
+            ...existing,
+            ...value.map((item) => deepClone(item))
+          ];
+        } else if (isPlainObject(value) && isPlainObject(existing)) {
+          resultObj[symbol] = merge(existing, value);
+        } else {
+          resultObj[symbol] = deepClone(value);
+        }
+      }
+    }
+  }
+  return result;
+}
+function mergeArrays(arr1, arr2, options) {
+  const { key, override = true } = options || {};
+  if (!key) {
+    return Array.from(/* @__PURE__ */ new Set([...arr1, ...arr2]));
+  }
+  const map = /* @__PURE__ */ new Map();
+  for (const item of arr1) {
+    map.set(item[key], item);
+  }
+  for (const item of arr2) {
+    const existing = map.get(item[key]);
+    if (!existing) {
+      map.set(item[key], item);
+    } else {
+      map.set(
+        item[key],
+        override ? { ...existing, ...item } : { ...item, ...existing }
+        // keep original
+      );
+    }
+  }
+  return Array.from(map.values());
+}
+function mergeInPlace(target, source) {
+  for (const key in source) {
+    const tVal = target[key];
+    const sVal = source[key];
+    const diff = diffObjectDetailed(tVal, sVal);
+    if (Array.isArray(tVal) && Array.isArray(sVal)) {
+      tVal.length = 0;
+      tVal.push(...sVal);
+    } else if (typeof tVal === "object" && typeof sVal === "object" && tVal && sVal && diff.hasChanges) {
+      applyDiff(tVal, sVal);
+    } else {
+      target[key] = sVal;
+    }
+  }
+}
+function deepMergeWithOptions(target, ...args) {
+  if (args.length === 0) return deepClone(target);
+  let options = { preserveTarget: false, strict: false };
+  let sources = args;
+  const lastArg = args[args.length - 1];
+  if (lastArg && typeof lastArg === "object" && ("preserveTarget" in lastArg || "strict" in lastArg)) {
+    options = { ...options, ...lastArg };
+    sources = args.slice(0, -1);
+  }
+  const result = options.preserveTarget ? target : deepClone(target);
+  const isArrayMerge = Array.isArray(result);
+  for (const source of sources) {
+    if (source && Array.isArray(source) !== isArrayMerge) {
+      throw new Error("Cannot mix arrays and objects in deepMergeWithOptions");
+    }
+  }
+  for (const source of sources) {
+    if (source == null) continue;
+    if (isArrayMerge) {
+      const resultArray = result;
+      const sourceArray = source;
+      if (options.strict) {
+        for (let i = 0; i < resultArray.length && i < sourceArray.length; i++) {
+          if (isPlainObject(resultArray[i]) && isPlainObject(sourceArray[i])) {
+            resultArray[i] = deepMergeWithOptions(
+              resultArray[i],
+              sourceArray[i],
+              options
+            );
+          } else {
+            if (typeof resultArray[i] === typeof sourceArray[i]) {
+              resultArray[i] = deepClone(sourceArray[i]);
+            }
+          }
+        }
+      } else {
+        mergeInPlace(resultArray, sourceArray);
+      }
+    } else {
+      if (!isPlainObject(source)) continue;
+      const resultObj = result;
+      const sourceObj = source;
+      for (const key in sourceObj) {
+        if (!Object.prototype.hasOwnProperty.call(sourceObj, key)) continue;
+        const value = sourceObj[key];
+        if (options.strict && !(key in resultObj)) {
+          continue;
+        }
+        const existing = resultObj[key];
+        if (existing === void 0) {
+          resultObj[key] = deepClone(value);
+        } else if (Array.isArray(value) && Array.isArray(existing)) {
+          if (options.strict) {
+            resultObj[key] = deepMergeWithOptions(existing, value, options);
+          } else {
+            resultObj[key] = [
+              ...existing,
+              ...value.map((item) => deepClone(item))
+            ];
+          }
+        } else if (isPlainObject(value) && isPlainObject(existing)) {
+          resultObj[key] = deepMergeWithOptions(existing, value, options);
+        } else {
+          resultObj[key] = deepClone(value);
+        }
+      }
+      const symbols = Object.getOwnPropertySymbols(sourceObj);
+      for (const symbol of symbols) {
+        if (options.strict && !(symbol in resultObj)) {
+          continue;
+        }
+        const value = sourceObj[symbol];
+        const existing = resultObj[symbol];
+        if (existing === void 0) {
+          resultObj[symbol] = deepClone(value);
+        } else if (Array.isArray(value) && Array.isArray(existing)) {
+          if (options.strict) {
+            resultObj[symbol] = deepMergeWithOptions(
+              existing,
+              value,
+              options
+            );
+          } else {
+            resultObj[symbol] = [
+              ...existing,
+              ...value.map((item) => deepClone(item))
+            ];
+          }
+        } else if (isPlainObject(value) && isPlainObject(existing)) {
+          resultObj[symbol] = deepMergeWithOptions(
+            existing,
+            value,
+            options
+          );
+        } else {
+          resultObj[symbol] = deepClone(value);
+        }
+      }
+    }
+  }
+  return result;
+}
+function deepMergeKeepReference(target, ...sources) {
+  return deepMergeWithOptions(target, ...sources, {
+    preserveTarget: true
+  });
+}
+function deepMergeStrict(target, ...args) {
+  let preserveReference = false;
+  let sources = args;
+  if (args.length > 0 && typeof args[args.length - 1] === "boolean") {
+    preserveReference = args[args.length - 1];
+    sources = args.slice(0, -1);
+  }
+  return deepMergeWithOptions(target, ...sources, {
+    preserveTarget: preserveReference,
+    strict: true
+  });
+}
+var mergeIntoStructure = (target, selector, value) => {
+  const segments = parseSelector(selector);
+  let current = target;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    const isLast = i === segments.length - 1;
+    switch (segment.type) {
+      case "property":
+        if (isLast) {
+          current[String(segment.value)] = value;
+        } else {
+          if (!current[String(segment.value)]) {
+            const nextSegment = segments[i + 1];
+            current[String(segment.value)] = nextSegment.type === "index" || nextSegment.type === "slice" || nextSegment.type === "union" || nextSegment.type === "wildcard" ? [] : {};
+          }
+          current = current[String(segment.value)];
+        }
+        break;
+      case "index":
+        if (!Array.isArray(current)) {
+          current = [];
+        }
+        const index = segment.value;
+        if (isLast) {
+          if (index >= current.length) {
+            for (let j = current.length; j <= index; j++) {
+              current.push(void 0);
+            }
+          }
+          current[index] = value;
+        } else {
+          if (!current[index]) {
+            const nextSegment = segments[i + 1];
+            current[index] = nextSegment.type === "index" || nextSegment.type === "slice" || nextSegment.type === "union" || nextSegment.type === "wildcard" ? [] : {};
+          }
+          current = current[index];
+        }
+        break;
+      case "wildcard":
+        if (Array.isArray(current)) {
+          if (isLast) {
+            for (let j = 0; j < current.length; j++) {
+              current[j] = value;
+            }
+          } else {
+            const nextSegment = segments[i + 1];
+            for (let j = 0; j < current.length; j++) {
+              if (!current[j]) {
+                current[j] = nextSegment.type === "index" || nextSegment.type === "slice" || nextSegment.type === "union" || nextSegment.type === "wildcard" ? [] : {};
+              }
+            }
+            if (current.length > 0) {
+              current = current[0];
+            }
+          }
+        }
+        break;
+    }
+  }
+};