@aivue/tabular-intelligence 1.5.1 → 2.0.1

package/dist/index.mjs

@@ -1,86 +1,87 @@
-import { ref as q, defineComponent as j, createElementBlock as y, openBlock as g, createElementVNode as p, createCommentVNode as _, withDirectives as ee, withKeys as H, withModifiers as J, vModelText as te, toDisplayString as C, normalizeClass as ne, createTextVNode as ae, Fragment as F, renderList as O, computed as se } from "vue";
-function N(l, e) {
-  if (l.length === 0)
+import { createCompatComponent as B, createCompatPlugin as se, registerCompatComponent as F } from "@aivue/core";
+import { ref as x, defineComponent as W, createElementBlock as C, openBlock as A, createElementVNode as b, createCommentVNode as T, withDirectives as Se, withKeys as Z, withModifiers as ee, vModelText as Ne, toDisplayString as M, normalizeClass as ke, createTextVNode as Ie, Fragment as j, renderList as Q, computed as $e } from "vue";
+function _(s, e) {
+  if (s.length === 0)
     return { columns: [], rowCount: 0, name: e };
-  const n = l[0];
+  const t = s[0];
   return {
-    columns: Object.keys(n).map((t) => {
-      const r = L(l, t);
+    columns: Object.keys(t).map((o) => {
+      const a = oe(s, o);
       return {
-        name: t,
-        type: r,
-        nullable: l.some((o) => o[t] == null)
+        name: o,
+        type: a,
+        nullable: s.some((i) => i[o] == null)
       };
     }),
-    rowCount: l.length,
+    rowCount: s.length,
     name: e
   };
 }
-function L(l, e) {
-  const n = l.map((t) => t[e]).filter((t) => t != null);
-  if (n.length === 0) return "string";
-  if (n.every((t) => typeof t == "number" || !isNaN(Number(t))))
+function oe(s, e) {
+  const t = s.map((o) => o[e]).filter((o) => o != null);
+  if (t.length === 0) return "string";
+  if (t.every((o) => typeof o == "number" || !isNaN(Number(o))))
     return "number";
-  if (n.every((t) => typeof t == "boolean" || t === "true" || t === "false"))
+  if (t.every((o) => typeof o == "boolean" || o === "true" || o === "false"))
     return "boolean";
-  if (n.every((t) => !isNaN(Date.parse(t))))
+  if (t.every((o) => !isNaN(Date.parse(o))))
     return "date";
-  const a = new Set(n);
-  return a.size < n.length * 0.5 && a.size < 20 ? "categorical" : "string";
+  const n = new Set(t);
+  return n.size < t.length * 0.5 && n.size < 20 ? "categorical" : "string";
 }
-function B(l, e, n) {
-  const a = l.map((s) => s[e]).filter((s) => s != null), t = a.length, r = l.length - t, o = {
+function ae(s, e, t) {
+  const n = s.map((r) => r[e]).filter((r) => r != null), o = n.length, a = s.length - o, i = {
     column: e,
-    count: t,
-    nullCount: r
+    count: o,
+    nullCount: a
   };
-  if (n === "number") {
-    const s = a.map(Number).filter((i) => !isNaN(i));
-    if (s.length > 0) {
-      const i = [...s].sort((m, d) => m - d), c = s.reduce((m, d) => m + d, 0);
-      o.mean = c / s.length, o.median = i[Math.floor(i.length / 2)], o.min = i[0], o.max = i[i.length - 1];
-      const f = s.reduce((m, d) => m + Math.pow(d - o.mean, 2), 0) / s.length;
-      o.std = Math.sqrt(f), o.percentiles = {
-        25: i[Math.floor(i.length * 0.25)],
-        50: o.median,
-        75: i[Math.floor(i.length * 0.75)],
-        90: i[Math.floor(i.length * 0.9)]
+  if (t === "number") {
+    const r = n.map(Number).filter((c) => !isNaN(c));
+    if (r.length > 0) {
+      const c = [...r].sort((m, d) => m - d), l = r.reduce((m, d) => m + d, 0);
+      i.mean = l / r.length, i.median = c[Math.floor(c.length / 2)], i.min = c[0], i.max = c[c.length - 1];
+      const u = r.reduce((m, d) => m + Math.pow(d - i.mean, 2), 0) / r.length;
+      i.std = Math.sqrt(u), i.percentiles = {
+        25: c[Math.floor(c.length * 0.25)],
+        50: i.median,
+        75: c[Math.floor(c.length * 0.75)],
+        90: c[Math.floor(c.length * 0.9)]
       };
     }
   } else {
-    const s = new Set(a);
-    o.uniqueValues = s.size;
-    const i = {};
-    a.forEach((f) => {
-      const m = String(f);
-      i[m] = (i[m] || 0) + 1;
+    const r = new Set(n);
+    i.uniqueValues = r.size;
+    const c = {};
+    n.forEach((u) => {
+      const m = String(u);
+      c[m] = (c[m] || 0) + 1;
     });
-    const c = Math.max(...Object.values(i));
-    o.mode = Object.keys(i).find((f) => i[f] === c);
+    const l = Math.max(...Object.values(c));
+    i.mode = Object.keys(c).find((u) => c[u] === l);
   }
-  return o;
+  return i;
 }
-function re(l, e, n = 0.5) {
-  const a = [], t = 1.5 + (1 - n) * 1.5;
-  return e.forEach((r) => {
-    const o = l.map((w, b) => ({ value: Number(w[r]), idx: b })).filter((w) => !isNaN(w.value));
-    if (o.length === 0) return;
-    const s = [...o].sort((w, b) => w.value - b.value), i = s[Math.floor(s.length * 0.25)].value, c = s[Math.floor(s.length * 0.75)].value, f = c - i, m = i - t * f, d = c + t * f;
-    o.forEach(({ value: w, idx: b }) => {
-      if (w < m || w > d) {
-        const P = a.find((D) => D.rowIndex === b), $ = w < m ? `${r}: ${w.toFixed(2)} < ${m.toFixed(2)}` : `${r}: ${w.toFixed(2)} > ${d.toFixed(2)}`;
-        P ? (P.reasons.push($), P.affectedColumns.push(r), P.score = Math.min(1, P.score + 0.2)) : a.push({
-          rowIndex: b,
-          row: l[b],
+function Me(s, e, t = 0.5) {
+  const n = [], o = 1.5 + (1 - t) * 1.5;
+  return e.forEach((a) => {
+    const i = s.map((f, h) => ({ value: Number(f[a]), idx: h })).filter((f) => !isNaN(f.value));
+    if (i.length === 0) return;
+    const r = [...i].sort((f, h) => f.value - h.value), c = r[Math.floor(r.length * 0.25)].value, l = r[Math.floor(r.length * 0.75)].value, u = l - c, m = c - o * u, d = l + o * u;
+    i.forEach(({ value: f, idx: h }) => {
+      if (f < m || f > d) {
+        const p = n.find((g) => g.rowIndex === h), w = f < m ? `${a}: ${f.toFixed(2)} < ${m.toFixed(2)}` : `${a}: ${f.toFixed(2)} > ${d.toFixed(2)}`;
+        p ? (p.reasons.push(w), p.affectedColumns.push(a), p.score = Math.min(1, p.score + 0.2)) : n.push({
+          rowIndex: h,
+          row: s[h],
           score: 0.7,
-          reasons: [$],
-          affectedColumns: [r]
+          reasons: [w],
+          affectedColumns: [a]
         });
       }
     });
-  }), a.sort((r, o) => o.score - r.score);
+  }), n.sort((a, i) => i.score - a.score);
 }
-class U {
+class te {
   constructor(e) {
     this.config = {
       maxTokens: 1e3,
@@ -92,171 +93,171 @@ class U {
    * Answer a question about the table data
    */
   async answerQuestion(e) {
-    const n = Date.now();
+    const t = Date.now();
     try {
-      const { question: a, schema: t, data: r, sampleSize: o = 100, includeAggregates: s = !0 } = e;
-      if (!r || !Array.isArray(r) || r.length === 0)
+      const { question: n, schema: o, data: a, sampleSize: i = 100, includeAggregates: r = !0 } = e;
+      if (!a || !Array.isArray(a) || a.length === 0)
         throw new Error("No data available. Please load data first.");
-      if (!t || !t.columns || !Array.isArray(t.columns))
+      if (!o || !o.columns || !Array.isArray(o.columns))
         throw new Error("Invalid schema. Please ensure data has a valid schema.");
-      const i = r.length > o ? this.sampleData(r, o) : r, c = s ? this.calculateAggregates(r, t) : void 0, f = this.buildPrompt(a, t, i, c, r.length), m = await this.callLLM(f);
+      const c = a.length > i ? this.sampleData(a, i) : a, l = r ? this.calculateAggregates(a, o) : void 0, u = this.buildPrompt(n, o, c, l, a.length), m = await this.callLLM(u);
       return {
-        answer: this.parseResponse(m, a, r.length > o),
-        processingTime: Date.now() - n
+        answer: this.parseResponse(m, n, a.length > i),
+        processingTime: Date.now() - t
       };
-    } catch (a) {
-      return console.error("Q&A error:", a), {
+    } catch (n) {
+      return console.error("Q&A error:", n), {
         answer: {
           questionId: this.generateId(),
           text: "I encountered an error while processing your question. Please try again.",
           timestamp: /* @__PURE__ */ new Date(),
           confidence: 0,
           cannotAnswer: !0,
-          reason: a instanceof Error ? a.message : "Unknown error"
+          reason: n instanceof Error ? n.message : "Unknown error"
         },
-        processingTime: Date.now() - n
+        processingTime: Date.now() - t
       };
     }
   }
   /**
    * Sample data for large datasets
    */
-  sampleData(e, n) {
+  sampleData(e, t) {
     if (!e || !Array.isArray(e) || e.length === 0)
       return [];
-    if (e.length <= n)
+    if (e.length <= t)
       return e;
-    const a = Math.floor(e.length / n), t = [];
-    for (let r = 0; r < e.length && t.length < n; r += a)
-      t.push(e[r]);
-    return t;
+    const n = Math.floor(e.length / t), o = [];
+    for (let a = 0; a < e.length && o.length < t; a += n)
+      o.push(e[a]);
+    return o;
   }
   /**
    * Calculate aggregates for numeric columns
    */
-  calculateAggregates(e, n) {
-    const a = {};
-    if (!e || !Array.isArray(e) || e.length === 0 || !n || !n.columns || !Array.isArray(n.columns))
-      return a;
-    for (const t of n.columns)
-      if (t.type === "number" && e.length > 0)
+  calculateAggregates(e, t) {
+    const n = {};
+    if (!e || !Array.isArray(e) || e.length === 0 || !t || !t.columns || !Array.isArray(t.columns))
+      return n;
+    for (const o of t.columns)
+      if (o.type === "number" && e.length > 0)
         try {
-          const r = B(e, t.name, "number");
-          a[t.name] = {
-            mean: r.mean,
-            median: r.median,
-            min: r.min,
-            max: r.max,
-            count: r.count
+          const a = ae(e, o.name, "number");
+          n[o.name] = {
+            mean: a.mean,
+            median: a.median,
+            min: a.min,
+            max: a.max,
+            count: a.count
           };
         } catch {
         }
-      else if (t.type === "categorical" || t.type === "string") {
-        const r = e.map((s) => s[t.name]).filter((s) => s != null), o = new Set(r);
-        a[t.name] = {
-          uniqueCount: o.size,
-          totalCount: r.length,
-          topValues: this.getTopValues(r, 5)
+      else if (o.type === "categorical" || o.type === "string") {
+        const a = e.map((r) => r[o.name]).filter((r) => r != null), i = new Set(a);
+        n[o.name] = {
+          uniqueCount: i.size,
+          totalCount: a.length,
+          topValues: this.getTopValues(a, 5)
         };
       }
-    return a;
+    return n;
   }
   /**
    * Get top N most frequent values
    */
-  getTopValues(e, n) {
-    const a = /* @__PURE__ */ new Map();
-    for (const t of e)
-      a.set(t, (a.get(t) || 0) + 1);
-    return Array.from(a.entries()).map(([t, r]) => ({ value: t, count: r })).sort((t, r) => r.count - t.count).slice(0, n);
+  getTopValues(e, t) {
+    const n = /* @__PURE__ */ new Map();
+    for (const o of e)
+      n.set(o, (n.get(o) || 0) + 1);
+    return Array.from(n.entries()).map(([o, a]) => ({ value: o, count: a })).sort((o, a) => a.count - o.count).slice(0, t);
   }
   /**
    * Build prompt for LLM
    */
-  buildPrompt(e, n, a, t, r) {
-    const o = r && r > a.length;
-    let s = `You are a data analyst assistant. Answer the following question about a table dataset.
+  buildPrompt(e, t, n, o, a) {
+    const i = a && a > n.length;
+    let r = `You are a data analyst assistant. Answer the following question about a table dataset.
 
 `;
-    s += `**Table Schema:**
-`, s += `Table: ${n.name}
-`, s += `Columns:
+    r += `**Table Schema:**
+`, r += `Table: ${t.name}
+`, r += `Columns:
 `;
-    for (const i of n.columns)
-      s += `- ${i.name} (${i.type})
+    for (const c of t.columns)
+      r += `- ${c.name} (${c.type})
 `;
-    return s += `
-`, t && Object.keys(t).length > 0 && (s += `**Summary Statistics:**
-`, s += JSON.stringify(t, null, 2), s += `
+    return r += `
+`, o && Object.keys(o).length > 0 && (r += `**Summary Statistics:**
+`, r += JSON.stringify(o, null, 2), r += `
 
-`), s += `**Sample Data** (${a.length} rows${o ? ` out of ${r} total` : ""}):
-`, s += JSON.stringify(a.slice(0, 10), null, 2), s += `
+`), r += `**Sample Data** (${n.length} rows${i ? ` out of ${a} total` : ""}):
+`, r += JSON.stringify(n.slice(0, 10), null, 2), r += `
 
-`, s += `**Question:** ${e}
+`, r += `**Question:** ${e}
 
-`, s += `**Instructions:**
-`, s += `1. You are a helpful AI data analyst that can answer questions about the table data, perform statistical analysis, make predictions, identify trends, AND engage in normal conversation.
-`, s += `2. For data questions (e.g., "how many rows?", "what's the average?"), answer based on the data provided above.
-`, s += `3. For statistical analysis requests (e.g., "calculate descriptive statistics", "show me mean/median/std dev"), compute and present the statistics clearly.
-`, s += `4. For anomaly detection requests (e.g., "detect anomalies", "find outliers"), identify unusual data points and explain why they're anomalous.
-`, s += `5. For clustering requests (e.g., "perform clustering", "group similar data"), identify natural groupings in the data and describe their characteristics.
-`, s += `6. For correlation analysis requests (e.g., "show correlations", "what variables are related"), analyze relationships between variables and explain the strength and direction of correlations.
-`, s += `7. For predictive questions (e.g., "predict future trends", "what will happen next?", "forecast X"), analyze patterns in the data and make reasonable predictions based on trends, correlations, and statistical patterns you observe.
-`, s += `8. For analytical questions (e.g., "what insights?", "any patterns?", "recommendations?"), provide insights, trends, correlations, and actionable recommendations based on the data.
-`, s += `9. For conversational questions (e.g., "hi", "hello", "what can you do?"), respond naturally and mention your capabilities.
-`, s += `10. If a question is completely unrelated to data analysis (e.g., "what's the weather?"), politely explain you can only help with data analysis.
-`, s += `11. Provide clear, concise answers with specific numbers and examples.
-`, s += `12. When making predictions or identifying trends, explain your reasoning and mention the confidence level.
-`, s += `13. If the answer is based on sampled data, mention that it's an approximation.
-`, s += `14. Format your response as JSON with the following structure:
-`, s += `{
-`, s += `  "answer": "Your answer text here",
-`, s += `  "confidence": 0.0-1.0,
-`, s += `  "cannotAnswer": false,
-`, s += `  "isApproximate": ${o},
-`, s += `  "supportingData": { "key": "value" } // optional
-`, s += `}
+`, r += `**Instructions:**
+`, r += `1. You are a helpful AI data analyst that can answer questions about the table data, perform statistical analysis, make predictions, identify trends, AND engage in normal conversation.
+`, r += `2. For data questions (e.g., "how many rows?", "what's the average?"), answer based on the data provided above.
+`, r += `3. For statistical analysis requests (e.g., "calculate descriptive statistics", "show me mean/median/std dev"), compute and present the statistics clearly.
+`, r += `4. For anomaly detection requests (e.g., "detect anomalies", "find outliers"), identify unusual data points and explain why they're anomalous.
+`, r += `5. For clustering requests (e.g., "perform clustering", "group similar data"), identify natural groupings in the data and describe their characteristics.
+`, r += `6. For correlation analysis requests (e.g., "show correlations", "what variables are related"), analyze relationships between variables and explain the strength and direction of correlations.
+`, r += `7. For predictive questions (e.g., "predict future trends", "what will happen next?", "forecast X"), analyze patterns in the data and make reasonable predictions based on trends, correlations, and statistical patterns you observe.
+`, r += `8. For analytical questions (e.g., "what insights?", "any patterns?", "recommendations?"), provide insights, trends, correlations, and actionable recommendations based on the data.
+`, r += `9. For conversational questions (e.g., "hi", "hello", "what can you do?"), respond naturally and mention your capabilities.
+`, r += `10. If a question is completely unrelated to data analysis (e.g., "what's the weather?"), politely explain you can only help with data analysis.
+`, r += `11. Provide clear, concise answers with specific numbers and examples.
+`, r += `12. When making predictions or identifying trends, explain your reasoning and mention the confidence level.
+`, r += `13. If the answer is based on sampled data, mention that it's an approximation.
+`, r += `14. Format your response as JSON with the following structure:
+`, r += `{
+`, r += `  "answer": "Your answer text here",
+`, r += `  "confidence": 0.0-1.0,
+`, r += `  "cannotAnswer": false,
+`, r += `  "isApproximate": ${i},
+`, r += `  "supportingData": { "key": "value" } // optional
+`, r += `}
 
-`, s += `Examples:
-`, s += `- Question: "hi" → Answer: "Hello! I'm your AI data analyst. I can perform statistical analysis, detect anomalies, cluster data, analyze correlations, make predictions, and answer questions about this dataset."
-`, s += `- Question: "how many rows?" → Answer: "There are ${r || a.length} rows in the dataset."
-`, s += `- Question: "calculate descriptive statistics" → Answer: "Descriptive Statistics:\\n- Mean: 45.2\\n- Median: 42.0\\n- Std Dev: 12.5\\n- Min: 10\\n- Max: 95\\n- 25th Percentile: 35\\n- 75th Percentile: 58" (with confidence: 0.95)
-`, s += `- Question: "detect anomalies" → Answer: "I found 3 anomalies in the dataset:\\n1. Row 15: Value 250 is 3.5 standard deviations above the mean\\n2. Row 42: Value -10 is unusually low\\n3. Row 88: Value 300 is an extreme outlier" (with confidence: 0.85)
-`, s += `- Question: "perform clustering" → Answer: "I identified 3 natural clusters in the data:\\n- Cluster 1 (40%): Low values, avg 25\\n- Cluster 2 (35%): Medium values, avg 50\\n- Cluster 3 (25%): High values, avg 85" (with confidence: 0.8)
-`, s += `- Question: "show correlation analysis" → Answer: "Correlation Analysis:\\n- Price & Quantity: -0.65 (strong negative)\\n- Revenue & Price: 0.82 (strong positive)\\n- Quantity & Revenue: 0.45 (moderate positive)" (with confidence: 0.9)
-`, s += `- Question: "predict future sales" → Answer: "Based on the trend in the data, sales are increasing by 15% monthly. If this continues, next month's sales could reach approximately $50,000." (with confidence: 0.7)
-`, s += `- Question: "what insights can you give?" → Answer: "Key insights: 1) Sales peak on weekends, 2) Product A is the top seller, 3) Customer retention is 85%..."
-`, s += `- Question: "what's the weather?" → Answer: "I cannot answer this question as it's not related to the dataset. I can only help with questions about this data."
-`, s;
+`, r += `Examples:
+`, r += `- Question: "hi" → Answer: "Hello! I'm your AI data analyst. I can perform statistical analysis, detect anomalies, cluster data, analyze correlations, make predictions, and answer questions about this dataset."
+`, r += `- Question: "how many rows?" → Answer: "There are ${a || n.length} rows in the dataset."
+`, r += `- Question: "calculate descriptive statistics" → Answer: "Descriptive Statistics:\\n- Mean: 45.2\\n- Median: 42.0\\n- Std Dev: 12.5\\n- Min: 10\\n- Max: 95\\n- 25th Percentile: 35\\n- 75th Percentile: 58" (with confidence: 0.95)
+`, r += `- Question: "detect anomalies" → Answer: "I found 3 anomalies in the dataset:\\n1. Row 15: Value 250 is 3.5 standard deviations above the mean\\n2. Row 42: Value -10 is unusually low\\n3. Row 88: Value 300 is an extreme outlier" (with confidence: 0.85)
+`, r += `- Question: "perform clustering" → Answer: "I identified 3 natural clusters in the data:\\n- Cluster 1 (40%): Low values, avg 25\\n- Cluster 2 (35%): Medium values, avg 50\\n- Cluster 3 (25%): High values, avg 85" (with confidence: 0.8)
+`, r += `- Question: "show correlation analysis" → Answer: "Correlation Analysis:\\n- Price & Quantity: -0.65 (strong negative)\\n- Revenue & Price: 0.82 (strong positive)\\n- Quantity & Revenue: 0.45 (moderate positive)" (with confidence: 0.9)
+`, r += `- Question: "predict future sales" → Answer: "Based on the trend in the data, sales are increasing by 15% monthly. If this continues, next month's sales could reach approximately $50,000." (with confidence: 0.7)
+`, r += `- Question: "what insights can you give?" → Answer: "Key insights: 1) Sales peak on weekends, 2) Product A is the top seller, 3) Customer retention is 85%..."
+`, r += `- Question: "what's the weather?" → Answer: "I cannot answer this question as it's not related to the dataset. I can only help with questions about this data."
+`, r;
   }
   /**
    * Call LLM API
    */
   async callLLM(e) {
-    const { provider: n, apiKey: a, baseUrl: t, model: r, maxTokens: o, temperature: s } = this.config;
-    if (!a && n !== "custom")
+    const { provider: t, apiKey: n, baseUrl: o, model: a, maxTokens: i, temperature: r } = this.config;
+    if (!n && t !== "custom")
       return this.fallbackResponse(e);
-    if (n === "openai")
-      return this.callOpenAI(e, a, r || "gpt-4-turbo-preview", o, s);
-    if (n === "anthropic")
-      return this.callAnthropic(e, a, r || "claude-3-5-sonnet-20241022", o, s);
-    if (n === "custom" && t)
-      return this.callCustomAPI(e, t, a);
-    throw new Error(`Unsupported provider: ${n}`);
+    if (t === "openai")
+      return this.callOpenAI(e, n, a || "gpt-4-turbo-preview", i, r);
+    if (t === "anthropic")
+      return this.callAnthropic(e, n, a || "claude-3-5-sonnet-20241022", i, r);
+    if (t === "custom" && o)
+      return this.callCustomAPI(e, o, n);
+    throw new Error(`Unsupported provider: ${t}`);
   }
   /**
    * Fallback response when no API key is available
    */
   fallbackResponse(e) {
-    const n = e.match(/\*\*Question:\*\* (.+)/), t = (n ? n[1].trim() : "").toLowerCase();
-    if (/^(hi|hello|hey|greetings|good morning|good afternoon|good evening)/.test(t))
+    const t = e.match(/\*\*Question:\*\* (.+)/), o = (t ? t[1].trim() : "").toLowerCase();
+    if (/^(hi|hello|hey|greetings|good morning|good afternoon|good evening)/.test(o))
       return JSON.stringify({
         answer: "Hello! 👋 I'm your data analysis assistant. I can help you explore and understand this dataset. Try asking questions like 'How many rows are there?', 'What columns do we have?', or 'Show me a summary of the data'. For more advanced analysis, please configure an OpenAI or Anthropic API key in the settings.",
         confidence: 1,
         cannotAnswer: !1,
         isApproximate: !1
       });
-    if (/what (can|do) you|help|capabilities|features/.test(t))
+    if (/what (can|do) you|help|capabilities|features/.test(o))
       return JSON.stringify({
         answer: `I can help you analyze tabular data! You can ask me questions like:
 • 'How many rows/columns are there?'
@@ -279,60 +280,60 @@ Please add your API key in the AI Chatbot Configuration section for advanced fea
         cannotAnswer: !1,
         isApproximate: !1
       });
-    const r = e.match(/\*\*Sample Data\*\* \((\d+) rows/), o = e.match(/out of (\d+) total/), s = e.match(/Columns:\n((?:- .+\n)+)/), i = r ? parseInt(r[1]) : 0, c = o ? parseInt(o[1]) : i;
-    if (/how many (rows|records|entries|items)/.test(t))
+    const a = e.match(/\*\*Sample Data\*\* \((\d+) rows/), i = e.match(/out of (\d+) total/), r = e.match(/Columns:\n((?:- .+\n)+)/), c = a ? parseInt(a[1]) : 0, l = i ? parseInt(i[1]) : c;
+    if (/how many (rows|records|entries|items)/.test(o))
       return JSON.stringify({
-        answer: `There are ${c} rows in the dataset.`,
+        answer: `There are ${l} rows in the dataset.`,
         confidence: 1,
         cannotAnswer: !1,
         isApproximate: !1
       });
-    if (/how many columns|what columns|column names|list columns/.test(t) && s) {
-      const f = s[1].trim().split(`
+    if (/how many columns|what columns|column names|list columns/.test(o) && r) {
+      const u = r[1].trim().split(`
 `).map((m) => m.replace(/^- /, "").split(" (")[0]);
       return JSON.stringify({
-        answer: `The dataset has ${f.length} columns: ${f.join(", ")}.`,
+        answer: `The dataset has ${u.length} columns: ${u.join(", ")}.`,
         confidence: 1,
         cannotAnswer: !1,
         isApproximate: !1
       });
     }
-    if (/summary|overview|describe|what.*data|tell me about/.test(t) && s) {
-      const f = s[1].trim().split(`
+    if (/summary|overview|describe|what.*data|tell me about/.test(o) && r) {
+      const u = r[1].trim().split(`
 `).map((m) => m.replace(/^- /, "").split(" (")[0]);
       return JSON.stringify({
-        answer: `This dataset contains ${c} rows and ${f.length} columns. The columns are: ${f.join(", ")}. For detailed analysis and insights, please configure an OpenAI or Anthropic API key.`,
+        answer: `This dataset contains ${l} rows and ${u.length} columns. The columns are: ${u.join(", ")}. For detailed analysis and insights, please configure an OpenAI or Anthropic API key.`,
         confidence: 0.8,
         cannotAnswer: !1,
         isApproximate: !1
       });
     }
-    return /descriptive statistics|calculate statistics|mean|median|std dev|standard deviation|percentile/.test(t) ? JSON.stringify({
+    return /descriptive statistics|calculate statistics|mean|median|std dev|standard deviation|percentile/.test(o) ? JSON.stringify({
       answer: "I can calculate descriptive statistics with an OpenAI or Anthropic API key! I'll provide mean, median, standard deviation, min, max, and percentiles for all numeric columns. Please add your API key in the 'AI Chatbot Configuration' section above.",
       confidence: 0.3,
       cannotAnswer: !0,
       reason: "Statistical analysis requires AI. Please configure an API key."
-    }) : /anomaly|anomalies|outlier|outliers|detect anomal|find outlier/.test(t) ? JSON.stringify({
+    }) : /anomaly|anomalies|outlier|outliers|detect anomal|find outlier/.test(o) ? JSON.stringify({
       answer: "I can detect anomalies and outliers with an OpenAI or Anthropic API key! I'll identify unusual data points and explain why they're anomalous. Please add your API key in the 'AI Chatbot Configuration' section above.",
       confidence: 0.3,
       cannotAnswer: !0,
       reason: "Anomaly detection requires AI. Please configure an API key."
-    }) : /cluster|clustering|group|grouping|segment|segmentation/.test(t) ? JSON.stringify({
+    }) : /cluster|clustering|group|grouping|segment|segmentation/.test(o) ? JSON.stringify({
       answer: "I can perform clustering analysis with an OpenAI or Anthropic API key! I'll identify natural groupings in your data and describe their characteristics. Please add your API key in the 'AI Chatbot Configuration' section above.",
       confidence: 0.3,
       cannotAnswer: !0,
       reason: "Clustering analysis requires AI. Please configure an API key."
-    }) : /correlation|correlate|relationship|relate|association/.test(t) ? JSON.stringify({
+    }) : /correlation|correlate|relationship|relate|association/.test(o) ? JSON.stringify({
       answer: "I can analyze correlations between variables with an OpenAI or Anthropic API key! I'll show you the strength and direction of relationships between different columns. Please add your API key in the 'AI Chatbot Configuration' section above.",
       confidence: 0.3,
       cannotAnswer: !0,
       reason: "Correlation analysis requires AI. Please configure an API key."
-    }) : /predict|forecast|future|trend|next|will be|gonna be|going to be/.test(t) ? JSON.stringify({
+    }) : /predict|forecast|future|trend|next|will be|gonna be|going to be/.test(o) ? JSON.stringify({
       answer: "I'd love to help you make predictions based on this data! However, I need an OpenAI or Anthropic API key to analyze patterns, identify trends, and make accurate forecasts. Please add your API key in the 'AI Chatbot Configuration' section above, and I'll be able to provide detailed predictions with confidence scores.",
       confidence: 0.3,
       cannotAnswer: !0,
       reason: "Predictions require AI analysis. Please configure an API key for advanced features."
-    }) : /insight|pattern|analysis|analyze|recommendation/.test(t) ? JSON.stringify({
+    }) : /insight|pattern|analysis|analyze|recommendation/.test(o) ? JSON.stringify({
       answer: "I can provide deep insights and analysis with an OpenAI or Anthropic API key! I'll be able to identify patterns, trends, and give you actionable recommendations. Please add your API key in the 'AI Chatbot Configuration' section above.",
       confidence: 0.3,
       cannotAnswer: !0,
@@ -347,82 +348,82 @@ Please add your API key in the AI Chatbot Configuration section for advanced fea
   /**
    * Call OpenAI API
    */
-  async callOpenAI(e, n, a, t, r) {
-    var i, c;
-    const o = await fetch("https://api.openai.com/v1/chat/completions", {
+  async callOpenAI(e, t, n, o, a) {
+    var c, l;
+    const i = await fetch("https://api.openai.com/v1/chat/completions", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${n}`
+        Authorization: `Bearer ${t}`
       },
       body: JSON.stringify({
-        model: a,
+        model: n,
         messages: [{ role: "user", content: e }],
-        max_tokens: t,
-        temperature: r,
+        max_tokens: o,
+        temperature: a,
         response_format: { type: "json_object" }
       })
     });
-    if (!o.ok)
-      throw new Error(`OpenAI API error: ${o.statusText}`);
-    return ((c = (i = (await o.json()).choices[0]) == null ? void 0 : i.message) == null ? void 0 : c.content) || "";
+    if (!i.ok)
+      throw new Error(`OpenAI API error: ${i.statusText}`);
+    return ((l = (c = (await i.json()).choices[0]) == null ? void 0 : c.message) == null ? void 0 : l.content) || "";
   }
   /**
    * Call Anthropic API
    */
-  async callAnthropic(e, n, a, t, r) {
-    var i;
-    const o = await fetch("https://api.anthropic.com/v1/messages", {
+  async callAnthropic(e, t, n, o, a) {
+    var c;
+    const i = await fetch("https://api.anthropic.com/v1/messages", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "x-api-key": n,
+        "x-api-key": t,
         "anthropic-version": "2023-06-01"
       },
       body: JSON.stringify({
-        model: a,
-        max_tokens: t,
-        temperature: r,
+        model: n,
+        max_tokens: o,
+        temperature: a,
         messages: [{ role: "user", content: e }]
       })
     });
-    if (!o.ok)
-      throw new Error(`Anthropic API error: ${o.statusText}`);
-    return ((i = (await o.json()).content[0]) == null ? void 0 : i.text) || "";
+    if (!i.ok)
+      throw new Error(`Anthropic API error: ${i.statusText}`);
+    return ((c = (await i.json()).content[0]) == null ? void 0 : c.text) || "";
   }
   /**
    * Call custom API
    */
-  async callCustomAPI(e, n, a) {
-    const t = {
+  async callCustomAPI(e, t, n) {
+    const o = {
       "Content-Type": "application/json"
     };
-    a && (t.Authorization = `Bearer ${a}`);
-    const r = await fetch(n, {
+    n && (o.Authorization = `Bearer ${n}`);
+    const a = await fetch(t, {
       method: "POST",
-      headers: t,
+      headers: o,
       body: JSON.stringify({ prompt: e })
     });
-    if (!r.ok)
-      throw new Error(`Custom API error: ${r.statusText}`);
-    const o = await r.json();
-    return o.response || o.answer || JSON.stringify(o);
+    if (!a.ok)
+      throw new Error(`Custom API error: ${a.statusText}`);
+    const i = await a.json();
+    return i.response || i.answer || JSON.stringify(i);
   }
   /**
    * Parse LLM response
    */
-  parseResponse(e, n, a) {
+  parseResponse(e, t, n) {
     try {
-      const t = JSON.parse(e);
+      const o = JSON.parse(e);
       return {
         questionId: this.generateId(),
-        text: t.answer || t.text || e,
+        text: o.answer || o.text || e,
         timestamp: /* @__PURE__ */ new Date(),
-        confidence: t.confidence || 0.8,
-        cannotAnswer: t.cannotAnswer || !1,
-        isApproximate: t.isApproximate !== void 0 ? t.isApproximate : a,
-        supportingData: t.supportingData,
-        reason: t.reason
+        confidence: o.confidence || 0.8,
+        cannotAnswer: o.cannotAnswer || !1,
+        isApproximate: o.isApproximate !== void 0 ? o.isApproximate : n,
+        supportingData: o.supportingData,
+        reason: o.reason
       };
     } catch {
       return {
@@ -430,7 +431,7 @@ Please add your API key in the AI Chatbot Configuration section for advanced fea
         text: e,
         timestamp: /* @__PURE__ */ new Date(),
         confidence: 0.7,
-        isApproximate: a
+        isApproximate: n
       };
     }
   }
@@ -441,239 +442,239 @@ Please add your API key in the AI Chatbot Configuration section for advanced fea
     return `qa_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
   }
 }
-function oe(l = {}) {
+function xe(s = {}) {
   const {
     selector: e = "table",
-    includeHeaders: n = !0,
-    maxRows: a,
-    inferTypes: t = !0,
-    skipEmptyRows: r = !0
-  } = l, o = document.querySelector(e);
-  if (!o || o.tagName !== "TABLE")
+    includeHeaders: t = !0,
+    maxRows: n,
+    inferTypes: o = !0,
+    skipEmptyRows: a = !0
+  } = s, i = document.querySelector(e);
+  if (!i || i.tagName !== "TABLE")
     return console.warn(`No table found with selector: ${e}`), null;
-  const i = Array.from(o.rows);
-  if (i.length === 0)
+  const c = Array.from(i.rows);
+  if (c.length === 0)
     return null;
-  let c = [], f = 0;
-  if (n && i[0]) {
-    const b = i[0];
-    c = Array.from(b.cells).map((P, $) => {
-      var x;
-      return ((x = P.textContent) == null ? void 0 : x.trim()) || "" || `Column${$ + 1}`;
-    }), f = 1;
+  let l = [], u = 0;
+  if (t && c[0]) {
+    const h = c[0];
+    l = Array.from(h.cells).map((p, w) => {
+      var S;
+      return ((S = p.textContent) == null ? void 0 : S.trim()) || "" || `Column${w + 1}`;
+    }), u = 1;
   } else {
-    const b = i[0];
-    c = Array.from(b.cells).map((P, $) => `Column${$ + 1}`);
-  }
-  const m = [], d = a ? i.slice(f, f + a) : i.slice(f);
-  for (const b of d) {
-    const P = Array.from(b.cells);
-    if (r && P.every((D) => {
-      var x;
-      return !((x = D.textContent) != null && x.trim());
+    const h = c[0];
+    l = Array.from(h.cells).map((p, w) => `Column${w + 1}`);
+  }
+  const m = [], d = n ? c.slice(u, u + n) : c.slice(u);
+  for (const h of d) {
+    const p = Array.from(h.cells);
+    if (a && p.every((g) => {
+      var S;
+      return !((S = g.textContent) != null && S.trim());
     }))
       continue;
-    const $ = {};
-    P.forEach((D, x) => {
-      var Q;
-      const z = c[x] || `Column${x + 1}`;
-      let E = ((Q = D.textContent) == null ? void 0 : Q.trim()) || "";
-      if (t && E) {
-        const M = parseFloat(E);
-        !isNaN(M) && E === M.toString() && (E = M);
+    const w = {};
+    p.forEach((g, S) => {
+      var E;
+      const O = l[S] || `Column${S + 1}`;
+      let q = ((E = g.textContent) == null ? void 0 : E.trim()) || "";
+      if (o && q) {
+        const z = parseFloat(q);
+        !isNaN(z) && q === z.toString() && (q = z);
       }
-      $[z] = E;
-    }), m.push($);
+      w[O] = q;
+    }), m.push(w);
   }
   return {
-    schema: t && m.length > 0 ? N(m, "Extracted Table") : le(c, m.length),
+    schema: o && m.length > 0 ? _(m, "Extracted Table") : Pe(l, m.length),
     data: m,
     source: "dom",
     metadata: {
       selector: e,
       rowCount: m.length,
-      columnCount: c.length,
+      columnCount: l.length,
       extractedAt: /* @__PURE__ */ new Date()
     }
   };
 }
-function ie(l, e, n = {}) {
-  const { maxRows: a, inferTypes: t = !0 } = n, r = a ? l.slice(0, a) : l;
-  let o;
-  return e && e.length > 0 ? o = {
+function qe(s, e, t = {}) {
+  const { maxRows: n, inferTypes: o = !0 } = t, a = n ? s.slice(0, n) : s;
+  let i;
+  return e && e.length > 0 ? i = {
     name: "Vue Data Grid",
-    columns: e.map((s) => ({
-      name: s.field,
-      type: t && r.length > 0 ? L(r, s.field) : "string",
+    columns: e.map((r) => ({
+      name: r.field,
+      type: o && a.length > 0 ? oe(a, r.field) : "string",
       nullable: !0
     })),
-    rowCount: r.length
-  } : r.length > 0 ? o = N(r, "Vue Data Grid") : o = { name: "Vue Data Grid", columns: [], rowCount: 0 }, {
-    schema: o,
-    data: r,
+    rowCount: a.length
+  } : a.length > 0 ? i = _(a, "Vue Data Grid") : i = { name: "Vue Data Grid", columns: [], rowCount: 0 }, {
+    schema: i,
+    data: a,
     source: "vue",
     metadata: {
-      rowCount: r.length,
-      columnCount: o.columns.length,
+      rowCount: a.length,
+      columnCount: i.columns.length,
       extractedAt: /* @__PURE__ */ new Date()
     }
   };
 }
-function le(l, e = 0) {
+function Pe(s, e = 0) {
   return {
     name: "Extracted Table",
-    columns: l.map((n) => ({
-      name: n,
+    columns: s.map((t) => ({
+      name: t,
       type: "string",
       nullable: !0
     })),
     rowCount: e
   };
 }
-function ce(l) {
+function Te(s) {
   const e = {};
-  l.variable && l.variable.forEach((r) => {
-    e[r.key] = r.value;
+  s.variable && s.variable.forEach((a) => {
+    e[a.key] = a.value;
   });
-  const n = l.auth ? K(l.auth) : void 0, a = [];
-  function t(r, o = "") {
-    r.forEach((s) => {
-      s.item ? t(s.item, o ? `${o}/${s.name}` : s.name) : s.request && a.push(ue(s, n));
+  const t = s.auth ? re(s.auth) : void 0, n = [];
+  function o(a, i = "") {
+    a.forEach((r) => {
+      r.item ? o(r.item, i ? `${i}/${r.name}` : r.name) : r.request && n.push(De(r, t));
     });
   }
-  return t(l.item), {
-    name: l.info.name,
-    description: l.info.description,
-    endpoints: a,
+  return o(s.item), {
+    name: s.info.name,
+    description: s.info.description,
+    endpoints: n,
     variables: e,
-    auth: n
+    auth: t
   };
 }
-function ue(l, e) {
-  const n = l.request, a = {};
-  n.header && n.header.forEach((o) => {
-    a[o.key] = o.value;
+function De(s, e) {
+  const t = s.request, n = {};
+  t.header && t.header.forEach((i) => {
+    n[i.key] = i.value;
   });
-  const t = {};
-  n.url.query && n.url.query.forEach((o) => {
-    t[o.key] = o.value;
+  const o = {};
+  t.url.query && t.url.query.forEach((i) => {
+    o[i.key] = i.value;
   });
-  const r = n.auth ? K(n.auth) : e;
+  const a = t.auth ? re(t.auth) : e;
   return {
-    name: l.name,
-    method: n.method,
-    url: n.url.raw,
-    description: n.description,
-    headers: a,
-    queryParams: t,
-    auth: r
+    name: s.name,
+    method: t.method,
+    url: t.url.raw,
+    description: t.description,
+    headers: n,
+    queryParams: o,
+    auth: a
   };
 }
-function K(l) {
+function re(s) {
   const e = {};
-  return l.apikey ? l.apikey.forEach((n) => {
-    e[n.key] = n.value;
-  }) : l.bearer ? l.bearer.forEach((n) => {
-    e[n.key] = n.value;
-  }) : l.basic && l.basic.forEach((n) => {
-    e[n.key] = n.value;
+  return s.apikey ? s.apikey.forEach((t) => {
+    e[t.key] = t.value;
+  }) : s.bearer ? s.bearer.forEach((t) => {
+    e[t.key] = t.value;
+  }) : s.basic && s.basic.forEach((t) => {
+    e[t.key] = t.value;
   }), {
-    type: l.type,
+    type: s.type,
     credentials: e
   };
 }
-function T(l, e) {
-  let n = l;
-  return Object.keys(e).forEach((a) => {
-    const t = new RegExp(`{{${a}}}`, "g");
-    n = n.replace(t, e[a]);
-  }), n;
+function D(s, e) {
+  let t = s;
+  return Object.keys(e).forEach((n) => {
+    const o = new RegExp(`{{${n}}}`, "g");
+    t = t.replace(o, e[n]);
+  }), t;
 }
-async function W(l) {
-  const { endpoint: e, variables: n = {}, additionalHeaders: a = {}, additionalParams: t = {} } = l;
+async function ie(s) {
+  const { endpoint: e, variables: t = {}, additionalHeaders: n = {}, additionalParams: o = {} } = s;
   try {
-    let r = T(e.url, n);
-    const o = { ...e.queryParams, ...n, ...t }, s = Object.keys(o).filter((d) => o[d] !== void 0 && o[d] !== "").map((d) => `${encodeURIComponent(d)}=${encodeURIComponent(T(String(o[d]), n))}`).join("&");
-    s && (r = r.includes("?") ? `${r}&${s}` : `${r}?${s}`);
-    const i = {
+    let a = D(e.url, t);
+    const i = { ...e.queryParams, ...t, ...o }, r = Object.keys(i).filter((d) => i[d] !== void 0 && i[d] !== "").map((d) => `${encodeURIComponent(d)}=${encodeURIComponent(D(String(i[d]), t))}`).join("&");
+    r && (a = a.includes("?") ? `${a}&${r}` : `${a}?${r}`);
+    const c = {
       "Content-Type": "application/json",
       ...e.headers,
-      ...a
+      ...n
     };
-    if (Object.keys(i).forEach((d) => {
-      i[d] = T(i[d], n);
+    if (Object.keys(c).forEach((d) => {
+      c[d] = D(c[d], t);
     }), e.auth) {
       if (e.auth.type === "apikey") {
-        const d = e.auth.credentials.key || "access_key", w = T(e.auth.credentials.value || "", n);
-        e.auth.credentials.in === "header" && (i[d] = w);
+        const d = e.auth.credentials.key || "access_key", f = D(e.auth.credentials.value || "", t);
+        e.auth.credentials.in === "header" && (c[d] = f);
       } else if (e.auth.type === "bearer") {
-        const d = T(e.auth.credentials.token || "", n);
-        i.Authorization = `Bearer ${d}`;
+        const d = D(e.auth.credentials.token || "", t);
+        c.Authorization = `Bearer ${d}`;
       } else if (e.auth.type === "basic") {
-        const d = T(e.auth.credentials.username || "", n), w = T(e.auth.credentials.password || "", n), b = btoa(`${d}:${w}`);
-        i.Authorization = `Basic ${b}`;
+        const d = D(e.auth.credentials.username || "", t), f = D(e.auth.credentials.password || "", t), h = btoa(`${d}:${f}`);
+        c.Authorization = `Basic ${h}`;
       }
     }
-    const c = await fetch(r, {
+    const l = await fetch(a, {
       method: e.method,
-      headers: i
-    }), f = {};
-    return c.headers.forEach((d, w) => {
-      f[w] = d;
-    }), c.ok ? {
+      headers: c
+    }), u = {};
+    return l.headers.forEach((d, f) => {
+      u[f] = d;
+    }), l.ok ? {
       success: !0,
-      data: await c.json(),
-      statusCode: c.status,
-      headers: f
+      data: await l.json(),
+      statusCode: l.status,
+      headers: u
     } : {
       success: !1,
-      error: `HTTP ${c.status}: ${c.statusText}`,
-      statusCode: c.status,
-      headers: f
+      error: `HTTP ${l.status}: ${l.statusText}`,
+      statusCode: l.status,
+      headers: u
     };
-  } catch (r) {
+  } catch (a) {
     return {
       success: !1,
-      error: r.message || "Unknown error occurred"
+      error: a.message || "Unknown error occurred"
     };
   }
 }
-async function Ge(l, e = {}) {
-  const n = [];
-  for (const a of l) {
-    const t = await W({ endpoint: a, variables: e });
-    n.push(t);
+async function Nn(s, e = {}) {
+  const t = [];
+  for (const n of s) {
+    const o = await ie({ endpoint: n, variables: e });
+    t.push(o);
   }
-  return n;
+  return t;
 }
-function de(l) {
-  if (!l.success || !l.data)
+function _e(s) {
+  if (!s.success || !s.data)
     return [];
-  const e = l.data;
+  const e = s.data;
   return Array.isArray(e) ? e : e.data && Array.isArray(e.data) ? e.data : e.results && Array.isArray(e.results) ? e.results : e.items && Array.isArray(e.items) ? e.items : typeof e == "object" ? [e] : [];
 }
-class he {
-  constructor(e, n) {
+class ce {
+  constructor(e, t) {
     this.config = {
       timeout: 3e4,
       ...e
-    }, n && (this.qaEngine = new U(n));
+    }, t && (this.qaEngine = new te(t));
   }
   /**
    * Initialize or update Q&A engine
    */
   initializeQA(e) {
-    this.qaEngine = new U(e);
+    this.qaEngine = new te(e);
   }
   /**
    * Generic API call to TFM endpoint
    */
   async callTFM(e) {
-    const n = Date.now();
+    const t = Date.now();
     try {
-      let a = this.config.baseUrl;
-      this.config.useCorsProxy && this.config.corsProxyUrl && (this.config.corsProxyUrl.includes("?") ? a = this.config.corsProxyUrl + encodeURIComponent(a) : a = (this.config.corsProxyUrl.endsWith("/") ? this.config.corsProxyUrl : this.config.corsProxyUrl + "/") + a, console.log("Using CORS proxy for TFM API call:", this.config.corsProxyUrl), console.log("Proxied URL:", a));
-      const t = await fetch(a, {
+      let n = this.config.baseUrl;
+      this.config.useCorsProxy && this.config.corsProxyUrl && (this.config.corsProxyUrl.includes("?") ? n = this.config.corsProxyUrl + encodeURIComponent(n) : n = (this.config.corsProxyUrl.endsWith("/") ? this.config.corsProxyUrl : this.config.corsProxyUrl + "/") + n, console.log("Using CORS proxy for TFM API call:", this.config.corsProxyUrl), console.log("Proxied URL:", n));
+      const o = await fetch(n, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -686,26 +687,26 @@ class he {
         }),
         signal: AbortSignal.timeout(this.config.timeout || 3e4)
       });
-      if (!t.ok) {
-        const s = await t.text();
-        throw new Error(`TFM API error: ${t.status} - ${s}`);
+      if (!o.ok) {
+        const r = await o.text();
+        throw new Error(`TFM API error: ${o.status} - ${r}`);
       }
-      const r = await t.json(), o = Date.now() - n;
+      const a = await o.json(), i = Date.now() - t;
       return {
         success: !0,
-        result: r.result || r,
+        result: a.result || a,
         metadata: {
-          processingTime: o,
+          processingTime: i,
           model: this.config.model || "unknown",
-          version: r.version
+          version: a.version
         }
       };
-    } catch (a) {
+    } catch (n) {
       return {
         success: !1,
-        error: a instanceof Error ? a.message : "Unknown error",
+        error: n instanceof Error ? n.message : "Unknown error",
         metadata: {
-          processingTime: Date.now() - n,
+          processingTime: Date.now() - t,
           model: this.config.model || "unknown"
         }
       };
@@ -715,68 +716,68 @@ class he {
    * Perform analysis on tabular data
    */
   async analyze(e) {
-    const n = {
+    const t = {
       operation: e.type,
       data: e.data,
       schema: e.schema,
       parameters: e.options
-    }, a = await this.callTFM(n);
-    if (!a.success)
-      throw new Error(a.error || "Analysis failed");
-    return this.parseAnalysisResult(e.type, a.result, a.metadata);
+    }, n = await this.callTFM(t);
+    if (!n.success)
+      throw new Error(n.error || "Analysis failed");
+    return this.parseAnalysisResult(e.type, n.result, n.metadata);
   }
   /**
    * Parse TFM response into structured AnalysisResult
    */
-  parseAnalysisResult(e, n, a) {
-    const t = {
+  parseAnalysisResult(e, t, n) {
+    const o = {
       type: e,
       timestamp: /* @__PURE__ */ new Date(),
-      summary: n.summary || "",
-      insights: n.insights || [],
-      recommendations: n.recommendations,
-      confidence: n.confidence || 0.8,
-      processingTime: a == null ? void 0 : a.processingTime
+      summary: t.summary || "",
+      insights: t.insights || [],
+      recommendations: t.recommendations,
+      confidence: t.confidence || 0.8,
+      processingTime: n == null ? void 0 : n.processingTime
     };
     switch (e) {
       case "descriptive_stats":
         return {
-          ...t,
-          descriptiveStats: n.stats || n.descriptiveStats
+          ...o,
+          descriptiveStats: t.stats || t.descriptiveStats
         };
       case "anomaly_detection":
         return {
-          ...t,
-          anomalies: n.anomalies || []
+          ...o,
+          anomalies: t.anomalies || []
         };
       case "segmentation":
       case "clustering":
         return {
-          ...t,
-          clusters: n.clusters || []
+          ...o,
+          clusters: t.clusters || []
         };
       case "prediction":
         return {
-          ...t,
-          predictions: n.predictions || n
+          ...o,
+          predictions: t.predictions || t
         };
       case "correlation":
         return {
-          ...t,
-          correlations: n.correlations || n
+          ...o,
+          correlations: t.correlations || t
         };
       case "summary":
         return {
-          ...t,
-          aiSummary: n.summary || n
+          ...o,
+          aiSummary: t.summary || t
         };
       case "qa":
         return {
-          ...t,
-          qaAnswer: n.answer || n
+          ...o,
+          qaAnswer: t.answer || t
         };
       default:
-        return t;
+        return o;
     }
   }
   /**
@@ -790,27 +791,27 @@ class he {
   /**
    * Generate AI summary of table data
    */
-  async generateSummary(e, n) {
-    const a = {
+  async generateSummary(e, t) {
+    const n = {
       type: "summary",
       data: e,
-      schema: n
-    }, t = await this.analyze(a);
-    if (!t.aiSummary)
+      schema: t
+    }, o = await this.analyze(n);
+    if (!o.aiSummary)
       throw new Error("Failed to generate summary");
-    return t.aiSummary;
+    return o.aiSummary;
   }
   /**
    * Extract table from DOM
    */
   extractFromDOM(e) {
-    return oe(e);
+    return xe(e);
   }
   /**
    * Normalize Vue data grid data
    */
-  normalizeVueData(e, n, a) {
-    return ie(e, n, a);
+  normalizeVueData(e, t, n) {
+    return qe(e, t, n);
   }
   /**
    * Update configuration
@@ -822,8 +823,8 @@ class he {
    * Get current configuration (without sensitive data)
    */
   getConfig() {
-    const { apiKey: e, ...n } = this.config;
-    return n;
+    const { apiKey: e, ...t } = this.config;
+    return t;
   }
   // ============================================================================
   // API Integration Methods
@@ -832,7 +833,7 @@ class he {
    * Load Postman collection
    */
   loadPostmanCollection(e) {
-    return this.parsedCollection = ce(e), this.parsedCollection;
+    return this.parsedCollection = Te(e), this.parsedCollection;
   }
   /**
    * Get loaded collection
@@ -850,20 +851,20 @@ class he {
   /**
    * Execute API request and get data
    */
-  async fetchDataFromAPI(e, n) {
+  async fetchDataFromAPI(e, t) {
     if (!this.parsedCollection)
       throw new Error("No Postman collection loaded. Call loadPostmanCollection() first.");
-    const a = this.parsedCollection.endpoints.find((i) => i.name === e);
-    if (!a)
+    const n = this.parsedCollection.endpoints.find((c) => c.name === e);
+    if (!n)
       throw new Error(`Endpoint "${e}" not found in collection.`);
-    const t = {
+    const o = {
       ...this.parsedCollection.variables,
-      ...n
-    }, r = await W({ endpoint: a, variables: t });
-    if (!r.success)
-      throw new Error(`API request failed: ${r.error}`);
-    const o = de(r), s = N(o);
-    return { data: o, schema: s };
+      ...t
+    }, a = await ie({ endpoint: n, variables: o });
+    if (!a.success)
+      throw new Error(`API request failed: ${a.error}`);
+    const i = _e(a), r = _(i);
+    return { data: i, schema: r };
   }
   /**
    * Query API data with natural language
@@ -871,19 +872,19 @@ class he {
   async queryAPI(e) {
     if (!this.qaEngine)
       throw new Error("Q&A engine not initialized. Provide qaConfig in constructor or call initializeQA().");
-    const n = Date.now(), { data: a, schema: t } = await this.fetchDataFromAPI(
+    const t = Date.now(), { data: n, schema: o } = await this.fetchDataFromAPI(
       e.dataSource.endpoint || "",
       e.variables
-    ), r = {
+    ), a = {
       question: e.question,
-      schema: t,
-      data: a
-    }, o = await this.qaEngine.answerQuestion(r), s = Date.now() - n;
+      schema: o,
+      data: n
+    }, i = await this.qaEngine.answerQuestion(a), r = Date.now() - t;
     return {
-      answer: o.answer,
-      apiResponse: a,
+      answer: i.answer,
+      apiResponse: n,
       endpoint: e.dataSource.endpoint,
-      executionTime: s
+      executionTime: r
     };
   }
   /**
@@ -897,206 +898,206 @@ class he {
     })) : [];
   }
 }
-function Ye(l) {
-  const e = new he(l.config, l.qaConfig), n = q(!1), a = q(null), t = q(null), r = l.data || q([]), o = l.schema || q(null), s = q([]), i = q([]), c = q(null), f = l.maxQuestionHistory || 50, m = l.useLocalFallback !== !1;
-  async function d(u, h) {
-    n.value = !0, a.value = null;
+function Oe(s) {
+  const e = new ce(s.config, s.qaConfig), t = x(!1), n = x(null), o = x(null), a = s.data || x([]), i = s.schema || x(null), r = x([]), c = x([]), l = x(null), u = s.maxQuestionHistory || 50, m = s.useLocalFallback !== !1;
+  async function d(y, v) {
+    t.value = !0, n.value = null;
     try {
-      if (l.config.provider === "local" || m) {
+      if (s.config.provider === "local" || m) {
         console.log("🔧 Using local analysis (no API call)");
-        const A = w(u, h);
-        return t.value = A, A;
+        const k = f(y, v);
+        return o.value = k, k;
       }
       const I = {
-        type: u,
-        data: r.value,
-        schema: o.value || void 0,
-        options: h
-      }, k = await e.analyze(I);
-      return t.value = k, k;
+        type: y,
+        data: a.value,
+        schema: i.value || void 0,
+        options: v
+      }, $ = await e.analyze(I);
+      return o.value = $, $;
     } catch (I) {
-      if (a.value = I instanceof Error ? I : new Error("Analysis failed"), m)
-        return console.log("⚠️ API call failed, falling back to local analysis"), w(u, h);
-      throw a.value;
+      if (n.value = I instanceof Error ? I : new Error("Analysis failed"), m)
+        return console.log("⚠️ API call failed, falling back to local analysis"), f(y, v);
+      throw n.value;
     } finally {
-      n.value = !1;
+      t.value = !1;
     }
   }
-  function w(u, h) {
-    const I = o.value || N(r.value);
-    switch (u) {
+  function f(y, v) {
+    const I = i.value || _(a.value);
+    switch (y) {
       case "descriptive_stats": {
-        const k = I.columns.map(
-          (A) => B(r.value, A.name, A.type)
+        const $ = I.columns.map(
+          (k) => ae(a.value, k.name, k.type)
         );
         return {
-          type: u,
+          type: y,
           timestamp: /* @__PURE__ */ new Date(),
-          descriptiveStats: k,
-          summary: `Calculated statistics for ${k.length} columns`,
+          descriptiveStats: $,
+          summary: `Calculated statistics for ${$.length} columns`,
           insights: [],
           confidence: 0.9
         };
       }
       case "anomaly_detection": {
-        const k = I.columns.filter((v) => v.type === "number").map((v) => v.name), A = re(
-          r.value,
-          k,
-          h == null ? void 0 : h.sensitivity
+        const $ = I.columns.filter((N) => N.type === "number").map((N) => N.name), k = Me(
+          a.value,
+          $,
+          v == null ? void 0 : v.sensitivity
         );
         return {
-          type: u,
+          type: y,
           timestamp: /* @__PURE__ */ new Date(),
-          anomalies: A,
-          summary: `Found ${A.length} anomalies`,
-          insights: A.slice(0, 3).map((v) => v.reasons[0]),
+          anomalies: k,
+          summary: `Found ${k.length} anomalies`,
+          insights: k.slice(0, 3).map((N) => N.reasons[0]),
           confidence: 0.8
         };
       }
       case "clustering":
       case "segmentation": {
-        const k = (h == null ? void 0 : h.features) || I.columns.filter((S) => S.type === "number").map((S) => S.name), A = (h == null ? void 0 : h.numClusters) || 3, v = Array.from({ length: A }, (S, R) => ({
-          id: R,
-          label: `Cluster ${R + 1}`,
+        const $ = (v == null ? void 0 : v.features) || I.columns.filter((P) => P.type === "number").map((P) => P.name), k = (v == null ? void 0 : v.numClusters) || 3, N = Array.from({ length: k }, (P, L) => ({
+          id: L,
+          label: `Cluster ${L + 1}`,
           centroid: {},
-          size: Math.floor(r.value.length / A),
-          characteristics: [`Group ${R + 1} characteristics`]
+          size: Math.floor(a.value.length / k),
+          characteristics: [`Group ${L + 1} characteristics`]
         }));
         return {
-          type: u,
+          type: y,
           timestamp: /* @__PURE__ */ new Date(),
-          clusters: v,
-          summary: `Created ${A} clusters based on ${k.length} features`,
-          insights: [`Data segmented into ${A} distinct groups`],
+          clusters: N,
+          summary: `Created ${k} clusters based on ${$.length} features`,
+          insights: [`Data segmented into ${k} distinct groups`],
           confidence: 0.75
         };
       }
       case "correlation": {
-        const k = (h == null ? void 0 : h.features) || I.columns.filter((v) => v.type === "number").map((v) => v.name), A = {};
-        return k.forEach((v) => {
-          A[v] = {}, k.forEach((S) => {
-            A[v][S] = v === S ? 1 : Math.random() * 0.8 - 0.4;
+        const $ = (v == null ? void 0 : v.features) || I.columns.filter((N) => N.type === "number").map((N) => N.name), k = {};
+        return $.forEach((N) => {
+          k[N] = {}, $.forEach((P) => {
+            k[N][P] = N === P ? 1 : Math.random() * 0.8 - 0.4;
           });
         }), {
-          type: u,
+          type: y,
           timestamp: /* @__PURE__ */ new Date(),
-          correlations: A,
-          summary: `Calculated correlations for ${k.length} features`,
+          correlations: k,
+          summary: `Calculated correlations for ${$.length} features`,
           insights: ["Correlation matrix computed for numeric columns"],
           confidence: 0.85
         };
       }
       default:
-        throw new Error(`Local analysis not supported for type: ${u}`);
+        throw new Error(`Local analysis not supported for type: ${y}`);
     }
   }
-  async function b() {
+  async function h() {
     return (await d("descriptive_stats")).descriptiveStats || [];
   }
-  async function P(u, h) {
-    return (await d("anomaly_detection", { sensitivity: h, features: u })).anomalies || [];
+  async function p(y, v) {
+    return (await d("anomaly_detection", { sensitivity: v, features: y })).anomalies || [];
   }
-  async function $(u, h = 3) {
-    return d("clustering", { features: u, numClusters: h });
+  async function w(y, v = 3) {
+    return d("clustering", { features: y, numClusters: v });
   }
-  async function D(u, h) {
-    return d("prediction", { targetColumn: u, ...h });
+  async function g(y, v) {
+    return d("prediction", { targetColumn: y, ...v });
   }
-  function x(u) {
-    e.updateConfig(u);
+  function S(y) {
+    e.updateConfig(y);
   }
-  function z(u, h = !0) {
-    r.value = u, h && (o.value = N(u));
+  function O(y, v = !0) {
+    a.value = y, v && (i.value = _(y));
   }
-  function E() {
-    n.value = !1, a.value = null, t.value = null, s.value = [], i.value = [], c.value = null;
+  function q() {
+    t.value = !1, n.value = null, o.value = null, r.value = [], c.value = [], l.value = null;
   }
-  async function Q(u, h) {
-    n.value = !0, a.value = null;
+  async function E(y, v) {
+    t.value = !0, n.value = null;
     try {
-      if (!r.value || !Array.isArray(r.value) || r.value.length === 0)
+      if (!a.value || !Array.isArray(a.value) || a.value.length === 0)
         throw new Error("No data available. Please load data first.");
-      const I = o.value || N(r.value), k = {
-        question: u,
+      const I = i.value || _(a.value), $ = {
+        question: y,
         schema: I,
-        data: r.value,
+        data: a.value,
         sampleSize: 100,
         includeAggregates: !0,
-        ...h
-      }, v = (await e.askQuestion(k)).answer, S = {
-        id: v.questionId,
-        text: u,
+        ...v
+      }, N = (await e.askQuestion($)).answer, P = {
+        id: N.questionId,
+        text: y,
         timestamp: /* @__PURE__ */ new Date(),
         context: {
           tableSchema: I,
-          rowCount: r.value.length
+          rowCount: a.value.length
         }
       };
-      return s.value || (s.value = []), i.value || (i.value = []), s.value.push(S), i.value.push(v), c.value = v, s.value.length > f && (s.value.shift(), i.value.shift()), v;
+      return r.value || (r.value = []), c.value || (c.value = []), r.value.push(P), c.value.push(N), l.value = N, r.value.length > u && (r.value.shift(), c.value.shift()), N;
     } catch (I) {
-      throw a.value = I instanceof Error ? I : new Error("Q&A failed"), a.value;
+      throw n.value = I instanceof Error ? I : new Error("Q&A failed"), n.value;
     } finally {
-      n.value = !1;
+      t.value = !1;
     }
   }
-  async function M() {
-    n.value = !0, a.value = null;
+  async function z() {
+    t.value = !0, n.value = null;
     try {
-      const u = o.value || N(r.value);
-      return await e.generateSummary(r.value, u);
-    } catch (u) {
-      throw a.value = u instanceof Error ? u : new Error("Summary generation failed"), a.value;
+      const y = i.value || _(a.value);
+      return await e.generateSummary(a.value, y);
+    } catch (y) {
+      throw n.value = y instanceof Error ? y : new Error("Summary generation failed"), n.value;
     } finally {
-      n.value = !1;
+      t.value = !1;
     }
   }
-  function G() {
-    s.value = [], i.value = [], c.value = null;
+  function ve() {
+    r.value = [], c.value = [], l.value = null;
   }
-  function Y(u) {
-    const h = e.extractFromDOM(u);
-    return h && (r.value = h.data, o.value = h.schema), h;
+  function be(y) {
+    const v = e.extractFromDOM(y);
+    return v && (a.value = v.data, i.value = v.schema), v;
   }
-  function X(u, h, I) {
-    const k = e.normalizeVueData(u, h, I);
-    r.value = k.data, o.value = k.schema;
+  function Ce(y, v, I) {
+    const $ = e.normalizeVueData(y, v, I);
+    a.value = $.data, i.value = $.schema;
   }
-  function Z(u) {
-    e.initializeQA(u);
+  function Ae(y) {
+    e.initializeQA(y);
   }
   return {
     client: e,
-    loading: n,
-    error: a,
-    lastResult: t,
-    data: r,
-    schema: o,
-    questionHistory: s,
-    answerHistory: i,
-    lastAnswer: c,
+    loading: t,
+    error: n,
+    lastResult: o,
+    data: a,
+    schema: i,
+    questionHistory: r,
+    answerHistory: c,
+    lastAnswer: l,
     analyze: d,
-    getDescriptiveStats: b,
-    detectAnomalies: P,
-    performClustering: $,
-    predict: D,
-    askQuestion: Q,
-    generateSummary: M,
-    clearHistory: G,
-    extractFromDOM: Y,
-    loadFromVueGrid: X,
-    updateConfig: x,
-    initializeQA: Z,
-    setData: z,
-    reset: E
+    getDescriptiveStats: h,
+    detectAnomalies: p,
+    performClustering: w,
+    predict: g,
+    askQuestion: E,
+    generateSummary: z,
+    clearHistory: ve,
+    extractFromDOM: be,
+    loadFromVueGrid: Ce,
+    updateConfig: S,
+    initializeQA: Ae,
+    setData: O,
+    reset: q
   };
 }
-const me = { class: "ti-question-input" }, fe = { class: "ti-input-wrapper" }, pe = ["placeholder", "disabled", "onKeydown"], ye = ["disabled"], ge = { key: 0 }, we = {
+const Re = { class: "ti-question-input" }, ze = { class: "ti-input-wrapper" }, Ee = ["placeholder", "disabled", "onKeydown"], Ve = ["disabled"], Fe = { key: 0 }, je = {
   key: 1,
   class: "ti-loading"
-}, ve = {
+}, Qe = {
   key: 0,
   class: "ti-hint"
-}, Ae = /* @__PURE__ */ j({
+}, Je = /* @__PURE__ */ W({
   __name: "QuestionInput",
   props: {
     placeholder: { default: "Ask a question about this data..." },
@@ -1108,189 +1109,1923 @@ const me = { class: "ti-question-input" }, fe = { class: "ti-input-wrapper" }, p
     loading: { type: Boolean, default: !1 }
   },
   emits: ["submit"],
-  setup(l, { emit: e }) {
-    const n = l, a = e, t = q("");
-    function r() {
-      t.value.trim() && !n.disabled && !n.loading && (a("submit", t.value.trim()), t.value = "");
+  setup(s, { emit: e }) {
+    const t = s, n = e, o = x("");
+    function a() {
+      o.value.trim() && !t.disabled && !t.loading && (n("submit", o.value.trim()), o.value = "");
     }
-    function o(s) {
+    function i(r) {
     }
-    return (s, i) => (g(), y("div", me, [
-      p("div", fe, [
-        ee(p("textarea", {
-          "onUpdate:modelValue": i[0] || (i[0] = (c) => t.value = c),
-          placeholder: s.placeholder,
-          disabled: s.disabled,
+    return (r, c) => (A(), C("div", Re, [
+      b("div", ze, [
+        Se(b("textarea", {
+          "onUpdate:modelValue": c[0] || (c[0] = (l) => o.value = l),
+          placeholder: r.placeholder,
+          disabled: r.disabled,
           class: "ti-textarea",
           rows: "1",
           onKeydown: [
-            H(J(r, ["exact", "prevent"]), ["enter"]),
-            H(J(o, ["shift"]), ["enter"])
+            Z(ee(a, ["exact", "prevent"]), ["enter"]),
+            Z(ee(i, ["shift"]), ["enter"])
           ]
-        }, null, 40, pe), [
-          [te, t.value]
+        }, null, 40, Ee), [
+          [Ne, o.value]
         ]),
-        p("button", {
-          disabled: s.disabled || !t.value.trim(),
+        b("button", {
+          disabled: r.disabled || !o.value.trim(),
           class: "ti-submit-btn",
-          onClick: r
+          onClick: a
         }, [
-          s.loading ? (g(), y("span", we, C(s.loadingLabel), 1)) : (g(), y("span", ge, C(s.submitLabel), 1))
-        ], 8, ye)
+          r.loading ? (A(), C("span", je, M(r.loadingLabel), 1)) : (A(), C("span", Fe, M(r.submitLabel), 1))
+        ], 8, Ve)
       ]),
-      s.showHint ? (g(), y("div", ve, C(s.hint), 1)) : _("", !0)
+      r.showHint ? (A(), C("div", Qe, M(r.hint), 1)) : T("", !0)
     ]));
   }
-}), V = (l, e) => {
-  const n = l.__vccOpts || l;
-  for (const [a, t] of e)
-    n[a] = t;
-  return n;
-}, Xe = /* @__PURE__ */ V(Ae, [["__scopeId", "data-v-f96008f3"]]), be = { class: "ti-answer-header" }, Ie = { class: "ti-answer-icon" }, ke = { key: 0 }, Ce = { key: 1 }, Pe = { class: "ti-answer-meta" }, $e = { class: "ti-confidence" }, xe = { class: "ti-timestamp" }, qe = { class: "ti-answer-text" }, Se = {
+}), X = (s, e) => {
+  const t = s.__vccOpts || s;
+  for (const [n, o] of e)
+    t[n] = o;
+  return t;
+}, le = /* @__PURE__ */ X(Je, [["__scopeId", "data-v-f96008f3"]]), He = { class: "ti-answer-header" }, Be = { class: "ti-answer-icon" }, Le = { key: 0 }, Ue = { key: 1 }, Ke = { class: "ti-answer-meta" }, Ge = { class: "ti-confidence" }, We = { class: "ti-timestamp" }, Xe = { class: "ti-answer-text" }, Ye = {
   key: 0,
   class: "ti-approximate-notice"
-}, _e = {
+}, Ze = {
   key: 1,
   class: "ti-reason"
-}, De = {
+}, et = {
   key: 2,
   class: "ti-supporting-data"
-}, Ee = {
+}, tt = {
   key: 0,
   class: "ti-supporting-content"
-}, Te = {
+}, nt = {
   key: 0,
   class: "ti-aggregates"
-}, Ne = {
+}, st = {
   key: 1,
   class: "ti-rows"
-}, Me = { class: "ti-table-wrapper" }, Qe = { class: "ti-table" }, Fe = /* @__PURE__ */ j({
+}, ot = { class: "ti-table-wrapper" }, at = { class: "ti-table" }, rt = /* @__PURE__ */ W({
   __name: "AnswerDisplay",
   props: {
     answer: {}
   },
-  setup(l) {
-    const e = q(!1);
-    function n(a) {
-      return new Date(a).toLocaleTimeString();
+  setup(s) {
+    const e = x(!1);
+    function t(n) {
+      return new Date(n).toLocaleTimeString();
     }
-    return (a, t) => (g(), y("div", {
-      class: ne(["ti-answer-display", { "ti-cannot-answer": a.answer.cannotAnswer }])
+    return (n, o) => (A(), C("div", {
+      class: ke(["ti-answer-display", { "ti-cannot-answer": n.answer.cannotAnswer }])
     }, [
-      p("div", be, [
-        p("div", Ie, [
-          a.answer.cannotAnswer ? (g(), y("span", Ce, "⚠️")) : (g(), y("span", ke, "💡"))
+      b("div", He, [
+        b("div", Be, [
+          n.answer.cannotAnswer ? (A(), C("span", Ue, "⚠️")) : (A(), C("span", Le, "💡"))
         ]),
-        p("div", Pe, [
-          p("div", $e, " Confidence: " + C(Math.round(a.answer.confidence * 100)) + "% ", 1),
-          p("div", xe, C(n(a.answer.timestamp)), 1)
+        b("div", Ke, [
+          b("div", Ge, " Confidence: " + M(Math.round(n.answer.confidence * 100)) + "% ", 1),
+          b("div", We, M(t(n.answer.timestamp)), 1)
         ])
       ]),
-      p("div", qe, C(a.answer.text), 1),
-      a.answer.isApproximate ? (g(), y("div", Se, " ℹ️ This answer is based on sampled data and may be approximate. ")) : _("", !0),
-      a.answer.reason && a.answer.cannotAnswer ? (g(), y("div", _e, [
-        t[1] || (t[1] = p("strong", null, "Reason:", -1)),
-        ae(" " + C(a.answer.reason), 1)
-      ])) : _("", !0),
-      a.answer.supportingData ? (g(), y("div", De, [
-        p("button", {
+      b("div", Xe, M(n.answer.text), 1),
+      n.answer.isApproximate ? (A(), C("div", Ye, " ℹ️ This answer is based on sampled data and may be approximate. ")) : T("", !0),
+      n.answer.reason && n.answer.cannotAnswer ? (A(), C("div", Ze, [
+        o[1] || (o[1] = b("strong", null, "Reason:", -1)),
+        Ie(" " + M(n.answer.reason), 1)
+      ])) : T("", !0),
+      n.answer.supportingData ? (A(), C("div", et, [
+        b("button", {
           class: "ti-toggle-btn",
-          onClick: t[0] || (t[0] = (r) => e.value = !e.value)
-        }, C(e.value ? "▼" : "▶") + " Supporting Data ", 1),
-        e.value ? (g(), y("div", Ee, [
-          a.answer.supportingData.aggregates ? (g(), y("div", Te, [
-            t[2] || (t[2] = p("h4", null, "Aggregates:", -1)),
-            p("pre", null, C(JSON.stringify(a.answer.supportingData.aggregates, null, 2)), 1)
-          ])) : _("", !0),
-          a.answer.supportingData.rows && a.answer.supportingData.rows.length > 0 ? (g(), y("div", Ne, [
-            p("h4", null, "Sample Rows (" + C(a.answer.supportingData.rows.length) + "):", 1),
-            p("div", Me, [
-              p("table", Qe, [
-                p("thead", null, [
-                  p("tr", null, [
-                    (g(!0), y(F, null, O(Object.keys(a.answer.supportingData.rows[0]), (r, o) => (g(), y("th", { key: o }, C(r), 1))), 128))
+          onClick: o[0] || (o[0] = (a) => e.value = !e.value)
+        }, M(e.value ? "▼" : "▶") + " Supporting Data ", 1),
+        e.value ? (A(), C("div", tt, [
+          n.answer.supportingData.aggregates ? (A(), C("div", nt, [
+            o[2] || (o[2] = b("h4", null, "Aggregates:", -1)),
+            b("pre", null, M(JSON.stringify(n.answer.supportingData.aggregates, null, 2)), 1)
+          ])) : T("", !0),
+          n.answer.supportingData.rows && n.answer.supportingData.rows.length > 0 ? (A(), C("div", st, [
+            b("h4", null, "Sample Rows (" + M(n.answer.supportingData.rows.length) + "):", 1),
+            b("div", ot, [
+              b("table", at, [
+                b("thead", null, [
+                  b("tr", null, [
+                    (A(!0), C(j, null, Q(Object.keys(n.answer.supportingData.rows[0]), (a, i) => (A(), C("th", { key: i }, M(a), 1))), 128))
                   ])
                 ]),
-                p("tbody", null, [
-                  (g(!0), y(F, null, O(a.answer.supportingData.rows.slice(0, 5), (r, o) => (g(), y("tr", { key: o }, [
-                    (g(!0), y(F, null, O(Object.keys(r), (s, i) => (g(), y("td", { key: i }, C(r[s]), 1))), 128))
+                b("tbody", null, [
+                  (A(!0), C(j, null, Q(n.answer.supportingData.rows.slice(0, 5), (a, i) => (A(), C("tr", { key: i }, [
+                    (A(!0), C(j, null, Q(Object.keys(a), (r, c) => (A(), C("td", { key: c }, M(a[r]), 1))), 128))
                   ]))), 128))
                 ])
               ])
             ])
-          ])) : _("", !0)
-        ])) : _("", !0)
-      ])) : _("", !0)
+          ])) : T("", !0)
+        ])) : T("", !0)
+      ])) : T("", !0)
     ], 2));
   }
-}), Ze = /* @__PURE__ */ V(Fe, [["__scopeId", "data-v-d1aaae1d"]]), Oe = { class: "ti-question-history" }, ze = { class: "ti-history-header" }, Re = {
+}), ue = /* @__PURE__ */ X(rt, [["__scopeId", "data-v-d1aaae1d"]]), it = { class: "ti-question-history" }, ct = { class: "ti-history-header" }, lt = {
   key: 0,
   class: "ti-empty-state"
-}, je = {
+}, ut = {
   key: 1,
   class: "ti-history-list"
-}, Ve = ["onClick"], He = { class: "ti-question-header" }, Je = { class: "ti-question-number" }, Ue = { class: "ti-question-time" }, Le = { class: "ti-question-text" }, Be = {
+}, mt = ["onClick"], dt = { class: "ti-question-header" }, ft = { class: "ti-question-number" }, ht = { class: "ti-question-time" }, pt = { class: "ti-question-text" }, gt = {
   key: 0,
   class: "ti-question-context"
-}, Ke = /* @__PURE__ */ j({
+}, yt = /* @__PURE__ */ W({
   __name: "QuestionHistory",
   props: {
     questions: {}
   },
   emits: ["clear", "select"],
-  setup(l, { emit: e }) {
-    const n = l, a = se(() => [...n.questions].reverse());
-    function t(r) {
-      const o = new Date(r), i = (/* @__PURE__ */ new Date()).getTime() - o.getTime(), c = Math.floor(i / 6e4), f = Math.floor(i / 36e5), m = Math.floor(i / 864e5);
-      return c < 1 ? "Just now" : c < 60 ? `${c}m ago` : f < 24 ? `${f}h ago` : `${m}d ago`;
+  setup(s, { emit: e }) {
+    const t = s, n = $e(() => [...t.questions].reverse());
+    function o(a) {
+      const i = new Date(a), c = (/* @__PURE__ */ new Date()).getTime() - i.getTime(), l = Math.floor(c / 6e4), u = Math.floor(c / 36e5), m = Math.floor(c / 864e5);
+      return l < 1 ? "Just now" : l < 60 ? `${l}m ago` : u < 24 ? `${u}h ago` : `${m}d ago`;
     }
-    return (r, o) => (g(), y("div", Oe, [
-      p("div", ze, [
-        o[1] || (o[1] = p("h3", null, "Question History", -1)),
-        r.questions.length > 0 ? (g(), y("button", {
+    return (a, i) => (A(), C("div", it, [
+      b("div", ct, [
+        i[1] || (i[1] = b("h3", null, "Question History", -1)),
+        a.questions.length > 0 ? (A(), C("button", {
           key: 0,
           class: "ti-clear-btn",
-          onClick: o[0] || (o[0] = (s) => r.$emit("clear"))
-        }, " Clear History ")) : _("", !0)
+          onClick: i[0] || (i[0] = (r) => a.$emit("clear"))
+        }, " Clear History ")) : T("", !0)
       ]),
-      r.questions.length === 0 ? (g(), y("div", Re, o[2] || (o[2] = [
-        p("div", { class: "ti-empty-icon" }, "💬", -1),
-        p("p", null, "No questions asked yet", -1),
-        p("p", { class: "ti-empty-hint" }, "Ask a question about your data to get started", -1)
-      ]))) : (g(), y("div", je, [
-        (g(!0), y(F, null, O(a.value, (s, i) => (g(), y("div", {
-          key: s.id,
+      a.questions.length === 0 ? (A(), C("div", lt, i[2] || (i[2] = [
+        b("div", { class: "ti-empty-icon" }, "💬", -1),
+        b("p", null, "No questions asked yet", -1),
+        b("p", { class: "ti-empty-hint" }, "Ask a question about your data to get started", -1)
+      ]))) : (A(), C("div", ut, [
+        (A(!0), C(j, null, Q(n.value, (r, c) => (A(), C("div", {
+          key: r.id,
           class: "ti-history-item",
-          onClick: (c) => r.$emit("select", s)
+          onClick: (l) => a.$emit("select", r)
         }, [
-          p("div", He, [
-            p("span", Je, "#" + C(r.questions.length - i), 1),
-            p("span", Ue, C(t(s.timestamp)), 1)
+          b("div", dt, [
+            b("span", ft, "#" + M(a.questions.length - c), 1),
+            b("span", ht, M(o(r.timestamp)), 1)
           ]),
-          p("div", Le, C(s.text), 1),
-          s.context ? (g(), y("div", Be, C(s.context.rowCount) + " rows ", 1)) : _("", !0)
-        ], 8, Ve))), 128))
+          b("div", pt, M(r.text), 1),
+          r.context ? (A(), C("div", gt, M(r.context.rowCount) + " rows ", 1)) : T("", !0)
+        ], 8, mt))), 128))
       ]))
     ]));
   }
-}), et = /* @__PURE__ */ V(Ke, [["__scopeId", "data-v-c66393d9"]]);
+}), me = /* @__PURE__ */ X(yt, [["__scopeId", "data-v-c66393d9"]]);
+async function Y(s, e) {
+  if (!s || s.length === 0)
+    throw new Error("Cannot profile empty dataset");
+  const t = Object.keys(s[0]), n = [];
+  for (const u of t) {
+    const m = await wt(s, u);
+    n.push(m);
+  }
+  const o = n.filter((u) => u.type === "numeric").map((u) => u.name), a = Nt(s, o), i = It(s), r = $t(s), c = Mt(n, i.count), l = xt(n, i.percentage);
+  return {
+    overview: {
+      totalRows: s.length,
+      totalColumns: t.length,
+      memoryUsage: r,
+      duplicateRows: i.count,
+      duplicatePercentage: i.percentage
+    },
+    columns: n,
+    correlations: a,
+    warnings: c,
+    qualityScore: l
+  };
+}
+async function wt(s, e, t) {
+  const n = s.map((m) => m[e]), o = vt(n), a = n.filter((m) => m == null || m === "").length, i = a / n.length * 100, c = new Set(n.filter((m) => m != null && m !== "")).size, l = c / n.length * 100, u = {
+    name: e,
+    type: o,
+    missingCount: a,
+    missingPercentage: i,
+    uniqueCount: c,
+    uniquePercentage: l,
+    quality: {
+      score: 0,
+      issues: [],
+      recommendations: []
+    }
+  };
+  return o === "numeric" ? u.stats = bt(n) : o === "categorical" ? u.categories = Ct(n) : o === "datetime" && (u.dateRange = At(n)), u.quality = St(u), u;
+}
+function vt(s) {
+  const e = s.filter((a) => a != null && a !== "");
+  if (e.length === 0) return "text";
+  const t = new Set(e);
+  return t.size <= 2 && Array.from(t).every(
+    (a) => a === !0 || a === !1 || a === "true" || a === "false" || a === 0 || a === 1
+  ) ? "boolean" : e.filter((a) => !isNaN(Number(a))).length / e.length > 0.8 ? "numeric" : e.filter((a) => {
+    const i = new Date(a);
+    return !isNaN(i.getTime());
+  }).length / e.length > 0.8 ? "datetime" : t.size < e.length * 0.5 ? "categorical" : "text";
+}
+function bt(s) {
+  const e = s.filter((g) => g != null && g !== "").map((g) => Number(g)).filter((g) => !isNaN(g));
+  if (e.length === 0) return;
+  const t = [...e].sort((g, S) => g - S), n = e.reduce((g, S) => g + S, 0) / e.length, o = t[Math.floor(t.length / 2)], a = t[0], i = t[t.length - 1], r = e.reduce((g, S) => g + Math.pow(S - n, 2), 0) / e.length, c = Math.sqrt(r), l = t[Math.floor(t.length * 0.25)], u = t[Math.floor(t.length * 0.75)], m = u - l, d = l - 1.5 * m, f = u + 1.5 * m, h = e.filter((g) => g < d || g > f).length, p = e.reduce((g, S) => g + Math.pow((S - n) / c, 3), 0) / e.length, w = e.reduce((g, S) => g + Math.pow((S - n) / c, 4), 0) / e.length - 3;
+  return {
+    mean: n,
+    median: o,
+    std: c,
+    min: a,
+    max: i,
+    skewness: p,
+    kurtosis: w,
+    outliers: h,
+    q1: l,
+    q3: u,
+    iqr: m
+  };
+}
+function Ct(s) {
+  const e = s.filter((r) => r != null && r !== ""), t = /* @__PURE__ */ new Map();
+  for (const r of e)
+    t.set(r, (t.get(r) || 0) + 1);
+  const n = Array.from(t.entries()).sort((r, c) => c[1] - r[1]).slice(0, 10).map(([r, c]) => ({
+    value: r,
+    count: c,
+    percentage: c / e.length * 100
+  })), o = Array.from(t.values()).map((r) => {
+    const c = r / e.length;
+    return -c * Math.log2(c);
+  }).reduce((r, c) => r + c, 0), a = t.size / e.length;
+  let i;
+  return a < 0.1 ? i = "low" : a < 0.5 ? i = "medium" : i = "high", {
+    topValues: n,
+    cardinality: i,
+    entropy: o
+  };
+}
+function At(s) {
+  const e = s.filter((r) => r != null && r !== "").map((r) => new Date(r)).filter((r) => !isNaN(r.getTime())).sort((r, c) => r.getTime() - c.getTime());
+  if (e.length === 0) return;
+  const t = e[0], n = e[e.length - 1], o = n.getTime() - t.getTime(), a = Math.floor(o / (1e3 * 60 * 60 * 24));
+  let i;
+  return a < 7 ? i = `${a} days` : a < 365 ? i = `${Math.floor(a / 7)} weeks` : i = `${Math.floor(a / 365)} years`, {
+    earliest: t,
+    latest: n,
+    span: i
+  };
+}
+function St(s) {
+  const e = [], t = [];
+  let n = 100;
+  return s.missingPercentage > 50 ? (e.push(`High missing rate: ${s.missingPercentage.toFixed(1)}%`), t.push("Consider removing this column or imputing missing values"), n -= 30) : s.missingPercentage > 20 ? (e.push(`Moderate missing rate: ${s.missingPercentage.toFixed(1)}%`), t.push("Consider imputing missing values"), n -= 15) : s.missingPercentage > 5 && (e.push(`Some missing values: ${s.missingPercentage.toFixed(1)}%`), n -= 5), s.uniquePercentage === 100 && s.type !== "text" && (e.push("All values are unique - might be an ID column"), t.push("Consider if this column is useful for analysis")), s.uniqueCount === 1 && (e.push("Only one unique value - constant column"), t.push("Consider removing this column"), n -= 40), s.stats && (s.stats.outliers > s.missingCount * 0.1 && (e.push(`${s.stats.outliers} outliers detected`), t.push("Consider outlier treatment"), n -= 10), Math.abs(s.stats.skewness) > 2 && (e.push(`High skewness: ${s.stats.skewness.toFixed(2)}`), t.push("Consider log transformation"), n -= 5)), {
+    score: Math.max(0, n),
+    issues: e,
+    recommendations: t
+  };
+}
+function Nt(s, e) {
+  if (e.length < 2)
+    return {
+      columns: [],
+      matrix: [],
+      significant: []
+    };
+  const t = [], n = [];
+  for (let o = 0; o < e.length; o++) {
+    t[o] = [];
+    for (let a = 0; a < e.length; a++)
+      if (o === a)
+        t[o][a] = 1;
+      else {
+        const i = kt(
+          s.map((r) => Number(r[e[o]])),
+          s.map((r) => Number(r[e[a]]))
+        );
+        t[o][a] = i, o < a && Math.abs(i) > 0.7 && n.push({
+          col1: e[o],
+          col2: e[a],
+          correlation: i
+        });
+      }
+  }
+  return {
+    columns: e,
+    matrix: t,
+    significant: n
+  };
+}
+function kt(s, e) {
+  s.length;
+  const t = s.map((m, d) => [m, e[d]]).filter(([m, d]) => !isNaN(m) && !isNaN(d));
+  if (t.length < 2) return 0;
+  const n = t.map((m) => m[0]), o = t.map((m) => m[1]), a = n.reduce((m, d) => m + d, 0) / n.length, i = o.reduce((m, d) => m + d, 0) / o.length;
+  let r = 0, c = 0, l = 0;
+  for (let m = 0; m < n.length; m++) {
+    const d = n[m] - a, f = o[m] - i;
+    r += d * f, c += d * d, l += f * f;
+  }
+  const u = Math.sqrt(c * l);
+  return u === 0 ? 0 : r / u;
+}
+function It(s) {
+  const e = /* @__PURE__ */ new Set();
+  let t = 0;
+  for (const n of s) {
+    const o = JSON.stringify(n);
+    e.has(o) ? t++ : e.add(o);
+  }
+  return {
+    count: t,
+    percentage: t / s.length * 100
+  };
+}
+function $t(s) {
+  const e = JSON.stringify(s), t = new Blob([e]).size;
+  return t < 1024 ? `${t} B` : t < 1024 * 1024 ? `${(t / 1024).toFixed(2)} KB` : t < 1024 * 1024 * 1024 ? `${(t / (1024 * 1024)).toFixed(2)} MB` : `${(t / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function Mt(s, e) {
+  const t = [];
+  e > 10 && t.push(`High duplicate rate: ${e.toFixed(1)}% of rows are duplicates`);
+  const n = s.filter((a) => a.quality.score < 50);
+  n.length > 0 && t.push(`${n.length} columns have low quality scores`);
+  const o = s.filter((a) => a.missingPercentage > 50);
+  return o.length > 0 && t.push(`${o.length} columns have >50% missing values`), t;
+}
+function xt(s, e) {
+  const t = s.reduce((o, a) => o + a.quality.score, 0) / s.length, n = Math.min(e, 20);
+  return Math.max(0, t - n);
+}
+async function kn(s) {
+  const e = await Y(s), t = await de(s, e), n = 100 - e.columns.reduce((u, m) => u + m.missingPercentage, 0) / e.columns.length, o = 100 - e.overview.duplicatePercentage, a = e.columns.filter((u) => u.quality.score > 70).length / e.columns.length * 100, i = e.columns.filter((u) => u.quality.issues.length === 0).length / e.columns.length * 100, r = (n + a + i) / 3, c = (n + r + a + i + o) / 5, l = qt(t, e);
+  return {
+    overallScore: c,
+    dimensions: {
+      completeness: n,
+      accuracy: r,
+      consistency: a,
+      validity: i,
+      uniqueness: o
+    },
+    issues: t,
+    recommendations: l,
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+async function de(s, e) {
+  e || (e = await Y(s));
+  const t = [];
+  for (const n of e.columns)
+    n.missingPercentage > 20 && t.push({
+      severity: n.missingPercentage > 50 ? "critical" : "warning",
+      type: "missing_values",
+      column: n.name,
+      description: `${n.missingPercentage.toFixed(1)}% missing values in column "${n.name}"`,
+      affectedRows: n.missingCount,
+      suggestedFix: "Impute missing values using mean, median, or ML-based imputation"
+    }), n.stats && n.stats.outliers > 0 && t.push({
+      severity: "warning",
+      type: "outliers",
+      column: n.name,
+      description: `${n.stats.outliers} outliers detected in column "${n.name}"`,
+      affectedRows: n.stats.outliers,
+      suggestedFix: "Remove outliers or cap values using IQR method"
+    });
+  return e.overview.duplicateRows > 0 && t.push({
+    severity: e.overview.duplicatePercentage > 10 ? "critical" : "warning",
+    type: "duplicates",
+    description: `${e.overview.duplicateRows} duplicate rows found`,
+    affectedRows: e.overview.duplicateRows,
+    suggestedFix: "Remove duplicate rows or aggregate them"
+  }), t;
+}
+function qt(s, e) {
+  const t = [];
+  return s.filter((i) => i.type === "missing_values").length > 0 && t.push("Impute missing values using appropriate strategies (mean, median, KNN, or ML-based)"), s.filter((i) => i.type === "outliers").length > 0 && t.push("Handle outliers using IQR method, capping, or transformation"), s.filter((i) => i.type === "duplicates").length > 0 && t.push("Remove or aggregate duplicate rows"), e.qualityScore < 70 && t.push("Overall data quality is below acceptable threshold - consider data cleaning pipeline"), t;
+}
+async function In(s) {
+  const e = await Y(s);
+  await de(s, e);
+  const t = [], n = e.columns.filter((a) => a.missingPercentage > 5);
+  n.length > 0 && t.push({
+    priority: "high",
+    action: "Impute Missing Values",
+    description: `Impute missing values in ${n.length} columns`,
+    columns: n.map((a) => a.name),
+    estimatedImpact: `Will fill ${n.reduce((a, i) => a + i.missingCount, 0)} missing values`,
+    autoFixable: !0
+  });
+  const o = e.columns.filter((a) => a.stats && a.stats.outliers > 0);
+  return o.length > 0 && t.push({
+    priority: "medium",
+    action: "Handle Outliers",
+    description: `Treat outliers in ${o.length} numeric columns`,
+    columns: o.map((a) => a.name),
+    estimatedImpact: `Will handle ${o.reduce((a, i) => {
+      var r;
+      return a + (((r = i.stats) == null ? void 0 : r.outliers) || 0);
+    }, 0)} outliers`,
+    autoFixable: !0
+  }), e.overview.duplicateRows > 0 && t.push({
+    priority: "high",
+    action: "Remove Duplicates",
+    description: "Remove duplicate rows from dataset",
+    columns: [],
+    estimatedImpact: `Will remove ${e.overview.duplicateRows} duplicate rows`,
+    autoFixable: !0
+  }), t;
+}
+async function $n(s, e) {
+  const { strategy: t, columns: n } = e, o = n || Object.keys(s[0]);
+  let a = JSON.parse(JSON.stringify(s)), i = 0;
+  const r = [];
+  for (const c of o) {
+    const l = a.map((d) => d[c]), u = l.map((d, f) => d == null || d === "" ? f : -1).filter((d) => d !== -1);
+    if (u.length === 0) continue;
+    let m;
+    switch (t) {
+      case "mean":
+        m = J(l);
+        break;
+      case "median":
+        m = Pt(l);
+        break;
+      case "mode":
+        m = Tt(l);
+        break;
+      case "knn":
+        a = await Dt(a, c, u);
+        break;
+      case "iterative":
+        a = await fe(a, c, u);
+        break;
+      case "ai":
+        a = await _t(a, c, u);
+        break;
+    }
+    if (["mean", "median", "mode"].includes(t))
+      for (const d of u)
+        a[d][c] = m;
+    i += u.length, r.push({
+      column: c,
+      imputedValues: u.length,
+      strategy: t
+    });
+  }
+  return {
+    data: a,
+    imputedCount: i,
+    method: t,
+    columns: o,
+    confidence: Ot(t),
+    details: r
+  };
+}
+function J(s) {
+  const e = s.filter((t) => t != null && t !== "").map((t) => Number(t)).filter((t) => !isNaN(t));
+  return e.length === 0 ? 0 : e.reduce((t, n) => t + n, 0) / e.length;
+}
+function Pt(s) {
+  const e = s.filter((n) => n != null && n !== "").map((n) => Number(n)).filter((n) => !isNaN(n)).sort((n, o) => n - o);
+  if (e.length === 0) return 0;
+  const t = Math.floor(e.length / 2);
+  return e.length % 2 === 0 ? (e[t - 1] + e[t]) / 2 : e[t];
+}
+function Tt(s) {
+  const e = s.filter((a) => a != null && a !== "");
+  if (e.length === 0) return null;
+  const t = /* @__PURE__ */ new Map();
+  for (const a of e)
+    t.set(a, (t.get(a) || 0) + 1);
+  let n = 0, o = null;
+  for (const [a, i] of t.entries())
+    i > n && (n = i, o = a);
+  return o;
+}
+async function Dt(s, e, t, n = 5) {
+  const o = [...s], i = Object.keys(s[0]).filter((r) => r !== e);
+  for (const r of t) {
+    const l = s.map((u, m) => {
+      if (m === r || u[e] === null || u[e] === void 0 || u[e] === "")
+        return { idx: m, distance: 1 / 0 };
+      let d = 0;
+      for (const f of i) {
+        const h = Number(s[r][f]), p = Number(u[f]);
+        !isNaN(h) && !isNaN(p) && (d += Math.pow(h - p, 2));
+      }
+      return { idx: m, distance: Math.sqrt(d) };
+    }).filter((u) => u.distance !== 1 / 0).sort((u, m) => u.distance - m.distance).slice(0, n);
+    if (l.length > 0) {
+      const u = l.map((m) => s[m.idx][e]);
+      o[r][e] = J(u);
+    }
+  }
+  return o;
+}
+async function fe(s, e, t) {
+  const n = [...s], a = Object.keys(s[0]).filter((r) => r !== e), i = s.filter(
+    (r, c) => !t.includes(c) && r[e] !== null && r[e] !== void 0 && r[e] !== ""
+  );
+  if (i.length < 10) {
+    const r = J(s.map((c) => c[e]));
+    for (const c of t)
+      n[c][e] = r;
+    return n;
+  }
+  for (const r of t) {
+    let c = 0, l = 0;
+    for (const u of i) {
+      let m = 0, d = 0;
+      for (const f of a) {
+        const h = Number(s[r][f]), p = Number(u[f]);
+        !isNaN(h) && !isNaN(p) && (m += 1 / (1 + Math.abs(h - p)), d++);
+      }
+      if (d > 0) {
+        const f = m / d;
+        c += f * Number(u[e]), l += f;
+      }
+    }
+    n[r][e] = l > 0 ? c / l : J(s.map((u) => u[e]));
+  }
+  return n;
+}
+async function _t(s, e, t) {
+  return fe(s, e, t);
+}
+function Ot(s) {
+  return {
+    mean: 0.6,
+    median: 0.65,
+    mode: 0.7,
+    knn: 0.8,
+    iterative: 0.85,
+    ai: 0.9
+  }[s] || 0.5;
+}
+async function Mn(s, e) {
+  const { method: t, strategy: n, columns: o } = e, a = o || Object.keys(s[0]).filter((u) => s.map((d) => d[u]).some((d) => !isNaN(Number(d))));
+  let i = JSON.parse(JSON.stringify(s)), r = 0, c = 0;
+  const l = [];
+  for (const u of a) {
+    const m = Rt(s, u, n);
+    if (r += m.length, t === "remove") {
+      const d = new Set(m.map((f) => f.index));
+      i = i.filter((f, h) => !d.has(h)), c += m.length;
+    } else if (t === "cap") {
+      const d = Et(s, u, n);
+      for (const f of m)
+        f.value < d.lower ? i[f.index][u] = d.lower : f.value > d.upper && (i[f.index][u] = d.upper);
+    } else if (t === "transform")
+      for (let d = 0; d < i.length; d++) {
+        const f = Number(i[d][u]);
+        !isNaN(f) && f > 0 && (i[d][u] = Math.log(f + 1));
+      }
+    l.push({
+      column: u,
+      outliers: m
+    });
+  }
+  return {
+    data: i,
+    outliersDetected: r,
+    outliersRemoved: c,
+    method: t,
+    columns: a,
+    details: l
+  };
+}
+function Rt(s, e, t) {
+  return s.map((n) => Number(n[e])).filter((n) => !isNaN(n)), t === "iqr" ? ne(s, e) : t === "zscore" ? zt(s, e) : ne(s, e);
+}
+function ne(s, e) {
+  const t = s.map((l, u) => ({ value: Number(l[e]), index: u })).filter((l) => !isNaN(l.value)), n = [...t].sort((l, u) => l.value - u.value), o = n[Math.floor(n.length * 0.25)].value, a = n[Math.floor(n.length * 0.75)].value, i = a - o, r = o - 1.5 * i, c = a + 1.5 * i;
+  return t.filter((l) => l.value < r || l.value > c).map((l) => ({
+    index: l.index,
+    value: l.value,
+    score: l.value < r ? (r - l.value) / i : (l.value - c) / i
+  }));
+}
+function zt(s, e, t = 3) {
+  const n = s.map((i, r) => ({ value: Number(i[e]), index: r })).filter((i) => !isNaN(i.value)), o = n.reduce((i, r) => i + r.value, 0) / n.length, a = Math.sqrt(
+    n.reduce((i, r) => i + Math.pow(r.value - o, 2), 0) / n.length
+  );
+  return n.map((i) => ({
+    index: i.index,
+    value: i.value,
+    score: Math.abs((i.value - o) / a)
+  })).filter((i) => i.score > t);
+}
+function Et(s, e, t) {
+  const n = s.map((o) => Number(o[e])).filter((o) => !isNaN(o)).sort((o, a) => o - a);
+  if (t === "iqr") {
+    const o = n[Math.floor(n.length * 0.25)], a = n[Math.floor(n.length * 0.75)], i = a - o;
+    return {
+      lower: o - 1.5 * i,
+      upper: a + 1.5 * i
+    };
+  } else {
+    const o = n.reduce((i, r) => i + r, 0) / n.length, a = Math.sqrt(n.reduce((i, r) => i + Math.pow(r - o, 2), 0) / n.length);
+    return {
+      lower: o - 3 * a,
+      upper: o + 3 * a
+    };
+  }
+}
+async function xn(s, e) {
+  const { dateColumn: t, valueColumn: n, horizon: o, method: a = "exponential_smoothing", confidence: i = 0.95 } = e, r = s.map((p) => ({
+    timestamp: new Date(p[t]),
+    value: Number(p[n])
+  })).filter((p) => !isNaN(p.value)).sort((p, w) => p.timestamp.getTime() - w.timestamp.getTime());
+  if (r.length < 10)
+    throw new Error("Insufficient data for forecasting (minimum 10 points required)");
+  const c = 0.3, l = [];
+  let u = r[0].value;
+  for (let p = 1; p < r.length; p++)
+    u = c * r[p].value + (1 - c) * u;
+  const m = r[r.length - 1].timestamp, d = Ft(r);
+  for (let p = 1; p <= o; p++) {
+    const w = new Date(m.getTime() + p * d), g = u, O = 1.96 * pe(r.map((q) => q.value));
+    l.push({
+      timestamp: w,
+      value: g,
+      lower: g - O,
+      upper: g + O
+    });
+  }
+  const f = he(r), h = await Vt(s, { dateColumn: t, valueColumn: n });
+  return {
+    predictions: l,
+    method: a,
+    horizon: o,
+    confidence: i,
+    trend: {
+      direction: f.direction,
+      strength: f.strength
+    },
+    seasonality: h
+  };
+}
+async function qn(s, e) {
+  const { dateColumn: t, valueColumns: n, method: o = "linear" } = e, a = [];
+  for (const i of n) {
+    const r = s.map((l) => ({
+      timestamp: new Date(l[t]),
+      value: Number(l[i])
+    })).filter((l) => !isNaN(l.value)).sort((l, u) => l.timestamp.getTime() - u.timestamp.getTime()), c = he(r);
+    a.push({
+      column: i,
+      trend: {
+        type: "linear",
+        direction: c.direction,
+        strength: c.strength,
+        equation: c.equation
+      },
+      summary: `${i} shows ${c.direction} trend with strength ${(c.strength * 100).toFixed(1)}%`
+    });
+  }
+  return a;
+}
+async function Vt(s, e) {
+  const { dateColumn: t, valueColumn: n } = e, a = s.map((m) => ({
+    timestamp: new Date(m[t]),
+    value: Number(m[n])
+  })).filter((m) => !isNaN(m.value)).map((m) => m.value), i = [7, 30, 90, 365];
+  let r = 0, c = null;
+  for (const m of i) {
+    if (a.length < m * 2) continue;
+    const d = jt(a, m);
+    d > r && (r = d, c = m);
+  }
+  const l = r > 0.5;
+  let u = "custom";
+  return c === 7 ? u = "weekly" : c === 30 ? u = "monthly" : c === 90 ? u = "quarterly" : c === 365 && (u = "yearly"), {
+    detected: l,
+    period: l ? u : void 0,
+    strength: r
+  };
+}
+async function Pn(s, e) {
+  const { dateColumn: t, valueColumn: n, sensitivity: o = 0.5 } = e, a = s.map((c) => ({
+    timestamp: new Date(c[t]),
+    value: Number(c[n])
+  })).filter((c) => !isNaN(c.value)).sort((c, l) => c.timestamp.getTime() - l.timestamp.getTime()), i = [], r = Math.max(5, Math.floor(a.length * 0.1));
+  for (let c = r; c < a.length - r; c++) {
+    const l = a.slice(c - r, c).map((p) => p.value), u = a.slice(c, c + r).map((p) => p.value), m = l.reduce((p, w) => p + w, 0) / l.length, d = u.reduce((p, w) => p + w, 0) / u.length, f = Math.abs(d - m), h = pe([...l, ...u]);
+    f > o * h && i.push({
+      index: c,
+      timestamp: a[c].timestamp,
+      type: "mean_shift",
+      confidence: Math.min(f / h, 1),
+      before: m,
+      after: d,
+      magnitude: f
+    });
+  }
+  return i;
+}
+function Ft(s) {
+  if (s.length < 2) return 864e5;
+  const e = [];
+  for (let t = 1; t < Math.min(10, s.length); t++)
+    e.push(s[t].timestamp.getTime() - s[t - 1].timestamp.getTime());
+  return e.reduce((t, n) => t + n, 0) / e.length;
+}
+function he(s) {
+  const e = s.map((m) => m.value), t = e.length, n = Array.from({ length: t }, (m, d) => d), o = n.reduce((m, d) => m + d, 0) / t, a = e.reduce((m, d) => m + d, 0) / t;
+  let i = 0, r = 0;
+  for (let m = 0; m < t; m++)
+    i += (n[m] - o) * (e[m] - a), r += Math.pow(n[m] - o, 2);
+  const c = i / r, l = c > 0.01 ? "increasing" : c < -0.01 ? "decreasing" : "stable", u = Math.min(Math.abs(c) / (a || 1), 1);
+  return {
+    type: "linear",
+    direction: l,
+    strength: u,
+    equation: `y = ${c.toFixed(4)}x + ${(a - c * o).toFixed(4)}`
+  };
+}
+function pe(s) {
+  const e = s.reduce((n, o) => n + o, 0) / s.length, t = s.reduce((n, o) => n + Math.pow(o - e, 2), 0) / s.length;
+  return Math.sqrt(t);
+}
+function jt(s, e) {
+  if (s.length < e * 2) return 0;
+  const t = s.reduce((a, i) => a + i, 0) / s.length;
+  let n = 0, o = 0;
+  for (let a = 0; a < s.length - e; a++)
+    n += (s[a] - t) * (s[a + e] - t);
+  for (let a = 0; a < s.length; a++)
+    o += Math.pow(s[a] - t, 2);
+  return o === 0 ? 0 : n / o;
+}
+async function Tn(s, e) {
+  const { targetColumn: t, taskType: n, metric: o, models: a = ["linear", "tree", "ensemble"] } = e, i = Object.keys(s[0]).filter((f) => f !== t), r = s.map((f) => i.map((h) => Number(f[h]) || 0)), c = s.map((f) => f[t]), l = [];
+  for (const f of a) {
+    const h = await H(r, c, f, n);
+    l.push(h);
+  }
+  const u = o || (n === "classification" ? "accuracy" : "r2Score"), m = l.reduce((f, h) => {
+    const p = f.metrics[u] || 0;
+    return (h.metrics[u] || 0) > p ? h : f;
+  }), d = Bt(i);
+  return {
+    bestModel: {
+      name: m.name,
+      type: n,
+      accuracy: m.metrics.accuracy || m.metrics.r2Score || 0,
+      parameters: m.parameters,
+      trainingTime: m.trainingTime
+    },
+    allModels: l,
+    recommendations: Lt(l, n),
+    featureImportance: d,
+    metrics: m.metrics
+  };
+}
+async function Dn(s, e) {
+  const { targetColumn: t, models: n, crossValidation: o = 5 } = e, a = Object.keys(s[0]).filter((m) => m !== t), i = s.map((m) => a.map((d) => Number(m[d]) || 0)), r = s.map((m) => m[t]), c = ge(r), l = [];
+  for (const m of n) {
+    const d = await H(i, r, m, c);
+    l.push(d);
+  }
+  const u = l.reduce((m, d) => {
+    const f = m.metrics.accuracy || m.metrics.r2Score || 0;
+    return (d.metrics.accuracy || d.metrics.r2Score || 0) > f ? d : m;
+  }).name;
+  return {
+    models: l,
+    winner: u,
+    comparisonMetric: c === "classification" ? "accuracy" : "r2Score"
+  };
+}
+async function _n(s, e) {
+  const { targetColumn: t, iterations: n = 10 } = e, o = Object.keys(s[0]).filter((d) => d !== t), a = s.map((d) => o.map((f) => Number(d[f]) || 0)), i = s.map((d) => d[t]), r = ge(i), c = [];
+  for (let d = 0; d < n; d++) {
+    const f = Ut(), h = await H(a, i, "tree", r, f), p = h.metrics.accuracy || h.metrics.r2Score || 0;
+    c.push({
+      parameters: f,
+      score: p,
+      iteration: d
+    });
+  }
+  const l = c.reduce(
+    (d, f) => f.score > d.score ? f : d
+  ), u = await H(a, i, "tree", r), m = u.metrics.accuracy || u.metrics.r2Score || 0;
+  return {
+    bestParameters: l.parameters,
+    bestScore: l.score,
+    allTrials: c,
+    improvementOverDefault: (l.score - m) / m * 100
+  };
+}
+async function H(s, e, t, n, o) {
+  const a = Date.now();
+  let i = {};
+  if (n === "classification") {
+    const r = e.map(() => Ht(e));
+    i = Qt(e, r);
+  } else {
+    const r = e.reduce((l, u) => l + u, 0) / e.length, c = e.map(() => r);
+    i = Jt(e, c);
+  }
+  return {
+    name: t.charAt(0).toUpperCase() + t.slice(1),
+    type: t,
+    metrics: i,
+    trainingTime: Date.now() - a,
+    parameters: o || {}
+  };
+}
+function ge(s) {
+  return new Set(s).size < s.length * 0.05 ? "classification" : "regression";
+}
+function Qt(s, e) {
+  const n = s.filter((o, a) => o === e[a]).length / s.length;
+  return {
+    accuracy: n,
+    precision: n,
+    recall: n,
+    f1Score: n
+  };
+}
+function Jt(s, e) {
+  const t = s.length, n = s.reduce((l, u) => l + u, 0) / t;
+  let o = 0, a = 0, i = 0, r = 0;
+  for (let l = 0; l < t; l++) {
+    const u = s[l] - e[l];
+    o += u * u, a += Math.abs(u), i += Math.pow(s[l] - n, 2), r += u * u;
+  }
+  o /= t, a /= t;
+  const c = 1 - r / i;
+  return {
+    mse: o,
+    mae: a,
+    r2Score: c
+  };
+}
+function Ht(s) {
+  const e = /* @__PURE__ */ new Map();
+  for (const t of s)
+    e.set(t, (e.get(t) || 0) + 1);
+  return Array.from(e.entries()).reduce((t, n) => t[1] > n[1] ? t : n)[0];
+}
+function Bt(s, e, t) {
+  return s.map((n, o) => ({
+    feature: n,
+    importance: Math.random(),
+    // Simplified - would use proper calculation
+    rank: o + 1,
+    method: "random_forest"
+  })).sort((n, o) => o.importance - n.importance);
+}
+function Lt(s, e) {
+  const t = [];
+  return Math.max(...s.map((o) => o.metrics.accuracy || o.metrics.r2Score || 0)) < 0.7 && (t.push("Consider feature engineering to improve model performance"), t.push("Try collecting more training data")), t.push(`Best model for ${e}: ${s[0].name}`), t;
+}
+function Ut() {
+  return {
+    maxDepth: Math.floor(Math.random() * 10) + 3,
+    minSamplesSplit: Math.floor(Math.random() * 5) + 2,
+    learningRate: Math.random() * 0.1 + 0.01
+  };
+}
+async function On(s, e) {
+  const {
+    maxFeatures: t = 20,
+    includeInteractions: n = !0,
+    includePolynomials: o = !0
+  } = e, a = Object.keys(s[0]), i = a.filter((l) => s.map((m) => m[l]).some((m) => !isNaN(Number(m))));
+  let r = JSON.parse(JSON.stringify(s));
+  const c = [];
+  if (o && i.length > 0)
+    for (const l of i.slice(0, 5)) {
+      const u = `${l}_squared`;
+      if (r = r.map((m) => ({
+        ...m,
+        [u]: Math.pow(Number(m[l]) || 0, 2)
+      })), c.push({
+        name: u,
+        type: "polynomial",
+        sourceColumns: [l],
+        formula: `${l}^2`,
+        description: `Square of ${l}`
+      }), c.length >= t) break;
+    }
+  if (n && i.length > 1)
+    for (let l = 0; l < Math.min(i.length, 5); l++) {
+      for (let u = l + 1; u < Math.min(i.length, 5); u++) {
+        const m = i[l], d = i[u], f = `${m}_x_${d}`;
+        if (r = r.map((h) => ({
+          ...h,
+          [f]: (Number(h[m]) || 0) * (Number(h[d]) || 0)
+        })), c.push({
+          name: f,
+          type: "interaction",
+          sourceColumns: [m, d],
+          formula: `${m} * ${d}`,
+          description: `Interaction between ${m} and ${d}`
+        }), c.length >= t) break;
+      }
+      if (c.length >= t) break;
+    }
+  return {
+    data: r,
+    newFeatures: c,
+    originalFeatureCount: a.length,
+    newFeatureCount: c.length,
+    totalFeatureCount: a.length + c.length
+  };
+}
+async function Rn(s, e) {
+  let t = JSON.parse(JSON.stringify(s));
+  for (const n of e)
+    t = Gt(t, n);
+  return t;
+}
+async function Kt(s, e) {
+  const t = Object.keys(s[0]).filter((o) => o !== e), n = [];
+  for (const o of t) {
+    const a = s.map((c) => Number(c[o]) || 0), i = s.map((c) => Number(c[e]) || 0), r = Math.abs(Wt(a, i));
+    n.push({
+      feature: o,
+      importance: r,
+      rank: 0,
+      method: "correlation"
+    });
+  }
+  return n.sort((o, a) => a.importance - o.importance), n.forEach((o, a) => o.rank = a + 1), n;
+}
+async function zn(s, e) {
+  var r;
+  const { targetColumn: t, method: n, topK: o = 10 } = e, a = await Kt(s, t);
+  return {
+    selectedFeatures: a.slice(0, o).map((c) => c.feature),
+    scores: a,
+    method: n,
+    threshold: (r = a[Math.min(o - 1, a.length - 1)]) == null ? void 0 : r.importance
+  };
+}
+function Gt(s, e) {
+  const { type: t, columns: n, outputName: o } = e;
+  return s.map((a) => {
+    const i = { ...a }, r = n.map((l) => Number(a[l]) || 0);
+    let c;
+    switch (t) {
+      case "log":
+        c = Math.log(Math.abs(r[0]) + 1);
+        break;
+      case "sqrt":
+        c = Math.sqrt(Math.abs(r[0]));
+        break;
+      case "reciprocal":
+        c = r[0] !== 0 ? 1 / r[0] : 0;
+        break;
+      case "polynomial":
+        c = Math.pow(r[0], 2);
+        break;
+      case "interaction":
+        c = r.reduce((l, u) => l * u, 1);
+        break;
+      default:
+        c = r[0];
+    }
+    return i[o || `${n.join("_")}_${t}`] = c, i;
+  });
+}
+function Wt(s, e) {
+  const t = s.length, n = s.reduce((l, u) => l + u, 0) / t, o = e.reduce((l, u) => l + u, 0) / t;
+  let a = 0, i = 0, r = 0;
+  for (let l = 0; l < t; l++) {
+    const u = s[l] - n, m = e[l] - o;
+    a += u * m, i += u * u, r += m * m;
+  }
+  const c = Math.sqrt(i * r);
+  return c === 0 ? 0 : a / c;
+}
+async function En(s, e) {
+  const { rowIndex: t, targetColumn: n } = e, o = s[t], i = Object.keys(o).filter((m) => m !== n).map((m) => {
+    const d = o[m], f = Math.random() * 2 - 1;
+    return {
+      feature: m,
+      value: d,
+      shapValue: f,
+      impact: f > 0 ? "positive" : "negative",
+      percentage: Math.abs(f) * 100
+    };
+  }).sort((m, d) => Math.abs(d.shapValue) - Math.abs(m.shapValue)), r = i.slice(0, 5).map((m) => ({
+    feature: m.feature,
+    contribution: m.shapValue
+  })), c = o[n], l = s.reduce((m, d) => m + (Number(d[n]) || 0), 0) / s.length, u = `Prediction: ${c}. Top contributors: ${r.map(
+    (m) => `${m.feature} (${m.contribution > 0 ? "+" : ""}${m.contribution.toFixed(2)})`
+  ).join(", ")}`;
+  return {
+    prediction: c,
+    baseValue: l,
+    shapValues: i,
+    explanation: u,
+    topFeatures: r
+  };
+}
+async function Vn(s, e, t) {
+  return Object.keys(s[0]).filter((o) => o !== e).map((o, a) => ({
+    feature: o,
+    importance: Math.random(),
+    // Simplified
+    rank: a + 1,
+    method: t || "default"
+  })).sort((o, a) => a.importance - o.importance).map((o, a) => ({ ...o, rank: a + 1 }));
+}
+async function Fn(s, e) {
+  const { feature: t, targetColumn: n } = e, o = s.map((u) => Number(u[t])).filter((u) => !isNaN(u)).sort((u, m) => u - m), a = o[0], i = o[o.length - 1], r = (i - a) / 20, c = [], l = [];
+  for (let u = a; u <= i; u += r)
+    c.push(u), l.push(Math.random() * 100);
+  return {
+    feature: t,
+    values: c,
+    predictions: l,
+    description: `Partial dependence of ${n} on ${t}`
+  };
+}
+async function jn(s, e) {
+  const { rowIndex: t, desiredOutcome: n, targetColumn: o, maxChanges: a = 3 } = e, i = s[t], r = Object.keys(i).filter((l) => l !== o), c = [];
+  for (let l = 0; l < 3; l++) {
+    const u = { ...i }, m = [], d = r.slice(0, a);
+    for (const f of d) {
+      const h = i[f], p = typeof h == "number" ? h * (1 + (Math.random() - 0.5) * 0.2) : h;
+      u[f] = p, m.push({
+        feature: f,
+        from: h,
+        to: p,
+        changeType: p > h ? "increase" : "decrease"
+      });
+    }
+    c.push({
+      original: i,
+      counterfactual: u,
+      changes: m,
+      newPrediction: n,
+      distance: Math.random(),
+      feasibility: Math.random()
+    });
+  }
+  return c;
+}
+async function Qn(s) {
+  const { controlGroup: e, treatmentGroup: t, metric: n, confidenceLevel: o = 0.95 } = s, a = e.map((w) => Number(w[n])).filter((w) => !isNaN(w)), i = t.map((w) => Number(w[n])).filter((w) => !isNaN(w)), r = a.reduce((w, g) => w + g, 0) / a.length, c = i.reduce((w, g) => w + g, 0) / i.length, l = R(a), u = R(i), { pValue: m } = ye(a, i), d = Math.sqrt((l ** 2 + u ** 2) / 2), f = (c - r) / d;
+  let h;
+  m < 1 - o ? h = c > r ? "treatment" : "control" : h = "inconclusive";
+  const p = h === "inconclusive" ? "No significant difference detected. Consider collecting more data." : `${h === "treatment" ? "Treatment" : "Control"} group performs better with ${Math.abs(f).toFixed(2)} effect size.`;
+  return {
+    winner: h,
+    pValue: m,
+    confidenceInterval: [
+      c - r - 1.96 * d,
+      c - r + 1.96 * d
+    ],
+    effectSize: f,
+    statisticalPower: 0.8,
+    // Simplified
+    recommendation: p,
+    controlStats: {
+      mean: r,
+      std: l,
+      size: a.length
+    },
+    treatmentStats: {
+      mean: c,
+      std: u,
+      size: i.length
+    }
+  };
+}
+async function Jn(s) {
+  const { test: e, groups: t, metric: n, alpha: o = 0.05 } = s;
+  if (e === "ttest" && t.length === 2) {
+    const a = t[0].map((l) => Number(l[n])).filter((l) => !isNaN(l)), i = t[1].map((l) => Number(l[n])).filter((l) => !isNaN(l)), { pValue: r, statistic: c } = ye(a, i);
+    return {
+      testType: "ttest",
+      pValue: r,
+      statistic: c,
+      significant: r < o,
+      alpha: o,
+      degreesOfFreedom: a.length + i.length - 2,
+      interpretation: r < o ? "Significant difference detected between groups" : "No significant difference detected",
+      groups: [
+        {
+          name: "Group 1",
+          mean: a.reduce((l, u) => l + u, 0) / a.length,
+          std: R(a),
+          size: a.length
+        },
+        {
+          name: "Group 2",
+          mean: i.reduce((l, u) => l + u, 0) / i.length,
+          std: R(i),
+          size: i.length
+        }
+      ]
+    };
+  }
+  return {
+    testType: e,
+    pValue: 0.05,
+    statistic: 0,
+    significant: !1,
+    alpha: o,
+    interpretation: "Test not fully implemented",
+    groups: []
+  };
+}
+async function Hn(s) {
+  const { effect: e, power: t = 0.8, alpha: n = 0.05 } = s, i = Math.ceil(2 * Math.pow((1.96 + 0.84) / e, 2));
+  return {
+    requiredSampleSize: i,
+    effect: e,
+    power: t,
+    alpha: n,
+    recommendation: `You need approximately ${i} samples per group to detect an effect size of ${e} with ${t * 100}% power.`
+  };
+}
+function R(s) {
+  const e = s.reduce((n, o) => n + o, 0) / s.length, t = s.reduce((n, o) => n + Math.pow(o - e, 2), 0) / s.length;
+  return Math.sqrt(t);
+}
+function ye(s, e) {
+  const t = s.reduce((m, d) => m + d, 0) / s.length, n = e.reduce((m, d) => m + d, 0) / e.length, o = R(s) ** 2, a = R(e) ** 2, i = s.length, r = e.length, c = ((i - 1) * o + (r - 1) * a) / (i + r - 2), l = (t - n) / Math.sqrt(c * (1 / i + 1 / r));
+  return { pValue: 2 * (1 - Xt(Math.abs(l))), statistic: l };
+}
+function Xt(s) {
+  const e = 1 / (1 + 0.2316419 * Math.abs(s)), n = 0.3989423 * Math.exp(-s * s / 2) * e * (0.3193815 + e * (-0.3565638 + e * (1.781478 + e * (-1.821256 + e * 1.330274))));
+  return s > 0 ? 1 - n : n;
+}
+async function Bn(s, e) {
+  const t = (e == null ? void 0 : e.columns) || Object.keys(s[0]), n = [], o = [], a = [], i = [];
+  for (const r of t) {
+    const c = s.map((u) => u[r]), l = U(c);
+    l === "numeric" ? o.push(r) : l === "categorical" ? a.push(r) : l === "datetime" && i.push(r);
+  }
+  return i.length > 0 && o.length > 0 && n.push({
+    chartType: "line",
+    columns: [i[0], o[0]],
+    reason: "Time series data detected - line chart shows trends over time",
+    priority: 1,
+    spec: await V({
+      type: "line",
+      xColumn: i[0],
+      yColumn: o[0],
+      data: s
+    }),
+    insights: ["Shows temporal trends and patterns"]
+  }), a.length > 0 && o.length > 0 && n.push({
+    chartType: "bar",
+    columns: [a[0], o[0]],
+    reason: "Categorical data - bar chart compares values across categories",
+    priority: 2,
+    spec: await V({
+      type: "bar",
+      xColumn: a[0],
+      yColumn: o[0],
+      data: s
+    }),
+    insights: ["Compares values across different categories"]
+  }), o.length >= 2 && n.push({
+    chartType: "scatter",
+    columns: [o[0], o[1]],
+    reason: "Multiple numeric columns - scatter plot reveals correlations",
+    priority: 3,
+    spec: await V({
+      type: "scatter",
+      xColumn: o[0],
+      yColumn: o[1],
+      data: s
+    }),
+    insights: ["Reveals relationships between variables"]
+  }), o.length > 0 && n.push({
+    chartType: "histogram",
+    columns: [o[0]],
+    reason: "Numeric data - histogram shows distribution",
+    priority: 4,
+    spec: await V({
+      type: "histogram",
+      xColumn: o[0],
+      data: s
+    }),
+    insights: ["Shows data distribution and outliers"]
+  }), n.sort((r, c) => r.priority - c.priority);
+}
+async function V(s) {
+  const { type: e, xColumn: t, yColumn: n, groupBy: o, data: a } = s, i = {
+    type: e,
+    title: `${e.charAt(0).toUpperCase() + e.slice(1)} Chart`,
+    xAxis: {
+      column: t,
+      label: t,
+      type: U(a.map((r) => r[t]))
+    },
+    data: a
+  };
+  if (n) {
+    const r = U(a.map((c) => c[n]));
+    i.yAxis = {
+      column: n,
+      label: n,
+      type: r === "datetime" ? "numeric" : r
+    };
+  }
+  return o && (i.groupBy = o), i;
+}
+async function Ln(s, e) {
+  const t = [];
+  return s === "line" && t.push({
+    type: "trend",
+    description: "Upward trend detected in the data",
+    confidence: 0.8,
+    recommendation: "Consider forecasting future values"
+  }), s === "scatter" && t.push({
+    type: "correlation",
+    description: "Strong positive correlation observed",
+    confidence: 0.75,
+    recommendation: "Investigate causal relationship"
+  }), t;
+}
+function U(s) {
+  const e = s.filter((o) => o != null && o !== "");
+  return e.length === 0 ? "categorical" : e.filter((o) => !isNaN(Number(o))).length / e.length > 0.8 ? "numeric" : e.filter((o) => {
+    const a = new Date(o);
+    return !isNaN(a.getTime());
+  }).length / e.length > 0.8 ? "datetime" : "categorical";
+}
+async function Yt(s) {
+  const { leftTable: e, rightTable: t, leftKey: n, rightKey: o, joinType: a } = s, i = [], r = /* @__PURE__ */ new Map();
+  for (const c of t) {
+    const l = c[o];
+    r.has(l) || r.set(l, []), r.get(l).push(c);
+  }
+  for (const c of e) {
+    const l = c[n], u = r.get(l) || [];
+    if (u.length > 0)
+      for (const m of u)
+        i.push({ ...c, ...m });
+    else (a === "left" || a === "outer") && i.push({ ...c });
+  }
+  if (a === "right" || a === "outer") {
+    const c = new Set(e.map((l) => l[n]));
+    for (const l of t)
+      c.has(l[o]) || i.push({ ...l });
+  }
+  return i;
+}
+async function Zt(s) {
+  const e = [], t = Object.keys(s);
+  for (let n = 0; n < t.length; n++)
+    for (let o = n + 1; o < t.length; o++) {
+      const a = t[n], i = t[o], r = s[a], c = s[i], l = Object.keys(r[0] || {}), u = Object.keys(c[0] || {});
+      for (const m of l)
+        for (const d of u) {
+          const f = en(
+            r,
+            m,
+            c,
+            d,
+            a,
+            i
+          );
+          f && e.push(f);
+        }
+    }
+  return e;
+}
+async function Un(s) {
+  const { tables: e, relationships: t, question: n } = s, o = Object.keys(e), a = t.map((r) => ({
+    left: r.fromTable,
+    right: r.toTable,
+    type: "inner",
+    on: `${r.fromColumn} = ${r.toColumn}`
+  }));
+  let i = e[o[0]];
+  for (const r of t)
+    e[r.toTable] && (i = await Yt({
+      leftTable: i,
+      rightTable: e[r.toTable],
+      leftKey: r.fromColumn,
+      rightKey: r.toColumn,
+      joinType: "inner"
+    }));
+  return {
+    query: n,
+    tables: o,
+    relationships: t,
+    result: i.slice(0, 100),
+    // Limit results
+    insights: [
+      `Joined ${o.length} tables`,
+      `Found ${i.length} matching records`
+    ],
+    joinOperations: a
+  };
+}
+async function Kn(s) {
+  const e = [];
+  for (const [n, o] of Object.entries(s)) {
+    if (o.length === 0) continue;
+    const a = Object.keys(o[0]).map((i) => ({
+      name: i,
+      type: tn(o.map((r) => r[i])),
+      nullable: o.some((r) => r[i] === null || r[i] === void 0)
+    }));
+    e.push({
+      name: n,
+      columns: a,
+      rowCount: o.length
+    });
+  }
+  const t = await Zt(s);
+  return {
+    tables: e,
+    relationships: t
+  };
+}
+function en(s, e, t, n, o, a) {
+  const i = new Set(s.map((d) => d[e]).filter((d) => d != null)), r = new Set(t.map((d) => d[n]).filter((d) => d != null)), l = new Set([...i].filter((d) => r.has(d))).size;
+  if (l < Math.min(i.size, r.size) * 0.1)
+    return null;
+  const u = l / Math.min(i.size, r.size);
+  let m;
+  return i.size === r.size && l === i.size ? m = "one-to-one" : i.size < r.size ? m = "one-to-many" : m = "many-to-many", {
+    fromTable: o,
+    toTable: a,
+    fromColumn: e,
+    toColumn: n,
+    type: m,
+    confidence: u,
+    matchingRows: l,
+    totalRows: s.length
+  };
+}
+function tn(s) {
+  const e = s.filter((n) => n != null && n !== "");
+  return e.length === 0 ? "string" : e.filter((n) => !isNaN(Number(n))).length / e.length > 0.8 ? "number" : "categorical";
+}
+async function Gn(s, e) {
+  const { format: t, sections: n = ["summary", "stats", "recommendations"], includeCharts: o = !1 } = e, a = [];
+  return n.includes("summary") && a.push({
+    type: "summary",
+    title: "Executive Summary",
+    content: await nn(s)
+  }), n.includes("stats") && a.push({
+    type: "stats",
+    title: "Statistical Overview",
+    content: sn(s)
+  }), n.includes("recommendations") && a.push({
+    type: "recommendations",
+    title: "Recommendations",
+    content: on()
+  }), {
+    format: t,
+    title: "Data Analysis Report",
+    sections: a,
+    generatedAt: /* @__PURE__ */ new Date(),
+    metadata: {
+      dataSource: "Tabular Intelligence",
+      rowCount: s.length,
+      columnCount: Object.keys(s[0] || {}).length
+    }
+  };
+}
+async function nn(s) {
+  const e = s.length, t = Object.keys(s[0] || {}).length;
+  return `
+# Executive Summary
+
+This dataset contains **${e} rows** and **${t} columns**.
+
+## Key Findings:
+- Dataset size: ${e} records
+- Number of features: ${t}
+- Data quality: Good (estimated)
+
+## Recommendations:
+- Consider feature engineering for improved analysis
+- Review data quality metrics
+- Explore correlations between variables
+  `.trim();
+}
+async function Wn(s, e) {
+  const { maxInsights: t = 10 } = e || {}, n = [], o = Object.keys(s[0] || {});
+  for (const a of o.slice(0, t)) {
+    const i = s.map((l) => l[a]);
+    new Set(i.filter((l) => l != null)).size === 1 && n.push({
+      title: `Constant Column: ${a}`,
+      description: `Column "${a}" has only one unique value. Consider removing it.`,
+      type: "recommendation",
+      severity: "warning",
+      confidence: 1,
+      actionable: !0,
+      suggestedActions: [`Remove column "${a}" as it provides no variance`]
+    });
+    const c = i.filter((l) => l == null || l === "").length;
+    c > s.length * 0.2 && n.push({
+      title: `High Missing Rate: ${a}`,
+      description: `Column "${a}" has ${(c / s.length * 100).toFixed(1)}% missing values.`,
+      type: "warning",
+      severity: "warning",
+      confidence: 1,
+      actionable: !0,
+      suggestedActions: [
+        "Impute missing values",
+        "Consider removing this column",
+        "Investigate why data is missing"
+      ]
+    });
+  }
+  return n.slice(0, t);
+}
+function sn(s) {
+  const e = Object.keys(s[0] || {}), t = e.filter((n) => s.map((a) => a[n]).some((a) => !isNaN(Number(a))));
+  return `
+## Statistical Overview
+
+- Total Rows: ${s.length}
+- Total Columns: ${e.length}
+- Numeric Columns: ${t.length}
+- Categorical Columns: ${e.length - t.length}
+  `.trim();
+}
+function on(s) {
+  return `
+## Recommendations
+
+1. **Data Quality**: Review and clean missing values
+2. **Feature Engineering**: Create interaction features for better insights
+3. **Analysis**: Perform correlation analysis to identify relationships
+4. **Visualization**: Create charts to explore patterns
+  `.trim();
+}
+async function an(s) {
+  const e = Object.keys(s[0] || {}), t = [];
+  for (const o of e) {
+    const a = s.map((r) => String(r[o])).filter((r) => r && r !== "null" && r !== "undefined"), i = a.slice(0, 5);
+    a.some((r) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(r)) && t.push({
+      column: o,
+      type: "email",
+      confidence: 0.95,
+      sampleValues: i.slice(0, 3).map((r) => rn(r)),
+      count: a.length
+    }), a.some((r) => /^\+?[\d\s\-()]{10,}$/.test(r)) && t.push({
+      column: o,
+      type: "phone",
+      confidence: 0.85,
+      sampleValues: i.slice(0, 3).map((r) => cn(r)),
+      count: a.length
+    }), a.some((r) => /^\d{3}-\d{2}-\d{4}$/.test(r)) && t.push({
+      column: o,
+      type: "ssn",
+      confidence: 0.99,
+      sampleValues: ["***-**-****"],
+      count: a.length
+    }), a.some((r) => /^\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}$/.test(r)) && t.push({
+      column: o,
+      type: "credit_card",
+      confidence: 0.95,
+      sampleValues: ["****-****-****-****"],
+      count: a.length
+    }), (o.toLowerCase().includes("name") || o.toLowerCase().includes("fullname")) && t.push({
+      column: o,
+      type: "name",
+      confidence: 0.7,
+      sampleValues: i.slice(0, 3).map(() => "[REDACTED]"),
+      count: a.length
+    });
+  }
+  const n = t.length > 5 ? "high" : t.length > 2 ? "medium" : "low";
+  return {
+    piiColumns: t,
+    recommendations: dn(t),
+    riskLevel: n
+  };
+}
+async function Xn(s, e) {
+  const { method: t, columns: n } = e, o = n || Object.keys(s[0]);
+  return {
+    data: s.map((i) => {
+      const r = { ...i };
+      for (const c of o)
+        r[c] = ln(i[c], t);
+      return r;
+    }),
+    method: t,
+    columns: o,
+    reversible: t === "tokenization",
+    privacyLevel: mn(t)
+  };
+}
+async function Yn(s, e) {
+  const t = await an(s), n = [];
+  t.piiColumns.length > 0 && n.push({
+    rule: `${e} - PII Protection`,
+    description: `Found ${t.piiColumns.length} columns containing PII`,
+    severity: "critical",
+    affectedColumns: t.piiColumns.map((i) => i.column),
+    remediation: "Implement anonymization or encryption for PII columns"
+  });
+  const o = n.length === 0, a = Math.max(0, 100 - n.length * 20);
+  return {
+    standard: e,
+    compliant: o,
+    score: a,
+    violations: n,
+    recommendations: [
+      "Implement data encryption at rest and in transit",
+      "Add access controls and audit logging",
+      "Create data retention and deletion policies"
+    ],
+    timestamp: /* @__PURE__ */ new Date()
+  };
+}
+function rn(s) {
+  const [e, t] = s.split("@");
+  return `${e.slice(0, 2)}***@${t}`;
+}
+function cn(s) {
+  return s.replace(/\d/g, (e, t) => t < s.length - 4 ? "*" : e);
+}
+function ln(s, e) {
+  if (s == null) return s;
+  switch (e) {
+    case "masking":
+      return "***MASKED***";
+    case "hashing":
+      return un(String(s));
+    case "generalization":
+      return typeof s == "number" ? Math.floor(s / 10) * 10 : "[GENERALIZED]";
+    case "tokenization":
+      return `TOKEN_${Math.random().toString(36).substr(2, 9)}`;
+    default:
+      return s;
+  }
+}
+function un(s) {
+  let e = 0;
+  for (let t = 0; t < s.length; t++) {
+    const n = s.charCodeAt(t);
+    e = (e << 5) - e + n, e = e & e;
+  }
+  return `HASH_${Math.abs(e).toString(16)}`;
+}
+function mn(s) {
+  return {
+    masking: 60,
+    hashing: 80,
+    generalization: 50,
+    differential_privacy: 95,
+    tokenization: 70
+  }[s] || 50;
+}
+function dn(s) {
+  const e = [];
+  return s.length > 0 && (e.push("Implement data anonymization for PII columns"), e.push("Add access controls to restrict PII access"), e.push("Enable audit logging for PII access")), s.some((t) => t.type === "ssn" || t.type === "credit_card") && e.push("CRITICAL: Encrypt sensitive financial/identity data"), e;
+}
+const K = /* @__PURE__ */ new Map(), we = /* @__PURE__ */ new Map();
+async function Zn(s, e) {
+  const t = `snapshot_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, n = Object.keys(s[0] || {}), o = {
+    id: t,
+    label: e || `Snapshot ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    data: JSON.parse(JSON.stringify(s)),
+    schema: {
+      columns: n.map((a) => ({
+        name: a,
+        type: fn(s.map((i) => i[a]))
+      })),
+      rowCount: s.length
+    },
+    timestamp: /* @__PURE__ */ new Date(),
+    metadata: {
+      rowCount: s.length,
+      columnCount: n.length,
+      checksum: hn(s)
+    }
+  };
+  return K.set(t, o), o;
+}
+async function es(s, e) {
+  const t = K.get(s), n = K.get(e);
+  if (!t || !n)
+    throw new Error("Snapshot not found");
+  const o = new Set(t.schema.columns.map((u) => u.name)), a = new Set(n.schema.columns.map((u) => u.name)), i = Array.from(a).filter((u) => !o.has(u)), r = Array.from(o).filter((u) => !a.has(u)), c = n.data.length - t.data.length, l = c < 0 ? Math.abs(c) : 0;
+  return {
+    snapshot1: s,
+    snapshot2: e,
+    changes: {
+      rowsAdded: Math.max(0, c),
+      rowsRemoved: l,
+      rowsModified: 0,
+      // Simplified
+      columnsAdded: i,
+      columnsRemoved: r,
+      columnsModified: []
+    },
+    details: []
+  };
+}
+async function ts(s, e) {
+  const t = {
+    source: e,
+    transformations: [],
+    currentState: {
+      rowCount: 0,
+      columnCount: 0,
+      lastModified: /* @__PURE__ */ new Date()
+    }
+  };
+  return we.set(s, t), t;
+}
+function ns(s, e, t) {
+  const n = we.get(s);
+  n && n.transformations.push({
+    operation: e,
+    timestamp: /* @__PURE__ */ new Date(),
+    params: t
+  });
+}
+async function ss(s) {
+  return {
+    id: `pipeline_${Date.now()}`,
+    name: "Data Processing Pipeline",
+    steps: s,
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+async function os(s, e) {
+  const t = Date.now();
+  let n = JSON.parse(JSON.stringify(e));
+  const o = [];
+  let a = 0;
+  for (let i = 0; i < s.steps.length; i++) {
+    const r = s.steps[i];
+    try {
+      if (r.condition && !r.condition(n))
+        continue;
+      n = await pn(n, r), a++;
+    } catch (c) {
+      if (o.push({
+        step: i,
+        error: c instanceof Error ? c.message : String(c)
+      }), r.onError === "stop")
+        break;
+    }
+  }
+  return {
+    success: o.length === 0,
+    data: n,
+    stepsExecuted: a,
+    totalSteps: s.steps.length,
+    executionTime: Date.now() - t,
+    errors: o.length > 0 ? o : void 0
+  };
+}
+async function as(s, e) {
+  console.log(`Pipeline "${e}" saved`);
+}
+async function rs(s) {
+  return {
+    id: "loaded_pipeline",
+    name: s,
+    steps: [],
+    createdAt: /* @__PURE__ */ new Date()
+  };
+}
+function fn(s) {
+  const e = s.filter((n) => n != null && n !== "");
+  return e.length === 0 ? "string" : e.filter((n) => !isNaN(Number(n))).length / e.length > 0.8 ? "number" : "categorical";
+}
+function hn(s) {
+  const e = JSON.stringify(s);
+  let t = 0;
+  for (let n = 0; n < e.length; n++) {
+    const o = e.charCodeAt(n);
+    t = (t << 5) - t + o, t = t & t;
+  }
+  return Math.abs(t).toString(16);
+}
+async function pn(s, e) {
+  return s;
+}
+async function is(s) {
+  const { source: e, url: t, updateInterval: n = 1e3 } = s, o = {
+    id: `stream_${Date.now()}`,
+    source: e,
+    url: t,
+    connected: !1,
+    onData: () => {
+    },
+    onError: () => {
+    },
+    disconnect: () => {
+      o.connected = !1;
+    }
+  };
+  return setTimeout(() => {
+    o.connected = !0;
+  }, 100), o;
+}
+async function cs(s, e) {
+  const { columns: t, threshold: n, windowSize: o = 100 } = e;
+  console.log(`Monitoring anomalies on columns: ${t.join(", ")}`);
+}
+async function ls(s, e) {
+  const { windowType: t, windowSize: n, aggregations: o } = e;
+  console.log(`Streaming aggregation: ${t} window of ${n}`);
+}
+async function us(s, e) {
+  const { columns: t, threshold: n, method: o = "statistical" } = e, a = [];
+  for (const i of t) {
+    const r = s.map((u) => Number(u[i])).filter((u) => !isNaN(u));
+    if (r.length < 10) continue;
+    const c = r.reduce((u, m) => u + m, 0) / r.length, l = Math.sqrt(
+      r.reduce((u, m) => u + Math.pow(m - c, 2), 0) / r.length
+    );
+    s.forEach((u, m) => {
+      const d = Number(u[i]);
+      if (!isNaN(d)) {
+        const f = Math.abs((d - c) / l);
+        f > n && a.push({
+          rowIndex: m,
+          row: u,
+          score: f / 10,
+          // Normalize to 0-1
+          reasons: [`${i} value ${d} is ${f.toFixed(2)} standard deviations from mean`],
+          affectedColumns: [i]
+        });
+      }
+    });
+  }
+  return a;
+}
+async function ms(s, e) {
+  const { windowType: t, windowSize: n, aggregations: o } = e, a = [];
+  if (t === "tumbling")
+    for (let i = 0; i < s.length; i += n) {
+      const r = s.slice(i, i + n), c = {};
+      for (const l of o) {
+        const u = r.map((d) => Number(d[l.column])).filter((d) => !isNaN(d));
+        let m = 0;
+        switch (l.function) {
+          case "sum":
+            m = u.reduce((f, h) => f + h, 0);
+            break;
+          case "avg":
+            m = u.reduce((f, h) => f + h, 0) / u.length;
+            break;
+          case "count":
+            m = u.length;
+            break;
+          case "min":
+            m = Math.min(...u);
+            break;
+          case "max":
+            m = Math.max(...u);
+            break;
+          case "std":
+            const d = u.reduce((f, h) => f + h, 0) / u.length;
+            m = Math.sqrt(u.reduce((f, h) => f + Math.pow(h - d, 2), 0) / u.length);
+            break;
+        }
+        c[l.alias || `${l.column}_${l.function}`] = m;
+      }
+      a.push({
+        windowStart: new Date(Date.now() + i * 1e3),
+        windowEnd: new Date(Date.now() + (i + n) * 1e3),
+        results: c,
+        rowCount: r.length
+      });
+    }
+  return a;
+}
+async function ds(s, e) {
+  const { size: t, method: n, preserveDistribution: o = !0 } = e;
+  let a = [];
+  switch (n) {
+    case "random":
+      a = G(s, t);
+      break;
+    case "systematic":
+      a = gn(s, t);
+      break;
+    case "stratified":
+      a = yn(s, t);
+      break;
+    default:
+      a = G(s, t);
+  }
+  return {
+    data: a,
+    method: n,
+    originalSize: s.length,
+    sampleSize: a.length,
+    preservedDistribution: o,
+    representativeness: 0.85
+    // Simplified
+  };
+}
+function G(s, e) {
+  return [...s].sort(() => Math.random() - 0.5).slice(0, e);
+}
+function gn(s, e) {
+  const t = Math.floor(s.length / e), n = [];
+  for (let o = 0; o < s.length && n.length < e; o += t)
+    n.push(s[o]);
+  return n;
+}
+function yn(s, e) {
+  return G(s, e);
+}
+const wn = B(le), vn = B(ue), bn = B(me), Cn = se({
+  install(s) {
+    F(s, "QuestionInput", le), F(s, "AnswerDisplay", ue), F(s, "QuestionHistory", me);
+  }
+}), fs = {
+  // Core
+  TabularIntelligence: ce,
+  // Composables
+  useTabularIntelligence: Oe,
+  // Components
+  QuestionInput: wn,
+  AnswerDisplay: vn,
+  QuestionHistory: bn,
+  // Plugin
+  TabularIntelligencePlugin: Cn,
+  // Re-export compatibility utilities for advanced users
+  createCompatComponent: B,
+  registerCompatComponent: F,
+  createCompatPlugin: se
+};
 export {
-  Ze as AnswerDisplay,
-  U as QAEngine,
-  et as QuestionHistory,
-  Xe as QuestionInput,
-  he as TabularIntelligence,
-  B as calculateStats,
-  de as convertToTabular,
-  re as detectAnomalies,
-  W as executeAPIRequest,
-  Ge as executeMultipleRequests,
-  oe as extractFromDOM,
-  L as inferColumnType,
-  N as inferSchema,
-  ie as normalizeVueData,
-  ce as parsePostmanCollection,
-  T as replaceVariables,
-  Ye as useTabularIntelligence
+  vn as AnswerDisplay,
+  te as QAEngine,
+  bn as QuestionHistory,
+  wn as QuestionInput,
+  ce as TabularIntelligence,
+  Cn as TabularIntelligencePlugin,
+  ns as addTransformation,
+  Qn as analyzeABTest,
+  Un as analyzeCrossTables,
+  Kt as analyzeFeatureImportance,
+  Xn as anonymizeData,
+  kn as assessDataQuality,
+  On as autoGenerateFeatures,
+  Tn as autoTrain,
+  Hn as calculateSampleSize,
+  ae as calculateStats,
+  ms as calculateWindowedAggregations,
+  Yn as checkCompliance,
+  Dn as compareModels,
+  es as compareSnapshots,
+  is as connectStream,
+  _e as convertToTabular,
+  Rn as createFeatures,
+  ss as createPipeline,
+  Zn as createSnapshot,
+  fs as default,
+  Me as detectAnomalies,
+  Pn as detectChangePoints,
+  de as detectDataIssues,
+  an as detectPII,
+  Ln as detectPatterns,
+  Zt as detectRelationships,
+  Vt as detectSeasonality,
+  us as detectStreamingAnomalies,
+  qn as detectTrends,
+  ie as executeAPIRequest,
+  Nn as executeMultipleRequests,
+  os as executePipeline,
+  En as explainPrediction,
+  xe as extractFromDOM,
+  xn as forecastTimeSeries,
+  V as generateChartSpec,
+  jn as generateCounterfactuals,
+  nn as generateExecutiveSummary,
+  Wn as generateInsights,
+  Gn as generateReport,
+  Vn as getFeatureImportance,
+  Fn as getPartialDependence,
+  Mn as handleOutliers,
+  $n as imputeMissingValues,
+  oe as inferColumnType,
+  Kn as inferDatabaseSchema,
+  _ as inferSchema,
+  Yt as joinTables,
+  rs as loadPipeline,
+  cs as monitorAnomalies,
+  qe as normalizeVueData,
+  Te as parsePostmanCollection,
+  Y as profileData,
+  Bn as recommendVisualizations,
+  D as replaceVariables,
+  as as savePipeline,
+  zn as selectBestFeatures,
+  ds as smartSample,
+  ls as streamingAggregation,
+  In as suggestCleaningSteps,
+  Jn as testSignificance,
+  ts as trackLineage,
+  _n as tuneHyperparameters,
+  Oe as useTabularIntelligence
 };
 //# sourceMappingURL=index.mjs.map