@kurot/core 1.0.12

package/dist/kurot/player/webgl/shaders/ShaderLib2.js

@@ -0,0 +1,280 @@
+/**
+ * GLSL ES 3.00 shaders — used with WebGL2 context.
+ * For WebGL1 (GLSL ES 1.00) shaders see ../webgl/ShaderLib.ts
+ */
+export const ShaderLib2 = {
+    default_vert: /* glsl */ `#version 300 es
+in vec2 aVertexPosition;
+in vec2 aTextureCoord;
+in vec4 aColor;
+uniform vec2 projectionVector;
+out vec2 vTextureCoord;
+out vec4 vColor;
+const vec2 center = vec2(-1.0, 1.0);
+void main(void) {
+   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);
+   vTextureCoord = aTextureCoord;
+   vColor = aColor;
+}`,
+    // Standalone vertex shader for fullscreen quad blits (filters, blur passes).
+    // Identical to default_vert but kept separate so filter passes can be
+    // paired with their own fragment shaders without colliding with the
+    // batched-texture program cache key.
+    fullscreen_vert: /* glsl */ `#version 300 es
+in vec2 aVertexPosition;
+in vec2 aTextureCoord;
+in vec4 aColor;
+uniform vec2 projectionVector;
+out vec2 vTextureCoord;
+out vec4 vColor;
+const vec2 center = vec2(-1.0, 1.0);
+void main(void) {
+   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);
+   vTextureCoord = aTextureCoord;
+   vColor = aColor;
+}`,
+    // Multi-texture vertex shader: carries textureId as a float attribute.
+    multi_vert: /* glsl */ `#version 300 es
+in vec2 aVertexPosition;
+in vec2 aTextureCoord;
+in vec4 aColor;
+in float aTextureId;
+uniform vec2 projectionVector;
+out vec2 vTextureCoord;
+out vec4 vColor;
+out float vTextureId;
+const vec2 center = vec2(-1.0, 1.0);
+void main(void) {
+   gl_Position = vec4((aVertexPosition / projectionVector) + center, 0.0, 1.0);
+   vTextureCoord = aTextureCoord;
+   vColor = aColor;
+   vTextureId = aTextureId;
+}`,
+    // Multi-texture fragment shader.
+    // Each branch uses a constant integer to index the sampler array, which
+    // satisfies GLSL ES 3.00's requirement that sampler indices be constant or
+    // dynamically uniform. (Direct variable indexing is NOT allowed.)
+    multi_frag: /* glsl */ `#version 300 es
+precision lowp float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+in float vTextureId;
+uniform sampler2D uSamplers[8];
+out vec4 fragColor;
+void main(void) {
+    vec4 color;
+    int id = int(vTextureId + 0.5);
+    if (id == 0)      color = texture(uSamplers[0], vTextureCoord);
+    else if (id == 1) color = texture(uSamplers[1], vTextureCoord);
+    else if (id == 2) color = texture(uSamplers[2], vTextureCoord);
+    else if (id == 3) color = texture(uSamplers[3], vTextureCoord);
+    else if (id == 4) color = texture(uSamplers[4], vTextureCoord);
+    else if (id == 5) color = texture(uSamplers[5], vTextureCoord);
+    else if (id == 6) color = texture(uSamplers[6], vTextureCoord);
+    else              color = texture(uSamplers[7], vTextureCoord);
+    fragColor = color * vColor;
+}`,
+    texture_frag: /* glsl */ `#version 300 es
+precision lowp float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+uniform sampler2D uSampler;
+out vec4 fragColor;
+void main(void) {
+    fragColor = texture(uSampler, vTextureCoord) * vColor;
+}`,
+    primitive_frag: /* glsl */ `#version 300 es
+precision lowp float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+out vec4 fragColor;
+void main(void) {
+    fragColor = vColor;
+}`,
+    blur_frag: /* glsl */ `#version 300 es
+precision mediump float;
+uniform vec2 blur;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+void main() {
+    const int sampleRadius = 5;
+    const int samples = sampleRadius * 2 + 1;
+    vec2 blurUv = blur / uTextureSize;
+    vec4 color = vec4(0.0, 0.0, 0.0, 0.0);
+    vec2 uv = vec2(0.0, 0.0);
+    blurUv /= float(sampleRadius);
+    for (int i = -sampleRadius; i <= sampleRadius; i++) {
+        uv.x = vTextureCoord.x + float(i) * blurUv.x;
+        uv.y = vTextureCoord.y + float(i) * blurUv.y;
+        color += texture(uSampler, uv);
+    }
+    color /= float(samples);
+    fragColor = color;
+}`,
+    // Horizontal blur pass for ping-pong two-pass Gaussian blur.
+    blur_h_frag: /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurX;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+void main() {
+    float step = 1.0 / uTextureSize.x;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -8; i <= 8; i++) {
+        if (abs(float(i)) > blurX) continue;
+        float weight = 1.0 - abs(float(i)) / (blurX + 1.0);
+        color += texture(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`,
+    // Vertical blur pass for ping-pong two-pass Gaussian blur.
+    blur_v_frag: /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurY;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+void main() {
+    float step = 1.0 / uTextureSize.y;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -8; i <= 8; i++) {
+        if (abs(float(i)) > blurY) continue;
+        float weight = 1.0 - abs(float(i)) / (blurY + 1.0);
+        color += texture(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`,
+    glow_frag: /* glsl */ `#version 300 es
+precision highp float;
+in vec2 vTextureCoord;
+uniform sampler2D uSampler;
+uniform float dist;
+uniform float angle;
+uniform vec4 color;
+uniform float alpha;
+uniform float blurX;
+uniform float blurY;
+uniform float strength;
+uniform float inner;
+uniform float knockout;
+uniform float hideObject;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+float random(vec2 scale) {
+    return fract(sin(dot(gl_FragCoord.xy, scale)) * 43758.5453);
+}
+void main(void) {
+    vec2 px = vec2(1.0 / uTextureSize.x, 1.0 / uTextureSize.y);
+    const float linearSamplingTimes = 7.0;
+    const float circleSamplingTimes = 12.0;
+    vec4 ownColor = texture(uSampler, vTextureCoord);
+    vec4 curColor;
+    float totalAlpha = 0.0;
+    float maxTotalAlpha = 0.0;
+    float offsetX = dist * cos(angle) * px.x;
+    float offsetY = dist * sin(angle) * px.y;
+    const float PI = 3.14159265358979323846264;
+    float offset = PI * 2.0 / circleSamplingTimes * random(vec2(12.9898, 78.233));
+    float stepX = blurX * px.x / linearSamplingTimes;
+    float stepY = blurY * px.y / linearSamplingTimes;
+    for (float a = 0.0; a <= PI * 2.0; a += PI * 2.0 / circleSamplingTimes) {
+        float cosAngle = cos(a + offset);
+        float sinAngle = sin(a + offset);
+        for (float i = 1.0; i <= linearSamplingTimes; i++) {
+            float curDistanceX = i * stepX * cosAngle;
+            float curDistanceY = i * stepY * sinAngle;
+            if (vTextureCoord.x + curDistanceX - offsetX >= 0.0 && vTextureCoord.y + curDistanceY + offsetY <= 1.0) {
+                curColor = texture(uSampler, vec2(vTextureCoord.x + curDistanceX - offsetX, vTextureCoord.y + curDistanceY + offsetY));
+                totalAlpha += (linearSamplingTimes - i) * curColor.a;
+            }
+            maxTotalAlpha += (linearSamplingTimes - i);
+        }
+    }
+    ownColor.a = max(ownColor.a, 0.0001);
+    ownColor.rgb = ownColor.rgb / ownColor.a;
+    float outerGlowAlpha = (totalAlpha / maxTotalAlpha) * strength * alpha * (1.0 - inner) * max(min(hideObject, knockout), 1.0 - ownColor.a);
+    float innerGlowAlpha = ((maxTotalAlpha - totalAlpha) / maxTotalAlpha) * strength * alpha * inner * ownColor.a;
+    ownColor.a = max(ownColor.a * knockout * (1.0 - hideObject), 0.0001);
+    vec3 mix1 = mix(ownColor.rgb, color.rgb, innerGlowAlpha / (innerGlowAlpha + ownColor.a));
+    vec3 mix2 = mix(mix1, color.rgb, outerGlowAlpha / (innerGlowAlpha + ownColor.a + outerGlowAlpha));
+    float resultAlpha = min(ownColor.a + outerGlowAlpha + innerGlowAlpha, 1.0);
+    fragColor = vec4(mix2 * resultAlpha, resultAlpha);
+}`,
+    colorTransform_frag: /* glsl */ `#version 300 es
+precision mediump float;
+in vec2 vTextureCoord;
+in vec4 vColor;
+uniform mat4 matrix;
+uniform vec4 colorAdd;
+uniform sampler2D uSampler;
+out vec4 fragColor;
+void main(void) {
+    vec4 texColor = texture(uSampler, vTextureCoord);
+    if (texColor.a > 0.0) {
+        texColor = vec4(texColor.rgb / texColor.a, texColor.a);
+    }
+    vec4 locColor = clamp(texColor * matrix + colorAdd, 0.0, 1.0);
+    fragColor = vColor * vec4(locColor.rgb * locColor.a, locColor.a);
+}`,
+};
+// ── Dynamic blur shader generation (GLSL ES 3.00) ─────────────────────────────
+export const BLUR_TIERS2 = [4, 8, 16, 32];
+export function getBlurTier2(radius) {
+    for (const tier of BLUR_TIERS2) {
+        if (radius <= tier)
+            return tier;
+    }
+    return 32;
+}
+export function makeBlurHFrag2(tier) {
+    return /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurX;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+void main() {
+    float step = 1.0 / uTextureSize.x;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -${tier}; i <= ${tier}; i++) {
+        if (abs(float(i)) > blurX) continue;
+        float weight = 1.0 - abs(float(i)) / (blurX + 1.0);
+        color += texture(uSampler, vTextureCoord + vec2(float(i) * step, 0.0)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`;
+}
+export function makeBlurVFrag2(tier) {
+    return /* glsl */ `#version 300 es
+precision mediump float;
+uniform float blurY;
+uniform sampler2D uSampler;
+in vec2 vTextureCoord;
+uniform vec2 uTextureSize;
+out vec4 fragColor;
+void main() {
+    float step = 1.0 / uTextureSize.y;
+    vec4 color = vec4(0.0);
+    float total = 0.0;
+    for (int i = -${tier}; i <= ${tier}; i++) {
+        if (abs(float(i)) > blurY) continue;
+        float weight = 1.0 - abs(float(i)) / (blurY + 1.0);
+        color += texture(uSampler, vTextureCoord + vec2(0.0, float(i) * step)) * weight;
+        total += weight;
+    }
+    fragColor = color / total;
+}`;
+}
+//# sourceMappingURL=ShaderLib2.js.map

package/dist/kurot/player/webgl/shaders/ShaderLib2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderLib2.js","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/shaders/ShaderLib2.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACzB,YAAY,EAAE,UAAU,CAAC;;;;;;;;;;;;EAYxB;IAED,6EAA6E;IAC7E,sEAAsE;IACtE,oEAAoE;IACpE,qCAAqC;IACrC,eAAe,EAAE,UAAU,CAAC;;;;;;;;;;;;EAY3B;IAED,uEAAuE;IACvE,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;EAetB;IAED,iCAAiC;IACjC,wEAAwE;IACxE,2EAA2E;IAC3E,kEAAkE;IAClE,UAAU,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;EAmBtB;IAED,YAAY,EAAE,UAAU,CAAC;;;;;;;;EAQxB;IAED,cAAc,EAAE,UAAU,CAAC;;;;;;;EAO1B;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;EAqBrB;IAED,6DAA6D;IAC7D,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBvB;IAED,2DAA2D;IAC3D,WAAW,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;EAkBvB;IAED,SAAS,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuDrB;IAED,mBAAmB,EAAE,UAAU,CAAC;;;;;;;;;;;;;;;EAe/B;CACQ,CAAC;AAEX,iFAAiF;AAEjF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAU,CAAC;AAGnD,MAAM,UAAU,YAAY,CAAC,MAAc;IAC1C,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAChC,IAAI,MAAM,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;IACjC,CAAC;IACD,OAAO,EAAE,CAAC;AACX,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAe;IAC7C,OAAO,UAAU,CAAC;;;;;;;;;;;oBAWC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAe;IAC7C,OAAO,UAAU,CAAC;;;;;;;;;;;oBAWC,IAAI,UAAU,IAAI;;;;;;;EAOpC,CAAC;AACH,CAAC"}

package/dist/kurot/player/webgl/shaders/index.d.ts

@@ -0,0 +1,5 @@
+export { ShaderLib, BLUR_TIERS, getBlurTier, makeBlurHFrag, makeBlurVFrag } from './ShaderLib.js';
+export type { BlurTier } from './ShaderLib.js';
+export { ShaderLib2, BLUR_TIERS2, getBlurTier2, makeBlurHFrag2, makeBlurVFrag2 } from './ShaderLib2.js';
+export type { BlurTier2 } from './ShaderLib2.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/kurot/player/webgl/shaders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/shaders/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAClG,YAAY,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACxG,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/kurot/player/webgl/shaders/index.js

@@ -0,0 +1,5 @@
+// GLSL ES 1.00 — WebGL1
+export { ShaderLib, BLUR_TIERS, getBlurTier, makeBlurHFrag, makeBlurVFrag } from './ShaderLib.js';
+// GLSL ES 3.00 — WebGL2
+export { ShaderLib2, BLUR_TIERS2, getBlurTier2, makeBlurHFrag2, makeBlurVFrag2 } from './ShaderLib2.js';
+//# sourceMappingURL=index.js.map

package/dist/kurot/player/webgl/shaders/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/kurot/player/webgl/shaders/index.ts"],"names":[],"mappings":"AAAA,wBAAwB;AACxB,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGlG,wBAAwB;AACxB,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/kurot/resource/Resource.d.ts

@@ -0,0 +1,126 @@
+import { ResourceEventType, type ResourceEvent } from './ResourceEvent.js';
+import { AnalyzerBase } from './analyzers/AnalyzerBase.js';
+/**
+ * Progress callback signature.
+ */
+export type ProgressCallback = (loaded: number, total: number) => void;
+/**
+ * Event listener callback signature.
+ */
+export type ResourceEventListener = (event: ResourceEvent) => void;
+/**
+ * Modern resource manager — async/await API, type-safe, module-based.
+ *
+ * @example
+ * ```ts
+ * import { resource } from '@kurot/core';
+ *
+ * await resource.loadConfig('resource.json', 'assets/');
+ * await resource.loadGroup('preload');
+ * const texture = resource.get<Texture>('bg.png');
+ * ```
+ */
+export declare class Resource {
+    private config;
+    private loader;
+    private analyzerMap;
+    private eventListeners;
+    private loadedNames;
+    private groupLoadQueue;
+    constructor();
+    /**
+     * Load and parse a resource configuration file.
+     * @param url URL of the resource.json file
+     * @param folder Base URL prefix for resource files (default: '')
+     */
+    loadConfig(url: string, folder?: string): Promise<void>;
+    /**
+     * Add a resource definition directly (without a config file).
+     */
+    addResource(def: {
+        name: string;
+        url: string;
+        type: string;
+    }): void;
+    /**
+     * Load all resources in a group. Returns a promise that resolves when done.
+     *
+     * `this.loader` is a single shared instance, so running two batches at once
+     * would let the second call's queue/callbacks silently replace the first's
+     * mid-flight. Concurrent calls (for the same or different groups) are
+     * therefore chained onto `groupLoadQueue` and run to completion one at a
+     * time; each call still gets its own promise that resolves/rejects
+     * independently once its turn comes up, and a failed batch doesn't block
+     * the ones queued after it.
+     *
+     * The already-loaded filter is recomputed once this call's turn actually
+     * starts (inside `run()`), not at call time — otherwise an
+     * already-queued, overlapping `loadGroup()` call could finish loading some
+     * of these items first, and a stale snapshot would re-load them anyway.
+     *
+     * @param groupName Name of the group to load
+     * @param priority Reserved for future prioritized loading; currently unused by `ResourceLoader`
+     * @param onProgress Optional progress callback
+     */
+    loadGroup(groupName: string, priority?: number, onProgress?: ProgressCallback): Promise<void>;
+    /**
+     * Load a single resource by name. Returns the cached data.
+     */
+    load<T = unknown>(name: string): Promise<T>;
+    /**
+     * Get a cached resource synchronously. Returns undefined if not loaded.
+     */
+    get<T = unknown>(name: string): T | undefined;
+    /**
+     * Check if a resource is loaded and cached.
+     */
+    hasRes(name: string): boolean;
+    /**
+     * Check if a group exists in the config.
+     */
+    hasGroup(name: string): boolean;
+    /**
+     * Get all group names.
+     */
+    getGroupNames(): string[];
+    /**
+     * Destroy a single cached resource by name.
+     */
+    destroy(name: string): boolean;
+    /**
+     * Destroy all resources in a group.
+     */
+    destroyGroup(groupName: string): void;
+    /**
+     * Destroy all cached resources.
+     */
+    destroyAll(): void;
+    /**
+     * Listen for resource events.
+     */
+    on(type: ResourceEventType, listener: ResourceEventListener): void;
+    /**
+     * Remove an event listener.
+     */
+    off(type: ResourceEventType, listener: ResourceEventListener): void;
+    /**
+     * Listen for loading progress on the next loadGroup/load call.
+     * Convenience method — shorthand for on(ResourceEventType.GROUP_PROGRESS, ...).
+     */
+    onProgress(callback: ProgressCallback): void;
+    /**
+     * Register a custom analyzer for a resource type.
+     */
+    registerAnalyzer(type: string, analyzer: AnalyzerBase): void;
+    private registerDefaultAnalyzers;
+    private fetchConfig;
+    private loadResourceList;
+    private getAnalyzer;
+    private isResourceLoaded;
+    private emit;
+}
+/**
+ * Convenience singleton instance.
+ */
+export declare const resource: Resource;
+//# sourceMappingURL=Resource.d.ts.map

package/dist/kurot/resource/Resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.d.ts","sourceRoot":"","sources":["../../../src/kurot/resource/Resource.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAW3D;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAEvE;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,qBAAa,QAAQ;IAGpB,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,MAAM,CAAwC;IACtD,OAAO,CAAC,WAAW,CAA8D;IACjF,OAAO,CAAC,cAAc,CAA0F;IAChH,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,cAAc,CAAuC;;IAU7D;;;;OAIG;IACU,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAWhE;;OAEG;IACI,WAAW,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAM1E;;;;;;;;;;;;;;;;;;;OAmBG;IACU,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,SAAI,EAAE,UAAU,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBrG;;OAEG;IACU,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IA8BxD;;OAEG;IACI,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IASpD;;OAEG;IACI,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOpC;;OAEG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAItC;;OAEG;IACI,aAAa,IAAI,MAAM,EAAE;IAMhC;;OAEG;IACI,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUrC;;OAEG;IACI,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAO5C;;OAEG;IACI,UAAU,IAAI,IAAI;IAUzB;;OAEG;IACI,EAAE,CAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IASzE;;OAEG;IACI,GAAG,CAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IAO1E;;;OAGG;IACI,UAAU,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAQnD;;OAEG;IACI,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAOnE,OAAO,CAAC,wBAAwB;YAqBlB,WAAW;IAkDzB,OAAO,CAAC,gBAAgB;IAsExB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,IAAI;CAYZ;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,QAAyB,CAAC"}