@framers/agentos 0.1.56 → 0.1.58

package/dist/extensions/packs/pii-redaction/index.js

@@ -1,195 +0,0 @@
-/**
- * @file index.ts
- * @description Pack factory for the PII Redaction extension pack.
- *
- * This module exports the main `createPiiRedactionPack()` factory function
- * that assembles the guardrail, scan tool, and redact tool into a single
- * {@link ExtensionPack} ready for registration with the AgentOS extension
- * manager.
- *
- * It also exports a `createExtensionPack()` bridge function that conforms to
- * the AgentOS manifest factory convention, delegating to
- * `createPiiRedactionPack()` with options extracted from the
- * {@link ExtensionPackContext}.
- *
- * ### Lifecycle
- *
- * Components are built eagerly at pack creation time for direct programmatic
- * use.  When the pack is activated by the extension manager, the `onActivate`
- * hook rebuilds all components with the manager's shared service registry and
- * secret resolver, ensuring heavyweight services (NLP models, NER weights)
- * are shared across the agent.
- *
- * @module pii-redaction
- */
-import { SharedServiceRegistry } from '../../SharedServiceRegistry.js';
-import { EXTENSION_KIND_GUARDRAIL, EXTENSION_KIND_TOOL } from '../../types.js';
-import { PiiRedactionGuardrail } from './PiiRedactionGuardrail.js';
-import { PiiScanTool } from './tools/PiiScanTool.js';
-import { PiiRedactTool } from './tools/PiiRedactTool.js';
-// ---------------------------------------------------------------------------
-// Re-exports
-// ---------------------------------------------------------------------------
-/**
- * Re-export all types from the PII redaction type definitions so consumers
- * can import everything from a single entry point:
- * ```ts
- * import { createPiiRedactionPack, PiiEntityType } from './pii-redaction';
- * ```
- */
-export * from './types.js';
-// ---------------------------------------------------------------------------
-// Pack factory
-// ---------------------------------------------------------------------------
-/**
- * Create an ExtensionPack that bundles the PII redaction guardrail with
- * the `pii_scan` and `pii_redact` tools.
- *
- * ### Default behaviour (zero-config)
- * When called without options, the pack detects all 18 PII entity types at
- * a confidence threshold of 0.5, redacts using the `placeholder` style
- * (`[EMAIL]`), and evaluates both input and output.
- *
- * ### Activation lifecycle
- * The pack uses mutable internal state (`state.services`, `state.getSecret`)
- * that is upgraded when the extension manager calls `onActivate` with its
- * shared service registry and secret resolver.  All three components
- * (guardrail, scan tool, redact tool) are rebuilt at that point so they
- * share NLP/NER model instances with other extensions.
- *
- * @param options - Optional pack-level configuration.  All properties have
- *                  sensible defaults; see {@link PiiRedactionPackOptions}.
- * @returns A fully-configured {@link ExtensionPack} with one guardrail and
- *          two tools.
- *
- * @example
- * ```ts
- * import { createPiiRedactionPack } from './pii-redaction';
- *
- * const pack = createPiiRedactionPack({
- *   entityTypes: ['EMAIL', 'PHONE', 'SSN'],
- *   redactionStyle: 'mask',
- *   guardrailScope: 'both',
- * });
- * ```
- */
-export function createPiiRedactionPack(options) {
-    /** Resolved options (defaults to empty object for zero-config). */
-    const opts = options ?? {};
-    // -----------------------------------------------------------------------
-    // Mutable state that onActivate can upgrade with the extension manager's
-    // shared registry and secret resolver.
-    // -----------------------------------------------------------------------
-    const state = {
-        /** Service registry — starts as a standalone instance, may be replaced. */
-        services: new SharedServiceRegistry(),
-        /** Secret resolver — initially undefined (no secrets available). */
-        getSecret: undefined,
-    };
-    // -----------------------------------------------------------------------
-    // Component instances — rebuilt by buildComponents()
-    // -----------------------------------------------------------------------
-    /** The guardrail service instance. */
-    let guardrail;
-    /** The PII scan tool instance. */
-    let scanTool;
-    /** The PII redact tool instance. */
-    let redactTool;
-    /**
-     * (Re)build all three pack components using the current `state.services`
-     * and `state.getSecret`.  Called once at pack creation and again during
-     * `onActivate` to upgrade to the shared registry.
-     */
-    function buildComponents() {
-        guardrail = new PiiRedactionGuardrail(state.services, opts, state.getSecret);
-        scanTool = new PiiScanTool(state.services, opts);
-        redactTool = new PiiRedactTool(state.services, opts);
-    }
-    // Initial build for direct programmatic use (before activation).
-    buildComponents();
-    // -----------------------------------------------------------------------
-    // ExtensionPack shape
-    // -----------------------------------------------------------------------
-    return {
-        /** Canonical pack name used in manifests and logs. */
-        name: 'pii-redaction',
-        /** Semantic version of the pack. */
-        version: '1.0.0',
-        /**
-         * Descriptors getter — returns the current component instances wrapped
-         * in the ExtensionDescriptor shape.  Uses a getter so that descriptors
-         * always reflect the latest (potentially rebuilt) component references.
-         */
-        get descriptors() {
-            return [
-                {
-                    id: 'pii-redaction-guardrail',
-                    kind: EXTENSION_KIND_GUARDRAIL,
-                    priority: 10,
-                    payload: guardrail,
-                },
-                {
-                    id: 'pii_scan',
-                    kind: EXTENSION_KIND_TOOL,
-                    priority: 0,
-                    payload: scanTool,
-                },
-                {
-                    id: 'pii_redact',
-                    kind: EXTENSION_KIND_TOOL,
-                    priority: 0,
-                    payload: redactTool,
-                },
-            ];
-        },
-        /**
-         * Lifecycle hook called by the extension manager when the pack is
-         * activated.  Upgrades the shared service registry and secret resolver
-         * to the manager's instances, then rebuilds all components so they
-         * share heavyweight services (NLP models, NER weights) with the rest
-         * of the agent.
-         *
-         * @param context - Activation context provided by the extension manager.
-         */
-        onActivate: (context) => {
-            // Upgrade the service registry if the manager provides one.
-            if (context.services) {
-                state.services = context.services;
-            }
-            // Upgrade the secret resolver if the manager provides one.
-            if (context.getSecret) {
-                state.getSecret = context.getSecret;
-            }
-            // Rebuild all components with the upgraded state.
-            buildComponents();
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// Manifest factory bridge
-// ---------------------------------------------------------------------------
-/**
- * AgentOS manifest factory function.
- *
- * This function conforms to the convention expected by the extension loader
- * when resolving packs from manifests.  It extracts `options` from the
- * {@link ExtensionPackContext} and delegates to {@link createPiiRedactionPack}.
- *
- * @param context - Manifest context containing optional pack options, secret
- *                  resolver, and shared service registry.
- * @returns A fully-configured {@link ExtensionPack}.
- *
- * @example
- * ```ts
- * // In an AgentOS manifest:
- * {
- *   "packs": [
- *     { "module": "./pii-redaction", "options": { "redactionStyle": "hash" } }
- *   ]
- * }
- * ```
- */
-export function createExtensionPack(context) {
-    return createPiiRedactionPack(context.options);
-}
-//# sourceMappingURL=index.js.map

package/dist/extensions/packs/pii-redaction/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/extensions/packs/pii-redaction/index.ts"],"names":[],"mappings":"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"}

package/dist/extensions/packs/pii-redaction/recognizers/IEntityRecognizer.d.ts

@@ -1,151 +0,0 @@
-/**
- * @file IEntityRecognizer.ts
- * @description Internal interface contract for all PII entity recognisers used
- * within the detection pipeline.
- *
- * Each detection tier (regex, NER model, LLM judge, denylist) implements this
- * interface so the orchestrating {@link PiiDetectionService} can treat them
- * uniformly — iterating, filtering by capability, and composing results
- * without coupling to concrete implementations.
- *
- * @module pii-redaction/recognizers
- */
-import type { PiiEntity, PiiEntityType } from '../types';
-/**
- * Options passed to {@link IEntityRecognizer.recognize} on every call.
- *
- * Recognisers are encouraged (but not required) to honour all fields;
- * a recogniser that cannot make use of a field should silently ignore it
- * rather than throwing.
- */
-export interface RecognizeOptions {
-    /**
-     * Subset of entity types the caller is interested in.
-     * The recogniser SHOULD skip detection for types not in this list to avoid
-     * redundant work.  If the array is empty or omitted the recogniser should
-     * use its own default set (typically everything it supports).
-     */
-    entityTypes?: PiiEntityType[];
-    /**
-     * BCP-47 language tag of the input text (e.g. `'en'`, `'de'`, `'zh-Hans'`).
-     * Recognisers that are language-sensitive (e.g. an NER model) use this to
-     * select the correct model variant or pattern set.
-     * @default `'en'`
-     */
-    language?: string;
-    /**
-     * Optional surrounding context provided by the caller — typically the full
-     * conversation turn or document paragraph from which the input chunk was
-     * extracted.  Recognisers (especially the LLM judge) may use this wider
-     * context to resolve ambiguous spans more accurately.
-     *
-     * The context string is NOT itself subject to detection in this call; it is
-     * purely informational.
-     */
-    context?: string;
-    /**
-     * Entities already discovered by previously-run recognisers in the same
-     * pipeline pass.  A recogniser may use these to avoid emitting duplicate
-     * spans, to improve confidence scoring on overlapping regions, or to skip
-     * re-examining character ranges already confirmed by an earlier tier.
-     */
-    priorEntities?: PiiEntity[];
-}
-/**
- * Contract that every entity recogniser in the PII detection pipeline must
- * satisfy.
- *
- * Recognisers are stateless with respect to individual calls: all per-call
- * configuration is passed via {@link RecognizeOptions}.  Long-lived state
- * (e.g. a loaded NER model, an LRU response cache) is kept in the
- * implementing class and initialised once at construction or on first use.
- *
- * ### Lifecycle
- * 1. The {@link PiiDetectionService} instantiates recognisers at pack startup.
- * 2. {@link recognize} is called once per input chunk for every detection pass.
- * 3. {@link dispose} is called when the pack is torn down (agent shutdown or
- *    hot-reload).  Implementations MUST release native resources (model
- *    handles, open file descriptors, HTTP keep-alive connections) here.
- *
- * @example Minimal regex-only recogniser
- * ```ts
- * class EmailRecognizer implements IEntityRecognizer {
- *   readonly name = 'EmailRecognizer';
- *   readonly supportedEntities: PiiEntityType[] = ['EMAIL'];
- *
- *   async recognize(input: string, options?: RecognizeOptions): Promise<PiiEntity[]> {
- *     const EMAIL_RE = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
- *     const entities: PiiEntity[] = [];
- *     let m: RegExpExecArray | null;
- *     while ((m = EMAIL_RE.exec(input)) !== null) {
- *       entities.push({
- *         entityType: 'EMAIL',
- *         text: m[0],
- *         start: m.index,
- *         end: m.index + m[0].length,
- *         score: 1.0,
- *         source: 'regex',
- *       });
- *     }
- *     return entities;
- *   }
- *
- *   async dispose(): Promise<void> { /* nothing to release *\/ }
- * }
- * ```
- */
-export interface IEntityRecognizer {
-    /**
-     * Human-readable name used in log messages and observability traces.
-     * Should be unique within a running pipeline but is not enforced by the
-     * registry.
-     *
-     * @example `'RegexRecognizer'`, `'SpacyNerRecognizer'`, `'OpenAiLlmJudge'`
-     */
-    readonly name: string;
-    /**
-     * The set of {@link PiiEntityType} values this recogniser is capable of
-     * detecting.
-     *
-     * The {@link PiiDetectionService} uses this list to route detection work:
-     * if the caller requests only `['EMAIL', 'PHONE']` and a recogniser's
-     * `supportedEntities` has no overlap, the recogniser is skipped entirely for
-     * that call.
-     */
-    readonly supportedEntities: PiiEntityType[];
-    /**
-     * Scan `input` for PII entities and return all matches above the
-     * recogniser's internal confidence threshold.
-     *
-     * Implementations MUST:
-     * - Return an empty array (never `null` or `undefined`) when no PII is found.
-     * - Not mutate `input` or any object in `options.priorEntities`.
-     * - Be safe to call concurrently from multiple async contexts (i.e. avoid
-     *   shared mutable state that is not protected by a lock or queue).
-     *
-     * Implementations SHOULD:
-     * - Respect `options.entityTypes` and skip patterns outside that set.
-     * - Set `PiiEntity.source` to the appropriate tier identifier.
-     * - Return overlapping spans only when they carry meaningfully different
-     *   semantic labels; prefer the highest-confidence span otherwise.
-     *
-     * @param input - The raw text string to analyse.  May be a partial chunk
-     *   when called from the streaming evaluator.
-     * @param options - Per-call tuning parameters.  All fields are optional.
-     * @returns A promise resolving to an array of detected {@link PiiEntity}
-     *   objects, possibly empty.
-     */
-    recognize(input: string, options?: RecognizeOptions): Promise<PiiEntity[]>;
-    /**
-     * Release all resources held by this recogniser instance.
-     *
-     * Called by the {@link PiiDetectionService} during agent shutdown or when
-     * the pack is dynamically unloaded.  After `dispose()` resolves, `recognize`
-     * MUST NOT be called again; the behaviour is undefined if it is.
-     *
-     * Implementations that hold no resources may return a resolved promise
-     * immediately: `async dispose() {}`.
-     */
-    dispose(): Promise<void>;
-}
-//# sourceMappingURL=IEntityRecognizer.d.ts.map

package/dist/extensions/packs/pii-redaction/recognizers/IEntityRecognizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"IEntityRecognizer.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/packs/pii-redaction/recognizers/IEntityRecognizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAMzD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,aAAa,EAAE,CAAC;IAE9B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,SAAS,EAAE,CAAC;CAC7B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,iBAAiB,EAAE,aAAa,EAAE,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAE3E;;;;;;;;;OASG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B"}

package/dist/extensions/packs/pii-redaction/recognizers/IEntityRecognizer.js

@@ -1,14 +0,0 @@
-/**
- * @file IEntityRecognizer.ts
- * @description Internal interface contract for all PII entity recognisers used
- * within the detection pipeline.
- *
- * Each detection tier (regex, NER model, LLM judge, denylist) implements this
- * interface so the orchestrating {@link PiiDetectionService} can treat them
- * uniformly — iterating, filtering by capability, and composing results
- * without coupling to concrete implementations.
- *
- * @module pii-redaction/recognizers
- */
-export {};
-//# sourceMappingURL=IEntityRecognizer.js.map

package/dist/extensions/packs/pii-redaction/recognizers/IEntityRecognizer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IEntityRecognizer.js","sourceRoot":"","sources":["../../../../../src/extensions/packs/pii-redaction/recognizers/IEntityRecognizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/extensions/packs/pii-redaction/recognizers/LlmJudgeRecognizer.d.ts

@@ -1,177 +0,0 @@
-/**
- * @file LlmJudgeRecognizer.ts
- * @description Tier 4 LLM-powered judge that re-examines individual PII
- * entity candidates using a chain-of-thought (CoT) prompt.
- *
- * Unlike the other recognisers, this class does **not** implement
- * {@link IEntityRecognizer} because it operates on already-detected entities
- * rather than raw text.  Its primary entry point is
- * {@link LlmJudgeRecognizer.judge}, which takes a single {@link PiiEntity}
- * plus the surrounding full text and returns either a confirmed/reclassified
- * entity or `null` if the LLM determines the span is not PII.
- *
- * ### Key features
- * - **Chain-of-thought prompt**: Forces the LLM to reason before classifying,
- *   improving accuracy on ambiguous spans.
- * - **LRU cache**: Keyed by `(span_text, context_hash)` to avoid redundant
- *   calls for identical spans in similar contexts.
- * - **Semaphore**: Limits concurrent LLM requests to prevent rate-limit
- *   exhaustion on high-throughput agents.
- * - **Fail-open**: If the LLM call fails for any reason, the original entity
- *   is returned unchanged (conservative — prefer false positive over leak).
- *
- * @module pii-redaction/recognizers
- */
-import type { PiiEntity, LlmJudgeConfig } from '../types';
-/**
- * Minimal fetch-compatible function signature.  Allows injection of a mock
- * fetch in tests without depending on the global `fetch` or any HTTP library.
- */
-type FetchFn = (url: string, init: {
-    method: string;
-    headers: Record<string, string>;
-    body: string;
-}) => Promise<{
-    ok: boolean;
-    status: number;
-    json(): Promise<unknown>;
-}>;
-/**
- * Tier 4 LLM-powered judge that confirms or reclassifies individual PII
- * entity candidates using chain-of-thought reasoning.
- *
- * ### Usage pattern
- * ```ts
- * const judge = new LlmJudgeRecognizer(config);
- * const result = await judge.judge(candidateEntity, fullText);
- * if (result === null) {
- *   // LLM says it's not PII — discard the candidate.
- * } else {
- *   // Use the confirmed/reclassified entity.
- * }
- * ```
- *
- * ### Caching
- * Results are cached by a composite key of the span text and a hash of
- * the surrounding context.  This means identical spans in similar contexts
- * won't trigger redundant LLM calls.
- *
- * ### Concurrency control
- * A counting semaphore limits the number of in-flight LLM requests to
- * {@link LlmJudgeConfig.maxConcurrency} (default 3), preventing rate-limit
- * errors when many entities are judged in parallel.
- *
- * ### Failure mode
- * The judge is **fail-open**: if the LLM call fails (network error, invalid
- * response, timeout), the original entity is returned unchanged.  This is
- * the conservative choice — a false positive (over-redaction) is preferable
- * to leaking real PII.
- */
-export declare class LlmJudgeRecognizer {
-    /** Human-readable name for logging/diagnostics. */
-    readonly name = "LlmJudgeRecognizer";
-    /** The LLM judge configuration. */
-    private readonly config;
-    /** LRU cache keyed by `(span_text, context_hash)`. */
-    private readonly cache;
-    /** Semaphore to limit concurrent LLM requests. */
-    private readonly semaphore;
-    /** Injectable fetch implementation (defaults to global fetch). */
-    private readonly fetchImpl;
-    /**
-     * Construct a new LlmJudgeRecognizer.
-     *
-     * @param config    - LLM provider/model configuration.
-     * @param fetchImpl - Optional injectable fetch function for testing.
-     *                    Defaults to the global `fetch`.
-     */
-    constructor(config: LlmJudgeConfig, fetchImpl?: FetchFn);
-    /**
-     * Judge a single PII entity candidate in context.
-     *
-     * @param entity   - The candidate entity to evaluate.
-     * @param fullText - The full text from which the entity was extracted,
-     *                   providing the LLM with surrounding context.
-     * @returns The confirmed/reclassified entity, or `null` if the LLM
-     *          determines the span is not PII.
-     */
-    judge(entity: PiiEntity, fullText: string): Promise<PiiEntity | null>;
-    /**
-     * Builds the cache key from the span text and a simple hash of the
-     * surrounding context.
-     *
-     * The context hash uses a fast DJB2 hash — sufficient for cache-key
-     * purposes without requiring a cryptographic hash function.
-     *
-     * @param spanText - The matched text span.
-     * @param context  - The full surrounding text.
-     * @returns A composite cache key string.
-     */
-    private buildCacheKey;
-    /**
-     * DJB2 hash function by Daniel J. Bernstein.
-     * Fast, non-cryptographic hash suitable for hash-table keys.
-     *
-     * @param str - String to hash.
-     * @returns Hex string representation of the hash.
-     */
-    private djb2Hash;
-    /**
-     * Builds the user prompt containing the span text and its surrounding
-     * context for the LLM to evaluate.
-     *
-     * @param entity   - The candidate entity.
-     * @param fullText - The full text for context.
-     * @returns The formatted user prompt string.
-     */
-    private buildUserPrompt;
-    /**
-     * Calls the LLM via OpenAI-compatible chat completions API.
-     *
-     * Uses raw `fetch` (no SDK dependency) to keep the extension lightweight
-     * and to support any OpenAI-compatible endpoint (OpenRouter, vLLM, etc.).
-     *
-     * @param userPrompt - The user message content.
-     * @returns Parsed LLM judgement response.
-     * @throws If the API call fails or the response is not valid JSON.
-     */
-    private callLlm;
-    /**
-     * Parses the LLM's response content into a structured judgement object.
-     *
-     * Handles common LLM response quirks:
-     * - Markdown code fences around JSON
-     * - Leading/trailing whitespace
-     *
-     * @param content - Raw response content string from the LLM.
-     * @returns Parsed {@link LlmJudgement}.
-     * @throws If the content cannot be parsed as valid JSON.
-     */
-    private parseJudgement;
-    /**
-     * Processes the LLM's judgement and returns the appropriate result.
-     *
-     * - If the LLM says the span is NOT PII, returns `null`.
-     * - If the LLM confirms PII, returns an updated entity with the LLM's
-     *   classification and confidence, preserving the original values in
-     *   metadata for audit.
-     *
-     * @param judgement - The parsed LLM response.
-     * @param original  - The original candidate entity.
-     * @returns Updated entity or `null`.
-     */
-    private processJudgement;
-    /**
-     * Maps the LLM's entity type string to our {@link PiiEntityType}.
-     *
-     * If the LLM returns a recognised type string, it is used directly.
-     * Otherwise, the original entity type is preserved.
-     *
-     * @param llmType  - Entity type string from the LLM response.
-     * @param fallback - Original entity type to use as fallback.
-     * @returns Resolved PiiEntityType.
-     */
-    private mapLlmEntityType;
-}
-export {};
-//# sourceMappingURL=LlmJudgeRecognizer.d.ts.map

package/dist/extensions/packs/pii-redaction/recognizers/LlmJudgeRecognizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LlmJudgeRecognizer.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/packs/pii-redaction/recognizers/LlmJudgeRecognizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAiB,cAAc,EAAE,MAAM,UAAU,CAAC;AAkLzE;;;GAGG;AACH,KAAK,OAAO,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd,KAAK,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAAC;AAMzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,kBAAkB;IAC7B,mDAAmD;IACnD,SAAgB,IAAI,wBAAwB;IAE5C,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IAExC,sDAAsD;IACtD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IAEnD,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IAEtC,kEAAkE;IAClE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IAEpC;;;;;;OAMG;gBACS,MAAM,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,OAAO;IAOvD;;;;;;;;OAQG;IACU,KAAK,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAyClF;;;;;;;;;;OAUG;IACH,OAAO,CAAC,aAAa;IAKrB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;IAShB;;;;;;;OAOG;IACH,OAAO,CAAC,eAAe;IAevB;;;;;;;;;OASG;YACW,OAAO;IAoCrB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;IAatB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IA+BxB;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;CAezB"}