@dcupl/common 1.11.10 → 2.0.0-beta.0

package/dist/esm/index.js

@@ -1,19 +1,3096 @@
-export * from './analytics.controller';
-export * from './cache.controller';
-export * from './changeDetection';
-export * from './computeSuggestions';
-export * from './dependency-graph';
-export * from './getAggregation';
-export * from './getFacets';
-export * from './helper';
-export * from './indices.controller';
-export * from './performance';
-export * from './pivot';
-export * from './property-parser';
-export * from './query-builder';
-export * from './query.helper';
-export * from './queryData';
-export * from './script.controller';
-export * from './template-parser';
-export * from './types';
-//# sourceMappingURL=index.js.map
+import { cloneDeep as y, get as v, every as B, findIndex as C, size as W, isEqual as E, differenceBy as q, startsWith as L, endsWith as H, isEqualWith as b, isMatch as U, find as V } from "lodash-es";
+function I(o) {
+  const e = K(o);
+  return J(e);
+}
+function K(o) {
+  if (typeof o != "object" || o === null)
+    return String(o);
+  if (Array.isArray(o))
+    return "[" + o.map(K).join(",") + "]";
+  const e = Object.keys(o).sort();
+  let t = "{";
+  for (let r = 0; r < e.length; r++) {
+    const s = e[r];
+    t += s + ":" + K(o[s]), r < e.length - 1 && (t += ",");
+  }
+  return t += "}", t;
+}
+function J(o) {
+  let e = 0;
+  for (let t = 0; t < o.length; t++) {
+    const r = o.charCodeAt(t);
+    e = (e << 5) - e + r, e |= 0;
+  }
+  return e.toString(16);
+}
+const x = {
+  now: () => typeof performance < "u" && performance.now ? performance.now() : (/* @__PURE__ */ new Date()).getTime(),
+  mark: (o) => {
+    typeof performance < "u" && performance.mark && performance.mark(o);
+  },
+  measure: (o, e, t) => {
+    typeof performance < "u" && performance.measure && performance.measure(o, e, t);
+  },
+  getEntriesByName(o) {
+    if (typeof performance < "u" && performance.getEntriesByName)
+      return performance.getEntriesByName(o);
+  },
+  getEntriesByType(o) {
+    if (typeof performance < "u" && performance.getEntriesByType)
+      return performance.getEntriesByType(o);
+  }
+};
+class De {
+  data;
+  enabled = !1;
+  constructor() {
+  }
+  init(e) {
+    this.data = /* @__PURE__ */ new Map(), this.enabled = e;
+  }
+  set(e) {
+    if (!this.enabled) return e.value;
+    const t = this.getKey(e.value.name, e.context);
+    return this.data.set(t, e.value), this.data.get(t);
+  }
+  mark(e) {
+    if (!this.enabled) return;
+    const t = this.getKey(e.name, e.context), r = {
+      name: e.name,
+      type: "mark",
+      value: x.now(),
+      createdAt: Date.now()
+    };
+    return this.data.set(t, r), r;
+  }
+  measure(e) {
+    if (!this.enabled) return;
+    const t = this.getKey(e.name, e.context), r = this.data.get(this.getKey(e.start, e.context)), s = this.data.get(this.getKey(e.end, e.context));
+    if (!r || !s)
+      return;
+    const i = s.value - r.value, n = Math.round(i * 100) / 100, a = this.data.get(t);
+    if (a && e.sum) {
+      const c = a.value + n, f = {
+        ...a,
+        value: c
+      };
+      return this.data.set(t, f), f;
+    }
+    const u = {
+      name: e.name,
+      type: "measure",
+      value: n,
+      createdAt: Date.now()
+    };
+    return e.detail && (u.detail = e.detail), this.data.set(t, u), u;
+  }
+  update(e) {
+    if (!this.enabled) return e.value;
+    const t = this.getKey(e.value.name, e.context), r = this.data.get(t);
+    if (r) {
+      const s = { ...r, ...e.value };
+      this.data.set(t, s);
+    } else
+      this.data.set(t, e.value);
+    return this.data.get(t);
+  }
+  getResourceInfosFromPerformanceAPI() {
+    return typeof performance > "u" ? [] : x.getEntriesByType("resource");
+  }
+  get(e) {
+    const t = this.getKey(e.name, e.context);
+    return this.data.get(t);
+  }
+  getByType(e) {
+    return Array.from(this.data.values()).filter((t) => t.type === e);
+  }
+  getByName(e) {
+    return Array.from(this.data.values()).filter((t) => t.name === e);
+  }
+  clear() {
+    this.data.clear();
+  }
+  getKey(e, t) {
+    if (!t)
+      return e;
+    const r = I(t);
+    return e + "_" + r;
+  }
+}
+let Z = class T {
+  nodes;
+  edges;
+  nodeKinds = /* @__PURE__ */ new Map();
+  nodeMeta = /* @__PURE__ */ new Map();
+  edgePolicy;
+  constructor() {
+    this.nodes = /* @__PURE__ */ new Set(), this.edges = /* @__PURE__ */ new Map();
+  }
+  addNode(e, t) {
+    this.nodes.has(e) || (this.nodes.add(e), this.edges.set(e, /* @__PURE__ */ new Set())), t?.kind !== void 0 && this.nodeKinds.set(e, t.kind), t?.meta !== void 0 && this.nodeMeta.set(e, t.meta);
+  }
+  addDependency(e, t) {
+    if (!this.nodes.has(e) || !this.nodes.has(t))
+      throw new Error("Both nodes must exist before adding a dependency.");
+    if (this.edgePolicy && !this.edgePolicy(
+      { name: e, kind: this.nodeKinds.get(e) },
+      { name: t, kind: this.nodeKinds.get(t) }
+    ))
+      throw new Error(`Edge policy rejected dependency from "${e}" to "${t}".`);
+    this.edges.get(e).add(t);
+  }
+  /** Configure an optional policy to validate edges before they are added */
+  setEdgePolicy(e) {
+    this.edgePolicy = e;
+  }
+  /** Assign or change a node's kind */
+  setNodeKind(e, t) {
+    if (!this.nodes.has(e)) throw new Error("Node does not exist.");
+    t === void 0 ? this.nodeKinds.delete(e) : this.nodeKinds.set(e, t);
+  }
+  /** Get a node's kind */
+  getNodeKind(e) {
+    return this.nodeKinds.get(e);
+  }
+  /** Set arbitrary metadata for a node */
+  setNodeMeta(e, t) {
+    if (!this.nodes.has(e)) throw new Error("Node does not exist.");
+    this.nodeMeta.set(e, t);
+  }
+  /** Get metadata for a node */
+  getNodeMeta(e) {
+    return this.nodeMeta.get(e);
+  }
+  removeNode(e) {
+    if (!this.nodes.has(e))
+      throw new Error("Node does not exist.");
+    this.nodes.delete(e), this.edges.delete(e);
+    for (let t of this.edges.values())
+      t.delete(e);
+  }
+  removeDependency(e, t) {
+    if (!this.edges.has(e))
+      throw new Error("From node does not exist.");
+    this.edges.get(e).delete(t);
+  }
+  hasNode(e) {
+    return this.nodes.has(e);
+  }
+  hasDependency(e, t) {
+    return this.edges.has(e) ? this.edges.get(e).has(t) : !1;
+  }
+  getDependencies(e) {
+    if (!this.edges.has(e))
+      throw new Error("Node does not exist.");
+    return Array.from(this.edges.get(e));
+  }
+  getDependents(e) {
+    const t = [];
+    for (let [r, s] of this.edges)
+      s.has(e) && t.push(r);
+    return t;
+  }
+  isCyclic() {
+    const e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), r = (s) => {
+      if (e.has(s))
+        return !1;
+      if (t.has(s))
+        return !0;
+      t.add(s);
+      const i = this.edges.get(s);
+      if (i) {
+        for (let n of i)
+          if (r(n))
+            return !0;
+      }
+      return t.delete(s), e.add(s), !1;
+    };
+    for (let s of this.nodes)
+      if (r(s))
+        return !0;
+    return !1;
+  }
+  /**
+   * Validates that the graph has no cycles.
+   * Returns an object with hasCycle boolean and the cycle path if found.
+   * @returns {hasCycle: boolean, path?: string[]} - hasCycle is true if a cycle exists, path contains the cycle nodes
+   */
+  validateNoCycles() {
+    const e = /* @__PURE__ */ new Set(), t = /* @__PURE__ */ new Set(), r = [], s = (i) => {
+      if (e.has(i))
+        return null;
+      if (t.has(i)) {
+        const a = r.indexOf(i);
+        return r.slice(a).concat([i]);
+      }
+      t.add(i), r.push(i);
+      const n = this.edges.get(i);
+      if (n)
+        for (let a of n) {
+          const u = s(a);
+          if (u)
+            return u;
+        }
+      return r.pop(), t.delete(i), e.add(i), null;
+    };
+    for (let i of this.nodes) {
+      const n = s(i);
+      if (n)
+        return { hasCycle: !0, path: n };
+    }
+    return { hasCycle: !1 };
+  }
+  order(e) {
+    const t = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), s = [], i = e?.allowCycles ?? !1, n = (a) => {
+      if (t.has(a))
+        return;
+      if (r.has(a)) {
+        if (i)
+          return;
+        throw new Error("Graph has a cycle.");
+      }
+      r.add(a);
+      const u = this.edges.get(a);
+      if (u)
+        for (let c of u)
+          n(c);
+      r.delete(a), t.add(a), s.push(a);
+    };
+    for (let a of this.nodes)
+      t.has(a) || n(a);
+    return s;
+  }
+  clear() {
+    this.nodes.clear(), this.edges.clear();
+  }
+  getNodes() {
+    return Array.from(this.nodes);
+  }
+  getAllEdges() {
+    const e = [];
+    for (let [t, r] of this.edges)
+      for (let s of r)
+        e.push([t, s]);
+    return e;
+  }
+  /**
+   * Returns all nodes that have no dependants (i.e., no other node depends on them).
+   * In graph terms, nodes with zero incoming edges.
+   */
+  getNodesWithNoDependants() {
+    if (this.nodes.size === 0)
+      return [];
+    const e = /* @__PURE__ */ new Set();
+    for (const r of this.edges.values())
+      for (const s of r)
+        e.add(s);
+    const t = [];
+    for (const r of this.nodes)
+      e.has(r) || t.push(r);
+    return t;
+  }
+  /** Return nodes filtered by kind */
+  getNodesByKind(e) {
+    const t = [];
+    for (const r of this.nodes)
+      this.nodeKinds.get(r) === e && t.push(r);
+    return t;
+  }
+  /** Roots by kind (zero incoming) */
+  getRootsByKind(e) {
+    const t = new Set(this.getNodesWithNoDependants()), r = Array.from(t);
+    return e ? r.filter((s) => this.nodeKinds.get(s) === e) : r;
+  }
+  /** Leaves by kind (zero outgoing) */
+  getLeavesByKind(e) {
+    const t = [];
+    for (const r of this.nodes) {
+      const s = this.edges.get(r);
+      (!s || s.size === 0) && (!e || this.nodeKinds.get(r) === e) && t.push(r);
+    }
+    return t;
+  }
+  /** Filter dependencies of a node by kind */
+  getDependenciesOfKind(e, t) {
+    return this.getDependencies(e).filter((s) => this.nodeKinds.get(s) === t);
+  }
+  /** Filter dependents of a node by kind */
+  getDependentsOfKind(e, t) {
+    return this.getDependents(e).filter((s) => this.nodeKinds.get(s) === t);
+  }
+  /**
+   * Create execution batches (topological levels). Throws if the graph has a cycle.
+   * If filterKinds is provided, batches contain only nodes of these kinds, but readiness
+   * is evaluated against the complete graph.
+   */
+  plan(e) {
+    const t = /* @__PURE__ */ new Map();
+    for (const n of this.nodes) t.set(n, 0);
+    for (const n of this.edges.values())
+      for (const a of n) t.set(a, (t.get(a) || 0) + 1);
+    const r = [];
+    let s = Array.from(this.nodes).filter((n) => (t.get(n) || 0) === 0);
+    const i = /* @__PURE__ */ new Set();
+    for (; s.length > 0; ) {
+      const n = s.slice();
+      r.push(n), s = [];
+      for (const a of n) {
+        if (i.has(a)) continue;
+        i.add(a);
+        const u = this.edges.get(a);
+        if (u)
+          for (const c of u)
+            t.set(c, (t.get(c) || 0) - 1), (t.get(c) || 0) === 0 && s.push(c);
+      }
+    }
+    if (i.size !== this.nodes.size)
+      throw new Error("Graph has a cycle.");
+    if (e?.filterKinds && e.filterKinds.length > 0) {
+      const n = new Set(e.filterKinds);
+      return {
+        batches: r.map((a) => a.filter((u) => n.has(this.nodeKinds.get(u))))
+      };
+    }
+    return { batches: r };
+  }
+  /**
+   * Impact analysis: return nodes impacted by a set of changed nodes.
+   * direction:
+   *  - 'downstream': nodes that depend (directly/indirectly) on changed
+   *  - 'upstream': nodes that changed depends on
+   *  - 'both': union of upstream and downstream
+   */
+  getImpactedNodes(e, t = "downstream", r) {
+    const s = new Set(e), i = (c) => !r || r.length === 0 || r.includes(this.nodeKinds.get(c) ?? void 0), n = () => {
+      const c = /* @__PURE__ */ new Set(), f = Array.from(s);
+      for (; f.length; ) {
+        const d = f.shift();
+        for (const [l, h] of this.edges)
+          h.has(d) && !c.has(l) && (c.add(l), f.push(l));
+      }
+      return c;
+    }, a = () => {
+      const c = /* @__PURE__ */ new Set(), f = Array.from(s);
+      for (; f.length; ) {
+        const d = f.shift(), l = this.edges.get(d);
+        if (l)
+          for (const h of l)
+            c.has(h) || (c.add(h), f.push(h));
+      }
+      return c;
+    };
+    let u;
+    return t === "both" ? u = /* @__PURE__ */ new Set([...n(), ...a()]) : t === "upstream" ? u = a() : u = n(), Array.from(u).filter(i);
+  }
+  toJSON() {
+    const e = Array.from(this.nodes).map((r) => ({
+      name: r,
+      kind: this.nodeKinds.get(r),
+      meta: this.nodeMeta.get(r)
+    })), t = this.getAllEdges().map(([r, s]) => ({ from: r, to: s }));
+    return { nodes: e, edges: t };
+  }
+  static fromJSON(e) {
+    const t = new T();
+    for (const r of e.nodes)
+      t.addNode(r.name, { kind: r.kind, meta: r.meta });
+    for (const r of e.edges)
+      t.addDependency(r.from, r.to);
+    return t;
+  }
+  diff(e) {
+    const t = new Set(this.getNodes()), r = new Set(e.getNodes()), s = Array.from(r).filter((d) => !t.has(d)), i = Array.from(t).filter((d) => !r.has(d)), n = new Set(this.getAllEdges().map((d) => d.join("→"))), a = new Set(e.getAllEdges().map((d) => d.join("→"))), u = Array.from(a).filter((d) => !n.has(d)).map((d) => d.split("→")), c = Array.from(n).filter((d) => !a.has(d)).map((d) => d.split("→")), f = [];
+    for (const d of /* @__PURE__ */ new Set([...t, ...r])) {
+      const l = this.nodeKinds.get(d), h = e.nodeKinds.get(d);
+      l !== h && f.push({ name: d, from: l, to: h });
+    }
+    return { addedNodes: s, removedNodes: i, addedEdges: u, removedEdges: c, kindChanges: f };
+  }
+};
+class Ke {
+  graph;
+  nodeIndex;
+  constructor() {
+    this.graph = new Z(), this.nodeIndex = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Creates a unique ID for an attribute node
+   */
+  getNodeId(e, t) {
+    return `${e}.${t}`;
+  }
+  /**
+   * Parses a node ID back into components
+   */
+  parseNodeId(e) {
+    const t = e.split(".");
+    return {
+      modelKey: t[0],
+      attributeKey: t.slice(1).join(".")
+      // Handle attribute keys with dots
+    };
+  }
+  /**
+   * Adds an attribute node to the graph
+   */
+  addAttribute(e) {
+    const t = this.getNodeId(e.modelKey, e.attributeKey);
+    this.nodeIndex.has(t) || (this.graph.addNode(t, { meta: e }), this.nodeIndex.set(t, e));
+  }
+  /**
+   * Adds a dependency between two attributes
+   * @param from - The dependent attribute (e.g., ModelA.derivedPrice)
+   * @param to - The source attribute it depends on (e.g., ModelB.baseCost)
+   */
+  addAttributeDependency(e, t) {
+    this.addAttribute(e), this.addAttribute(t);
+    const r = this.getNodeId(e.modelKey, e.attributeKey), s = this.getNodeId(t.modelKey, t.attributeKey);
+    this.graph.hasDependency(r, s) || this.graph.addDependency(r, s);
+  }
+  /**
+   * Gets all attributes impacted by changes to the given attributes
+   * @param changed - Array of changed attribute nodes
+   * @returns Array of all impacted attribute nodes (including the changed ones)
+   */
+  getImpactedAttributes(e) {
+    const t = e.map((a) => this.getNodeId(a.modelKey, a.attributeKey)), s = this.graph.getImpactedNodes(t, "downstream").map((a) => this.nodeIndex.get(a)).filter((a) => a !== void 0), i = [...e, ...s], n = /* @__PURE__ */ new Set();
+    return i.filter((a) => {
+      const u = this.getNodeId(a.modelKey, a.attributeKey);
+      return n.has(u) ? !1 : (n.add(u), !0);
+    });
+  }
+  /**
+   * Generates a processing plan for the given attributes
+   * Groups attributes by model and processing step for efficient batch processing
+   *
+   * @param attributes - Array of attributes to process
+   * @returns Map<modelKey, Map<processingStep, Set<attributeKeys>>>
+   */
+  getProcessingOrder(e) {
+    const t = /* @__PURE__ */ new Map(), r = [...e].sort((s, i) => s.processingStep - i.processingStep);
+    for (const s of r) {
+      const { modelKey: i, attributeKey: n, processingStep: a } = s;
+      t.has(i) || t.set(i, /* @__PURE__ */ new Map());
+      const u = t.get(i);
+      u.has(a) || u.set(a, /* @__PURE__ */ new Set()), u.get(a).add(n);
+    }
+    return t;
+  }
+  /**
+   * Gets all attributes for a specific model
+   */
+  getAttributesForModel(e) {
+    const t = [];
+    for (const r of this.nodeIndex.values())
+      r.modelKey === e && t.push(r);
+    return t;
+  }
+  /**
+   * Gets dependencies for a specific attribute
+   */
+  getDependencies(e) {
+    const t = this.getNodeId(e.modelKey, e.attributeKey);
+    return this.graph.hasNode(t) ? this.graph.getDependencies(t).map((s) => this.nodeIndex.get(s)).filter((s) => s !== void 0) : [];
+  }
+  /**
+   * Gets dependents for a specific attribute (attributes that depend on this one)
+   */
+  getDependents(e) {
+    const t = this.getNodeId(e.modelKey, e.attributeKey);
+    return this.graph.hasNode(t) ? this.graph.getDependents(t).map((s) => this.nodeIndex.get(s)).filter((s) => s !== void 0) : [];
+  }
+  /**
+   * Checks if an attribute has any dependencies
+   */
+  hasDependencies(e) {
+    const t = this.getNodeId(e.modelKey, e.attributeKey);
+    return this.graph.hasNode(t) ? this.graph.getDependencies(t).length > 0 : !1;
+  }
+  /**
+   * Checks if a node exists in the graph
+   */
+  hasNode(e) {
+    return this.nodeIndex.has(e);
+  }
+  /**
+   * Gets all attribute nodes in the graph
+   */
+  getAllAttributes() {
+    return Array.from(this.nodeIndex.values());
+  }
+  /**
+   * Gets the maximum dependency depth in the graph
+   * Useful for determining if full update might be more efficient
+   */
+  getMaxDepth() {
+    let e = 0;
+    const t = (r, s = /* @__PURE__ */ new Set()) => {
+      if (s.has(r)) return 0;
+      s.add(r);
+      const i = this.graph.getDependencies(r);
+      if (i.length === 0) return 1;
+      let n = 0;
+      for (const a of i) {
+        const u = t(a, new Set(s));
+        n = Math.max(n, u);
+      }
+      return n + 1;
+    };
+    for (const r of this.graph.getNodes()) {
+      const s = t(r);
+      e = Math.max(e, s);
+    }
+    return e;
+  }
+  /**
+   * Validates that all expected attributes are present in the graph.
+   * This helps catch silent failures during graph building where attributes
+   * with expressions or derivations might not be properly added.
+   *
+   * @param expectedAttributes - Map of modelKey to array of attribute keys that should exist
+   * @returns Object with validation result and any missing attributes
+   */
+  validateCompleteness(e) {
+    const t = [];
+    for (const [r, s] of e)
+      for (const i of s) {
+        const n = this.getNodeId(r, i);
+        this.hasNode(n) || t.push({ modelKey: r, attributeKey: i });
+      }
+    return {
+      isComplete: t.length === 0,
+      missing: t
+    };
+  }
+  /**
+   * Clears the entire graph
+   */
+  clear() {
+    this.graph.clear(), this.nodeIndex.clear();
+  }
+  /**
+   * Gets statistics about the graph
+   */
+  getStats() {
+    const e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map();
+    for (const r of this.nodeIndex.values())
+      e.set(r.modelKey, (e.get(r.modelKey) || 0) + 1), t.set(r.processingStep, (t.get(r.processingStep) || 0) + 1);
+    return {
+      totalAttributes: this.nodeIndex.size,
+      totalDependencies: this.graph.getAllEdges().length,
+      maxDepth: this.getMaxDepth(),
+      attributesByModel: e,
+      attributesByStep: t
+    };
+  }
+  /**
+   * Exports the graph to JSON for debugging
+   */
+  toJSON() {
+    return {
+      nodes: Array.from(this.nodeIndex.values()),
+      edges: this.graph.getAllEdges().map(([e, t]) => {
+        const r = this.parseNodeId(e), s = this.parseNodeId(t);
+        return {
+          from: r,
+          to: s
+        };
+      })
+    };
+  }
+}
+const O = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+class p {
+  config;
+  static globalConfig = {};
+  constructor(e = {}) {
+    this.config = {
+      level: e.level ?? p.globalConfig.level ?? this.getDefaultLevel(),
+      format: e.format ?? p.globalConfig.format ?? this.getDefaultFormat(),
+      prefix: e.prefix,
+      onLog: e.onLog ?? p.globalConfig.onLog,
+      onTrackError: e.onTrackError ?? p.globalConfig.onTrackError
+    };
+  }
+  /**
+   * Set global logger configuration (affects all logger instances)
+   */
+  static setGlobalConfig(e) {
+    p.globalConfig = { ...p.globalConfig, ...e };
+  }
+  /**
+   * Get the global logger configuration
+   */
+  static getGlobalConfig() {
+    return { ...p.globalConfig };
+  }
+  /**
+   * Configure module-specific log levels
+   * @example
+   * logger.setModuleLevel('ModelParser', 'debug');
+   * logger.setModuleLevel('Catalog', 'warn');
+   */
+  static setModuleLevel(e, t) {
+    p.globalConfig.onLog || (p.globalConfig.onLog = void 0), p._moduleOverrides || (p._moduleOverrides = /* @__PURE__ */ new Map()), p._moduleOverrides.set(e, t);
+  }
+  /**
+   * Get module-specific log level
+   */
+  static getModuleLevel(e) {
+    if (!(!e || !p._moduleOverrides))
+      return p._moduleOverrides.get(e);
+  }
+  getDefaultLevel() {
+    return "info";
+  }
+  getDefaultFormat() {
+    return "pretty";
+  }
+  getEffectiveLevel() {
+    if (this.config.prefix) {
+      const e = p.getModuleLevel(this.config.prefix);
+      if (e)
+        return e;
+    }
+    return this.config.level;
+  }
+  shouldLog(e) {
+    const t = this.getEffectiveLevel();
+    return O[e] <= O[t];
+  }
+  formatMessage(e) {
+    if (this.config.format === "json") {
+      const n = {
+        timestamp: new Date(e.timestamp).toISOString(),
+        level: e.level,
+        message: e.message
+      };
+      return e.prefix && (n.module = e.prefix), e.context && (n.context = e.context), e.error && (n.error = {
+        name: e.error.name,
+        message: e.error.message,
+        stack: e.error.stack
+      }), JSON.stringify(n);
+    }
+    const t = new Date(e.timestamp).toISOString().substring(11, 23), r = e.prefix ? `[${e.prefix}]` : "", s = this.getLevelIcon(e.level), i = e.context ? ` ${JSON.stringify(e.context)}` : "";
+    return `${t} ${s} ${r} ${e.message}${i}`.trim();
+  }
+  getLevelIcon(e) {
+    switch (e) {
+      case "error":
+        return "✖";
+      case "warn":
+        return "⚠";
+      case "info":
+        return "ℹ";
+      case "debug":
+        return "⚙";
+      default:
+        return " ";
+    }
+  }
+  log(e, t, r, s) {
+    if (!this.shouldLog(e))
+      return;
+    const i = {
+      level: e,
+      message: t,
+      timestamp: Date.now(),
+      prefix: this.config.prefix,
+      context: r,
+      error: s
+    };
+    if (this.config.onLog) {
+      this.config.onLog(i);
+      return;
+    }
+    const n = this.formatMessage(i);
+    if (typeof console < "u")
+      switch (e) {
+        case "error":
+          s ? console.error(n, s) : console.error(n);
+          break;
+        case "warn":
+          console.warn(n);
+          break;
+        case "debug":
+          console.debug ? console.debug(n) : console.log(n);
+          break;
+        default:
+          console.log(n);
+      }
+  }
+  /**
+   * Log an error message
+   */
+  error(e, t, r) {
+    const s = t instanceof Error ? t : void 0, i = t instanceof Error ? r : t;
+    this.log("error", e, i, s);
+  }
+  /**
+   * Log and track an error (integrates with QualityController)
+   * @param message Error message
+   * @param error Error object
+   * @param options Additional context and error classification
+   */
+  trackError(e, t, r) {
+    if (this.error(e, t, r?.context), this.config.onTrackError) {
+      const s = {
+        level: "error",
+        message: e,
+        timestamp: Date.now(),
+        prefix: this.config.prefix,
+        context: r?.context,
+        error: t,
+        errorType: r?.errorType,
+        errorGroup: r?.errorGroup
+      };
+      this.config.onTrackError(s);
+    }
+  }
+  /**
+   * Log a warning message
+   */
+  warn(e, t) {
+    this.log("warn", e, t);
+  }
+  /**
+   * Log an info message
+   */
+  info(e, t) {
+    this.log("info", e, t);
+  }
+  /**
+   * Log a debug message
+   */
+  debug(e, t) {
+    this.log("debug", e, t);
+  }
+  /**
+   * Create a child logger with additional context or configuration
+   * Child loggers inherit parent config but can override specific settings
+   *
+   * @example
+   * const modelLogger = logger.child({ prefix: 'ModelParser' });
+   * modelLogger.info('Processing data'); // [ModelParser] Processing data
+   *
+   * @example
+   * const debugLogger = logger.child({ prefix: 'Catalog', level: 'debug' });
+   */
+  child(e) {
+    const t = {
+      ...this.config,
+      ...e,
+      // Handle prefix concatenation for nested children
+      prefix: e.prefix ? this.config.prefix ? `${this.config.prefix}:${e.prefix}` : e.prefix : this.config.prefix
+    };
+    return new p(t);
+  }
+  /**
+   * Update this logger's configuration
+   */
+  configure(e) {
+    Object.assign(this.config, e);
+  }
+}
+const Y = new p();
+class Se {
+  constructor(e) {
+    this.enabled = e, this.cache = /* @__PURE__ */ new Map(), this.cacheDependencies = /* @__PURE__ */ new Map();
+  }
+  cache;
+  // Track which models and attributes each cache entry depends on
+  cacheDependencies;
+  // Track cache hits and misses for statistics
+  hitCount = 0;
+  missCount = 0;
+  log = Y.child({ prefix: "CacheController" });
+  get(e, t) {
+    if (!this.enabled) return;
+    const r = this.getCacheName(e, t);
+    return this.cache.has(r) ? this.hitCount++ : this.missCount++, this.cache.get(r);
+  }
+  set(e, t, r, s) {
+    if (!this.enabled) return;
+    const i = this.getCacheName(e, t);
+    this.cache.set(i, r), s ? this.cacheDependencies.set(i, s) : this.log.debug(
+      `Cache entry '${e}' stored without dependencies. This prevents granular invalidation and may cause stale data.`
+    );
+  }
+  has(e, t) {
+    return this.cache.has(this.getCacheName(e, t));
+  }
+  clear() {
+    this.cache.clear(), this.cacheDependencies.clear(), this.hitCount = 0, this.missCount = 0;
+  }
+  /**
+   * Invalidates cache entries that depend on the specified models and attributes
+   * @param changedModels - Map of modelKey → Set of changed attributeKeys
+   */
+  invalidateByDependencies(e) {
+    if (!this.enabled) return;
+    const t = [];
+    for (const [r, s] of this.cacheDependencies) {
+      let i = !1;
+      for (const [n, a] of e) {
+        if (s.models.has(n))
+          if (s.modelAttributes.has(n)) {
+            const u = s.modelAttributes.get(n);
+            for (const c of a)
+              if (u.has(c)) {
+                i = !0;
+                break;
+              }
+          } else
+            i = !0;
+        if (i) break;
+      }
+      i && t.push(r);
+    }
+    for (const r of t)
+      this.cache.delete(r), this.cacheDependencies.delete(r);
+  }
+  /**
+   * Invalidates all cache entries for specific models
+   * @param modelKeys - Array of model keys to invalidate
+   */
+  invalidateByModels(e) {
+    if (!this.enabled) return;
+    const t = new Set(e), r = [];
+    for (const [s, i] of this.cacheDependencies)
+      for (const n of t)
+        if (i.models.has(n)) {
+          r.push(s);
+          break;
+        }
+    for (const s of r)
+      this.cache.delete(s), this.cacheDependencies.delete(s);
+  }
+  /**
+   * Invalidates cache entries by key prefix (e.g., 'query', 'facets')
+   * @param keyPrefix - The key prefix to match
+   */
+  invalidateByKeyPrefix(e) {
+    if (!this.enabled) return;
+    const t = [];
+    for (const r of this.cache.keys())
+      r.startsWith(e + "_") && t.push(r);
+    for (const r of t)
+      this.cache.delete(r), this.cacheDependencies.delete(r);
+  }
+  /**
+   * Invalidates all cache entries for a specific model
+   * @param modelKey - The model key to invalidate
+   */
+  invalidateForModel(e) {
+    this.invalidateByModels([e]);
+  }
+  /**
+   * Invalidates cache entries that depend on a specific attribute of a model
+   * @param modelKey - The model key
+   * @param attributeKey - The attribute key to invalidate
+   */
+  invalidateForAttribute(e, t) {
+    if (!this.enabled) return;
+    const r = /* @__PURE__ */ new Map();
+    r.set(e, /* @__PURE__ */ new Set([t])), this.invalidateByDependencies(r);
+  }
+  /**
+   * Invalidates cache entries matching a custom predicate
+   * @param predicate - Function that returns true for cache keys to invalidate
+   */
+  invalidateMatching(e) {
+    if (!this.enabled) return;
+    const t = [];
+    for (const r of this.cache.keys())
+      e(r) && t.push(r);
+    for (const r of t)
+      this.cache.delete(r), this.cacheDependencies.delete(r);
+  }
+  generateContext(e) {
+    try {
+      return y(e);
+    } catch (t) {
+      return this.log.error("Error in cache generateContext", t), e;
+    }
+  }
+  getCacheName(e, t) {
+    const r = I(t);
+    return e + "_" + r;
+  }
+  /**
+   * Gets cache statistics including hit rate
+   */
+  getStats() {
+    const e = this.hitCount + this.missCount, t = e > 0 ? this.hitCount / e : 0;
+    return {
+      size: this.cache.size,
+      hitRate: t,
+      totalEntries: this.cache.size,
+      entriesWithDependencies: this.cacheDependencies.size,
+      hits: this.hitCount,
+      misses: this.missCount
+    };
+  }
+}
+const Ie = (o, e = "") => `${o}#${e}`, Qe = (o) => `${o.gt}_${o.gte}_${o.lt}_${o.lte}_${o.eq}_${o.ne}`, Me = (o) => `${o.gt}_${o.gte}_${o.lt}_${o.lte}_${o.eq}_${o.ne}`, Ne = (o, e) => {
+  const t = typeof e == "function" ? e : (r) => r[e];
+  return [
+    ...o.reduce((r, s) => {
+      const i = s == null ? s : t(s);
+      return r.has(i) || r.set(i, s), r;
+    }, /* @__PURE__ */ new Map()).values()
+  ];
+}, ke = (o, e) => o.reduce(function(t, r) {
+  const s = typeof e == "function" ? e(r) : r[e];
+  return Object.prototype.hasOwnProperty.call(t, s) || (t[s] = []), t[s].push(r), t;
+}, {});
+function X(o = 10) {
+  let e = "";
+  const t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  for (let r = 0; r < o; r++) e += t.charAt(Math.floor(Math.random() * t.length));
+  return e;
+}
+const Ce = (o) => o.replace(/\/+$/, ""), ee = (o) => typeof o != "string" ? "" : o.replace(/[[\]{}()*+?.,\\^$|#]/g, "\\$&"), Ee = (o) => typeof o != "string" ? "" : o.replace(/\\([[\]{}()*+?.,\\^$|#])/g, "$1"), qe = (o, e) => {
+  try {
+    return te(o, e) >= 0;
+  } catch {
+    return !1;
+  }
+}, te = (o, e) => {
+  if (!$(o) || !$(e))
+    throw new Error(`Invalid version format: v1="${o}", v2="${e}". Expected format: "x.y.z"`);
+  const t = o.split(".").map(Number), r = e.split(".").map(Number);
+  for (let s = 0; s < 3; s++) {
+    const i = t[s] || 0, n = r[s] || 0;
+    if (i > n) return 1;
+    if (i < n) return -1;
+  }
+  return 0;
+}, $ = (o) => /^\d+(\.\d+){0,2}$/.test(o);
+class Oe {
+  key;
+  parentCd;
+  dcuplInitOptions;
+  analyticsController;
+  off;
+  updateListener = /* @__PURE__ */ new Set();
+  // only the "root" counter will be increased and used in the events
+  counter = 0;
+  constructor() {
+  }
+  _init(e) {
+    this.key = e.cdRefKey, this.analyticsController = e.analyticsController, this.parentCd = e.parentCd, this.dcuplInitOptions = e.dcuplInitOptions, this.parentCd && (this.off = this.parentCd.on((t) => {
+      t.action === "update" && t.originCdRefKey === this.parentCd?.key && (t.connectMessage = !1, this.trigger(t));
+    }));
+  }
+  getCounter() {
+    return this.parentCd ? this.parentCd.getCounter() : this.counter;
+  }
+  increaseCounter() {
+    this.parentCd ? this.parentCd.increaseCounter() : this.counter++;
+  }
+  destroy() {
+    this.off && this.off();
+  }
+  trigger(e) {
+    e.originCdRefKey || (e.originCdRefKey = this.key), e.key || (this.increaseCounter(), e.key = this.getCounter()), e.end || (e.end = x.now(), e.duration = e.start - e.end), this.updateListener.forEach((t) => {
+      t(e);
+    });
+  }
+  on(e) {
+    return this.updateListener.add(e), () => {
+      this.updateListener.delete(e);
+    };
+  }
+}
+const j = (o, e) => e ? typeof structuredClone < "u" ? structuredClone(o) : y(o) : o, F = (o, e, t, r, s, i) => {
+  try {
+    const n = !!e.dcuplInitOptions.performance?.clone?.enabled && !!t.cloneResult, a = j(i, n);
+    if (t.scope === "list" && (t.listKey = o.cdRef?.key || o.key, t.modelKey = o.model?.key || o.modelKey), t.type === "list_created" && t.args[0].listKey.startsWith("__global_list__") || t.listKey?.startsWith("__global_list__"))
+      return a;
+    const u = x.now(), c = u - r, f = Math.round(c * 1e3) / 1e3;
+    t.duration = f, t.start = r, t.end = u;
+    const d = {
+      duration: t.duration
+    };
+    return t.modelKey && (d.model = t.modelKey), t.connectMessageResult && (t.result = a), t.args && (d.args = t.args), e?.trigger(t), e.analyticsController.mark({
+      name: `${t.type}:end`,
+      context: s
+    }), e.analyticsController.measure({
+      name: t.type,
+      start: `${t.type}:start`,
+      end: `${t.type}:end`,
+      context: s,
+      detail: d
+    }), a;
+  } catch {
+    return i;
+  }
+}, $e = (o) => (t, r, s) => {
+  const i = s.value;
+  return s.value = function(...n) {
+    const a = x.now(), u = this.cdRef, c = j(o, !0);
+    c.key || (u.increaseCounter(), c.key = u.getCounter());
+    const f = X();
+    u.analyticsController.mark({
+      name: `${c.type}:start`,
+      context: f
+    });
+    const d = this.model?.key;
+    !c.originCdRefKey && u.key && (c.originCdRefKey = u.key), d && (c.modelKey = d);
+    const l = i.apply(this, n);
+    return c.method = r, c.args = n, l && typeof l == "object" && "then" in l ? l.then((h) => F(this, u, c, a, f, h)) : F(this, u, c, a, f, l);
+  }, s;
+};
+function Fe(o, e, t, r) {
+  t.max || (t.max = 20);
+  const s = [], i = t.transform ? r.transformValue(t.value, t.transform) : t.value;
+  for (const [n, a] of e.entries()) {
+    const u = Array.from(a).some((f) => o.has(f)), c = t.transform ? r.transformValue(n, t.transform) : n;
+    if (!(t.excludeUndefineds && typeof n > "u") && !(t.excludeNulls && n === null)) {
+      if (u && (i === "" || i === "//")) {
+        const f = {
+          value: n,
+          keys: t.calculateResultKeys ? Array.from(a) : []
+        };
+        s.push(f);
+      } else if (u && typeof i == "string" && i.startsWith("/") && i.endsWith("/")) {
+        if (r.queryFind(c, i, "some")) {
+          const f = {
+            value: n,
+            keys: t.calculateResultKeys ? Array.from(a) : []
+          };
+          s.push(f);
+        }
+      } else if (u && typeof i == "string") {
+        const f = String(c ?? ""), d = i;
+        if (f.toLowerCase().startsWith(d.toLowerCase())) {
+          const l = {
+            value: n,
+            keys: t.calculateResultKeys ? Array.from(a) : []
+          };
+          s.push(l);
+        }
+      } else if (u && r.queryFind(c, i, "some")) {
+        const f = {
+          value: n,
+          keys: t.calculateResultKeys ? Array.from(a) : []
+        };
+        s.push(f);
+      }
+      if (s.length === t.max)
+        break;
+    }
+  }
+  return s;
+}
+function re(o) {
+  return o instanceof Date;
+}
+function se(o) {
+  return o instanceof Date && !isNaN(o.getTime());
+}
+const ne = {
+  yyyy: { type: "year", pattern: "yyyy", regex: "(\\d{4})" },
+  yy: { type: "year", pattern: "yy", regex: "(\\d{2})" },
+  MM: { type: "month", pattern: "MM", regex: "(\\d{2})" },
+  M: { type: "month", pattern: "M", regex: "(\\d{1,2})" },
+  dd: { type: "day", pattern: "dd", regex: "(\\d{2})" },
+  d: { type: "day", pattern: "d", regex: "(\\d{1,2})" },
+  HH: { type: "hour", pattern: "HH", regex: "(\\d{2})" },
+  H: { type: "hour", pattern: "H", regex: "(\\d{1,2})" },
+  mm: { type: "minute", pattern: "mm", regex: "(\\d{2})" },
+  m: { type: "minute", pattern: "m", regex: "(\\d{1,2})" },
+  ss: { type: "second", pattern: "ss", regex: "(\\d{2})" },
+  s: { type: "second", pattern: "s", regex: "(\\d{1,2})" },
+  SSS: { type: "millisecond", pattern: "SSS", regex: "(\\d{3})" }
+};
+function ie(o) {
+  let e = "^";
+  const t = [];
+  let r = o;
+  const s = Object.entries(ne).sort((i, n) => n[0].length - i[0].length);
+  for (; r.length > 0; ) {
+    let i = !1;
+    for (const [n, a] of s)
+      if (r.startsWith(n)) {
+        e += a.regex, t.push({ type: a.type, pattern: n }), r = r.slice(n.length), i = !0;
+        break;
+      }
+    if (!i) {
+      const n = r[0];
+      if (!n)
+        break;
+      e += n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), r = r.slice(1);
+    }
+  }
+  return e += "$", { regex: new RegExp(e), tokenOrder: t };
+}
+function oe(o, e) {
+  const t = {
+    year: 1970,
+    month: 1,
+    day: 1,
+    hour: 0,
+    minute: 0,
+    second: 0,
+    millisecond: 0
+  };
+  for (let r = 0; r < e.length; r++) {
+    const s = o[r + 1];
+    if (!s)
+      continue;
+    const i = parseInt(s, 10), n = e[r];
+    n && (n.type === "year" && n.pattern === "yy" ? t.year = 2e3 + i : t[n.type] = i);
+  }
+  return t;
+}
+function ae(o) {
+  if (o.month < 1 || o.month > 12)
+    return /* @__PURE__ */ new Date(NaN);
+  if (o.day < 1 || o.day > 31)
+    return /* @__PURE__ */ new Date(NaN);
+  if (o.hour < 0 || o.hour > 23)
+    return /* @__PURE__ */ new Date(NaN);
+  if (o.minute < 0 || o.minute > 59)
+    return /* @__PURE__ */ new Date(NaN);
+  if (o.second < 0 || o.second > 59)
+    return /* @__PURE__ */ new Date(NaN);
+  if (o.millisecond < 0 || o.millisecond > 999)
+    return /* @__PURE__ */ new Date(NaN);
+  const e = new Date(
+    o.year,
+    o.month - 1,
+    o.day,
+    o.hour,
+    o.minute,
+    o.second,
+    o.millisecond
+  );
+  return se(e) ? e.getFullYear() !== o.year || e.getMonth() !== o.month - 1 || e.getDate() !== o.day ? /* @__PURE__ */ new Date(NaN) : e : /* @__PURE__ */ new Date(NaN);
+}
+function Ge(o, e, t) {
+  if (o = o.trim(), e === "t") {
+    const a = Number(o);
+    return isNaN(a) ? /* @__PURE__ */ new Date(NaN) : new Date(a * 1e3);
+  }
+  if (e === "T") {
+    const a = Number(o);
+    return isNaN(a) ? /* @__PURE__ */ new Date(NaN) : new Date(a);
+  }
+  const { regex: r, tokenOrder: s } = ie(e), i = o.match(r);
+  if (!i)
+    return /* @__PURE__ */ new Date(NaN);
+  const n = oe(i, s);
+  return ae(n);
+}
+class ue {
+  cache;
+  maxSize;
+  accessOrder;
+  constructor(e) {
+    this.cache = /* @__PURE__ */ new Map(), this.maxSize = e, this.accessOrder = [];
+  }
+  get(e) {
+    const t = this.cache.get(e);
+    return t !== void 0 && this.updateAccessOrder(e), t;
+  }
+  set(e, t) {
+    if (this.cache.has(e))
+      this.cache.set(e, t), this.updateAccessOrder(e);
+    else {
+      if (this.cache.size >= this.maxSize) {
+        const r = this.accessOrder.shift();
+        r !== void 0 && this.cache.delete(r);
+      }
+      this.cache.set(e, t), this.accessOrder.push(e);
+    }
+  }
+  has(e) {
+    return this.cache.has(e);
+  }
+  clear() {
+    this.cache.clear(), this.accessOrder = [];
+  }
+  get size() {
+    return this.cache.size;
+  }
+  updateAccessOrder(e) {
+    const t = this.accessOrder.indexOf(e);
+    t > -1 && this.accessOrder.splice(t, 1), this.accessOrder.push(e);
+  }
+  // For testing/debugging
+  getStats() {
+    return {
+      size: this.cache.size,
+      maxSize: this.maxSize
+    };
+  }
+}
+class ce {
+  graph;
+  constructor() {
+    this.graph = /* @__PURE__ */ new Map();
+  }
+  addDependency(e, t) {
+    this.graph.has(e) || this.graph.set(e, /* @__PURE__ */ new Set()), this.graph.get(e).add(t);
+  }
+  hasCycle(e) {
+    if (e.length === 0) return !1;
+    const t = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), s = (i) => {
+      t.add(i), r.add(i);
+      const n = this.graph.get(i);
+      if (n) {
+        for (const a of n)
+          if (t.has(a)) {
+            if (r.has(a))
+              return !0;
+          } else if (s(a))
+            return !0;
+      }
+      return r.delete(i), !1;
+    };
+    for (let i = 0; i < e.length - 1; i++) {
+      const n = e[i], a = e[i + 1];
+      n && a && this.addDependency(n, a);
+    }
+    for (const i of e)
+      if (!t.has(i) && s(i))
+        return !0;
+    return !1;
+  }
+  clear() {
+    this.graph.clear();
+  }
+}
+class fe {
+  parseCache;
+  circularRefDetector;
+  cacheHits = 0;
+  cacheMisses = 0;
+  constructor(e = 1e3) {
+    this.parseCache = new ue(e), this.circularRefDetector = new ce();
+  }
+  /**
+   * Parse an attribute string into its components
+   *
+   * Supports:
+   * - Dot notation: `customer.name`
+   * - Bracket notation: `items[0].price`, `items[*].price`
+   * - Multi-level: `order.customer.address.city`
+   *
+   * @param attribute - The attribute path to parse
+   * @returns QueryAttributeEntry with isDeepQuery, reference, referenceAttribute
+   *
+   * @example
+   * ```typescript
+   * const service = new DeepQueryService();
+   * const entry = service.parse('customer.name');
+   * // Returns: { attribute: 'customer.name', isDeepQuery: true, reference: 'customer', referenceAttribute: 'name' }
+   * ```
+   */
+  parse(e) {
+    if (this.parseCache.has(e))
+      return this.cacheHits++, this.parseCache.get(e);
+    this.cacheMisses++;
+    let t, r;
+    const s = e.includes("."), i = e.includes("["), n = s || i;
+    if (n)
+      if (r = e.split(/[.[]/)[0], i) {
+        const u = e.indexOf("]");
+        if (u > -1) {
+          const c = e.indexOf(".", u + 1);
+          c > -1 ? t = e.substring(c + 1) : t = void 0;
+        } else s && (t = e.substring(e.indexOf(".") + 1));
+      } else s && (t = e.substring(e.indexOf(".") + 1));
+    const a = {
+      attribute: e,
+      isDeepQuery: n
+    };
+    return r && (a.reference = r), typeof t < "u" && t !== "" && (a.referenceAttribute = t), this.parseCache.set(e, a), a;
+  }
+  /**
+   * Detect circular references in a path
+   *
+   * Checks for:
+   * - Direct circular: A→B→A
+   * - Indirect circular: A→B→C→A
+   * - Self-referential: A→A
+   *
+   * @param path - Array of model/reference keys in the dependency chain
+   * @returns true if circular reference detected
+   *
+   * @example
+   * ```typescript
+   * const service = new DeepQueryService();
+   * const hasCircular = service.detectCircular(['Order', 'Customer', 'Order']);
+   * // Returns: true
+   * ```
+   */
+  detectCircular(e) {
+    return e.length === 0 ? !1 : new Set(e).size !== e.length ? !0 : this.circularRefDetector.hasCycle(e);
+  }
+  /**
+   * Validate attribute path syntax
+   *
+   * Checks for:
+   * - Empty strings
+   * - Malformed bracket notation
+   * - Invalid characters
+   * - Excessive nesting depth
+   *
+   * @param attribute - The attribute path to validate
+   * @param maxDepth - Maximum allowed nesting depth (default: 10)
+   * @returns ValidationResult with errors if invalid
+   *
+   * @example
+   * ```typescript
+   * const service = new DeepQueryService();
+   * const result = service.validatePath('customer.name');
+   * // Returns: { valid: true }
+   *
+   * const badResult = service.validatePath('customer.[invalid]');
+   * // Returns: { valid: false, errors: ['Invalid bracket notation: customer.[invalid]'] }
+   * ```
+   */
+  validatePath(e, t = 10) {
+    const r = [];
+    if (!e || e.trim().length === 0)
+      return r.push("Attribute path cannot be empty"), { valid: !1, errors: r };
+    (e.startsWith(".") || e.endsWith(".")) && r.push(`Invalid path: Leading or trailing dots are not allowed: ${e}`), e.includes("..") && r.push(`Invalid path: Consecutive dots are not allowed: ${e}`);
+    const s = (e.match(/\[/g) || []).length, i = (e.match(/]/g) || []).length;
+    s !== i && r.push(`Invalid bracket notation: Mismatched brackets in ${e}`), e.includes("[]") && r.push(`Invalid bracket notation: Empty brackets not allowed: ${e}`);
+    const n = /\[([^\]]+)\]/g;
+    let a;
+    for (; (a = n.exec(e)) !== null; ) {
+      const f = a[1];
+      f && f !== "*" && !/^\d+$/.test(f) && r.push(`Invalid bracket content: Must be a number or '*', got '${f}' in ${e}`);
+    }
+    const u = (e.match(/\./g) || []).length + 1;
+    u > t && r.push(`Path too deep: Maximum depth is ${t}, got ${u} in ${e}`);
+    const c = e.match(/[^a-zA-Z0-9._[\]*-]/g);
+    return c && r.push(`Invalid characters in path: ${c.join(", ")} in ${e}`), {
+      valid: r.length === 0,
+      errors: r.length > 0 ? r : void 0
+    };
+  }
+  /**
+   * Clear the parse cache
+   * Should be called when models are updated or removed
+   */
+  clearCache() {
+    this.parseCache.clear(), this.cacheHits = 0, this.cacheMisses = 0;
+  }
+  /**
+   * Clear the circular reference detector
+   */
+  clearCircularDetector() {
+    this.circularRefDetector.clear();
+  }
+  /**
+   * Get cache statistics for monitoring and debugging
+   *
+   * @returns Object containing cache size, hit rate, and other metrics
+   */
+  getCacheStats() {
+    const e = this.parseCache.getStats(), t = this.cacheHits + this.cacheMisses, r = t > 0 ? this.cacheHits / t : 0;
+    return {
+      ...e,
+      hits: this.cacheHits,
+      misses: this.cacheMisses,
+      hitRate: r
+    };
+  }
+  /**
+   * Extract path segments from an attribute string
+   * Useful for analyzing deep query structure
+   *
+   * @param attribute - The attribute path
+   * @returns Array of path segments
+   *
+   * @example
+   * ```typescript
+   * const service = new DeepQueryService();
+   * const segments = service.getPathSegments('order.customer.name');
+   * // Returns: ['order', 'customer', 'name']
+   * ```
+   */
+  getPathSegments(e) {
+    return e.replace(/\[[^\]]+\]/g, "").split(".").filter((r) => r.length > 0);
+  }
+  /**
+   * Get the depth of a deep query path
+   *
+   * @param attribute - The attribute path
+   * @returns Depth of the path (1 for shallow, 2+ for deep)
+   */
+  getPathDepth(e) {
+    return this.getPathSegments(e).length;
+  }
+}
+const g = new fe();
+function D(o) {
+  let e = 0;
+  for (let t of o) {
+    const r = t.toString().split(".")[1];
+    r && (e = Math.max(e, r.length));
+  }
+  return Math.pow(10, e);
+}
+function G(o, e, t) {
+  return (o * t + e * t) / t;
+}
+function de(o, e, t) {
+  return o * t / (e * t);
+}
+const Q = (o, e, t, r) => {
+  if (!r)
+    throw new Error("Attribute not found");
+  const s = {
+    attribute: r,
+    types: o.types
+  };
+  let i;
+  (s.types.includes("sum") || s.types.includes("avg") || s.types.includes("count")) && (i = pe(r, e));
+  let n;
+  return (s.types.includes("min") || s.types.includes("max")) && (n = le(r, e)), o.types.forEach((a) => {
+    a === "sum" ? s.sum = i?.sum : a === "avg" ? s.avg = i?.average : a === "count" ? s.count = i?.count : a === "min" ? s.min = n && n[0] : a === "max" ? s.max = n && n[1] : a === "distinct" ? s.distinct = ge(o, e, t) : a === "group" && (s.group = he(o, e));
+  }), s;
+}, le = (o, e) => {
+  let t, r;
+  const i = g.parse(o).isDeepQuery;
+  for (const n of e.values())
+    if (n) {
+      const a = i ? v(n, o) : n[o];
+      (t === void 0 || a < t) && (t = a), (r === void 0 || a > r) && (r = a);
+    }
+  if (!(t === void 0 || r === void 0))
+    return [t, r];
+}, he = (o, e) => {
+  const t = [];
+  o.groupOptions?.groups?.forEach((n) => {
+    t.push({
+      option: n,
+      count: 0,
+      keys: []
+    });
+  });
+  const r = {
+    option: { value: ["$dcupl_not_found"] },
+    count: 0,
+    keys: []
+  }, i = g.parse(o.attribute).isDeepQuery;
+  for (const n of e.values()) {
+    const a = i ? v(n, o.attribute) : n[o.attribute];
+    for (const u of t)
+      typeof u.option.value < "u" && u.option.value.includes(a) || typeof u.option.from < "u" && u.option.from < a && typeof u.option.to < "u" && u.option.to > a ? (u.count++, u.keys.push(n.key)) : o?.groupOptions?.calculateNotFound && (r.count++, r.keys.push(n.key));
+  }
+  return o?.groupOptions?.calculateNotFound && t.push(r), t;
+}, pe = (o, e) => {
+  let t = 0, r = 0;
+  const i = g.parse(o).isDeepQuery;
+  for (const u of e.values()) {
+    if (!u) continue;
+    const c = i ? v(u, o) : u[o];
+    if (Array.isArray(c))
+      for (const f of c)
+        typeof f == "number" && (t = G(t, f, D([t, f])), r++);
+    else typeof c == "number" && (t = G(t, c, D([t, c])), r++);
+  }
+  return r === 0 || r === 0 ? void 0 : {
+    average: de(t, r, D([t, r])),
+    count: e.size,
+    sum: t
+  };
+}, ge = (o, e, t) => {
+  const r = [];
+  for (const [s, i] of t)
+    if (!(o.excludeUndefineds && typeof s > "u") && Array.from(i).find((n) => e.has(n))) {
+      const n = {
+        value: s,
+        count: i.size
+      };
+      if (o.distinctOptions?.skipKeys || (n.keys = Array.from(i)), r.push(n), o.distinctOptions?.limit && r.length >= o.distinctOptions.limit)
+        break;
+    }
+  return r;
+};
+class w extends Error {
+  query;
+  constructor(e, t) {
+    const r = `Query Error: ${e} in ${JSON.stringify(t, null, 2)}`;
+    super(r), this.query = t, this.name = "DcuplQueryError";
+  }
+}
+class P {
+  _defaultQueryOptions = {
+    modelKey: "",
+    groupKey: "root",
+    groupType: "and",
+    queries: []
+  };
+  _initOptions;
+  currentQuery = y(this._defaultQueryOptions);
+  deepQueryService;
+  constructor(e) {
+    this.deepQueryService = e || g;
+  }
+  /**
+   * Initialize the query builder.
+   * Accepts either minimal options with just modelKey, or a complete query object.
+   *
+   * @param options - Minimal { modelKey } or full DcuplGlobalQueryOptions
+   *
+   * @example
+   * // Minimal initialization
+   * builder.init({ modelKey: 'Product' });
+   *
+   * @example
+   * // Full query initialization
+   * builder.init({
+   *   modelKey: 'Product',
+   *   groupType: 'and',
+   *   queries: [
+   *     { operator: 'eq', attribute: 'status', value: 'active' },
+   *     { operator: 'gte', attribute: 'price', value: 100 }
+   *   ],
+   *   count: 10,
+   *   sort: { price: 'asc' }
+   * });
+   */
+  init(e) {
+    this._initOptions = y(e), this.currentQuery = y(this._defaultQueryOptions), this.currentQuery.modelKey = e.modelKey, "queries" in e && Array.isArray(e.queries) && (e.groupType && (this.currentQuery.groupType = e.groupType), e.queries && (this.currentQuery.queries = y(e.queries)), e.count !== void 0 && (this.currentQuery.count = e.count), e.start !== void 0 && (this.currentQuery.start = e.start), e.sort && (this.currentQuery.sort = e.sort), e.projection && (this.currentQuery.projection = e.projection));
+  }
+  reset() {
+    return this.init(this._initOptions), this.getQuery();
+  }
+  isQuery(e) {
+    return "attribute" in e;
+  }
+  isQueryGroup(e) {
+    return "groupKey" in e;
+  }
+  isRootQueryGroup(e) {
+    return this.isQueryGroup(e) && e.groupKey === "root";
+  }
+  getQueryGroup(e) {
+    return this.currentQuery.queries.find((t) => this.isQueryGroup(t) && t.groupKey === e);
+  }
+  getQuery() {
+    return y(this.currentQuery);
+  }
+  hasQueryGroup(e) {
+    return this.currentQuery.queries.some((t) => this.isQueryGroup(t) && t.groupKey === e);
+  }
+  has(e) {
+    if (e.groupKey && e.queryKey) {
+      const t = this.getQueryGroup(e.groupKey);
+      if (t)
+        return t.queries.some((r) => this.isQuery(r) && r.queryKey === e.queryKey);
+    } else if (e.groupKey)
+      return this.hasQueryGroup(e.groupKey);
+    return !1;
+  }
+  validate(e) {
+    const t = e.queries.map((s) => this.validateQuery(s));
+    return { valid: B(t, (s) => s.valid), errors: t.map((s) => s.errors).flat() };
+  }
+  applyOptions(e, t = "update") {
+    return t === "set" ? (this.currentQuery.count = e.count, this.currentQuery.start = e.start, this.currentQuery.sort = e.sort, this.currentQuery.projection = e.projection) : (typeof e?.sort < "u" && (this.currentQuery.sort = e.sort), typeof e?.count < "u" && (this.currentQuery.count = e.count), typeof e?.start < "u" && (this.currentQuery.start = e?.start), typeof e?.projection < "u" && (this.currentQuery.projection = e?.projection)), this.getQuery();
+  }
+  /**
+   * Apply query conditions, groups, or complete queries.
+   * This method has implicit behavior based on input type.
+   *
+   * @deprecated Use explicit methods instead for clearer intent:
+   * - {@link addCondition} - Add single condition
+   * - {@link addConditions} - Add multiple conditions
+   * - {@link addGroup} - Add query group
+   * - {@link setCondition} - Replace condition
+   * - {@link setConditions} - Replace conditions
+   * - {@link setGroup} - Replace query group
+   * - {@link mergeQuery} - Merge complete query
+   * - {@link replaceQuery} - Replace complete query
+   *
+   * @param queryToApply - Query, condition, or array to apply
+   * @param options - Mode: 'add' (default) or 'set' (replace)
+   * @param relevantQuery - Target query (defaults to current)
+   * @returns Updated query
+   */
+  applyQuery(e, t, r) {
+    if (r || (r = this.currentQuery), Array.isArray(e))
+      for (const s of e)
+        this.applyQuery(s, t, r);
+    else if (this.isRootQueryGroup(e))
+      e.groupType && (r.groupType = e.groupType), t?.mode === "set" ? r.queries = e.queries : r.queries = [...r.queries, ...e.queries], this.applyOptions(e, "set");
+    else if (this.isQuery(e)) {
+      const s = r.queries.findIndex(
+        (i) => this.isQueryGroup(i) && i.groupKey === e.attribute
+      );
+      if (s > -1) {
+        const i = r.queries[s];
+        t?.mode === "set" ? i.queries = [e] : i.queries.push(e);
+      } else
+        r.queries.push({
+          groupKey: e.attribute,
+          groupType: "or",
+          queries: [e]
+        });
+    } else if (this.isQueryGroup(e)) {
+      const s = r.queries.findIndex(
+        (i) => this.isQueryGroup(i) && i.groupKey === e.groupKey
+      );
+      if (s > -1) {
+        const i = r.queries[s];
+        e.groupType && (i.groupType = e.groupType), t?.mode === "set" ? r.queries[s] = e : i.queries = [...i.queries, ...e.queries];
+      } else
+        r.queries.push({
+          groupKey: e.groupKey,
+          groupType: e.groupType || "or",
+          queries: e.queries
+          // options: queryToApply.options,
+        });
+    }
+    return r;
+  }
+  /**
+   * Remove all query conditions.
+   *
+   * @deprecated Use {@link clearConditions} for clearer intent.
+   * @returns Query with no conditions
+   */
+  removeAllQueries() {
+    return this.currentQuery.queries = [], this.getQuery();
+  }
+  /**
+   * Remove a specific query or query group.
+   *
+   * @param queryToRemove - Query or group to remove (partial match)
+   * @param relevantQuery - Target query (defaults to current)
+   * @returns Updated query
+   */
+  removeQuery(e, t) {
+    if (t || (t = this.currentQuery), this.isQuery(e)) {
+      const r = t.queries.findIndex(
+        (s) => this.isQueryGroup(s) && s.groupKey === e.attribute
+      );
+      if (r > -1) {
+        const s = t.queries[r], i = C(s.queries, e);
+        i > -1 && s.queries.splice(i, 1), s.queries.length === 0 && t.queries.splice(r, 1);
+      }
+    } else if (this.isQueryGroup(e)) {
+      const r = t.queries.findIndex(
+        (s) => this.isQueryGroup(s) && s.groupKey === e.groupKey
+      );
+      if (r > -1)
+        if (!e.queries)
+          t.queries.splice(r, 1);
+        else {
+          const s = t.queries[r];
+          for (const i of e.queries) {
+            const n = C(s.queries, i);
+            n > -1 && s.queries.splice(n, 1);
+          }
+          s.queries.length === 0 && t.queries.splice(r, 1);
+        }
+    }
+    return t;
+  }
+  validateQuery(e) {
+    const t = [];
+    if (this.isQuery(e))
+      return e.attribute || t.push(new w("Missing attribute", e)), e.operator || t.push(new w("Missing operator", e)), typeof e.value > "u" && t.push(new w("Missing value", e)), e.operator === "find" && Array.isArray(e.value) && t.push(new w("find operator cannot have array value", e)), t.length > 0 ? { valid: !1, errors: t } : { valid: !0 };
+    if (this.isQueryGroup(e)) {
+      const i = e.queries.map((n) => this.validateQuery(n)).filter((n) => !n.valid).map((n) => n.errors).flat();
+      return i.length > 0 ? { valid: !1, errors: i } : { valid: !0 };
+    }
+    return t.push(new w("Invalid query definition", e)), { valid: !1, errors: t };
+  }
+  /**
+   * Get all attribute names used in the query.
+   *
+   * @deprecated Use {@link getAttributeNames} for clearer naming.
+   * @param query - Optional query to analyze
+   * @returns Array of attribute names
+   */
+  getQueryAttributes(e) {
+    const t = [], r = /* @__PURE__ */ new Set(), s = (i) => {
+      for (const n of i)
+        this.isQuery(n) ? n.attribute && !r.has(n.attribute) && (t.push(n.attribute), r.add(n.attribute)) : this.isQueryGroup(n) && s(n.queries);
+    };
+    return s(e?.queries || this.currentQuery.queries), t;
+  }
+  /**
+   * Extract detailed attribute information from query.
+   *
+   * @deprecated Use {@link getAttributeDetails} for clearer naming.
+   * @param query - Query to analyze
+   * @returns Array of QueryAttributeEntry objects
+   */
+  extractQueryAttributes(e) {
+    const t = [], r = /* @__PURE__ */ new Set(), s = (i) => {
+      for (const n of i)
+        if (this.isQuery(n)) {
+          if (n.attribute && !r.has(n.attribute)) {
+            const a = this.getQueryAttributeForString(n.attribute);
+            t.push(a), r.add(n.attribute);
+          }
+        } else this.isQueryGroup(n) && s(n.queries);
+    };
+    return s(e?.queries || this.currentQuery.queries), t;
+  }
+  /**
+   * Parse an attribute string into its components using the DeepQueryService
+   * This method now delegates to the centralized DeepQueryService for consistent
+   * parsing, caching, and validation across the codebase.
+   *
+   * @param attribute - The attribute path to parse (e.g., 'customer.name', 'items[0].price')
+   * @returns QueryAttributeEntry with isDeepQuery, reference, referenceAttribute
+   */
+  getQueryAttributeForString(e) {
+    return this.deepQueryService.parse(e);
+  }
+  /**
+   * Get the DeepQueryService instance used by this query builder
+   * Useful for accessing cache statistics and other service methods
+   *
+   * @returns The DeepQueryService instance
+   */
+  getDeepQueryService() {
+    return this.deepQueryService;
+  }
+  getProjectionForAttributes(e) {
+    const t = {};
+    return e.forEach((r) => {
+      t[r] = !0;
+    }), t;
+  }
+  getProjectionForAttributeEntries(e) {
+    const t = {
+      $: !0
+    };
+    return e.forEach((r) => {
+      if (r.isDeepQuery) {
+        if (r.reference)
+          if (r.referenceAttribute && r.referenceAttribute.length > 0) {
+            t[r.reference] || (t[r.reference] = { $: !0 });
+            const s = this.deepQueryService.parse(r.referenceAttribute);
+            if (s.isDeepQuery && r.reference) {
+              const i = this.getProjectionForAttributeEntries([s]);
+              Object.keys(i).forEach((n) => {
+                n !== "$" && r.reference && (t[r.reference][n] = i[n]);
+              });
+            } else r.reference && (t[r.reference][r.referenceAttribute] = !0);
+          } else
+            t[r.reference] = !0;
+      } else
+        t[r.attribute] = !0;
+    }), t;
+  }
+  // ============================================================================
+  // Semantic Method Aliases - Clearer naming for improved developer experience
+  // ============================================================================
+  /**
+   * Get all attribute names used in the query.
+   * Returns a simple array of unique attribute names.
+   *
+   * Clearer alternative to {@link getQueryAttributes}.
+   *
+   * @param query - Optional query to analyze. If not provided, uses current query.
+   * @returns Array of attribute names used in the query
+   *
+   * @example
+   * ```typescript
+   * builder.addCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+   * builder.addCondition({ operator: 'gte', attribute: 'price', value: 100 });
+   * const attrs = builder.getAttributeNames(); // ['status', 'price']
+   * ```
+   */
+  getAttributeNames(e) {
+    return this.getQueryAttributes(e);
+  }
+  /**
+   * Get detailed information about attributes used in the query.
+   * Returns entries with deep query information (reference, referenceAttribute).
+   *
+   * Clearer alternative to {@link extractQueryAttributes}.
+   *
+   * @param query - Query to analyze. Defaults to current query if not provided.
+   * @returns Array of QueryAttributeEntry objects with details about each attribute
+   *
+   * @example
+   * ```typescript
+   * builder.addCondition({ operator: 'eq', attribute: 'customer.name', value: 'John' });
+   * const details = builder.getAttributeDetails();
+   * // [{ attribute: 'customer.name', isDeepQuery: true, reference: 'customer', referenceAttribute: 'name' }]
+   * ```
+   */
+  getAttributeDetails(e) {
+    return this.extractQueryAttributes(e || this.currentQuery);
+  }
+  /**
+   * Get attribute names from the current query state.
+   * Convenience method that operates on the current query.
+   *
+   * @returns Array of attribute names in current query
+   *
+   * @example
+   * ```typescript
+   * const attrs = builder.getCurrentAttributeNames();
+   * ```
+   */
+  getCurrentAttributeNames() {
+    return this.getAttributeNames(this.currentQuery);
+  }
+  /**
+   * Get detailed attribute information from the current query state.
+   * Convenience method that operates on the current query.
+   *
+   * @returns Array of QueryAttributeEntry objects from current query
+   *
+   * @example
+   * ```typescript
+   * const details = builder.getCurrentAttributeDetails();
+   * ```
+   */
+  getCurrentAttributeDetails() {
+    return this.getAttributeDetails(this.currentQuery);
+  }
+  // ============================================================================
+  // Explicit Query Application Methods - Intention-revealing alternatives to applyQuery
+  // ============================================================================
+  /**
+   * Add query condition(s) to the current query.
+   * Accepts single condition or array of conditions.
+   * Each condition is added to its respective attribute group.
+   *
+   * Clearer alternative to `applyQuery(condition, { mode: 'add' })`.
+   *
+   * @param condition - Single query condition or array of conditions to add
+   * @returns Updated query
+   *
+   * @example
+   * ```typescript
+   * // Add single condition
+   * builder.addCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+   *
+   * // Add multiple conditions
+   * builder.addCondition([
+   *   { operator: 'eq', attribute: 'status', value: 'active' },
+   *   { operator: 'gte', attribute: 'price', value: 100 }
+   * ]);
+   * ```
+   */
+  addCondition(e) {
+    return this.applyQuery(e, { mode: "add" });
+  }
+  /**
+   * Add a query group to the current query.
+   * If a group with the same groupKey exists, extends it; otherwise creates new group.
+   *
+   * @param group - Query group to add
+   * @returns Updated query
+   *
+   * @example
+   * ```typescript
+   * builder.addGroup({
+   *   groupKey: 'priceRange',
+   *   groupType: 'and',
+   *   queries: [
+   *     { operator: 'gte', attribute: 'price', value: 50 },
+   *     { operator: 'lte', attribute: 'price', value: 100 }
+   *   ]
+   * });
+   * ```
+   */
+  addGroup(e) {
+    return this.applyQuery(e, { mode: "add" });
+  }
+  /**
+   * Replace query with new condition(s).
+   * Accepts single condition or array of conditions.
+   * Each condition replaces all existing conditions for its attribute.
+   *
+   * Clearer alternative to `applyQuery(condition, { mode: 'set' })`.
+   *
+   * @param condition - Single query condition or array of conditions to set
+   * @returns Updated query
+   *
+   * @example
+   * ```typescript
+   * // Replace with single condition
+   * builder.setCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+   *
+   * // Replace with multiple conditions
+   * builder.setCondition([
+   *   { operator: 'eq', attribute: 'status', value: 'active' },
+   *   { operator: 'gte', attribute: 'price', value: 100 }
+   * ]);
+   * ```
+   */
+  setCondition(e) {
+    return this.applyQuery(e, { mode: "set" });
+  }
+  /**
+   * Replace a query group with new definition.
+   * If group exists, replaces it; otherwise creates new group.
+   *
+   * @param group - Query group to set
+   * @returns Updated query
+   *
+   * @example
+   * ```typescript
+   * builder.setGroup({
+   *   groupKey: 'priceRange',
+   *   groupType: 'and',
+   *   queries: [
+   *     { operator: 'gte', attribute: 'price', value: 100 },
+   *     { operator: 'lte', attribute: 'price', value: 200 }
+   *   ]
+   * });
+   * ```
+   */
+  setGroup(e) {
+    return this.applyQuery(e, { mode: "set" });
+  }
+  /**
+   * Merge a complete query into the current query.
+   * Adds all conditions and groups from the provided query.
+   *
+   * @param query - Complete query to merge
+   * @returns Updated query
+   *
+   * @example
+   * ```typescript
+   * builder.mergeQuery({
+   *   modelKey: 'Product',
+   *   groupType: 'and',
+   *   queries: [
+   *     { operator: 'eq', attribute: 'status', value: 'active' },
+   *     { operator: 'gte', attribute: 'price', value: 100 }
+   *   ]
+   * });
+   * ```
+   */
+  mergeQuery(e) {
+    if (e.queries && Array.isArray(e.queries))
+      for (const t of e.queries)
+        this.applyQuery(t, { mode: "add" });
+    return this.currentQuery;
+  }
+  /**
+   * Replace the entire current query with a new query.
+   * Completely replaces all conditions, groups, and options.
+   *
+   * @param query - Complete query to replace with
+   * @returns Updated query
+   *
+   * @example
+   * ```typescript
+   * builder.replaceQuery({
+   *   modelKey: 'Product',
+   *   groupType: 'or',
+   *   queries: [
+   *     { operator: 'eq', attribute: 'featured', value: true },
+   *     { operator: 'gte', attribute: 'rating', value: 4.5 }
+   *   ]
+   * });
+   * ```
+   */
+  replaceQuery(e) {
+    return this.currentQuery.queries = [], e.groupType && (this.currentQuery.groupType = e.groupType), e.queries && Array.isArray(e.queries) && (this.currentQuery.queries = e.queries), this.currentQuery;
+  }
+  // ============================================================================
+  // State Management Clarity Methods
+  // ============================================================================
+  /**
+   * Clear all query conditions and reset to initial state.
+   * Alias for {@link reset} with clearer intent.
+   *
+   * @returns Empty query
+   *
+   * @example
+   * ```typescript
+   * builder.addCondition({ operator: 'eq', attribute: 'status', value: 'active' });
+   * builder.clear(); // Removes all conditions
+   * ```
+   */
+  clear() {
+    return this.reset();
+  }
+  /**
+   * Remove all query conditions but keep query structure.
+   * Alias for {@link removeAllQueries} with clearer intent.
+   *
+   * @returns Query with no conditions
+   *
+   * @example
+   * ```typescript
+   * builder.clearConditions(); // Remove all conditions but keep modelKey, etc.
+   * ```
+   */
+  clearConditions() {
+    return this.removeAllQueries();
+  }
+  /**
+   * Get an immutable copy of the current query state.
+   * Alias for {@link getQuery} with clearer intent.
+   *
+   * @returns Deep clone of current query
+   *
+   * @example
+   * ```typescript
+   * const snapshot = builder.getCurrentQuery();
+   * ```
+   */
+  getCurrentQuery() {
+    return this.getQuery();
+  }
+  /**
+   * Check if the query has any conditions.
+   *
+   * @returns true if query has no conditions, false otherwise
+   *
+   * @example
+   * ```typescript
+   * if (builder.isEmpty()) {
+   *   console.log('No filters applied');
+   * }
+   * ```
+   */
+  isEmpty() {
+    return this.currentQuery.queries.length === 0;
+  }
+  /**
+   * Check if a specific condition exists in the query.
+   *
+   * @param condition - Condition to check for (partial match)
+   * @returns true if condition exists
+   *
+   * @example
+   * ```typescript
+   * const hasStatus = builder.hasCondition({ attribute: 'status', value: 'active' });
+   * ```
+   */
+  hasCondition(e) {
+    const t = (r) => {
+      for (const s of r)
+        if (this.isQuery(s)) {
+          let i = !0;
+          for (const n in e)
+            if (s[n] !== e[n]) {
+              i = !1;
+              break;
+            }
+          if (i) return !0;
+        } else if (this.isQueryGroup(s) && t(s.queries))
+          return !0;
+      return !1;
+    };
+    return t(this.currentQuery.queries);
+  }
+  /**
+   * Check if a query group with the given key exists.
+   * Alias for {@link hasQueryGroup} with consistent naming.
+   *
+   * @param groupKey - Group key to check
+   * @returns true if group exists
+   *
+   * @example
+   * ```typescript
+   * if (builder.hasGroup('priceRange')) {
+   *   console.log('Price range filter is active');
+   * }
+   * ```
+   */
+  hasGroup(e) {
+    return this.hasQueryGroup(e);
+  }
+  // ============================================================================
+  // Query Inspection Methods
+  // ============================================================================
+  /**
+   * Get all unique attribute names used in the query.
+   * Convenience alias for {@link getAttributeNames}.
+   *
+   * @returns Array of attribute names
+   *
+   * @example
+   * ```typescript
+   * const attrs = builder.getUsedAttributes(); // ['status', 'price', 'customer.name']
+   * ```
+   */
+  getUsedAttributes() {
+    return this.getAttributeNames();
+  }
+  /**
+   * Get only deep query attributes (e.g., 'customer.name', 'items[0].price').
+   * Filters out simple attributes and returns only those with references.
+   *
+   * @returns Array of deep query attribute details
+   *
+   * @example
+   * ```typescript
+   * const deepAttrs = builder.getDeepQueryAttributes();
+   * // [{ attribute: 'customer.name', isDeepQuery: true, reference: 'customer', referenceAttribute: 'name' }]
+   * ```
+   */
+  getDeepQueryAttributes() {
+    return this.getAttributeDetails().filter((t) => t.isDeepQuery);
+  }
+  /**
+   * Get all query groups in the current query.
+   *
+   * @returns Array of query groups
+   *
+   * @example
+   * ```typescript
+   * const groups = builder.getGroups();
+   * // [{ groupKey: 'priceRange', groupType: 'and', queries: [...] }]
+   * ```
+   */
+  getGroups() {
+    return this.currentQuery.queries.filter((e) => this.isQueryGroup(e));
+  }
+  /**
+   * Get top-level conditions (queries not inside groups).
+   *
+   * @returns Array of top-level query conditions
+   *
+   * @example
+   * ```typescript
+   * const topLevel = builder.getTopLevelConditions();
+   * ```
+   */
+  getTopLevelConditions() {
+    return this.currentQuery.queries.filter((e) => this.isQuery(e));
+  }
+  /**
+   * Get a specific query group by its key.
+   * Alias for {@link getQueryGroup} with consistent naming.
+   *
+   * @param groupKey - Key of the group to retrieve
+   * @returns Query group or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * const group = builder.getGroup('priceRange');
+   * if (group) {
+   *   console.log('Price range:', group.queries);
+   * }
+   * ```
+   */
+  getGroup(e) {
+    return this.getQueryGroup(e);
+  }
+  /**
+   * Count total number of conditions in the query (including nested).
+   *
+   * @returns Total count of query conditions
+   *
+   * @example
+   * ```typescript
+   * const count = builder.getConditionCount(); // 5
+   * ```
+   */
+  getConditionCount() {
+    const e = (t) => {
+      let r = 0;
+      for (const s of t)
+        this.isQuery(s) ? r++ : this.isQueryGroup(s) && (r += e(s.queries));
+      return r;
+    };
+    return e(this.currentQuery.queries);
+  }
+}
+const S = new P();
+function Be(o, e, t, r, s, i, n) {
+  const a = [], u = S.removeQuery({ groupKey: s }, y(r)), c = n.queryData(o, u, !1, i), f = e ? [...e.keys()] : [], d = new Set(f), l = i.get(s);
+  if (!t.excludeUnresolved)
+    for (const h of l.keys())
+      d.add(h);
+  t.excludeUndefineds ? d.delete(void 0) : d.add(void 0);
+  for (const h of d.values()) {
+    const A = /* @__PURE__ */ new Map(), _ = l.get(h) || /* @__PURE__ */ new Set();
+    for (const N of _) {
+      const k = c.get(N);
+      if (k && (A.set(N, k), !t?.calculateFacets))
+        break;
+    }
+    const M = {
+      key: String(h),
+      value: h,
+      selected: ye(s, h, r),
+      enabled: A.size > 0,
+      size: A.size,
+      entry: e.get(h),
+      resultKeys: Array.from(A.keys())
+    };
+    if (!(t?.excludeZeros && M.size === 0)) {
+      if (t?.count && a.length === t?.count)
+        return a;
+      a.push(M);
+    }
+  }
+  return a;
+}
+const ye = (o, e, t) => {
+  const r = t.queries.findIndex((s) => S.isQueryGroup(s) && s.groupKey === o);
+  return r > -1 ? !!t.queries[r].queries.find((i) => {
+    if (S.isQuery(i)) {
+      const n = i.value?.key || i.value;
+      return i.attribute === o && n === e;
+    }
+    return !1;
+  }) : !1;
+};
+class me {
+  indexMap = /* @__PURE__ */ new Map();
+  // Possible performance gain*
+  dataMap = /* @__PURE__ */ new Map();
+  indexMetadata = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  reset(e) {
+    e ? (this.indexMap.delete(e), this.dataMap.delete(e), this.indexMetadata.delete(e)) : (this.indexMap.clear(), this.dataMap.clear(), this.indexMetadata.clear());
+  }
+  fillDataMap(e, t) {
+    let r = this.dataMap.get(e);
+    r || (r = /* @__PURE__ */ new Map(), this.dataMap.set(e, r));
+    for (const s of t) {
+      let i;
+      if (typeof s == "object" && s && s.key)
+        i = s.key;
+      else if (Array.isArray(s)) {
+        for (const a of s)
+          this.fillDataMap(e, [a]);
+        return;
+      } else s instanceof Date ? i = s.toISOString() : i = s;
+      let n = r.get(i);
+      n || (n = { key: i }, this.dataMap.get(e)?.set(i, n));
+    }
+  }
+  fillInverseIndex(e, t, r) {
+    if (!e || !t || !r || !Array.isArray(r))
+      return;
+    const s = this.indexMap.get(e) || /* @__PURE__ */ new Map();
+    for (const i of r) {
+      let n;
+      if (typeof i == "object" && i && i.key)
+        n = i.key;
+      else if (Array.isArray(i)) {
+        for (const u of i)
+          this.fillInverseIndex(e, t, [u]);
+        return;
+      } else i instanceof Date ? n = i.toISOString() : n = i;
+      let a = s.get(n);
+      a || (a = /* @__PURE__ */ new Set(), s.set(n, a)), a.add(t);
+    }
+    this.indexMap.set(e, s);
+  }
+  getIndex(e, t) {
+    const r = this.getIndexName(e, t);
+    return this.indexMap.get(r);
+  }
+  getData(e, t) {
+    const r = this.getIndexName(e, t);
+    return this.dataMap.get(r);
+  }
+  getOrCreateIndex(e, t, r) {
+    const s = this.getIndexName(e, r);
+    let i = this.getIndex(s);
+    const n = this.indexMetadata.get(s);
+    if (n)
+      n.lastAccessedAt = Date.now();
+    else if (!i) {
+      const u = g.parse(e).isDeepQuery ?? !1;
+      this.indexMetadata.set(s, {
+        createdAt: Date.now(),
+        lastAccessedAt: Date.now(),
+        context: r,
+        type: u ? "deep" : "shallow"
+      });
+    }
+    if (!i) {
+      this.reset(s), this.indexMap.set(s, /* @__PURE__ */ new Map());
+      const u = g.parse(e).isDeepQuery;
+      for (const c of t.values()) {
+        const f = u ? v(c, e) : c[e];
+        this.fillInverseIndex(s, c.key, [f]), this.fillDataMap(s, [f]);
+      }
+      i = this.getIndex(s) || /* @__PURE__ */ new Map();
+    }
+    return i;
+  }
+  getIndexName(e, t) {
+    return t ? e + "_" + I(t) : e;
+  }
+  // ========== PARTIAL UPDATE METHODS ==========
+  /**
+   * Removes a specific item from an inverse index
+   * @param attributeKey - The attribute key
+   * @param itemKey - The item key to remove
+   * @param oldValues - The old attribute values to remove from the index
+   */
+  removeFromInverseIndex(e, t, r) {
+    const s = this.indexMap.get(e);
+    if (s)
+      for (const i of r) {
+        let n;
+        if (typeof i == "object" && i && i.key)
+          n = i.key;
+        else if (Array.isArray(i)) {
+          for (const u of i)
+            this.removeFromInverseIndex(e, t, [u]);
+          return;
+        } else i instanceof Date ? n = i.toISOString() : n = i;
+        const a = s.get(n);
+        a && (a.delete(t), a.size === 0 && s.delete(n));
+      }
+  }
+  /**
+   * Updates inverse index for a specific item by removing old values and adding new ones
+   * @param attributeKey - The attribute key
+   * @param itemKey - The item key being updated
+   * @param oldValues - The old attribute values to remove
+   * @param newValues - The new attribute values to add
+   */
+  updateInverseIndex(e, t, r, s) {
+    this.removeFromInverseIndex(e, t, r), this.fillInverseIndex(e, t, s);
+  }
+  /**
+   * Removes a specific item from the data map
+   * @param attributeKey - The attribute key
+   * @param values - The values to remove
+   */
+  removeFromDataMap(e, t) {
+    const r = this.dataMap.get(e);
+    if (r)
+      for (const s of t) {
+        let i;
+        if (typeof s == "object" && s && s.key)
+          i = s.key;
+        else if (Array.isArray(s)) {
+          for (const n of s)
+            this.removeFromDataMap(e, [n]);
+          return;
+        } else s instanceof Date ? i = s.toISOString() : i = s;
+        r.delete(i);
+      }
+  }
+  /**
+   * Updates data map for a specific item by removing old values and adding new ones
+   * @param attributeKey - The attribute key
+   * @param oldValues - The old values to remove
+   * @param newValues - The new values to add
+   */
+  updateDataMap(e, t, r) {
+    this.removeFromDataMap(e, t), this.fillDataMap(e, r);
+  }
+  /**
+   * Completely removes an item from all indices
+   * Used when an item is deleted
+   * @param itemKey - The item key to remove
+   */
+  removeItemFromAllIndices(e) {
+    for (const t of this.indexMap.values())
+      for (const [r, s] of t)
+        s.delete(e) && s.size === 0 && t.delete(r);
+    for (const t of this.dataMap.values())
+      t.has(e) && t.delete(e);
+  }
+  /**
+   * Resets indices for specific attributes only
+   * Useful for partial updates when only certain attributes changed
+   * @param attributeKeys - Array of attribute keys to reset
+   */
+  resetAttributes(e) {
+    for (const t of e)
+      this.reset(t);
+  }
+  /**
+   * Checks if an index key represents a deep query (contains dots in the attribute path)
+   * Uses deep query service for accurate detection
+   * @param indexKey - The index key to check
+   * @returns true if the index is for a deep query attribute
+   */
+  isDeepQueryIndex(e) {
+    const t = e.includes("_") ? e.split("_")[0] : e;
+    try {
+      return g.parse(t).isDeepQuery ?? !1;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Gets all deep query index keys currently in the index map
+   * @returns Array of index keys that represent deep queries
+   */
+  getDeepIndexKeys() {
+    const e = [];
+    for (const t of this.indexMap.keys())
+      this.isDeepQueryIndex(t) && e.push(t);
+    return e;
+  }
+  /**
+   * Resets all deep query indices (e.g., "customer.country", "order.customer.address.city")
+   * This is critical for data updates as deep query indices need to be rebuilt
+   * when underlying data changes.
+   *
+   * Shallow indices (direct attributes) are preserved as they're updated incrementally.
+   */
+  resetAllDeepIndices() {
+    const e = this.getDeepIndexKeys();
+    for (const t of e)
+      this.indexMap.delete(t), this.dataMap.delete(t);
+  }
+  /**
+   * Gets count of indices by type for monitoring and debugging
+   * @returns Object with counts of shallow and deep indices
+   */
+  getIndexCount() {
+    let e = 0, t = 0;
+    for (const r of this.indexMap.keys())
+      this.isDeepQueryIndex(r) ? t++ : e++;
+    return {
+      shallow: e,
+      deep: t,
+      total: e + t
+    };
+  }
+  /**
+   * Removes stale indices that haven't been accessed recently
+   * This helps prevent memory buildup from indices with varying contexts
+   * @param maxAge - Maximum age in milliseconds (default: 5 minutes)
+   * @returns Number of indices cleaned up
+   */
+  cleanupStaleIndices(e = 300 * 1e3) {
+    const t = Date.now();
+    let r = 0;
+    for (const [s, i] of this.indexMetadata)
+      t - i.lastAccessedAt > e && (this.reset(s), r++);
+    return r;
+  }
+  /**
+   * Gets comprehensive statistics about indices for monitoring
+   * @returns IndexStats object with counts and age information
+   */
+  getStats() {
+    const e = this.getIndexCount(), t = Date.now();
+    let r = 0, s = 0;
+    for (const n of this.indexMetadata.values()) {
+      const a = t - n.createdAt;
+      r += a, a > s && (s = a);
+    }
+    const i = this.indexMetadata.size > 0 ? r / this.indexMetadata.size : 0;
+    return {
+      shallow: e.shallow,
+      deep: e.deep,
+      total: e.total,
+      oldestAge: s,
+      avgAge: i
+    };
+  }
+}
+const m = "__";
+function R(o, e, t = { key: "root" }, r = "root", s = new me(), i) {
+  const n = i || o;
+  for (const a of e.columns)
+    a.attribute && (g.parse(a.attribute), s.getOrCreateIndex(a.attribute, n));
+  for (const a of e.rows)
+    a.attribute && (g.parse(a.attribute), s.getOrCreateIndex(a.attribute, n));
+  for (const a of e.values)
+    a.attribute && (g.parse(a.attribute), s.getOrCreateIndex(a.attribute, n));
+  if (e.rows && e.rows.length > 0) {
+    t.rows = t.rows || [];
+    const a = ve(o, e.rows[0], e, s, r, i);
+    t.rows.push(a);
+  }
+  if (e.columns && e.columns.length > 0) {
+    t.columns = t.columns || [];
+    const a = z(o, e.columns[0], e, s, r, i);
+    t.columns.push(a);
+  }
+  if (t.key === "root")
+    for (const a of e.values) {
+      if (t.values = t.values || [], r === "root" && e.options?.calculateTotals === !1)
+        continue;
+      const u = Q(a, o, s.getIndex(a.attribute), a.attribute);
+      t.values.push(u);
+    }
+  return t;
+}
+function ve(o, e, t, r, s = "", i) {
+  const n = { key: e.attribute }, a = r.getIndex(e.attribute);
+  if (!a)
+    return n;
+  for (const [u, c] of a.entries()) {
+    const f = {
+      key: u,
+      value: u
+    }, d = /* @__PURE__ */ new Map();
+    for (const l of c)
+      o.has(l) && d.set(l, o.get(l));
+    if (d.size) {
+      for (const l of t.values) {
+        if (f.values = f.values || [], s === "root" && e?.calculateTotals === !1)
+          continue;
+        const h = Q(l, d, r.getIndex(l.attribute), l.attribute);
+        f.values.push(h);
+      }
+      if (n.rows = n.rows || [], n.rows.push(f), t.rows.length > 1) {
+        const l = { ...t, rows: t.rows.slice(1) };
+        R(
+          d,
+          l,
+          f,
+          s + m + e.attribute + m + u,
+          r,
+          i
+        );
+      } else if (t.columns)
+        for (const l of t.columns) {
+          f.columns = f.columns || [];
+          const h = z(
+            d,
+            l,
+            t,
+            r,
+            s + m + e.attribute + m + u,
+            i
+          );
+          f.columns.push(h);
+        }
+    }
+  }
+  return n;
+}
+function z(o, e, t, r, s = "", i) {
+  const n = { key: e.attribute }, a = r.getIndex(e.attribute);
+  if (!a)
+    return n;
+  for (const [u, c] of a.entries()) {
+    const f = {
+      key: u,
+      value: u
+    }, d = /* @__PURE__ */ new Map();
+    for (const l of c)
+      o.has(l) && d.set(l, o.get(l));
+    if (d.size) {
+      for (const l of t.values) {
+        if (f.values = f.values || [], s === "root" && e?.calculateTotals === !1)
+          continue;
+        const h = Q(l, d, r.getIndex(l.attribute), l.attribute);
+        f.values.push(h);
+      }
+      if (n.columns = n.columns || [], n.columns.push(f), t.columns.length > 1) {
+        const l = { ...t, columns: t.columns.slice(1) };
+        R(
+          d,
+          l,
+          f,
+          s + m + e.attribute + m + u,
+          r,
+          i
+        );
+      }
+    }
+  }
+  return n;
+}
+const Te = (o, e) => {
+  const t = [];
+  for (const r of o) {
+    for (const [s, i] of Object.entries(r)) {
+      const n = t.find((u) => u.key === s), a = Ae(i);
+      if (n)
+        n.type !== a && (n.type = "any");
+      else {
+        const u = {
+          key: s,
+          type: a
+        };
+        t.push(u);
+      }
+    }
+    if (!e)
+      break;
+  }
+  return t;
+}, we = (o) => Number(o) === o && o % 1 === 0, xe = (o) => Number(o) === o && o % 1 !== 0, Ae = (o) => {
+  switch (typeof o) {
+    case "string":
+      return "string";
+    case "number":
+      return we(o) ? "int" : xe(o) ? "float" : "any";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return re(o) ? "date" : "json";
+    default:
+      return "any";
+  }
+}, je = (o, e) => {
+  const t = ee(o.text || ""), r = e?.attributeKey || o.filterKey;
+  let s;
+  const i = e?.comparisonType || "containsIgnoreCase";
+  return i === "containsIgnoreCase" ? s = {
+    groupKey: o.filterKey,
+    queries: [
+      {
+        queryKey: o.text,
+        attribute: r,
+        value: `/${t}/`,
+        operator: "find",
+        options: {
+          transform: ["lowercase"]
+        }
+      }
+    ]
+  } : i === "containsIgnoreCaseAndWhitespace" ? s = {
+    groupKey: o.filterKey,
+    queries: [
+      {
+        queryKey: o.text,
+        attribute: r,
+        value: `/${t}/`,
+        operator: "find",
+        options: {
+          transform: ["removeWhitespace", "lowercase"]
+        }
+      }
+    ]
+  } : i === "contains" ? s = {
+    groupKey: o.filterKey,
+    queries: [
+      {
+        queryKey: o.text,
+        attribute: r,
+        value: `/${t}/`,
+        operator: "find"
+      }
+    ]
+  } : i === "equal" ? s = {
+    groupKey: o.filterKey,
+    queries: [
+      {
+        queryKey: o.text,
+        attribute: r,
+        value: o.text,
+        operator: "eq"
+      }
+    ]
+  } : i === "equalIgnoreCase" && (s = {
+    groupKey: o.filterKey,
+    queries: [
+      {
+        queryKey: o.text,
+        attribute: r,
+        value: o.text,
+        operator: "eq",
+        options: {
+          transform: ["lowercase"]
+        }
+      }
+    ]
+  }), s;
+}, Pe = (o, e) => {
+  const t = e?.attributeKey || o.filterKey;
+  return {
+    groupKey: o.filterKey,
+    queries: [
+      {
+        queryKey: o.value,
+        attribute: t,
+        value: o.value,
+        operator: "eq"
+      }
+    ]
+  };
+}, Re = (o, e) => {
+  const t = e?.attributeKey || o.filterKey, r = {
+    groupKey: o.filterKey,
+    queries: []
+  };
+  return typeof o.eq < "u" && (r.groupType = "or", Array.isArray(o.eq) ? o.eq.forEach((s) => {
+    r.queries.push({ attribute: t, value: s, operator: "eq" });
+  }) : r.queries.push({ attribute: t, value: o.eq, operator: "eq" })), typeof o.ne < "u" && (r.groupType = "and", Array.isArray(o.ne) ? o.ne.forEach((s) => {
+    r.queries.push({ attribute: t, value: s, operator: "eq", options: { invert: !0 } });
+  }) : r.queries.push({
+    attribute: t,
+    value: o.ne,
+    operator: "eq",
+    options: { invert: !0 }
+  })), typeof o.gt < "u" && (r.groupType = "and", r.queries.push({ attribute: t, value: o.gt, operator: "gt" })), typeof o.lt < "u" && (r.groupType = "and", r.queries.push({ attribute: t, value: o.lt, operator: "lt" })), typeof o.gte < "u" && (r.groupType = "and", r.queries.push({ attribute: t, value: o.gte, operator: "gte" })), typeof o.lte < "u" && (r.groupType = "and", r.queries.push({ attribute: t, value: o.lte, operator: "lte" })), r;
+}, ze = (o, e) => {
+  const t = e?.attributeKey || o.filterKey, r = {
+    groupKey: o.filterKey,
+    queries: []
+  };
+  return o.itemKeys.forEach((s) => {
+    r.queries.push({
+      queryKey: s,
+      attribute: t,
+      value: { key: s },
+      operator: "eq"
+    });
+  }), r;
+}, _e = (o) => !(typeof o.modelKey != "string" || !Array.isArray(o.queries));
+class We {
+  constructor(e, t, r) {
+    this.scriptController = e, this.globalItemService = t, this.modelParser = r;
+  }
+  registeredCustomOperator = /* @__PURE__ */ new Map();
+  queryBuilder = new P();
+  registerCustomOperator(e, t) {
+    this.registeredCustomOperator.set(e, t);
+  }
+  transformValue(e, t) {
+    if (Array.isArray(e))
+      return e.map((r) => this.transformValue(r, t));
+    if (typeof e != "string")
+      return e;
+    for (const r of t)
+      r === "lowercase" ? e = e.toLowerCase() : r === "trim" ? e = e.trim() : r === "removeWhitespace" && (e = e.replace(/\s/g, ""));
+    return e;
+  }
+  evaluateQuery(e, t) {
+    let r, s = e.value;
+    const i = e.options?.arrayValueHandling || "some";
+    if (Array.isArray(e.options?.transform) && e.options.transform.length > 0 && (s = this.transformValue(s, e.options.transform)), e.attribute.includes(".") || e.attribute.includes("[") ? r = v(t, e.attribute) : r = t[e.attribute], Array.isArray(e.options?.transform) && e.options.transform.length > 0 && (r = this.transformValue(r, e.options.transform)), (typeof r > "u" || r === null) && !["typeof", "isTruthy", "eq"].includes(e.operator))
+      return !1;
+    switch (e.operator) {
+      case "eq":
+        return e.options?.invert ? !E(r, s) : E(r, s);
+      case "find":
+        return e.options?.invert ? !this.queryFind(r, s, i) : this.queryFind(r, s, i);
+      case "lt":
+        return Array.isArray(r) ? i === "some" ? r.some((n) => n < s) : r.every((n) => n < s) : r < s;
+      case "gt":
+        return Array.isArray(r) ? i === "some" ? r.some((n) => n > s) : r.every((n) => n > s) : r > s;
+      case "lte":
+        return Array.isArray(r) ? i === "some" ? r.some((n) => n <= s) : r.every((n) => n <= s) : r <= s;
+      case "gte":
+        return Array.isArray(r) ? i === "some" ? r.some((n) => n >= s) : r.every((n) => n >= s) : r >= s;
+      case "typeof":
+        return e.options?.invert ? typeof r !== s : Array.isArray(r) ? i === "some" ? r.some((n) => typeof n === s) : r.every((n) => typeof n === s) : typeof r === s;
+      case "isTruthy":
+        return s === !0 ? Array.isArray(r) ? i === "some" ? r.some((n) => typeof !!n) : r.every((n) => typeof !!n) : !!r : !r;
+      case "size":
+        return typeof r == "string" ? r.length === s : W(r) === s;
+      default:
+        if (this.scriptController.hasScript(e.operator))
+          return this.scriptController.executeScript(e.operator, "operator", { query: e, item: t });
+        if (this.registeredCustomOperator.has(e.operator)) {
+          const n = this.registeredCustomOperator.get(e.operator);
+          if (typeof n == "function")
+            return n(e, t);
+        }
+    }
+    return !1;
+  }
+  evaluateEqOperator(e, t, r, s) {
+    const i = /* @__PURE__ */ new Map(), n = s.get(t.attribute);
+    if (n) {
+      let a;
+      if (typeof t.value == "string" ? a = t.value : t.value?.key && Object.keys(t.value).length === 1 && (a = t.value.key), typeof a < "u") {
+        const u = n.get(a);
+        if (u)
+          if (u.forEach((c) => {
+            r.has(c) && i.set(c, r.get(c));
+          }), t.options?.invert) {
+            const c = q(Array.from(r.values()), Array.from(i.values()), "key"), f = /* @__PURE__ */ new Map();
+            return c.forEach((d) => {
+              f.set(d.key, d);
+            }), f;
+          } else
+            return i;
+      }
+    }
+    for (let [a, u] of r) {
+      const c = this.queryBuilder.extractQueryAttributes({ queries: [t] });
+      if (c.some((f) => f.isDeepQuery)) {
+        const f = this.queryBuilder.getProjectionForAttributeEntries(
+          c.filter((d) => d.isDeepQuery)
+        );
+        u = this.globalItemService.getProjectedData(
+          f,
+          this.modelParser.models.get(e.modelKey),
+          u
+        );
+      }
+      this.evaluateQuery(t, u) && i.set(a, u);
+    }
+    return i;
+  }
+  equalRegexFn(e, t) {
+    if (typeof t == "string" && L(t, "/") && H(t, "/"))
+      try {
+        return new RegExp(t.slice(1, -1)).test(e);
+      } catch {
+        return !1;
+      }
+    else return Array.isArray(e) ? !!e.find((r) => b(r, t, this.equalRegexFn)) : typeof t == "object" ? U(e, t) : e === t;
+  }
+  queryFind(e, t, r) {
+    return Array.isArray(e) ? typeof t == "string" || typeof t == "number" || typeof t == "boolean" ? r === "some" ? e.some((s) => b(s, t, this.equalRegexFn)) : e.every((s) => b(s, t, this.equalRegexFn)) : !!V(e, t) : b(e, t, this.equalRegexFn);
+  }
+  validateQuery(e) {
+    if (this.queryBuilder.isQuery(e)) {
+      if (!e.attribute || !e.operator)
+        throw new Error("invalid query - missing attribute or operator");
+      if (e.operator === "find" && Array.isArray(e.value))
+        throw new Error("invalid query - find operator cannot have array value");
+      return !0;
+    } else {
+      if (this.queryBuilder.isQueryGroup(e))
+        return B(e.queries, (t) => this.validateQuery(t));
+      throw new Error("invalid query - missing query or attribute");
+    }
+  }
+  getEvaluatedQueryDataset(e, t, r, s) {
+    const i = /* @__PURE__ */ new Map();
+    if (t.attribute.includes("[*]"))
+      for (let n of r.values()) {
+        const a = this.queryBuilder.extractQueryAttributes({ queries: [t] });
+        if (a.some((c) => c.isDeepQuery)) {
+          const c = this.queryBuilder.getProjectionForAttributeEntries(
+            a.filter((f) => f.isDeepQuery)
+          );
+          n = this.globalItemService.getProjectedData(
+            c,
+            this.modelParser.models.get(e.modelKey),
+            n
+          );
+        }
+        const u = this.handleArrayStarQuery(t, n);
+        for (const c of u.queries)
+          this.evaluateQuery(c, n) && i.set(n.key, n);
+      }
+    else {
+      if (t.operator === "eq")
+        return this.evaluateEqOperator(e, t, r, s);
+      for (let [n, a] of r) {
+        const u = this.queryBuilder.extractQueryAttributes({ queries: [t] });
+        if (u.some((c) => c.isDeepQuery)) {
+          const c = this.queryBuilder.getProjectionForAttributeEntries(
+            u.filter((f) => f.isDeepQuery)
+          );
+          a = this.globalItemService.getProjectedData(
+            c,
+            this.modelParser.models.get(e.modelKey),
+            a
+          );
+        }
+        this.evaluateQuery(t, a) && i.set(n, a);
+      }
+    }
+    return i;
+  }
+  handleArrayStarQuery(e, t) {
+    const r = e.attribute.indexOf("[*]"), s = {
+      groupKey: e.queryKey || e.attribute + "[*]",
+      groupType: "or",
+      queries: []
+    };
+    if (r !== -1) {
+      const i = e.attribute.substring(0, r), n = t[i];
+      if (Array.isArray(n))
+        for (let a = 0; a < n.length; a++) {
+          const u = e.attribute.replace("[*]", `[${a}]`);
+          s.queries.push({
+            attribute: u,
+            operator: e.operator,
+            value: e.value
+          });
+        }
+    }
+    return s;
+  }
+  evaluateQueryGroup(e, t, r, s, i) {
+    let n = /* @__PURE__ */ new Map(), a = r;
+    if (!t.queries || t.queries?.length === 0)
+      return a;
+    for (const u of t.queries) {
+      let c = /* @__PURE__ */ new Map();
+      if (this.queryBuilder.isQuery(u) ? c = this.getEvaluatedQueryDataset(e, u, a, i) : c = this.evaluateQueryGroup(e, u, a, s, i), n.size === 0 && (n = c), t.groupType === "or")
+        c.forEach((f) => {
+          n.set(f.key, f);
+        });
+      else {
+        const f = q(Array.from(n.values()), Array.from(c.values()), "key");
+        for (const d of f)
+          n.delete(d.key);
+      }
+      t.groupType === "and" ? a = n : a = r;
+    }
+    return n;
+  }
+  queryData(e, t, r, s) {
+    const i = new Map(e);
+    return t.queries.length === 0 ? e : (t.groupKey || (t.groupKey = "root"), t.groupType || (t.groupType = "and"), t.queries || (t.queries = []), this.validateQuery(t), this.evaluateQueryGroup(t, t, i, r, s));
+  }
+  // public getRelevantQueryData(data: any, options: DcuplGlobalQueryOptions<any>, model: DcuplModel<ListItem>) {
+  //   // detect if any of the query attributes are a deep query.
+  //   // a deep query is a query that references another models property.
+  //   // if so we need to make a getItems call with the projected data.
+  //   const attributes = this.queryBuilder.getQueryAttributes(options);
+  //   const deepQueries = attributes.filter((attr) => {
+  //     return attr.includes('.') || attr.includes('[');
+  //   });
+  //   if (deepQueries.length > 0) {
+  //     const projection: Projection<any> = {
+  //       $: true,
+  //     };
+  //     for (const deepQuery of deepQueries) {
+  //       // split the deep query into modelKey and attribute
+  //       // e.g. modelA.someAttribute or modelB[0].someAttribute or modelB[*].someAttribute
+  //       // the result should the modelKey: modelA and attribute: someAttribute
+  //       // const [modelKey, attribute] = deepQuery.split(new RegExp(/\.|\[|\]/)).filter(Boolean);
+  //       const parts = deepQuery.split(new RegExp(/\.|\[|\]/)).filter(Boolean);
+  //       const modelKey = parts[0];
+  //       if (modelKey) {
+  //         (projection as any)[modelKey] = {
+  //           $: true,
+  //         };
+  //       }
+  //     }
+  //     const relevantData = this.globalItemService.getItemsAsMap(data, model, {
+  //       projection,
+  //     } as DcuplItemsOptions<ListItem>);
+  //     return relevantData;
+  //   } else {
+  //     return data;
+  //   }
+  // }
+}
+class Le {
+  scripts = /* @__PURE__ */ new Map();
+  scriptFunctions = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  keys() {
+    return Array.from(this.scripts.keys());
+  }
+  setScript(e, t) {
+    this.scripts.set(e, t);
+  }
+  removeScript(e) {
+    this.scripts.delete(e);
+  }
+  getScript(e) {
+    return this.scripts.get(e);
+  }
+  hasScript(e) {
+    return this.scripts.has(e);
+  }
+  getScriptAsFn(e, t) {
+    if (this.scriptFunctions.has(e))
+      return this.scriptFunctions.get(e);
+    const r = this.getScript(e);
+    if (!r)
+      throw new Error(`Script ${e} not found`);
+    const s = this.getWrapperScript(r), i = new Function("script_type", ...t, s);
+    return this.scriptFunctions.set(e, i), i;
+  }
+  getWrapperScript(e) {
+    return `
+    "use strict";
+      ${e}
+      `;
+  }
+  executeScript(e, t, r) {
+    if (!this.getScript(e))
+      throw new Error(`Script ${e} not found`);
+    r.context || (r.context = r.options || {});
+    const i = Object.keys(r), n = Object.values(r);
+    return this.getScriptAsFn(e, i)(t, ...n);
+  }
+}
+const He = (o, e) => o ? (e || (e = {}), o.replace(/\$\{(.*?)\}/g, (t, r) => v(e, r.trim(), ""))) : "", Ue = (o) => {
+  const e = /* @__PURE__ */ new Set();
+  return o.replace(/\$\{(.*?)\}/g, (r, s) => (e.add(s.trim()), "")), { variables: Array.from(e).map((r) => ({ name: r })) };
+}, Ve = [
+  "any",
+  "Array<date>",
+  "Array<float>",
+  "Array<int>",
+  "Array<string>",
+  "boolean",
+  "date",
+  "float",
+  "int",
+  "json",
+  "string"
+], Je = ["int", "float", "Array<int>", "Array<float>"], Ze = ["date", "Array<date>"], Ye = [
+  "eq",
+  "find",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "typeof",
+  "isTruthy",
+  "size"
+];
+export {
+  De as AnalyticsController,
+  Ke as AttributeDependencyGraph,
+  Se as CacheController,
+  Oe as ChangeDetector,
+  Ze as DatePropertyTypes,
+  P as DcuplQueryBuilder,
+  Ye as DcuplQueryOperatorsAsArray,
+  fe as DeepQueryService,
+  Z as DependencyGraph,
+  me as IndicesController,
+  p as Logger,
+  Je as NumberPropertyTypes,
+  Ve as PropertyTypesAsArray,
+  We as QueryManager,
+  Le as ScriptController,
+  j as clone,
+  te as compareVersions,
+  Fe as computeSuggestions,
+  g as deepQueryService,
+  ee as escapeRegExp,
+  He as evaluateTemplate,
+  Pe as generateBooleanQuery,
+  X as generateKey,
+  Re as generateNumberAndDateQuery,
+  ze as generateReferenceQuery,
+  je as generateTextQuery,
+  Q as getAggregation,
+  Me as getDateConstraintUid,
+  Ae as getDcuplPropertyTypeForNativeType,
+  ge as getDistinct,
+  Be as getFacets,
+  Ie as getFilterEntryId,
+  Qe as getNumberConstraintUid,
+  Te as getPropertiesForData,
+  ke as groupBy,
+  qe as hasMinimumVersion,
+  re as isDateInstance,
+  xe as isFloat,
+  we as isInt,
+  se as isValidDate,
+  _e as isValidQueryStatement,
+  $ as isValidVersion,
+  Y as logger,
+  Ge as parseDate,
+  Ue as parseTemplate,
+  x as perf,
+  R as pivot,
+  Ce as removeTrailingSlash,
+  $e as trigger,
+  Ee as unescapeRegExp,
+  Ne as uniqBy
+};
+//# sourceMappingURL=index.js.map