@kaleidorg/mind 0.0.1 → 0.1.0

package/src/skills/skills.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Skills tests — parse SKILL.md, select per query, compose system + tool
+ * filter, and verify the engine honours allowedTools (progressive disclosure).
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { SkillRegistry, parseSkill, READ_REFERENCE_TOOL } from './registry.js';
+import { createSkillReferenceToolSource } from './reference-source.js';
+import { skillsFromBundle } from './bundle.js';
+import { Engine } from '../engine.js';
+import { ToolRegistry } from '../tools/registry.js';
+import { InProcessToolSource } from '../tools/in-process.js';
+import type { LLMProvider } from '../providers/types.js';
+import type { ToolCall } from '../types.js';
+
+// A real-spec SKILL.md: quoted multi-line description, nested metadata, no tools.
+const BITREFILL_SKILL = `---
+name: bitrefill
+description: "Buy or browse Bitrefill — gift cards, mobile top-ups, and eSIMs. Triggers when the user mentions Bitrefill, gift cards, mobile top-up, or eSIM."
+compatibility: "Detects host capabilities at runtime."
+metadata:
+  author: bitrefill
+  version: "2.1.5"
+---
+
+# Bitrefill
+
+Routes by capability. See the references for each path.`;
+
+const PORTFOLIO_SKILL = `---
+name: portfolio-manager
+description: Rebalance the BTC, USDT and XAUT portfolio to target allocations.
+tools: get_balance, place_order
+triggers: rebalance, allocation, portfolio
+---
+You manage a Bitcoin L2 portfolio. Check balances first, then place orders to
+hit the target allocation. Never exceed the user's risk band.`;
+
+describe('parseSkill', () => {
+  it('parses frontmatter + body', () => {
+    const s = parseSkill(PORTFOLIO_SKILL);
+    expect(s.name).toBe('portfolio-manager');
+    expect(s.description).toMatch(/Rebalance/);
+    expect(s.tools).toEqual(['get_balance', 'place_order']);
+    expect(s.triggers).toEqual(['rebalance', 'allocation', 'portfolio']);
+    expect(s.instructions).toMatch(/manage a Bitcoin L2 portfolio/);
+  });
+});
+
+describe('SkillRegistry selection', () => {
+  const reg = new SkillRegistry();
+  reg.addMarkdown(PORTFOLIO_SKILL);
+  reg.addMarkdown(`---
+name: channel-manager
+description: Open and manage Lightning channels.
+triggers: channel, liquidity, lsp
+---
+Manage Lightning channels via LSPS1.`);
+
+  it('routes a query to the right skill by trigger/description', () => {
+    expect(reg.select('please rebalance my portfolio')?.name).toBe('portfolio-manager');
+    expect(reg.select('open a new lightning channel')?.name).toBe('channel-manager');
+  });
+
+  it('returns null when nothing matches', () => {
+    expect(reg.select('what is the weather today')).toBeNull();
+  });
+
+  it('composes the system prompt + exposes the skill tool list', () => {
+    const skill = reg.select('rebalance my allocation')!;
+    const { system, allowedTools } = reg.compose('You are KaleidoMind.', skill);
+    expect(system).toMatch(/You are KaleidoMind\./);
+    expect(system).toMatch(/Active skill: portfolio-manager/);
+    expect(allowedTools).toEqual(['get_balance', 'place_order']);
+  });
+});
+
+describe('parseSkill — real Agent-Skills spec', () => {
+  it('unquotes the description, captures metadata, tolerates no tools', () => {
+    const s = parseSkill(BITREFILL_SKILL);
+    expect(s.name).toBe('bitrefill');
+    expect(s.description.startsWith('"')).toBe(false);
+    expect(s.description).toMatch(/gift cards/);
+    expect(s.tools).toBeUndefined();
+    // nested metadata keys fold into the flat metadata map
+    expect(s.metadata?.author).toBe('bitrefill');
+    expect(s.metadata?.version).toBe('2.1.5');
+    expect(s.metadata?.compatibility).toMatch(/host capabilities/);
+  });
+
+  it('selects on the long description embedding trigger phrases', () => {
+    const reg = new SkillRegistry();
+    reg.addMarkdown(BITREFILL_SKILL);
+    expect(reg.select('can you buy me an amazon gift card')?.name).toBe('bitrefill');
+    expect(reg.select('I want to buy an eSIM data plan')?.name).toBe('bitrefill');
+  });
+});
+
+describe('progressive disclosure — references', () => {
+  const refs = [
+    { name: 'mcp.md', content: '# MCP\nUse the remote MCP at api.bitrefill.com/mcp.' },
+    { name: 'cli.md', content: '# CLI\nGuest checkout via @bitrefill/cli.' },
+  ];
+
+  it('compose() advertises the reference files + keeps the reader tool reachable', () => {
+    const reg = new SkillRegistry();
+    reg.addMarkdown(
+      `---\nname: bitrefill\ndescription: shop with bitcoin\ntools: buy_product\ntriggers: bitrefill\n---\nbody`,
+      refs,
+    );
+    const skill = reg.get('bitrefill')!;
+    const { system, allowedTools } = reg.compose('base', skill);
+    expect(system).toMatch(/Reference files/);
+    expect(system).toMatch(/mcp\.md, cli\.md/);
+    expect(system).toMatch(READ_REFERENCE_TOOL);
+    // scoped tools, plus the reference reader so refs stay readable
+    expect(allowedTools).toEqual(['buy_product', READ_REFERENCE_TOOL]);
+  });
+
+  it('the reference tool source returns file contents and lists on miss', async () => {
+    const reg = new SkillRegistry();
+    reg.addMarkdown(`---\nname: bitrefill\ndescription: d\n---\nbody`, refs);
+    const src = createSkillReferenceToolSource(reg);
+    expect(src.has(READ_REFERENCE_TOOL)).toBe(true);
+
+    const out = await src.execute(READ_REFERENCE_TOOL, { file: 'mcp.md' });
+    expect(out).toMatch(/remote MCP/);
+
+    // scoping by skill + path-prefixed filename both resolve
+    const out2 = await src.execute(READ_REFERENCE_TOOL, { file: 'references/cli.md', skill: 'bitrefill' });
+    expect(out2).toMatch(/Guest checkout/);
+
+    await expect(src.execute(READ_REFERENCE_TOOL, { file: 'nope.md' })).rejects.toThrow(
+      /not found.*bitrefill\/mcp\.md/,
+    );
+  });
+});
+
+describe('skillsFromBundle — RN-safe loading', () => {
+  it('rehydrates skills (incl. references) from a v1 bundle', () => {
+    const skills = skillsFromBundle({
+      version: 1,
+      skills: [
+        {
+          dir: 'bitrefill',
+          markdown: '---\nname: bitrefill\ndescription: shop with bitcoin\ntriggers: bitrefill, gift card\n---\nbody',
+          references: [{ name: 'mcp.md', content: '# MCP' }],
+        },
+      ],
+    });
+    expect(skills).toHaveLength(1);
+    expect(skills[0].name).toBe('bitrefill');
+    expect(skills[0].references?.[0]?.name).toBe('mcp.md');
+    expect(skills[0].dir).toBe('bitrefill');
+    // and it's selectable through a registry built from the bundle
+    expect(new SkillRegistry(skills).select('buy a gift card')?.name).toBe('bitrefill');
+  });
+
+  it('rejects a malformed bundle', () => {
+    expect(() => skillsFromBundle({ version: 2 as 1, skills: [] })).toThrow(/valid v1/);
+  });
+});
+
+describe('engine honours allowedTools (progressive disclosure)', () => {
+  it('only exposes the skill’s tools to the model', async () => {
+    const seenToolNames: string[][] = [];
+    const provider: LLMProvider = {
+      name: 'spy',
+      async runTurn(input) {
+        seenToolNames.push(input.tools.map((t) => t.name));
+        return { text: 'done', rawContent: 'done', toolCalls: [] as ToolCall[] };
+      },
+    };
+    const tools = new ToolRegistry([
+      new InProcessToolSource('wallet', [
+        { name: 'get_balance', description: '', parameters: {}, handler: async () => ({}) },
+        { name: 'place_order', description: '', parameters: {}, handler: async () => ({}) },
+        { name: 'open_channel', description: '', parameters: {}, handler: async () => ({}) },
+        { name: 'delete_everything', description: '', parameters: {}, handler: async () => ({}) },
+      ]),
+    ]);
+    const engine = new Engine({ provider, tools });
+
+    await engine.runAgentic([{ role: 'user', content: 'rebalance' }], {
+      allowedTools: ['get_balance', 'place_order'],
+    });
+
+    // The model only saw the two allowed tools — not open_channel / delete_everything.
+    expect(seenToolNames[0].sort()).toEqual(['get_balance', 'place_order']);
+  });
+});

package/src/skills/types.ts

@@ -0,0 +1,55 @@
+/**
+ * Skills — Claude-style Agent Skills the brain can "enter".
+ *
+ * A skill is the top layer of tool use: a folder with a `SKILL.md` (YAML
+ * frontmatter + a markdown playbook) and optional `references/*.md` files that
+ * are loaded on demand. Entering a skill injects its playbook into the system
+ * prompt and (optionally) scopes the agent to a subset of tools. The tools are
+ * still invoked via function calling and may be backed by in-process handlers
+ * or MCP servers — skills don't replace those, they *direct* them.
+ *
+ * This is progressive disclosure, the core idea behind Anthropic's Agent Skills:
+ * a small local model never sees every tool or instruction at once — only the
+ * selected skill's playbook, and it can pull a reference file in when it needs
+ * the detail. The format is compatible with skills published for Claude (e.g.
+ * `bitrefill/agents`), so the same SKILL.md runs the QVAC brain unchanged.
+ */
+
+/** A reference file (references/*.md) the agent can read on demand. */
+export interface SkillReference {
+  /** Filename, e.g. "mcp.md". */
+  name: string;
+  /** Markdown contents. */
+  content: string;
+}
+
+export interface Skill {
+  /** Stable id, e.g. "bitrefill" / "portfolio-manager". */
+  name: string;
+  /**
+   * "When to use this" — the spec's selection signal. May be long and embed the
+   * trigger phrases ("…Triggers when the user mentions gift cards, eSIM…").
+   */
+  description: string;
+  /** The playbook: markdown instructions injected into the system prompt. */
+  instructions: string;
+  /**
+   * Tool names this skill is allowed to use. When set, the engine exposes only
+   * these tools while the skill is active (progressive disclosure). Omit to
+   * allow all registered tools (the default for capability-routing skills).
+   */
+  tools?: string[];
+  /** Optional trigger keywords to boost selection (in addition to description). */
+  triggers?: string[];
+  /** Remaining frontmatter (compatibility, author, version, homepage, …). */
+  metadata?: Record<string, string>;
+  /** Reference files (references/*.md) for progressive disclosure. */
+  references?: SkillReference[];
+  /** Source folder, when loaded from disk (Node). */
+  dir?: string;
+}
+
+/** Picks the most relevant skill for a query (or null for none). */
+export interface SkillSelector {
+  select(query: string, skills: Skill[]): Skill | null;
+}

package/src/tools/l402.test.ts

@@ -0,0 +1,113 @@
+/**
+ * L402 tool tests — the "agent pays for a tool in sats" flow, deterministic
+ * with a stubbed fetch. No network, no model.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { createL402ToolSource, parseL402Challenge, bolt11AmountSats } from './l402.js';
+
+describe('L402 helpers', () => {
+  it('parses an L402 challenge header', () => {
+    const h = 'L402 macaroon="AbCdEf==", invoice="lnbc100n1xyz"';
+    expect(parseL402Challenge(h)).toEqual({ macaroon: 'AbCdEf==', invoice: 'lnbc100n1xyz' });
+  });
+
+  it('returns null when the header is not an L402 challenge', () => {
+    expect(parseL402Challenge('Bearer xyz')).toBeNull();
+  });
+
+  it('parses bolt11 amounts to sats', () => {
+    expect(bolt11AmountSats('lnbc100n1xyz')).toBe(10); // 100 nano-BTC = 10 sats
+    expect(bolt11AmountSats('lnbc1u1xyz')).toBe(100); // 1 micro-BTC = 100 sats
+    expect(bolt11AmountSats('lnbc2500u1xyz')).toBe(250_000);
+  });
+});
+
+describe('createL402ToolSource — pay-and-fetch flow', () => {
+  it('pays the invoice on 402 then re-fetches with the L402 token', async () => {
+    const payInvoice = vi.fn(async () => ({ preimage: 'deadbeefpreimage' }));
+
+    // First call → 402 with a challenge; second (authed) call → 200 with data.
+    const fetchImpl = vi
+      .fn()
+      .mockResolvedValueOnce({
+        status: 402,
+        ok: false,
+        headers: new Map([
+          ['www-authenticate', 'L402 macaroon="MAC123", invoice="lnbc100n1demo"'],
+        ]) as any,
+      })
+      .mockResolvedValueOnce({
+        status: 200,
+        ok: true,
+        headers: new Map() as any,
+        async text() {
+          return JSON.stringify({ btc_usd: 73000 });
+        },
+      });
+
+    const src = createL402ToolSource({ payInvoice, fetchImpl: fetchImpl as unknown as typeof fetch });
+
+    const result = await src.execute('fetch_paid_resource', { url: 'https://api.example/premium/price' });
+
+    // paid the right invoice + amount (100n = 10 sats)
+    expect(payInvoice).toHaveBeenCalledWith('lnbc100n1demo', 10);
+    // second fetch carried the L402 Authorization header
+    const secondCallArgs = fetchImpl.mock.calls[1];
+    expect(secondCallArgs[1].headers.Authorization).toBe('L402 MAC123:deadbeefpreimage');
+    // returned the parsed JSON resource
+    expect(result).toEqual({ btc_usd: 73000 });
+  });
+
+  it('returns the resource directly when no payment is required (200)', async () => {
+    const payInvoice = vi.fn();
+    const fetchImpl = vi.fn().mockResolvedValueOnce({
+      status: 200,
+      ok: true,
+      headers: new Map() as any,
+      async text() {
+        return 'plain text resource';
+      },
+    });
+    const src = createL402ToolSource({ payInvoice, fetchImpl: fetchImpl as unknown as typeof fetch });
+
+    const result = await src.execute('fetch_paid_resource', { url: 'https://api.example/free' });
+
+    expect(payInvoice).not.toHaveBeenCalled();
+    expect(result).toBe('plain text resource');
+  });
+
+  it('exposes the tool with confirmation required (money tool)', () => {
+    const src = createL402ToolSource({ payInvoice: vi.fn() });
+    const tools = src.listTools();
+    expect(tools).toHaveLength(1);
+    expect(tools[0].name).toBe('fetch_paid_resource');
+    expect(tools[0].requiresConfirmation).toBe(true);
+  });
+
+  it('honours requiresConfirmation: false (auto-pay hosts)', () => {
+    const src = createL402ToolSource({ payInvoice: vi.fn(), requiresConfirmation: false });
+    expect(src.listTools()[0].requiresConfirmation).toBe(false);
+  });
+
+  it('declines invoices above maxAutoPaySats', async () => {
+    const payInvoice = vi.fn(async () => ({ preimage: 'x' }));
+    const fetchImpl = vi.fn().mockResolvedValueOnce({
+      status: 402,
+      ok: false,
+      headers: new Map([
+        // 2500u = 250,000 sats — above the 1000 cap
+        ['www-authenticate', 'L402 macaroon="M", invoice="lnbc2500u1big"'],
+      ]) as any,
+    });
+    const src = createL402ToolSource({
+      payInvoice,
+      maxAutoPaySats: 1000,
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+    await expect(src.execute('fetch_paid_resource', { url: 'https://x/y' })).rejects.toThrow(
+      /above the 1000 sat auto-pay cap/,
+    );
+    expect(payInvoice).not.toHaveBeenCalled();
+  });
+});

package/src/tools/l402.ts

@@ -0,0 +1,122 @@
+/**
+ * L402 tool source — lets the agent pay for paywalled HTTP resources in sats.
+ *
+ * Exposes one tool, `fetch_paid_resource(url)`, that runs the L402 flow:
+ *   GET url → 402 with an L402 challenge (macaroon + Lightning invoice)
+ *   → pay the invoice (via the injected `payInvoice`, e.g. the on-device wallet)
+ *   → re-GET with `Authorization: L402 <macaroon>:<preimage>` → return the body.
+ *
+ * This is the "agent pays for a tool in sats" capability: any KaleidoMind agent
+ * (mobile or desktop) can buy premium data / inference autonomously. Payment
+ * runs through the host's wallet, so it stays on-device; the engine's
+ * confirmation gate can wrap the spend if desired.
+ *
+ * No dependencies — uses global fetch (Node ≥18, React Native). The fetch impl
+ * is injectable for testing.
+ */
+
+import type { ToolDef } from '../types.js';
+import type { ToolSource } from './source.js';
+
+export interface L402PayResult {
+  /** Payment preimage (hex) — proves the invoice was paid. */
+  preimage: string;
+}
+
+export interface L402Options {
+  /** Pay a BOLT11 invoice, resolve with the preimage. Wallet on device; mock in tests. */
+  payInvoice: (invoice: string, amountSats: number) => Promise<L402PayResult>;
+  /** Override fetch (tests). Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Optional progress logging. */
+  log?: (msg: string) => void;
+  /**
+   * Gate the tool behind the engine's confirmation (default true). The catch:
+   * the invoice amount is only known DURING execution (the 402 challenge), so a
+   * pre-execution confirmation can't show it. On hosts without a dedicated L402
+   * confirmation UX, set this false and bound spending with `maxAutoPaySats`.
+   */
+  requiresConfirmation?: boolean;
+  /** Auto-pay only invoices up to this many sats; reject larger ones. */
+  maxAutoPaySats?: number;
+}
+
+/** Parse an L402 (or legacy LSAT) WWW-Authenticate challenge. */
+export function parseL402Challenge(header: string): { macaroon: string; invoice: string } | null {
+  const macaroon = header.match(/macaroon="([^"]+)"/i)?.[1];
+  const invoice = header.match(/invoice="([^"]+)"/i)?.[1];
+  return macaroon && invoice ? { macaroon, invoice } : null;
+}
+
+/** Rough BOLT11 amount → sats (for logging / spend caps). 0 if unparseable. */
+export function bolt11AmountSats(invoice: string): number {
+  const m = invoice.match(/^ln(?:bc|tb|bcrt)(\d+)([munp]?)/i);
+  if (!m) return 0;
+  const n = Number(m[1]);
+  const mult = (m[2] || '').toLowerCase();
+  const btc = mult === 'm' ? n / 1e3 : mult === 'u' ? n / 1e6 : mult === 'n' ? n / 1e9 : mult === 'p' ? n / 1e12 : n;
+  return Math.round(btc * 1e8);
+}
+
+export function createL402ToolSource(opts: L402Options): ToolSource {
+  const doFetch = opts.fetchImpl ?? fetch;
+
+  const tool: ToolDef = {
+    name: 'fetch_paid_resource',
+    description:
+      'Fetch a paywalled (L402) HTTP resource, automatically paying the required ' +
+      'Lightning invoice in sats. Use this for premium or paid APIs (market data, ' +
+      'inference, etc.). Pass the resource URL.',
+    parameters: {
+      type: 'object',
+      properties: { url: { type: 'string', description: 'The resource URL to fetch' } },
+      required: ['url'],
+    },
+    requiresConfirmation: opts.requiresConfirmation ?? true,
+  };
+
+  async function execute(_name: string, args: Record<string, unknown>): Promise<unknown> {
+    const url = String(args.url ?? '');
+    if (!url) throw new Error('fetch_paid_resource: url is required');
+
+    let res = await doFetch(url);
+
+    if (res.status === 402) {
+      const challenge = parseL402Challenge(res.headers.get('www-authenticate') ?? '');
+      if (!challenge) throw new Error('402 Payment Required but no L402 challenge present');
+
+      const amountSats =
+        bolt11AmountSats(challenge.invoice) || Number(res.headers.get('x-amount-sats') ?? 0);
+
+      if (opts.maxAutoPaySats != null && amountSats > opts.maxAutoPaySats) {
+        throw new Error(
+          `L402 invoice is ${amountSats} sats, above the ${opts.maxAutoPaySats} sat auto-pay cap — declined`,
+        );
+      }
+
+      opts.log?.(`L402: ${url} requires ${amountSats} sats — paying…`);
+
+      const { preimage } = await opts.payInvoice(challenge.invoice, amountSats);
+
+      res = await doFetch(url, {
+        headers: { Authorization: `L402 ${challenge.macaroon}:${preimage}` },
+      });
+      opts.log?.(`L402: paid ${amountSats} sats → ${res.status}`);
+    }
+
+    if (!res.ok) throw new Error(`fetch_paid_resource: ${res.status} ${res.statusText}`);
+    const body = await res.text();
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+
+  return {
+    id: 'l402',
+    listTools: () => [tool],
+    has: (name) => name === tool.name,
+    execute,
+  };
+}

package/dist/providers/qvac.d.ts

@@ -1,89 +0,0 @@
-/**
- * QVAC provider — primary, on-device.
- *
- * Wraps the QVAC SDK's llamacpp-completion plugin. The actual binding
- * differs slightly per host (RN vs Node vs browser worker), so the heavy
- * lifting is delegated to a `QvacBinding` injected by the adapter packages.
- *
- * Node (kaleido-agent):       binding = await import('@qvac/sdk/node')
- * React Native (rate):        binding from @kaleido/mind-rn → wraps QVACService
- * Browser (rate-extension):   binding from @kaleido/mind-browser → talks to worker
- */
-import type { LLMProvider, ProviderConfig, ProviderRunOptions, ProviderRunResult } from './types.js';
-import type { Message, ToolDef, TurnEvent } from '../types.js';
-/**
- * Host-injected binding. Each adapter package supplies its own.
- * We keep this duck-typed (not an abstract class) so adapters
- * don't have to extend anything heavy.
- */
-export interface QvacBinding {
-    load(modelPath: string, opts: {
-        contextSize: number;
-        backend?: 'metal' | 'cpu' | 'auto';
-    }): Promise<void>;
-    unload(): Promise<void>;
-    isReady(): boolean;
-    /** Synchronous completion. The adapter handles the QVAC SDK plumbing. */
-    complete(prompt: string, opts: {
-        maxTokens?: number;
-        temperature?: number;
-        topP?: number;
-        stop?: string[];
-        signal?: AbortSignal;
-    }): Promise<{
-        text: string;
-        usage?: {
-            prompt: number;
-            completion: number;
-        };
-    }>;
-    /** Streaming completion — yields token strings. */
-    stream(prompt: string, opts: {
-        maxTokens?: number;
-        temperature?: number;
-        topP?: number;
-        stop?: string[];
-        signal?: AbortSignal;
-    }): AsyncIterable<string>;
-}
-export interface QvacProviderOpts extends ProviderConfig {
-    binding: QvacBinding;
-    /**
-     * Chat template family. Auto-detect from model name when omitted.
-     *   'qwen3' — Qwen 3 family (thinking-mode aware)
-     *   'hermes' — Hermes 3/4 family
-     *   'llama3' — Llama 3.x Instruct
-     *   'chatml' — generic ChatML
-     */
-    template?: 'qwen3' | 'hermes' | 'llama3' | 'chatml';
-    backend?: 'metal' | 'cpu' | 'auto';
-}
-export declare class QvacProvider implements LLMProvider {
-    readonly name = "qvac";
-    readonly modelId: string;
-    private readonly binding;
-    private readonly contextSize;
-    private readonly temperature;
-    private readonly topP;
-    private readonly template;
-    private readonly backend;
-    constructor(opts: QvacProviderOpts);
-    load(): Promise<void>;
-    unload(): Promise<void>;
-    isReady(): boolean;
-    run(messages: Message[], tools: ToolDef[], opts?: ProviderRunOptions): Promise<ProviderRunResult>;
-    stream(messages: Message[], tools: ToolDef[], opts?: ProviderRunOptions): AsyncIterable<TurnEvent>;
-    private detectTemplate;
-    /**
-     * Render messages + tools into the model's chat template.
-     * TODO: full implementations per family. This stub uses a minimal
-     * tool-aware ChatML rendering that works for Qwen3 / Hermes / Llama 3.
-     */
-    private formatPrompt;
-    /**
-     * Parse the model's text output into (text, tool_calls).
-     * Recognises <tool_call>{...}</tool_call> blocks.
-     */
-    private parseCompletion;
-}
-//# sourceMappingURL=qvac.d.ts.map

package/dist/providers/qvac.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"qvac.d.ts","sourceRoot":"","sources":["../../src/providers/qvac.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,OAAO,EAAY,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzE;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1G,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,OAAO,IAAI,OAAO,CAAC;IACnB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;QAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC;IAC9E,mDAAmD;IACnD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACpD,OAAO,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;CACpC;AAED,qBAAa,YAAa,YAAW,WAAW;IAC9C,SAAgB,IAAI,UAAU;IAC9B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAEhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4C;IACrE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;gBAEvD,IAAI,EAAE,gBAAgB;IAU5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQrB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B,OAAO,IAAI,OAAO;IAIZ,GAAG,CACP,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,iBAAiB,CAAC;IAYtB,MAAM,CACX,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,IAAI,GAAE,kBAAuB,GAC5B,aAAa,CAAC,SAAS,CAAC;IAoB3B,OAAO,CAAC,cAAc;IAQtB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IA+BpB;;;OAGG;IACH,OAAO,CAAC,eAAe;CAwBxB"}