@reftrixmcp/mcp-server 0.1.7

package/dist/services/page/webgl-detector.service.d.ts

@@ -0,0 +1,113 @@
+/**
+ * WebGL Detector Service
+ *
+ * Detects WebGL/3D libraries on web pages to optimize loading strategies.
+ * Used to prevent timeouts on heavy WebGL sites like lbproject.dev.
+ *
+ * Features:
+ * - Canvas element detection
+ * - WebGL 1/2 context detection
+ * - Library detection (Three.js, Babylon.js, PixiJS, A-Frame, p5.js, etc.)
+ * - Heavy site classification
+ * - Wait strategy recommendation
+ *
+ * @module services/page/webgl-detector.service
+ */
+import type { Page } from "playwright";
+/**
+ * Detected WebGL library names
+ */
+export type WebGLLibrary = "three.js" | "babylon.js" | "pixi.js" | "a-frame" | "p5.js" | "playcanvas" | "gsap" | "lottie" | "phaser" | "unknown";
+/**
+ * Recommended wait strategy based on WebGL detection
+ */
+export type WaitStrategy = "standard" | "webgl-extended" | "networkidle";
+/**
+ * WebGL detection result
+ */
+export interface WebGLDetectionResult {
+    /** Whether WebGL context is available */
+    hasWebGL: boolean;
+    /** Whether canvas elements exist */
+    hasCanvas: boolean;
+    /** Number of canvas elements */
+    canvasCount: number;
+    /** Detected 3D/WebGL libraries */
+    detectedLibraries: string[];
+    /** WebGL version (1 or 2, null if not detected) */
+    webglVersion: 1 | 2 | null;
+    /** Whether the site is considered "heavy" (many assets, large canvases) */
+    isHeavySite: boolean;
+    /** Recommended wait strategy */
+    recommendedWaitStrategy: WaitStrategy;
+    /** Recommended timeout in milliseconds */
+    recommendedTimeout: number;
+    /** Time taken for detection in milliseconds */
+    detectionTimeMs: number;
+}
+/**
+ * Detection configuration defaults
+ */
+export declare const WEBGL_DETECTION_DEFAULTS: {
+    /** Standard timeout for non-WebGL pages */
+    readonly standardTimeout: 30000;
+    /** Extended timeout for WebGL pages */
+    readonly webglTimeout: 60000;
+    /** Timeout for heavy sites with complex 3D content */
+    readonly heavySiteTimeout: 120000;
+    /** Number of canvases to consider a site "heavy" */
+    readonly heavyCanvasThreshold: 3;
+    /** Canvas size (width * height) to consider heavy */
+    readonly heavyCanvasSizeThreshold: 1000000;
+    /** Detection timeout */
+    readonly detectionTimeout: 5000;
+};
+/**
+ * WebGL Detector Service
+ *
+ * Detects WebGL capabilities and 3D libraries on web pages to optimize
+ * loading strategies and prevent timeouts.
+ *
+ * @example
+ * ```typescript
+ * const detector = new WebGLDetectorService();
+ * const result = await detector.detect(page);
+ *
+ * if (result.isHeavySite) {
+ *   // Use extended timeout and networkidle wait strategy
+ *   await page.goto(url, {
+ *     timeout: result.recommendedTimeout,
+ *     waitUntil: 'networkidle',
+ *   });
+ * }
+ * ```
+ */
+export declare class WebGLDetectorService {
+    /**
+     * Detect WebGL capabilities and libraries on the page
+     *
+     * @param page - Playwright Page instance (after navigation)
+     * @returns Detection result with recommendations
+     */
+    detect(page: Page): Promise<WebGLDetectionResult>;
+    /**
+     * Get the detection script for manual execution
+     *
+     * This is useful when you need to execute the detection script
+     * at a specific timing or with custom handling.
+     *
+     * @returns JavaScript function string for browser evaluation
+     */
+    getDetectionScript(): string;
+}
+/**
+ * Get the WebGL detector service instance
+ *
+ * @returns WebGLDetectorService instance
+ */
+export declare function getWebGLDetectorService(): WebGLDetectorService;
+/**
+ * Reset the singleton instance (for testing)
+ */
+export declare function resetWebGLDetectorService(): void;
+//# sourceMappingURL=webgl-detector.service.d.ts.map

package/dist/services/page/webgl-detector.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-detector.service.d.ts","sourceRoot":"","sources":["../../../src/services/page/webgl-detector.service.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAOvC;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,UAAU,GACV,YAAY,GACZ,SAAS,GACT,SAAS,GACT,OAAO,GACP,YAAY,GACZ,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAEzE;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,QAAQ,EAAE,OAAO,CAAC;IAClB,oCAAoC;IACpC,SAAS,EAAE,OAAO,CAAC;IACnB,gCAAgC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,kCAAkC;IAClC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,mDAAmD;IACnD,YAAY,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IAC3B,2EAA2E;IAC3E,WAAW,EAAE,OAAO,CAAC;IACrB,gCAAgC;IAChC,uBAAuB,EAAE,YAAY,CAAC;IACtC,0CAA0C;IAC1C,kBAAkB,EAAE,MAAM,CAAC;IAC3B,+CAA+C;IAC/C,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,eAAO,MAAM,wBAAwB;IACnC,2CAA2C;;IAE3C,uCAAuC;;IAEvC,sDAAsD;;IAEtD,oDAAoD;;IAEpD,qDAAqD;;IAErD,wBAAwB;;CAEhB,CAAC;AAyJX;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,oBAAoB;IAC/B;;;;;OAKG;IACG,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAuDvD;;;;;;;OAOG;IACH,kBAAkB,IAAI,MAAM;CAG7B;AAWD;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,oBAAoB,CAK9D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}

package/dist/services/page/webgl-detector.service.js

@@ -0,0 +1,280 @@
+"use strict";
+// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGLDetectorService = exports.WEBGL_DETECTION_DEFAULTS = void 0;
+exports.getWebGLDetectorService = getWebGLDetectorService;
+exports.resetWebGLDetectorService = resetWebGLDetectorService;
+const logger_1 = require("../../utils/logger");
+/**
+ * Detection configuration defaults
+ */
+exports.WEBGL_DETECTION_DEFAULTS = {
+    /** Standard timeout for non-WebGL pages */
+    standardTimeout: 30000,
+    /** Extended timeout for WebGL pages */
+    webglTimeout: 60000,
+    /** Timeout for heavy sites with complex 3D content */
+    heavySiteTimeout: 120000,
+    /** Number of canvases to consider a site "heavy" */
+    heavyCanvasThreshold: 3,
+    /** Canvas size (width * height) to consider heavy */
+    heavyCanvasSizeThreshold: 1000000, // 1000x1000
+    /** Detection timeout */
+    detectionTimeout: 5000,
+};
+// =====================================================
+// Logger
+// =====================================================
+const logger = (0, logger_1.createLogger)("WebGLDetector");
+// =====================================================
+// Detection Script
+// =====================================================
+/**
+ * Browser-side detection script (runs in page context)
+ *
+ * This script is evaluated inside the browser to detect WebGL capabilities
+ * and libraries without requiring additional network requests.
+ */
+const DETECTION_SCRIPT = `(() => {
+  const startTime = performance.now();
+  const result = {
+    hasWebGL: false,
+    hasCanvas: false,
+    canvasCount: 0,
+    detectedLibraries: [],
+    webglVersion: null,
+    isHeavySite: false,
+    recommendedWaitStrategy: 'standard',
+    recommendedTimeout: ${exports.WEBGL_DETECTION_DEFAULTS.standardTimeout},
+    detectionTimeMs: 0,
+  };
+
+  try {
+    // 1. Detect canvas elements
+    const canvases = document.querySelectorAll('canvas');
+    result.canvasCount = canvases.length;
+    result.hasCanvas = canvases.length > 0;
+
+    // 2. Check for WebGL context
+    if (result.hasCanvas) {
+      for (const canvas of canvases) {
+        try {
+          const gl2 = canvas.getContext('webgl2');
+          if (gl2) {
+            result.hasWebGL = true;
+            result.webglVersion = 2;
+            break;
+          }
+          const gl1 = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
+          if (gl1) {
+            result.hasWebGL = true;
+            result.webglVersion = 1;
+            break;
+          }
+        } catch {
+          // Context acquisition failed, continue checking other canvases
+        }
+      }
+    }
+
+    // 3. Detect WebGL/3D libraries
+    const libraries = [];
+
+    // Three.js
+    if (typeof window.THREE !== 'undefined') {
+      libraries.push('three.js');
+    }
+
+    // Babylon.js
+    if (typeof window.BABYLON !== 'undefined') {
+      libraries.push('babylon.js');
+    }
+
+    // PixiJS
+    if (typeof window.PIXI !== 'undefined') {
+      libraries.push('pixi.js');
+    }
+
+    // A-Frame (also uses Three.js internally)
+    if (typeof window.AFRAME !== 'undefined' || document.querySelector('a-scene')) {
+      libraries.push('a-frame');
+    }
+
+    // p5.js
+    if (typeof window.p5 !== 'undefined') {
+      libraries.push('p5.js');
+    }
+
+    // PlayCanvas
+    if (typeof window.pc !== 'undefined') {
+      libraries.push('playcanvas');
+    }
+
+    // GSAP (animation library often used with WebGL)
+    if (typeof window.gsap !== 'undefined' || typeof window.TweenMax !== 'undefined') {
+      libraries.push('gsap');
+    }
+
+    // Lottie (animation library)
+    if (typeof window.lottie !== 'undefined' || typeof window.bodymovin !== 'undefined') {
+      libraries.push('lottie');
+    }
+
+    // Phaser (2D/WebGL game engine)
+    if (typeof window.Phaser !== 'undefined') {
+      libraries.push('phaser');
+    }
+
+    result.detectedLibraries = libraries;
+
+    // 4. Determine if site is "heavy"
+    const is3DLibrary = libraries.some(lib =>
+      ['three.js', 'babylon.js', 'a-frame', 'playcanvas'].includes(lib)
+    );
+    const hasLargeCanvas = Array.from(canvases).some(canvas => {
+      const width = canvas.width || canvas.clientWidth;
+      const height = canvas.height || canvas.clientHeight;
+      return width * height >= ${exports.WEBGL_DETECTION_DEFAULTS.heavyCanvasSizeThreshold};
+    });
+    const hasManyCanvases = result.canvasCount >= ${exports.WEBGL_DETECTION_DEFAULTS.heavyCanvasThreshold};
+
+    result.isHeavySite =
+      (result.hasWebGL && is3DLibrary) ||
+      hasManyCanvases ||
+      (result.hasWebGL && hasLargeCanvas);
+
+    // 5. Recommend wait strategy and timeout
+    if (result.isHeavySite) {
+      result.recommendedWaitStrategy = 'networkidle';
+      result.recommendedTimeout = ${exports.WEBGL_DETECTION_DEFAULTS.heavySiteTimeout};
+    } else if (result.hasWebGL) {
+      result.recommendedWaitStrategy = 'webgl-extended';
+      result.recommendedTimeout = ${exports.WEBGL_DETECTION_DEFAULTS.webglTimeout};
+    } else {
+      result.recommendedWaitStrategy = 'standard';
+      result.recommendedTimeout = ${exports.WEBGL_DETECTION_DEFAULTS.standardTimeout};
+    }
+
+  } catch (error) {
+    // Detection failed, return safe defaults
+    if (typeof console !== 'undefined') {
+      console.warn('[WebGLDetector] Detection failed:', error);
+    }
+  }
+
+  result.detectionTimeMs = performance.now() - startTime;
+  return result;
+})()`;
+// =====================================================
+// Service Class
+// =====================================================
+/**
+ * WebGL Detector Service
+ *
+ * Detects WebGL capabilities and 3D libraries on web pages to optimize
+ * loading strategies and prevent timeouts.
+ *
+ * @example
+ * ```typescript
+ * const detector = new WebGLDetectorService();
+ * const result = await detector.detect(page);
+ *
+ * if (result.isHeavySite) {
+ *   // Use extended timeout and networkidle wait strategy
+ *   await page.goto(url, {
+ *     timeout: result.recommendedTimeout,
+ *     waitUntil: 'networkidle',
+ *   });
+ * }
+ * ```
+ */
+class WebGLDetectorService {
+    /**
+     * Detect WebGL capabilities and libraries on the page
+     *
+     * @param page - Playwright Page instance (after navigation)
+     * @returns Detection result with recommendations
+     */
+    async detect(page) {
+        const startTime = Date.now();
+        try {
+            if ((0, logger_1.isDevelopment)()) {
+                logger.debug("[WebGLDetector] Starting detection");
+            }
+            // Execute detection script in browser context
+            const result = (await Promise.race([
+                page.evaluate(DETECTION_SCRIPT),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("Detection timeout")), exports.WEBGL_DETECTION_DEFAULTS.detectionTimeout)),
+            ]));
+            if ((0, logger_1.isDevelopment)()) {
+                logger.debug("[WebGLDetector] Detection completed", {
+                    hasWebGL: result.hasWebGL,
+                    canvasCount: result.canvasCount,
+                    libraries: result.detectedLibraries,
+                    isHeavySite: result.isHeavySite,
+                    recommendedStrategy: result.recommendedWaitStrategy,
+                    detectionTimeMs: result.detectionTimeMs,
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if ((0, logger_1.isDevelopment)()) {
+                logger.warn("[WebGLDetector] Detection failed, using safe defaults", {
+                    error: errorMessage,
+                });
+            }
+            // Return safe defaults on error
+            return {
+                hasWebGL: false,
+                hasCanvas: false,
+                canvasCount: 0,
+                detectedLibraries: [],
+                webglVersion: null,
+                isHeavySite: false,
+                recommendedWaitStrategy: "standard",
+                recommendedTimeout: exports.WEBGL_DETECTION_DEFAULTS.standardTimeout,
+                detectionTimeMs: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Get the detection script for manual execution
+     *
+     * This is useful when you need to execute the detection script
+     * at a specific timing or with custom handling.
+     *
+     * @returns JavaScript function string for browser evaluation
+     */
+    getDetectionScript() {
+        return DETECTION_SCRIPT;
+    }
+}
+exports.WebGLDetectorService = WebGLDetectorService;
+// =====================================================
+// Singleton Instance
+// =====================================================
+/**
+ * Singleton instance of WebGLDetectorService
+ */
+let webglDetectorInstance = null;
+/**
+ * Get the WebGL detector service instance
+ *
+ * @returns WebGLDetectorService instance
+ */
+function getWebGLDetectorService() {
+    if (!webglDetectorInstance) {
+        webglDetectorInstance = new WebGLDetectorService();
+    }
+    return webglDetectorInstance;
+}
+/**
+ * Reset the singleton instance (for testing)
+ */
+function resetWebGLDetectorService() {
+    webglDetectorInstance = null;
+}
+//# sourceMappingURL=webgl-detector.service.js.map

package/dist/services/page/webgl-detector.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-detector.service.js","sourceRoot":"","sources":["../../../src/services/page/webgl-detector.service.ts"],"names":[],"mappings":"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"}

package/dist/services/page-analyze-service.d.ts

@@ -0,0 +1,30 @@
+import type { PageAnalyzeInput, PageAnalyzeOutput } from "../tools/page/index";
+/**
+ * page.analyzeツールを直接実行するService関数
+ * 外部モジュールから直接呼び出し可能
+ *
+ * @param input - page.analyze入力パラメータ
+ * @returns page.analyzeの実行結果
+ * @throws エラーが発生した場合、PageAnalyzeErrorOutputで返却される
+ *
+ * @example
+ * ```typescript
+ * const result = await executePageAnalyze({
+ *   url: 'https://example.com',
+ *   summary: true,
+ *   timeout: 60000,
+ * });
+ *
+ * if (result.ok) {
+ *   console.log('Analysis result:', result.data);
+ * } else {
+ *   console.error('Analysis failed:', result.error);
+ * }
+ * ```
+ */
+export declare function executePageAnalyze(input: PageAnalyzeInput): Promise<PageAnalyzeOutput>;
+export type { PageAnalyzeInput, PageAnalyzeOutput, PageAnalyzeData, PageAnalyzeError, LayoutResult, MotionResult, QualityResult, PageMetadata, AnalysisWarning, } from "../tools/page/index";
+export { sourceTypeSchema, usageScopeSchema, waitUntilSchema, gradeSchema, type SourceType, type UsageScope, type WaitUntil, type Grade, } from "../tools/page/index";
+export { pageAnalyzeInputSchema, pageAnalyzeOutputSchema, analysisFeaturesSchema, viewportSchema, layoutOptionsSchema, motionOptionsSchema, qualityOptionsSchema, type AnalysisFeatures, type Viewport, type LayoutOptions, type MotionOptions, type QualityOptions, } from "../tools/page/index";
+export { PAGE_ANALYZE_ERROR_CODES, type PageAnalyzeErrorCode } from "../tools/page/index";
+//# sourceMappingURL=page-analyze-service.d.ts.map

package/dist/services/page-analyze-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-analyze-service.d.ts","sourceRoot":"","sources":["../../src/services/page-analyze-service.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAE5F;AAGD,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,eAAe,GAChB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,KAAK,GACX,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,KAAK,gBAAgB,EACrB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,wBAAwB,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/services/page-analyze-service.js

@@ -0,0 +1,58 @@
+"use strict";
+// SPDX-FileCopyrightText: 2026 TKMD and Reftrix Contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAGE_ANALYZE_ERROR_CODES = exports.qualityOptionsSchema = exports.motionOptionsSchema = exports.layoutOptionsSchema = exports.viewportSchema = exports.analysisFeaturesSchema = exports.pageAnalyzeOutputSchema = exports.pageAnalyzeInputSchema = exports.gradeSchema = exports.waitUntilSchema = exports.usageScopeSchema = exports.sourceTypeSchema = void 0;
+exports.executePageAnalyze = executePageAnalyze;
+/**
+ * page.analyze MCPツール用Service層
+ * Service関数をエクスポート
+ *
+ * @module services/page-analyze-service
+ */
+const analyze_tool_1 = require("../tools/page/analyze.tool");
+/**
+ * page.analyzeツールを直接実行するService関数
+ * 外部モジュールから直接呼び出し可能
+ *
+ * @param input - page.analyze入力パラメータ
+ * @returns page.analyzeの実行結果
+ * @throws エラーが発生した場合、PageAnalyzeErrorOutputで返却される
+ *
+ * @example
+ * ```typescript
+ * const result = await executePageAnalyze({
+ *   url: 'https://example.com',
+ *   summary: true,
+ *   timeout: 60000,
+ * });
+ *
+ * if (result.ok) {
+ *   console.log('Analysis result:', result.data);
+ * } else {
+ *   console.error('Analysis failed:', result.error);
+ * }
+ * ```
+ */
+async function executePageAnalyze(input) {
+    return await (0, analyze_tool_1.pageAnalyzeHandler)(input);
+}
+// Enumsをre-export
+var index_1 = require("../tools/page/index");
+Object.defineProperty(exports, "sourceTypeSchema", { enumerable: true, get: function () { return index_1.sourceTypeSchema; } });
+Object.defineProperty(exports, "usageScopeSchema", { enumerable: true, get: function () { return index_1.usageScopeSchema; } });
+Object.defineProperty(exports, "waitUntilSchema", { enumerable: true, get: function () { return index_1.waitUntilSchema; } });
+Object.defineProperty(exports, "gradeSchema", { enumerable: true, get: function () { return index_1.gradeSchema; } });
+// Schemasをre-export
+var index_2 = require("../tools/page/index");
+Object.defineProperty(exports, "pageAnalyzeInputSchema", { enumerable: true, get: function () { return index_2.pageAnalyzeInputSchema; } });
+Object.defineProperty(exports, "pageAnalyzeOutputSchema", { enumerable: true, get: function () { return index_2.pageAnalyzeOutputSchema; } });
+Object.defineProperty(exports, "analysisFeaturesSchema", { enumerable: true, get: function () { return index_2.analysisFeaturesSchema; } });
+Object.defineProperty(exports, "viewportSchema", { enumerable: true, get: function () { return index_2.viewportSchema; } });
+Object.defineProperty(exports, "layoutOptionsSchema", { enumerable: true, get: function () { return index_2.layoutOptionsSchema; } });
+Object.defineProperty(exports, "motionOptionsSchema", { enumerable: true, get: function () { return index_2.motionOptionsSchema; } });
+Object.defineProperty(exports, "qualityOptionsSchema", { enumerable: true, get: function () { return index_2.qualityOptionsSchema; } });
+// Error codesをre-export
+var index_3 = require("../tools/page/index");
+Object.defineProperty(exports, "PAGE_ANALYZE_ERROR_CODES", { enumerable: true, get: function () { return index_3.PAGE_ANALYZE_ERROR_CODES; } });
+//# sourceMappingURL=page-analyze-service.js.map

package/dist/services/page-analyze-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-analyze-service.js","sourceRoot":"","sources":["../../src/services/page-analyze-service.ts"],"names":[],"mappings":";AAAA,6DAA6D;AAC7D,yCAAyC;;;AAmCzC,gDAEC;AAnCD;;;;;GAKG;AAEH,6DAAgE;AAGhE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACI,KAAK,UAAU,kBAAkB,CAAC,KAAuB;IAC9D,OAAO,MAAM,IAAA,iCAAkB,EAAC,KAAK,CAAC,CAAC;AACzC,CAAC;AAeD,kBAAkB;AAClB,6CAS6B;AAR3B,yGAAA,gBAAgB,OAAA;AAChB,yGAAA,gBAAgB,OAAA;AAChB,wGAAA,eAAe,OAAA;AACf,oGAAA,WAAW,OAAA;AAOb,oBAAoB;AACpB,6CAa6B;AAZ3B,+GAAA,sBAAsB,OAAA;AACtB,gHAAA,uBAAuB,OAAA;AACvB,+GAAA,sBAAsB,OAAA;AACtB,uGAAA,cAAc,OAAA;AACd,4GAAA,mBAAmB,OAAA;AACnB,4GAAA,mBAAmB,OAAA;AACnB,6GAAA,oBAAoB,OAAA;AAQtB,wBAAwB;AACxB,6CAA0F;AAAjF,iHAAA,wBAAwB,OAAA"}