@salimassili/ai-costguard 2.0.0 → 2.1.0

package/benchmarks/run.mjs

@@ -1,229 +1,229 @@
-import { performance } from 'node:perf_hooks';
-import { guardFunction } from '../dist/index.js';
-import { GuardCore, GuardError } from '../dist/core/GuardCore.js';
-import { estimateRequestTokens } from '../dist/core/tokenizer.js';
-
-const iterations = readIterations(process.argv.slice(2));
-
-const result = {
-  generatedAt: new Date().toISOString(),
-  node: process.version,
-  platform: process.platform,
-  iterations,
-  runtimeOverhead: await measureRuntimeOverhead(iterations),
-  memoryOverhead: await measureMemoryOverhead(Math.max(250, Math.min(iterations, 2000))),
-  falsePositiveScenarios: measureFalsePositiveScenarios(),
-  loopDetectionBehavior: measureLoopDetectionBehavior(),
-  costEstimationBoundaries: measureCostEstimationBoundaries(),
-};
-
-console.log(JSON.stringify(result, null, 2));
-
-async function measureRuntimeOverhead(count) {
-  async function directCall(request) {
-    return { ok: true, usage: { prompt_tokens: 12, completion_tokens: request.max_tokens ?? 8 } };
-  }
-
-  const guardedCall = guardFunction(directCall, {
-    budget: 1_000,
-    behaviorAnalysis: false,
-    scope: { projectId: 'benchmark' },
-  });
-
-  const request = {
-    model: 'gpt-4o-mini',
-    prompt: 'benchmark request',
-    max_tokens: 8,
-  };
-
-  await warmup(directCall, guardedCall, request);
-
-  const directMs = await timeAsync(count, () => directCall(request));
-  const guardedMs = await timeAsync(count, () => guardedCall(request));
-  const directPerCallMs = directMs / count;
-  const guardedPerCallMs = guardedMs / count;
-
-  return {
-    directTotalMs: round(directMs, 3),
-    guardedTotalMs: round(guardedMs, 3),
-    directPerCallMs: round(directPerCallMs, 6),
-    guardedPerCallMs: round(guardedPerCallMs, 6),
-    addedPerCallMs: round(guardedPerCallMs - directPerCallMs, 6),
-  };
-}
-
-async function measureMemoryOverhead(count) {
-  const guardedCall = guardFunction(
-    async (request) => ({ ok: true, usage: { prompt_tokens: 12, completion_tokens: request.max_tokens ?? 8 } }),
-    {
-      budget: 1_000,
-      maxHistory: count,
-      loopMinRepeats: count + 1,
-      scope: { projectId: 'memory-benchmark' },
-    }
-  );
-
-  collectGarbageIfAvailable();
-  const beforeBytes = process.memoryUsage().heapUsed;
-
-  for (let index = 0; index < count; index++) {
-    await guardedCall({
-      model: 'gpt-4o-mini',
-      prompt: `memory benchmark unique prompt ${index}`,
-      max_tokens: 8,
-    });
-  }
-
-  collectGarbageIfAvailable();
-  const afterBytes = process.memoryUsage().heapUsed;
-
-  return {
-    calls: count,
-    heapDeltaBytes: afterBytes - beforeBytes,
-    heapDeltaPerCallBytes: round((afterBytes - beforeBytes) / count, 2),
-    gcAvailable: typeof globalThis.gc === 'function',
-    note: 'Heap measurements are process-local and noisy unless Node is run with --expose-gc.',
-  };
-}
-
-function measureFalsePositiveScenarios() {
-  const core = new GuardCore({
-    budget: 1,
-    retryThreshold: 2,
-    loopSimilarityThreshold: 0.9,
-    scope: { projectId: 'false-positive-benchmark' },
-  });
-  const prompts = [
-    'again compare the two product options',
-    'again summarize the second option with different tradeoffs',
-    'again write a new title for the launch note',
-  ];
-  let blocked = 0;
-
-  for (const prompt of prompts) {
-    try {
-      core.check(context(prompt));
-    } catch (error) {
-      if (error instanceof GuardError) blocked += 1;
-      else throw error;
-    }
-  }
-
-  return {
-    scenario: 'Repeated benign "again" prompts without failure/error language',
-    prompts: prompts.length,
-    blocked,
-  };
-}
-
-function measureLoopDetectionBehavior() {
-  const core = new GuardCore({
-    budget: 1,
-    loopSimilarityThreshold: 0.9,
-    loopMinRepeats: 2,
-    scope: { projectId: 'loop-benchmark' },
-  });
-  const prompt = 'summarize the same tool observation and continue the agent plan';
-
-  for (let step = 1; step <= 5; step++) {
-    try {
-      core.check(context(prompt));
-    } catch (error) {
-      if (error instanceof GuardError) {
-        return {
-          repeatedPrompt: prompt,
-          blockedAtStep: step,
-          code: error.code,
-          reason: error.message,
-        };
-      }
-
-      throw error;
-    }
-  }
-
-  return {
-    repeatedPrompt: prompt,
-    blockedAtStep: null,
-  };
-}
-
-function measureCostEstimationBoundaries() {
-  const samples = [
-    { label: 'short chat', request: { messages: [{ role: 'user', content: 'hello' }], max_tokens: 32 } },
-    {
-      label: 'long instruction',
-      request: {
-        messages: [{ role: 'user', content: 'Summarize the following requirements. '.repeat(120) }],
-        max_tokens: 256,
-      },
-    },
-    {
-      label: 'code-heavy prompt',
-      request: {
-        prompt: 'function example(value) { return value.map((item) => item.id).join(","); }\n'.repeat(40),
-        max_tokens: 128,
-      },
-    },
-  ];
-
-  return {
-    tokenizer: 'dependency-free estimator',
-    doesNotClaimProviderExactness: true,
-    samples: samples.map((sample) => {
-      const estimate = estimateRequestTokens(sample.request);
-      return {
-        label: sample.label,
-        inputTokens: estimate.inputTokens,
-        outputTokens: estimate.outputTokens,
-        totalTokens: estimate.tokens,
-      };
-    }),
-  };
-}
-
-async function warmup(directCall, guardedCall, request) {
-  for (let index = 0; index < 100; index++) {
-    await directCall(request);
-    await guardedCall(request);
-  }
-}
-
-async function timeAsync(count, fn) {
-  const start = performance.now();
-  for (let index = 0; index < count; index++) {
-    await fn();
-  }
-  return performance.now() - start;
-}
-
-function context(prompt) {
-  return {
-    model: 'gpt-4o-mini',
-    pricingKnown: true,
-    tokens: 100,
-    inputTokens: 40,
-    outputTokens: 60,
-    estimatedCost: 0.0001,
-    timestamp: Date.now(),
-    prompt,
-  };
-}
-
-function collectGarbageIfAvailable() {
-  if (typeof globalThis.gc === 'function') {
-    globalThis.gc();
-  }
-}
-
-function readIterations(args) {
-  const index = args.indexOf('--iterations');
-  if (index === -1) return 5000;
-  const value = Number(args[index + 1]);
-  return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 5000;
-}
-
-function round(value, digits) {
-  const factor = 10 ** digits;
-  return Math.round(value * factor) / factor;
-}
+import { performance } from 'node:perf_hooks';
+import { guardFunction } from '../dist/index.js';
+import { GuardCore, GuardError } from '../dist/core/GuardCore.js';
+import { estimateRequestTokens } from '../dist/core/tokenizer.js';
+
+const iterations = readIterations(process.argv.slice(2));
+
+const result = {
+  generatedAt: new Date().toISOString(),
+  node: process.version,
+  platform: process.platform,
+  iterations,
+  runtimeOverhead: await measureRuntimeOverhead(iterations),
+  memoryOverhead: await measureMemoryOverhead(Math.max(250, Math.min(iterations, 2000))),
+  falsePositiveScenarios: measureFalsePositiveScenarios(),
+  loopDetectionBehavior: measureLoopDetectionBehavior(),
+  costEstimationBoundaries: measureCostEstimationBoundaries(),
+};
+
+console.log(JSON.stringify(result, null, 2));
+
+async function measureRuntimeOverhead(count) {
+  async function directCall(request) {
+    return { ok: true, usage: { prompt_tokens: 12, completion_tokens: request.max_tokens ?? 8 } };
+  }
+
+  const guardedCall = guardFunction(directCall, {
+    budget: 1_000,
+    behaviorAnalysis: false,
+    scope: { projectId: 'benchmark' },
+  });
+
+  const request = {
+    model: 'gpt-4o-mini',
+    prompt: 'benchmark request',
+    max_tokens: 8,
+  };
+
+  await warmup(directCall, guardedCall, request);
+
+  const directMs = await timeAsync(count, () => directCall(request));
+  const guardedMs = await timeAsync(count, () => guardedCall(request));
+  const directPerCallMs = directMs / count;
+  const guardedPerCallMs = guardedMs / count;
+
+  return {
+    directTotalMs: round(directMs, 3),
+    guardedTotalMs: round(guardedMs, 3),
+    directPerCallMs: round(directPerCallMs, 6),
+    guardedPerCallMs: round(guardedPerCallMs, 6),
+    addedPerCallMs: round(guardedPerCallMs - directPerCallMs, 6),
+  };
+}
+
+async function measureMemoryOverhead(count) {
+  const guardedCall = guardFunction(
+    async (request) => ({ ok: true, usage: { prompt_tokens: 12, completion_tokens: request.max_tokens ?? 8 } }),
+    {
+      budget: 1_000,
+      maxHistory: count,
+      loopMinRepeats: count + 1,
+      scope: { projectId: 'memory-benchmark' },
+    }
+  );
+
+  collectGarbageIfAvailable();
+  const beforeBytes = process.memoryUsage().heapUsed;
+
+  for (let index = 0; index < count; index++) {
+    await guardedCall({
+      model: 'gpt-4o-mini',
+      prompt: `memory benchmark unique prompt ${index}`,
+      max_tokens: 8,
+    });
+  }
+
+  collectGarbageIfAvailable();
+  const afterBytes = process.memoryUsage().heapUsed;
+
+  return {
+    calls: count,
+    heapDeltaBytes: afterBytes - beforeBytes,
+    heapDeltaPerCallBytes: round((afterBytes - beforeBytes) / count, 2),
+    gcAvailable: typeof globalThis.gc === 'function',
+    note: 'Heap measurements are process-local and noisy unless Node is run with --expose-gc.',
+  };
+}
+
+function measureFalsePositiveScenarios() {
+  const core = new GuardCore({
+    budget: 1,
+    retryThreshold: 2,
+    loopSimilarityThreshold: 0.9,
+    scope: { projectId: 'false-positive-benchmark' },
+  });
+  const prompts = [
+    'again compare the two product options',
+    'again summarize the second option with different tradeoffs',
+    'again write a new title for the launch note',
+  ];
+  let blocked = 0;
+
+  for (const prompt of prompts) {
+    try {
+      core.check(context(prompt));
+    } catch (error) {
+      if (error instanceof GuardError) blocked += 1;
+      else throw error;
+    }
+  }
+
+  return {
+    scenario: 'Repeated benign "again" prompts without failure/error language',
+    prompts: prompts.length,
+    blocked,
+  };
+}
+
+function measureLoopDetectionBehavior() {
+  const core = new GuardCore({
+    budget: 1,
+    loopSimilarityThreshold: 0.9,
+    loopMinRepeats: 2,
+    scope: { projectId: 'loop-benchmark' },
+  });
+  const prompt = 'summarize the same tool observation and continue the agent plan';
+
+  for (let step = 1; step <= 5; step++) {
+    try {
+      core.check(context(prompt));
+    } catch (error) {
+      if (error instanceof GuardError) {
+        return {
+          repeatedPrompt: prompt,
+          blockedAtStep: step,
+          code: error.code,
+          reason: error.message,
+        };
+      }
+
+      throw error;
+    }
+  }
+
+  return {
+    repeatedPrompt: prompt,
+    blockedAtStep: null,
+  };
+}
+
+function measureCostEstimationBoundaries() {
+  const samples = [
+    { label: 'short chat', request: { messages: [{ role: 'user', content: 'hello' }], max_tokens: 32 } },
+    {
+      label: 'long instruction',
+      request: {
+        messages: [{ role: 'user', content: 'Summarize the following requirements. '.repeat(120) }],
+        max_tokens: 256,
+      },
+    },
+    {
+      label: 'code-heavy prompt',
+      request: {
+        prompt: 'function example(value) { return value.map((item) => item.id).join(","); }\n'.repeat(40),
+        max_tokens: 128,
+      },
+    },
+  ];
+
+  return {
+    tokenizer: 'dependency-free estimator',
+    doesNotClaimProviderExactness: true,
+    samples: samples.map((sample) => {
+      const estimate = estimateRequestTokens(sample.request);
+      return {
+        label: sample.label,
+        inputTokens: estimate.inputTokens,
+        outputTokens: estimate.outputTokens,
+        totalTokens: estimate.tokens,
+      };
+    }),
+  };
+}
+
+async function warmup(directCall, guardedCall, request) {
+  for (let index = 0; index < 100; index++) {
+    await directCall(request);
+    await guardedCall(request);
+  }
+}
+
+async function timeAsync(count, fn) {
+  const start = performance.now();
+  for (let index = 0; index < count; index++) {
+    await fn();
+  }
+  return performance.now() - start;
+}
+
+function context(prompt) {
+  return {
+    model: 'gpt-4o-mini',
+    pricingKnown: true,
+    tokens: 100,
+    inputTokens: 40,
+    outputTokens: 60,
+    estimatedCost: 0.0001,
+    timestamp: Date.now(),
+    prompt,
+  };
+}
+
+function collectGarbageIfAvailable() {
+  if (typeof globalThis.gc === 'function') {
+    globalThis.gc();
+  }
+}
+
+function readIterations(args) {
+  const index = args.indexOf('--iterations');
+  if (index === -1) return 5000;
+  const value = Number(args[index + 1]);
+  return Number.isFinite(value) && value > 0 ? Math.trunc(value) : 5000;
+}
+
+function round(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}

package/benchmarks/token-accuracy.mjs

@@ -0,0 +1,182 @@
+import { estimateTokensFromText } from '../dist/core/tokenizer.js';
+
+const corpus = [
+  { label: 'short english', text: 'Summarize this ticket.', referenceTokens: 5 },
+  {
+    label: 'long english',
+    text:
+      'A customer reports that their nightly invoice reconciliation agent loops after a database timeout. ' +
+      'Explain the likely failure mode and propose two safe remediation steps.',
+    referenceTokens: 31,
+  },
+  { label: 'support summary', text: 'Summarize this support ticket in two bullets.', referenceTokens: 9 },
+  {
+    label: 'agent instruction',
+    text: 'You are an agent. Use the search tool, then cite the result in JSON.',
+    referenceTokens: 16,
+  },
+  {
+    label: 'retry guard',
+    text: 'The database migration failed with timeout 504. Retry only if the previous step is idempotent.',
+    referenceTokens: 19,
+  },
+  {
+    label: 'typescript code',
+    text: 'function normalizeUser(user) { return { id: user.id, email: user.email?.toLowerCase() }; }',
+    referenceTokens: 24,
+  },
+  {
+    label: 'python code',
+    text: 'def should_retry(error):\n    return error.status in {429, 500, 503} and error.attempts < 3',
+    referenceTokens: 27,
+  },
+  {
+    label: 'json config',
+    text: '{"model":"gpt-4o-mini","max_tokens":400,"tools":[{"name":"search","strict":true}]}',
+    referenceTokens: 25,
+  },
+  {
+    label: 'markdown task',
+    text: '## Release checklist\n- Run tests\n- Verify npm pack\n- Publish patch\n- Tag the release',
+    referenceTokens: 22,
+  },
+  {
+    label: 'arabic prompt',
+    text: 'لخص محادثة الدعم هذه وحدد السبب الجذري والخطوة التالية.',
+    referenceTokens: 18,
+  },
+  {
+    label: 'french prompt',
+    text: 'Explique pourquoi le budget de l’agent a été dépassé et propose une limite plus sûre.',
+    referenceTokens: 20,
+  },
+  {
+    label: 'repeated loop',
+    text: 'retry retry retry retry retry retry retry retry retry retry',
+    referenceTokens: 10,
+  },
+  {
+    label: 'tool call like',
+    text:
+      'tool_call: {"name":"fetch_invoice","arguments":{"customerId":"cus_123","month":"2026-06"}} ' +
+      'result: {"status":"timeout"}',
+    referenceTokens: 34,
+  },
+  {
+    label: 'agent loop like',
+    text:
+      'Step 12 failed. Try the same retrieval again with identical arguments, then repeat until the API returns data.',
+    referenceTokens: 22,
+  },
+  {
+    label: 'model comparison',
+    text: 'Compare Claude Haiku and GPT-4o mini for a budget-sensitive chatbot.',
+    referenceTokens: 17,
+  },
+  {
+    label: 'customer apology',
+    text: 'Write a concise customer apology for a delayed shipment and include one next step.',
+    referenceTokens: 16,
+  },
+  {
+    label: 'log line',
+    text: 'Analyze these logs: ERROR rate_limit_exceeded request_id=req_123 retry_after=2s',
+    referenceTokens: 24,
+  },
+  {
+    label: 'interface request',
+    text: 'Create a TypeScript interface for a webhook payload with cost, model, and reason fields.',
+    referenceTokens: 17,
+  },
+  {
+    label: 'sql query',
+    text: 'SELECT tenant_id, SUM(cost_usd) FROM ai_events WHERE blocked = false GROUP BY tenant_id;',
+    referenceTokens: 23,
+  },
+  {
+    label: 'error stack',
+    text: 'Error: Budget exceeded\n    at GuardCore.check (src/core/GuardCore.ts:144:11)\n    at agent.run (agent.ts:42:7)',
+    referenceTokens: 33,
+  },
+  {
+    label: 'anthropic workflow',
+    text:
+      'Claude should inspect the document, call the classifier once, and stop if confidence is below 0.7.',
+    referenceTokens: 21,
+  },
+  {
+    label: 'vercel chatbot',
+    text:
+      'streamText should answer the user only after the guard confirms the remaining session budget is sufficient.',
+    referenceTokens: 19,
+  },
+  {
+    label: 'ci budget check',
+    text: 'npx aifw check --budget 1 --model gpt-4o-mini --tokens 800 --max-steps 20',
+    referenceTokens: 29,
+  },
+  {
+    label: 'mixed punctuation',
+    text: 'Guard this: $$$, retries=3, model=gpt-4o-mini, scope=session:abc, max_tokens=250.',
+    referenceTokens: 28,
+  },
+];
+
+const samples = corpus.map((sample) => {
+  const estimatedTokens = estimateTokensFromText(sample.text);
+  const absoluteError = Math.abs(estimatedTokens - sample.referenceTokens);
+  const percentError = (absoluteError / sample.referenceTokens) * 100;
+
+  return {
+    label: sample.label,
+    estimatedTokens,
+    referenceTokens: sample.referenceTokens,
+    absoluteError,
+    percentError: round(percentError, 2),
+  };
+});
+
+const percentErrors = samples.map((sample) => sample.percentError).sort((a, b) => a - b);
+const report = {
+  generatedAt: new Date().toISOString(),
+  reference: {
+    tokenizer: 'fixed proxy fixture counts',
+    note:
+      'Reference counts are dependency-free proxy fixtures, not live provider tokenizers. Use this to understand estimator bias and boundaries, not to claim exact provider parity.',
+  },
+  sampleCount: samples.length,
+  averageErrorPercent: round(average(percentErrors), 2),
+  medianErrorPercent: round(median(percentErrors), 2),
+  maxErrorPercent: Math.max(...percentErrors),
+  markdownTable: formatMarkdownTable(samples),
+  samples,
+};
+
+console.log(JSON.stringify(report, null, 2));
+
+function average(values) {
+  return values.reduce((total, value) => total + value, 0) / values.length;
+}
+
+function median(values) {
+  const midpoint = Math.floor(values.length / 2);
+  if (values.length % 2 === 1) return values[midpoint];
+  return (values[midpoint - 1] + values[midpoint]) / 2;
+}
+
+function round(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+function formatMarkdownTable(rows) {
+  const lines = ['| sample | estimate | proxy | error | error % |', '| --- | ---: | ---: | ---: | ---: |'];
+
+  for (const row of rows) {
+    lines.push(
+      `| ${row.label} | ${row.estimatedTokens} | ${row.referenceTokens} | ${row.absoluteError} | ${row.percentError}% |`
+    );
+  }
+
+  return lines.join('\n');
+}

package/dist/cli.d.ts

@@ -35,6 +35,13 @@ export interface CliDashboardOptions extends DashboardOptions {
     once: boolean;
     json: boolean;
 }
+/**
+ * Parsed options for the pricing freshness command.
+ */
+export interface CliPricingOptions {
+    checkStale: boolean;
+    days: number;
+}
 /**
  * Parses arguments for `aifw check`.
  */
@@ -43,6 +50,10 @@ export declare function parseCheckArgs(args: readonly string[]): CliCheckOptions
  * Parses arguments for `aifw dashboard`.
  */
 export declare function parseDashboardArgs(args: readonly string[]): CliDashboardOptions;
+/**
+ * Parses arguments for `aifw pricing`.
+ */
+export declare function parsePricingArgs(args: readonly string[]): CliPricingOptions;
 /**
  * Runs the aifw CLI and returns a process exit code.
  */

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAGA,OAAO,EAKL,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,8BAA8B;IAC9B,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,6BAA6B;IAC7B,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe,CA0BvE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,mBAAmB,CAgC/E;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,IAAI,GAAE,SAAS,MAAM,EAA0B,EAAE,EAAE,GAAE,KAAiB,GAAG,MAAM,CA4ErG"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAGA,OAAO,EAKL,KAAK,gBAAgB,EACtB,MAAM,gBAAgB,CAAC;AAExB;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,8BAA8B;IAC9B,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,6BAA6B;IAC7B,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mDAAmD;IACnD,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB;IAC3D,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe,CA0BvE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,mBAAmB,CAgC/E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,iBAAiB,CA+B3E;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,IAAI,GAAE,SAAS,MAAM,EAA0B,EAAE,EAAE,GAAE,KAAiB,GAAG,MAAM,CA6GrG"}