@glubean/sdk 0.1.39 → 0.2.1

package/dist/test-builder.d.ts

@@ -0,0 +1,249 @@
+/**
+ * @module test-builder
+ *
+ * Fluent builder for multi-step tests (`TestBuilder`).
+ *
+ * Entry point: `test("id")` (no callback) returns a `TestBuilder`.
+ * Chain `.setup()` → `.step()` → `.teardown()` to define the test workflow.
+ * State flows between steps via the return value of each step function.
+ * `.build()` is optional — the builder auto-registers via microtask.
+ */
+import type { ExtensionFn, StepMeta, Test, TestContext, TestMeta } from "./types.js";
+/**
+ * Builder class for creating tests with a fluent API.
+ *
+ * @template S The state type for multi-step tests
+ * @template Ctx The context type (defaults to TestContext; augmented by test.extend())
+ *
+ * @example Simple test (quick mode)
+ * ```ts
+ * export const login = test("login", async (ctx) => {
+ *   ctx.assert(true, "works");
+ * });
+ * ```
+ *
+ * @example Multi-step test (builder mode)
+ * ```ts
+ * export const checkout = test("checkout")
+ *   .meta({ tags: ["e2e"] })
+ *   .setup(async (ctx) => ({ cart: await createCart() }))
+ *   .step("Add to cart", async (ctx, state) => {
+ *     await addItem(state.cart, "item-1");
+ *     return state;
+ *   })
+ *   .step("Checkout", async (ctx, state) => {
+ *     await checkout(state.cart);
+ *     return state;
+ *   })
+ *   .teardown(async (ctx, state) => {
+ *     await cleanup(state.cart);
+ *   })
+ *   .build();
+ * ```
+ */
+export declare class TestBuilder<S = unknown, Ctx extends TestContext = TestContext> {
+    private _meta;
+    private _setup?;
+    private _teardown?;
+    private _steps;
+    private _built;
+    _fixtures?: Record<string, ExtensionFn<any>>;
+    /**
+     * Marker property so the runner can detect un-built TestBuilder exports
+     * without importing the SDK. The runner checks this string to auto-build.
+     */
+    readonly __glubean_type: "builder";
+    constructor(id: string, fixtures?: Record<string, ExtensionFn<any>>);
+    /**
+     * Set additional metadata for the test.
+     *
+     * @example
+     * ```ts
+     * test("my-test")
+     *   .meta({ tags: ["smoke"], description: "A smoke test" })
+     *   .step(...)
+     * ```
+     */
+    meta(meta: Omit<TestMeta, "id">): TestBuilder<S, Ctx>;
+    /**
+     * Mark this test as focused.
+     *
+     * Focused tests are intended for local debugging sessions. When any tests in
+     * a run are marked as `only`, non-focused tests may be excluded by discovery
+     * tooling/orchestrators. If `skip` is also set on the same test, `skip`
+     * still wins during run selection.
+     */
+    only(): TestBuilder<S, Ctx>;
+    /**
+     * Mark this test as skipped.
+     *
+     * Skip takes precedence over `only` when both are present.
+     */
+    skip(): TestBuilder<S, Ctx>;
+    /**
+     * Set the setup function that runs before all steps.
+     * The returned state is passed to all steps and teardown.
+     *
+     * @example
+     * ```ts
+     * test("auth")
+     *   .setup(async (ctx) => {
+     *     const baseUrl = ctx.vars.require("BASE_URL");
+     *     const apiKey = ctx.secrets.require("API_KEY");
+     *     const { token } = await ctx.http.post(`${baseUrl}/auth/token`, {
+     *       headers: { "X-API-Key": apiKey },
+     *     }).json();
+     *     return { token };
+     *   })
+     *   .step("verify", async (ctx, { token }) => { ... })
+     * ```
+     */
+    setup<NewS>(fn: (ctx: Ctx) => Promise<NewS>): TestBuilder<NewS, Ctx>;
+    /**
+     * Set the teardown function that runs after all steps (even on failure).
+     *
+     * @example
+     * ```ts
+     * test("db-test")
+     *   .setup(async (ctx) => ({ conn: await connect() }))
+     *   .step(...)
+     *   .teardown(async (ctx, { conn }) => {
+     *     await conn.close();
+     *   })
+     * ```
+     */
+    teardown(fn: (ctx: Ctx, state: S) => Promise<void>): TestBuilder<S, Ctx>;
+    /**
+     * Add a step that does not return state (void).
+     * The state type is preserved for subsequent steps.
+     *
+     * @param name Step name (displayed in reports)
+     * @param fn Step function that performs assertions/side-effects without returning state
+     */
+    step(name: string, fn: (ctx: Ctx, state: S) => Promise<void>): TestBuilder<S, Ctx>;
+    /**
+     * Add a step that returns new state, replacing the current state type.
+     *
+     * The returned value becomes the `state` argument for subsequent steps.
+     * This enables fully type-safe chained steps without needing `.setup()`.
+     *
+     * @param name Step name (displayed in reports)
+     * @param fn Step function receiving context and current state, returning new state
+     *
+     * @example
+     * ```ts
+     * test("auth-flow")
+     *   .step("login", async (ctx) => {
+     *     const data = await ctx.http.post("/auth/login", { json: creds }).json<{ token: string }>();
+     *     return { token: data.token };
+     *   })
+     *   .step("get profile", async (ctx, { token }) => {
+     *     // token is inferred as string ✓
+     *     const profile = await ctx.http.get("/auth/me", {
+     *       headers: { Authorization: `Bearer ${token}` },
+     *     }).json<{ name: string }>();
+     *     return { token, name: profile.name };
+     *   })
+     * ```
+     */
+    step<NewS>(name: string, fn: (ctx: Ctx, state: S) => Promise<NewS>): TestBuilder<NewS, Ctx>;
+    /**
+     * Add a step with options (void return).
+     */
+    step(name: string, options: Omit<StepMeta, "name">, fn: (ctx: Ctx, state: S) => Promise<void>): TestBuilder<S, Ctx>;
+    /**
+     * Add a step with additional options, returning new state.
+     */
+    step<NewS>(name: string, options: Omit<StepMeta, "name">, fn: (ctx: Ctx, state: S) => Promise<NewS>): TestBuilder<NewS, Ctx>;
+    /**
+     * Apply a builder transform function for step composition.
+     *
+     * Reusable step sequences are just plain functions that take a builder
+     * and return a builder. `.use()` applies such a function to the current
+     * chain, preserving state flow.
+     *
+     * @param fn Transform function that receives this builder and returns a (possibly re-typed) builder
+     *
+     * @example Reusable step sequence
+     * ```ts
+     * // Define once — just a function
+     * const withAuth = (b: TestBuilder<unknown>) => b
+     *   .step("login", async (ctx) => {
+     *     const data = await ctx.http.post("/login", { json: creds }).json<{ token: string }>();
+     *     return { token: data.token };
+     *   });
+     *
+     * // Reuse across tests
+     * export const testA = test("test-a").use(withAuth).step("act", async (ctx, { token }) => { ... });
+     * export const testB = test("test-b").use(withAuth).step("verify", async (ctx, { token }) => { ... });
+     * ```
+     */
+    use<NewS>(fn: (builder: TestBuilder<S, Ctx>) => TestBuilder<NewS, Ctx>): TestBuilder<NewS, Ctx>;
+    /**
+     * Apply a builder transform and tag all newly added steps with a group ID.
+     *
+     * Works exactly like `.use()`, but every step added by `fn` is marked with
+     * `group` metadata for visual grouping in reports and dashboards.
+     *
+     * @param id Group identifier (displayed in reports as a section header)
+     * @param fn Transform function that adds steps to the builder
+     *
+     * @example Reusable steps with grouping
+     * ```ts
+     * const withAuth = (b: TestBuilder<unknown>) => b
+     *   .step("login", async (ctx) => ({ token: "..." }))
+     *   .step("verify", async (ctx, { token }) => ({ token, verified: true }));
+     *
+     * export const checkout = test("checkout")
+     *   .group("auth", withAuth)
+     *   .step("pay", async (ctx, { token }) => { ... });
+     *
+     * // Report output:
+     * // checkout
+     * //   ├─ [auth]
+     * //   │   ├─ login ✓
+     * //   │   └─ verify ✓
+     * //   └─ pay ✓
+     * ```
+     *
+     * @example Inline grouping (no reuse, just organization)
+     * ```ts
+     * export const e2e = test("e2e")
+     *   .group("setup", b => b
+     *     .step("seed db", async (ctx) => ({ dbId: "..." }))
+     *     .step("create user", async (ctx, { dbId }) => ({ dbId, userId: "..." }))
+     *   )
+     *   .step("verify", async (ctx, { dbId, userId }) => { ... });
+     * ```
+     */
+    group<NewS>(id: string, fn: (builder: TestBuilder<S, Ctx>) => TestBuilder<NewS, Ctx>): TestBuilder<NewS, Ctx>;
+    /**
+     * Finalize and register the test in the global registry.
+     * Called automatically via microtask if not explicitly invoked via build().
+     * Idempotent — safe to call multiple times.
+     * @internal
+     */
+    private _finalize;
+    /**
+     * Build and register the test. Returns a plain `Test<S>` object.
+     *
+     * **Optional** — if omitted, the builder auto-finalizes via microtask
+     * after all synchronous chaining completes, and the runner will
+     * auto-detect the builder export. Calling `.build()` explicitly is
+     * still supported for backward compatibility.
+     *
+     * @example
+     * ```ts
+     * // With .build() (explicit — backward compatible)
+     * export const myTest = test("my-test")
+     *   .step("step-1", async (ctx) => { ... })
+     *   .build();
+     *
+     * // Without .build() (auto-finalized — recommended)
+     * export const myTest = test("my-test")
+     *   .step("step-1", async (ctx) => { ... });
+     * ```
+     */
+    build(): Test<S>;
+}
+//# sourceMappingURL=test-builder.d.ts.map

package/dist/test-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-builder.d.ts","sourceRoot":"","sources":["../src/test-builder.ts"],"names":[],"mappings":"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"}

package/dist/test-builder.js

@@ -0,0 +1,265 @@
+import { registerTest } from "./internal.js";
+import { toArray } from "./data.js";
+/**
+ * Builder class for creating tests with a fluent API.
+ *
+ * @template S The state type for multi-step tests
+ * @template Ctx The context type (defaults to TestContext; augmented by test.extend())
+ *
+ * @example Simple test (quick mode)
+ * ```ts
+ * export const login = test("login", async (ctx) => {
+ *   ctx.assert(true, "works");
+ * });
+ * ```
+ *
+ * @example Multi-step test (builder mode)
+ * ```ts
+ * export const checkout = test("checkout")
+ *   .meta({ tags: ["e2e"] })
+ *   .setup(async (ctx) => ({ cart: await createCart() }))
+ *   .step("Add to cart", async (ctx, state) => {
+ *     await addItem(state.cart, "item-1");
+ *     return state;
+ *   })
+ *   .step("Checkout", async (ctx, state) => {
+ *     await checkout(state.cart);
+ *     return state;
+ *   })
+ *   .teardown(async (ctx, state) => {
+ *     await cleanup(state.cart);
+ *   })
+ *   .build();
+ * ```
+ */
+export class TestBuilder {
+    _meta;
+    _setup;
+    _teardown;
+    _steps = [];
+    _built = false;
+    _fixtures;
+    /**
+     * Marker property so the runner can detect un-built TestBuilder exports
+     * without importing the SDK. The runner checks this string to auto-build.
+     */
+    __glubean_type = "builder";
+    constructor(id, fixtures) {
+        this._meta = { id, name: id };
+        this._fixtures = fixtures;
+        // Auto-finalize (register) after all synchronous chaining completes.
+        // Module top-level code is synchronous, so by the time the microtask
+        // fires, all .step() / .meta() / .setup() / .teardown() calls are done.
+        queueMicrotask(() => this._finalize());
+    }
+    /**
+     * Set additional metadata for the test.
+     *
+     * @example
+     * ```ts
+     * test("my-test")
+     *   .meta({ tags: ["smoke"], description: "A smoke test" })
+     *   .step(...)
+     * ```
+     */
+    meta(meta) {
+        this._meta = { ...this._meta, ...meta };
+        return this;
+    }
+    /**
+     * Mark this test as focused.
+     *
+     * Focused tests are intended for local debugging sessions. When any tests in
+     * a run are marked as `only`, non-focused tests may be excluded by discovery
+     * tooling/orchestrators. If `skip` is also set on the same test, `skip`
+     * still wins during run selection.
+     */
+    only() {
+        this._meta = { ...this._meta, only: true };
+        return this;
+    }
+    /**
+     * Mark this test as skipped.
+     *
+     * Skip takes precedence over `only` when both are present.
+     */
+    skip() {
+        this._meta = { ...this._meta, skip: true };
+        return this;
+    }
+    /**
+     * Set the setup function that runs before all steps.
+     * The returned state is passed to all steps and teardown.
+     *
+     * @example
+     * ```ts
+     * test("auth")
+     *   .setup(async (ctx) => {
+     *     const baseUrl = ctx.vars.require("BASE_URL");
+     *     const apiKey = ctx.secrets.require("API_KEY");
+     *     const { token } = await ctx.http.post(`${baseUrl}/auth/token`, {
+     *       headers: { "X-API-Key": apiKey },
+     *     }).json();
+     *     return { token };
+     *   })
+     *   .step("verify", async (ctx, { token }) => { ... })
+     * ```
+     */
+    setup(fn) {
+        this._setup = fn;
+        return this;
+    }
+    /**
+     * Set the teardown function that runs after all steps (even on failure).
+     *
+     * @example
+     * ```ts
+     * test("db-test")
+     *   .setup(async (ctx) => ({ conn: await connect() }))
+     *   .step(...)
+     *   .teardown(async (ctx, { conn }) => {
+     *     await conn.close();
+     *   })
+     * ```
+     */
+    teardown(fn) {
+        this._teardown = fn;
+        return this;
+    }
+    step(name, optionsOrFn, maybeFn) {
+        const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+        const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+        this._steps.push({
+            meta: { name, ...options },
+            fn: fn,
+        });
+        return this;
+    }
+    /**
+     * Apply a builder transform function for step composition.
+     *
+     * Reusable step sequences are just plain functions that take a builder
+     * and return a builder. `.use()` applies such a function to the current
+     * chain, preserving state flow.
+     *
+     * @param fn Transform function that receives this builder and returns a (possibly re-typed) builder
+     *
+     * @example Reusable step sequence
+     * ```ts
+     * // Define once — just a function
+     * const withAuth = (b: TestBuilder<unknown>) => b
+     *   .step("login", async (ctx) => {
+     *     const data = await ctx.http.post("/login", { json: creds }).json<{ token: string }>();
+     *     return { token: data.token };
+     *   });
+     *
+     * // Reuse across tests
+     * export const testA = test("test-a").use(withAuth).step("act", async (ctx, { token }) => { ... });
+     * export const testB = test("test-b").use(withAuth).step("verify", async (ctx, { token }) => { ... });
+     * ```
+     */
+    use(fn) {
+        return fn(this);
+    }
+    /**
+     * Apply a builder transform and tag all newly added steps with a group ID.
+     *
+     * Works exactly like `.use()`, but every step added by `fn` is marked with
+     * `group` metadata for visual grouping in reports and dashboards.
+     *
+     * @param id Group identifier (displayed in reports as a section header)
+     * @param fn Transform function that adds steps to the builder
+     *
+     * @example Reusable steps with grouping
+     * ```ts
+     * const withAuth = (b: TestBuilder<unknown>) => b
+     *   .step("login", async (ctx) => ({ token: "..." }))
+     *   .step("verify", async (ctx, { token }) => ({ token, verified: true }));
+     *
+     * export const checkout = test("checkout")
+     *   .group("auth", withAuth)
+     *   .step("pay", async (ctx, { token }) => { ... });
+     *
+     * // Report output:
+     * // checkout
+     * //   ├─ [auth]
+     * //   │   ├─ login ✓
+     * //   │   └─ verify ✓
+     * //   └─ pay ✓
+     * ```
+     *
+     * @example Inline grouping (no reuse, just organization)
+     * ```ts
+     * export const e2e = test("e2e")
+     *   .group("setup", b => b
+     *     .step("seed db", async (ctx) => ({ dbId: "..." }))
+     *     .step("create user", async (ctx, { dbId }) => ({ dbId, userId: "..." }))
+     *   )
+     *   .step("verify", async (ctx, { dbId, userId }) => { ... });
+     * ```
+     */
+    group(id, fn) {
+        const before = this._steps.length;
+        const result = fn(this);
+        for (let i = before; i < this._steps.length; i++) {
+            this._steps[i].meta.group = id;
+        }
+        return result;
+    }
+    /**
+     * Finalize and register the test in the global registry.
+     * Called automatically via microtask if not explicitly invoked via build().
+     * Idempotent — safe to call multiple times.
+     * @internal
+     */
+    _finalize() {
+        if (this._built)
+            return;
+        this._built = true;
+        registerTest({
+            id: this._meta.id,
+            name: this._meta.name || this._meta.id,
+            type: "steps",
+            tags: toArray(this._meta.tags),
+            description: this._meta.description,
+            steps: this._steps.map((s) => ({
+                name: s.meta.name,
+                ...(s.meta.group ? { group: s.meta.group } : {}),
+            })),
+            hasSetup: !!this._setup,
+            hasTeardown: !!this._teardown,
+        });
+    }
+    /**
+     * Build and register the test. Returns a plain `Test<S>` object.
+     *
+     * **Optional** — if omitted, the builder auto-finalizes via microtask
+     * after all synchronous chaining completes, and the runner will
+     * auto-detect the builder export. Calling `.build()` explicitly is
+     * still supported for backward compatibility.
+     *
+     * @example
+     * ```ts
+     * // With .build() (explicit — backward compatible)
+     * export const myTest = test("my-test")
+     *   .step("step-1", async (ctx) => { ... })
+     *   .build();
+     *
+     * // Without .build() (auto-finalized — recommended)
+     * export const myTest = test("my-test")
+     *   .step("step-1", async (ctx) => { ... });
+     * ```
+     */
+    build() {
+        this._finalize();
+        return {
+            meta: this._meta,
+            type: "steps",
+            setup: this._setup,
+            teardown: this._teardown,
+            steps: this._steps,
+            ...(this._fixtures ? { fixtures: this._fixtures } : {}),
+        };
+    }
+}
+//# sourceMappingURL=test-builder.js.map

package/dist/test-builder.js.map

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

package/dist/test-extend.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @module test-extend
+ *
+ * Fixture extension system for augmenting `TestContext` (`test.extend()`).
+ *
+ * `test.extend(fixtures)` returns an `ExtendedTest` function whose `ctx`
+ * includes the resolved fixture properties alongside the base `TestContext`.
+ * Supports chained `.extend()`, `.each()`, and `.pick()`.
+ * Also exports the `ExtendedTest` interface and `EachOptions`.
+ */
+import type { ExtensionFn, ResolveExtensions, Test, TestContext, TestMeta } from "./types.js";
+import { TestBuilder } from "./test-builder.js";
+import { EachBuilder } from "./each-builder.js";
+/** Keys that cannot be used as extension names (they shadow core TestContext). */
+export declare const EXTEND_RESERVED_KEYS: Set<string>;
+/**
+ * An extended `test` function created by `test.extend()`.
+ *
+ * Behaves identically to the base `test()` but augments the context type
+ * with fixture properties. Supports quick mode, builder mode, `.each()`,
+ * `.pick()`, and chained `.extend()`.
+ *
+ * @template Ctx The augmented context type (TestContext & extensions)
+ */
+export interface ExtendedTest<Ctx extends TestContext> {
+    /** Quick mode: single-function test with augmented context. */
+    (idOrMeta: string | TestMeta, fn: (ctx: Ctx) => Promise<void>): Test;
+    /** Builder mode: multi-step test with augmented context. */
+    <S = unknown>(idOrMeta: string | TestMeta): TestBuilder<S, Ctx>;
+    /**
+     * Chain another set of extensions on top of the current ones.
+     * The returned test function has `Ctx & NewExtensions` as its context type.
+     */
+    extend<E extends Record<string, ExtensionFn<unknown>>>(extensions: E): ExtendedTest<Ctx & ResolveExtensions<E>>;
+    /** Data-driven tests with augmented context. */
+    each<T extends Record<string, unknown>>(table: readonly T[], options?: EachOptions): {
+        (idOrMeta: string | TestMeta, fn: (ctx: Ctx, data: T) => Promise<void>): Test[];
+        (idOrMeta: string | TestMeta): EachBuilder<unknown, T, Ctx>;
+    };
+    /** Example-selection tests with augmented context. */
+    pick<T extends Record<string, unknown>>(examples: Record<string, T>, count?: number): {
+        (idOrMeta: string | TestMeta, fn: (ctx: Ctx, data: T & {
+            _pick: string;
+        }) => Promise<void>): Test[];
+        (idOrMeta: string | TestMeta): EachBuilder<unknown, T & {
+            _pick: string;
+        }, Ctx>;
+    };
+}
+/** @deprecated Use `parallel` in TestMeta instead. */
+export interface EachOptions {
+    parallel?: boolean;
+}
+/**
+ * Create an extended test function with fixture definitions.
+ * @internal
+ */
+export declare function createExtendedTest<Ctx extends TestContext>(allFixtures: Record<string, ExtensionFn<any>>): ExtendedTest<Ctx>;
+//# sourceMappingURL=test-extend.d.ts.map

package/dist/test-extend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-extend.d.ts","sourceRoot":"","sources":["../src/test-extend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EACV,WAAW,EACX,iBAAiB,EAEjB,IAAI,EACJ,WAAW,EACX,QAAQ,EACT,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,aAAuC,CAAC;AAEzE;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY,CAAC,GAAG,SAAS,WAAW;IACnD,+DAA+D;IAC/D,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACrE,4DAA4D;IAC5D,CAAC,CAAC,GAAG,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAEhE;;;OAGG;IACH,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC,EACnD,UAAU,EAAE,CAAC,GACZ,YAAY,CAAC,GAAG,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;IAE5C,gDAAgD;IAChD,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,OAAO,CAAC,EAAE,WAAW,GACpB;QACD,CACE,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAC3B,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GACvC,IAAI,EAAE,CAAC;QACV,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;KAC7D,CAAC;IAEF,sDAAsD;IACtD,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAC3B,KAAK,CAAC,EAAE,MAAM,GACb;QACD,CACE,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAC3B,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,GAAG;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAC3D,IAAI,EAAE,CAAC;QACV,CACE,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAC1B,WAAW,CAAC,OAAO,EAAE,CAAC,GAAG;YAAE,KAAK,EAAE,MAAM,CAAA;SAAE,EAAE,GAAG,CAAC,CAAC;KACrD,CAAC;CACH;AAED,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,SAAS,WAAW,EACxD,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,GAC5C,YAAY,CAAC,GAAG,CAAC,CA8HnB"}