@vorionsys/platform-core 0.1.0

package/dist/security/injection-detector.d.ts

@@ -0,0 +1,510 @@
+/**
+ * Injection Detection System
+ *
+ * Comprehensive detection and prevention of injection attacks including:
+ * - SQL Injection
+ * - Cross-Site Scripting (XSS)
+ * - Command Injection
+ * - Template Injection
+ * - Path Traversal
+ * - LDAP Injection
+ * - XML Injection (XXE)
+ * - NoSQL Injection
+ *
+ * Provides configurable detection, allowlisting, and Fastify middleware integration.
+ *
+ * @packageDocumentation
+ */
+import type { FastifyPluginCallback, preHandlerHookHandler } from 'fastify';
+import { ValidationError } from '../common/validation.js';
+/**
+ * Types of injection attacks that can be detected
+ */
+export declare enum InjectionType {
+    /** SQL Injection - attacks targeting SQL databases */
+    SQL = "SQL",
+    /** Cross-Site Scripting - malicious script injection */
+    XSS = "XSS",
+    /** Command Injection - OS command execution */
+    COMMAND = "COMMAND",
+    /** Template Injection - server-side template manipulation */
+    TEMPLATE = "TEMPLATE",
+    /** Path Traversal - unauthorized file system access */
+    PATH_TRAVERSAL = "PATH_TRAVERSAL",
+    /** LDAP Injection - directory service attacks */
+    LDAP = "LDAP",
+    /** XML Injection - XML External Entity attacks */
+    XML = "XML",
+    /** NoSQL Injection - attacks targeting NoSQL databases */
+    NOSQL = "NOSQL"
+}
+/**
+ * Context in which input is being checked.
+ * Different contexts have different risk profiles and require different patterns.
+ */
+export declare enum InputContext {
+    /** URL query parameters */
+    URL_PARAM = "URL_PARAM",
+    /** Request body (JSON, form data, etc.) */
+    BODY = "BODY",
+    /** HTTP headers */
+    HEADER = "HEADER",
+    /** Path segment in URL */
+    PATH = "PATH",
+    /** Generic/unknown context (most restrictive) */
+    GENERIC = "GENERIC"
+}
+/**
+ * Sensitivity level for detection.
+ * Higher levels are more aggressive but may have more false positives.
+ */
+export declare enum SensitivityLevel {
+    /** Low sensitivity - only detect clear attack patterns */
+    LOW = "LOW",
+    /** Medium sensitivity - balanced detection (default) */
+    MEDIUM = "MEDIUM",
+    /** High sensitivity - aggressive detection, may have false positives */
+    HIGH = "HIGH"
+}
+/**
+ * Comprehensive regex patterns for detecting various injection attacks.
+ * Patterns are designed to minimize false positives while catching common attack vectors.
+ */
+export declare const INJECTION_PATTERNS: Record<InjectionType, RegExp[]>;
+/**
+ * Context-specific patterns that are only checked in certain contexts.
+ * This reduces false positives by not applying overly broad patterns everywhere.
+ */
+export declare const CONTEXT_SPECIFIC_PATTERNS: Record<InputContext, Partial<Record<InjectionType, RegExp[]>>>;
+/**
+ * Sensitivity-based pattern filtering.
+ * Maps sensitivity levels to which pattern indices to use.
+ */
+export declare const SENSITIVITY_CONFIG: Record<SensitivityLevel, {
+    /** Skip patterns at these indices (0-based) for each injection type */
+    skipPatternsByType: Partial<Record<InjectionType, number[]>>;
+    /** Whether to check less common injection types */
+    checkRareTypes: boolean;
+    /** Minimum pattern match length to consider (reduces noise) */
+    minMatchLength: number;
+}>;
+/**
+ * Default safe patterns that should be allowed in specific contexts.
+ * These are patterns that commonly appear in legitimate data but match
+ * injection detection patterns.
+ */
+export declare const DEFAULT_SAFE_PATTERNS: {
+    pattern: RegExp;
+    contexts: InputContext[];
+    description: string;
+}[];
+/**
+ * Configuration options for the injection detector
+ */
+export interface InjectionDetectorConfig {
+    /** Enable SQL injection detection */
+    enableSQLDetection: boolean;
+    /** Enable XSS detection */
+    enableXSSDetection: boolean;
+    /** Enable command injection detection */
+    enableCommandDetection: boolean;
+    /** Enable template injection detection */
+    enableTemplateDetection: boolean;
+    /** Enable path traversal detection */
+    enablePathTraversalDetection: boolean;
+    /** Enable LDAP injection detection */
+    enableLDAPDetection: boolean;
+    /** Enable XML/XXE injection detection */
+    enableXMLDetection: boolean;
+    /** Enable NoSQL injection detection */
+    enableNoSQLDetection: boolean;
+    /** Custom regex patterns to check */
+    customPatterns: RegExp[];
+    /** Known safe patterns to allowlist (bypass detection) */
+    allowlist: string[];
+    /** Whether to log detection events */
+    logDetections: boolean;
+    /** Whether to block requests on detection (vs just logging) */
+    blockOnDetection: boolean;
+    /** Sensitivity level for detection (default: MEDIUM) */
+    sensitivity?: SensitivityLevel;
+    /** Whether to use context-aware detection (default: true) */
+    contextAware?: boolean;
+    /** Custom safe patterns to add to the default list */
+    customSafePatterns?: Array<{
+        pattern: RegExp;
+        contexts: InputContext[];
+        description?: string;
+    }>;
+}
+/**
+ * Result of injection detection analysis
+ */
+export interface InjectionDetectionResult {
+    /** Whether any injection was detected */
+    detected: boolean;
+    /** Types of injections detected */
+    types: InjectionType[];
+    /** String representations of patterns that matched */
+    patterns: string[];
+    /** Sanitized version of input if sanitization was applied */
+    sanitized?: string;
+    /** Original input for reference */
+    originalInput?: string;
+    /** Timestamp of detection */
+    detectedAt?: string;
+}
+/**
+ * Options for the injection detection middleware
+ */
+export interface InjectionDetectionMiddlewareOptions {
+    /** Injection detector configuration */
+    config?: Partial<InjectionDetectorConfig>;
+    /** Paths to skip detection for */
+    skipPaths?: string[];
+    /** HTTP methods to skip */
+    skipMethods?: string[];
+    /** Whether to check query parameters */
+    checkQuery?: boolean;
+    /** Whether to check request body */
+    checkBody?: boolean;
+    /** Whether to check headers */
+    checkHeaders?: boolean;
+    /** Headers to skip checking */
+    skipHeaders?: string[];
+    /** Custom error response */
+    errorResponse?: {
+        statusCode: number;
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Default injection detector configuration with all detections enabled
+ */
+export declare const DEFAULT_INJECTION_DETECTOR_CONFIG: InjectionDetectorConfig;
+/**
+ * Injection attack detector with comprehensive pattern matching
+ *
+ * Provides detection, sanitization, and allowlisting capabilities for
+ * protecting against various injection attack vectors.
+ *
+ * @example
+ * ```typescript
+ * const detector = new InjectionDetector({
+ *   enableSQLDetection: true,
+ *   enableXSSDetection: true,
+ *   logDetections: true,
+ * });
+ *
+ * const result = detector.detect("SELECT * FROM users WHERE id = '1' OR '1'='1'");
+ * if (result.detected) {
+ *   console.log('Injection detected:', result.types);
+ * }
+ * ```
+ */
+export declare class InjectionDetector {
+    private config;
+    private allowlistPatterns;
+    private safePatterns;
+    private sensitivityConfig;
+    /**
+     * Create a new InjectionDetector instance
+     *
+     * @param config - Configuration options (merged with defaults)
+     */
+    constructor(config?: Partial<InjectionDetectorConfig>);
+    /**
+     * Check if input matches a safe pattern for the given context
+     *
+     * @param input - The input to check
+     * @param context - The input context
+     * @returns true if the input matches a safe pattern
+     */
+    private matchesSafePattern;
+    /**
+     * Get patterns to use for a specific injection type and context
+     *
+     * @param type - The injection type
+     * @param context - The input context
+     * @returns Array of patterns to check
+     */
+    private getPatternsForContext;
+    /**
+     * Filter patterns based on sensitivity level
+     */
+    private filterByNensitivity;
+    /**
+     * Detect injection attacks in an input string
+     *
+     * Checks the input against all enabled detection patterns and returns
+     * detailed information about any matches found.
+     *
+     * @param input - The string to analyze for injection patterns
+     * @param context - The context in which the input was received (optional)
+     * @returns Detection result with matched types and patterns
+     *
+     * @example
+     * ```typescript
+     * const result = detector.detect("<script>alert('xss')</script>");
+     * // result.detected === true
+     * // result.types includes InjectionType.XSS
+     *
+     * // With context-aware detection
+     * const bodyResult = detector.detect(jsonBody, InputContext.BODY);
+     * ```
+     */
+    detect(input: string, context?: InputContext): InjectionDetectionResult;
+    /**
+     * Detect injection attacks in all string values of an object
+     *
+     * Recursively traverses an object and checks all string values for
+     * injection patterns. Returns a map of field paths to detection results.
+     *
+     * @param obj - The object to analyze
+     * @param context - The input context for detection
+     * @param prefix - Internal prefix for tracking nested paths
+     * @returns Map of field paths to their detection results
+     *
+     * @example
+     * ```typescript
+     * const results = detector.detectInObject({
+     *   username: "admin",
+     *   query: "SELECT * FROM users",
+     *   nested: { field: "<script>xss</script>" }
+     * }, InputContext.BODY);
+     *
+     * for (const [field, result] of results) {
+     *   if (result.detected) {
+     *     console.log(`Injection in ${field}:`, result.types);
+     *   }
+     * }
+     * ```
+     */
+    detectInObject(obj: Record<string, unknown>, context?: InputContext, prefix?: string): Map<string, InjectionDetectionResult>;
+    /**
+     * Sanitize an input string by removing or escaping dangerous patterns
+     *
+     * Applies multiple sanitization techniques to neutralize potential
+     * injection attacks while preserving legitimate content where possible.
+     *
+     * @param input - The string to sanitize
+     * @returns Sanitized string
+     *
+     * @example
+     * ```typescript
+     * const sanitized = detector.sanitize("<script>alert('xss')</script>Hello");
+     * // sanitized === "&lt;script&gt;alert('xss')&lt;/script&gt;Hello"
+     * ```
+     */
+    sanitize(input: string): string;
+    /**
+     * Check if an input string is in the allowlist
+     *
+     * Allowlisted strings bypass injection detection entirely.
+     * Use sparingly for known-safe patterns.
+     *
+     * @param input - The string to check
+     * @returns True if the string is allowlisted
+     *
+     * @example
+     * ```typescript
+     * const detector = new InjectionDetector({
+     *   allowlist: ['SELECT count(*) FROM users']
+     * });
+     *
+     * detector.isAllowlisted('SELECT count(*) FROM users'); // true
+     * detector.isAllowlisted('SELECT * FROM users');        // false
+     * ```
+     */
+    isAllowlisted(input: string): boolean;
+    /**
+     * Add a pattern to the allowlist at runtime
+     *
+     * @param pattern - The pattern string to allowlist
+     */
+    addToAllowlist(pattern: string): void;
+    /**
+     * Add a custom detection pattern at runtime
+     *
+     * @param pattern - The regex pattern to add
+     */
+    addCustomPattern(pattern: RegExp): void;
+    /**
+     * Get the current configuration
+     *
+     * @returns Current detector configuration
+     */
+    getConfig(): InjectionDetectorConfig;
+    /**
+     * Update configuration at runtime
+     *
+     * @param updates - Partial configuration updates
+     */
+    updateConfig(updates: Partial<InjectionDetectorConfig>): void;
+}
+/**
+ * Error thrown when an injection attack is detected
+ */
+export declare class InjectionDetectedError extends ValidationError {
+    /** Types of injections detected */
+    injectionTypes: InjectionType[];
+    /** Detection result details */
+    detectionResult: InjectionDetectionResult;
+    constructor(message: string, detectionResult: InjectionDetectionResult, field?: string);
+}
+/**
+ * Fastify middleware type
+ */
+export type FastifyMiddleware = preHandlerHookHandler;
+/**
+ * Create a Fastify middleware for injection detection
+ *
+ * Automatically checks request query parameters, body, and headers
+ * for injection attacks based on configuration.
+ *
+ * @param options - Middleware configuration options
+ * @returns Fastify preHandler hook function
+ *
+ * @example
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { createInjectionDetectionMiddleware } from './injection-detector.js';
+ *
+ * const fastify = Fastify();
+ *
+ * fastify.addHook('preHandler', createInjectionDetectionMiddleware({
+ *   config: {
+ *     enableSQLDetection: true,
+ *     enableXSSDetection: true,
+ *     logDetections: true,
+ *     blockOnDetection: true,
+ *   },
+ *   skipPaths: ['/health', '/metrics'],
+ *   checkQuery: true,
+ *   checkBody: true,
+ *   checkHeaders: false,
+ * }));
+ * ```
+ */
+export declare function createInjectionDetectionMiddleware(options?: InjectionDetectionMiddlewareOptions): FastifyMiddleware;
+/**
+ * Fastify plugin options
+ */
+export interface InjectionDetectionPluginOptions extends InjectionDetectionMiddlewareOptions {
+    /** Register the detector as a request decorator */
+    decorateRequest?: boolean;
+}
+/**
+ * Fastify plugin for comprehensive injection detection
+ *
+ * Provides automatic injection detection on all routes with
+ * configurable options.
+ *
+ * @example
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import { injectionDetectionPlugin } from './injection-detector.js';
+ *
+ * const fastify = Fastify();
+ *
+ * await fastify.register(injectionDetectionPlugin, {
+ *   config: {
+ *     enableSQLDetection: true,
+ *     enableXSSDetection: true,
+ *     blockOnDetection: true,
+ *   },
+ *   skipPaths: ['/health', '/metrics'],
+ * });
+ * ```
+ */
+export declare const injectionDetectionPlugin: FastifyPluginCallback<InjectionDetectionPluginOptions>;
+declare module 'fastify' {
+    interface FastifyInstance {
+        injectionDetector?: InjectionDetector;
+    }
+}
+/**
+ * Create a pre-configured detector for SQL-only detection
+ *
+ * @returns InjectionDetector configured for SQL injection only
+ */
+export declare function createSQLInjectionDetector(): InjectionDetector;
+/**
+ * Create a pre-configured detector for XSS-only detection
+ *
+ * @returns InjectionDetector configured for XSS detection only
+ */
+export declare function createXSSDetector(): InjectionDetector;
+/**
+ * Create a pre-configured detector for API security (SQL, NoSQL, Command)
+ *
+ * @returns InjectionDetector configured for common API attack vectors
+ */
+export declare function createAPISecurityDetector(): InjectionDetector;
+/**
+ * Quick check function for ad-hoc injection detection
+ *
+ * @param input - String to check
+ * @param types - Specific injection types to check (default: all)
+ * @returns True if any injection patterns are detected
+ *
+ * @example
+ * ```typescript
+ * if (hasInjection(userInput, [InjectionType.SQL, InjectionType.XSS])) {
+ *   throw new Error('Invalid input');
+ * }
+ * ```
+ */
+export declare function hasInjection(input: string, types?: InjectionType[]): boolean;
+/**
+ * Quick sanitize function for ad-hoc input sanitization
+ *
+ * @param input - String to sanitize
+ * @returns Sanitized string
+ */
+export declare function sanitizeInput(input: string): string;
+/**
+ * Create a detector with low sensitivity (fewer false positives)
+ *
+ * Low sensitivity is suitable for environments where legitimate data
+ * may contain patterns that look like injection (e.g., code snippets,
+ * documentation, or technical data).
+ *
+ * @returns InjectionDetector with low sensitivity
+ */
+export declare function createLowSensitivityDetector(): InjectionDetector;
+/**
+ * Create a detector with high sensitivity (more aggressive detection)
+ *
+ * High sensitivity is suitable for environments where security is
+ * paramount and false positives are acceptable (e.g., user registration,
+ * public-facing forms, or untrusted input).
+ *
+ * @returns InjectionDetector with high sensitivity
+ */
+export declare function createHighSensitivityDetector(): InjectionDetector;
+/**
+ * Create a context-aware detector with custom safe patterns
+ *
+ * @param safePatterns - Additional patterns to treat as safe
+ * @param sensitivity - Detection sensitivity level
+ * @returns Configured InjectionDetector
+ *
+ * @example
+ * ```typescript
+ * const detector = createContextAwareDetector([
+ *   {
+ *     pattern: /^my-app-\d+$/,
+ *     contexts: [InputContext.BODY, InputContext.URL_PARAM],
+ *     description: 'Application ID format',
+ *   },
+ * ], SensitivityLevel.MEDIUM);
+ * ```
+ */
+export declare function createContextAwareDetector(safePatterns?: Array<{
+    pattern: RegExp;
+    contexts: InputContext[];
+    description?: string;
+}>, sensitivity?: SensitivityLevel): InjectionDetector;
+//# sourceMappingURL=injection-detector.d.ts.map

package/dist/security/injection-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injection-detector.d.ts","sourceRoot":"","sources":["../../src/security/injection-detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAIV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAQ1D;;GAEG;AACH,oBAAY,aAAa;IACvB,sDAAsD;IACtD,GAAG,QAAQ;IACX,wDAAwD;IACxD,GAAG,QAAQ;IACX,+CAA+C;IAC/C,OAAO,YAAY;IACnB,6DAA6D;IAC7D,QAAQ,aAAa;IACrB,uDAAuD;IACvD,cAAc,mBAAmB;IACjC,iDAAiD;IACjD,IAAI,SAAS;IACb,kDAAkD;IAClD,GAAG,QAAQ;IACX,0DAA0D;IAC1D,KAAK,UAAU;CAChB;AAED;;;GAGG;AACH,oBAAY,YAAY;IACtB,2BAA2B;IAC3B,SAAS,cAAc;IACvB,2CAA2C;IAC3C,IAAI,SAAS;IACb,mBAAmB;IACnB,MAAM,WAAW;IACjB,0BAA0B;IAC1B,IAAI,SAAS;IACb,iDAAiD;IACjD,OAAO,YAAY;CACpB;AAED;;;GAGG;AACH,oBAAY,gBAAgB;IAC1B,0DAA0D;IAC1D,GAAG,QAAQ;IACX,wDAAwD;IACxD,MAAM,WAAW;IACjB,wEAAwE;IACxE,IAAI,SAAS;CACd;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,CAwQ9D,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,CAAC,CA4DpG,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,gBAAgB,EAAE;IACxD,uEAAuE;IACvE,kBAAkB,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IAC7D,mDAAmD;IACnD,cAAc,EAAE,OAAO,CAAC;IACxB,+DAA+D;IAC/D,cAAc,EAAE,MAAM,CAAC;CACxB,CAyBA,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;CACrB,EAyEA,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,qCAAqC;IACrC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,2BAA2B;IAC3B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,yCAAyC;IACzC,sBAAsB,EAAE,OAAO,CAAC;IAChC,0CAA0C;IAC1C,uBAAuB,EAAE,OAAO,CAAC;IACjC,sCAAsC;IACtC,4BAA4B,EAAE,OAAO,CAAC;IACtC,sCAAsC;IACtC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,yCAAyC;IACzC,kBAAkB,EAAE,OAAO,CAAC;IAC5B,uCAAuC;IACvC,oBAAoB,EAAE,OAAO,CAAC;IAC9B,qCAAqC;IACrC,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,sCAAsC;IACtC,aAAa,EAAE,OAAO,CAAC;IACvB,+DAA+D;IAC/D,gBAAgB,EAAE,OAAO,CAAC;IAC1B,wDAAwD;IACxD,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,6DAA6D;IAC7D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,sDAAsD;IACtD,kBAAkB,CAAC,EAAE,KAAK,CAAC;QACzB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,YAAY,EAAE,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,yCAAyC;IACzC,QAAQ,EAAE,OAAO,CAAC;IAClB,mCAAmC;IACnC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,sDAAsD;IACtD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mCAAmC;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,mCAAmC;IAClD,uCAAuC;IACvC,MAAM,CAAC,EAAE,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC1C,kCAAkC;IAClC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,2BAA2B;IAC3B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,wCAAwC;IACxC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+BAA+B;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,+BAA+B;IAC/B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,4BAA4B;IAC5B,aAAa,CAAC,EAAE;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAMD;;GAEG;AACH,eAAO,MAAM,iCAAiC,EAAE,uBAgB/C,CAAC;AAMF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,iBAAiB,CAAW;IACpC,OAAO,CAAC,YAAY,CAGjB;IACH,OAAO,CAAC,iBAAiB,CAA8C;IAEvE;;;;OAIG;gBACS,MAAM,GAAE,OAAO,CAAC,uBAAuB,CAAM;IAsBzD;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,YAAmC,GAAG,wBAAwB;IA8I7F;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,cAAc,CACZ,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,OAAO,GAAE,YAAgC,EACzC,MAAM,SAAK,GACV,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC;IA4CxC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAmD/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;OAIG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAOrC;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKvC;;;;OAIG;IACH,SAAS,IAAI,uBAAuB;IAIpC;;;;OAIG;IACH,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,uBAAuB,CAAC,GAAG,IAAI;CAU9D;AAMD;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,eAAe;IACzD,mCAAmC;IACnC,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,+BAA+B;IAC/B,eAAe,EAAE,wBAAwB,CAAC;gBAGxC,OAAO,EAAE,MAAM,EACf,eAAe,EAAE,wBAAwB,EACzC,KAAK,CAAC,EAAE,MAAM;CAOjB;AAMD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,GAAE,mCAAwC,GAChD,iBAAiB,CAqJnB;AAMD;;GAEG;AACH,MAAM,WAAW,+BACf,SAAQ,mCAAmC;IAC3C,mDAAmD;IACnD,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAyCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,wBAAwB,wDAGnC,CAAC;AAGH,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,eAAe;QACvB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;KACvC;CACF;AAMD;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,iBAAiB,CAW9D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,iBAAiB,CAWrD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,IAAI,iBAAiB,CAW7D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,aAAa,EAAE,GACtB,OAAO,CAaT;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,IAAI,iBAAiB,CAKhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,IAAI,iBAAiB,CAKjE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,GAAE,KAAK,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAM,EACP,WAAW,GAAE,gBAA0C,GACtD,iBAAiB,CAMnB"}