@thymian/plugin-sampler 0.3.0-canary.20261007-e6cb8dc → 0.3.0-canary.20261007-cdbe1d3

package/dist/hooks/hook-registration.d.ts

@@ -0,0 +1,108 @@
+import type { Selector } from '../selectors/selector.js';
+import type { TransactionFilter } from '../selectors/transaction-filter.js';
+/**
+ * The brand every registration carries.
+ *
+ * `Symbol.for` rather than a fresh symbol: the plugin's jiti instance evaluates
+ * the hooks runtime in its own module registry, so a hook file and the loader
+ * hold different module instances of that file. A registry-local symbol would
+ * differ between them; a well-known one is the same symbol in both realms.
+ */
+export declare const HOOK_REGISTRATION: unique symbol;
+export type HookKind = 'defineSample' | 'beforeEach' | 'afterEach' | 'authorize' | 'beforeAll' | 'afterAll';
+/**
+ * What a per-transaction hook is aimed at: exactly one Transaction by Selector,
+ * several by a list of them, or a set by a filter.
+ */
+export type HookTarget = Selector | readonly Selector[] | TransactionFilter;
+/**
+ * Callbacks are stored, never inspected. Each kind's precise signature is the
+ * runner's contract, and the generated `.d.ts` is what types it for the author;
+ * here they only have to be functions.
+ */
+export type HookCallback = (...args: never[]) => unknown;
+type Brand = {
+    readonly [HOOK_REGISTRATION]: true;
+};
+/**
+ * One hook, as a value.
+ *
+ * A registration is **returned**, not pushed into an ambient registry, because
+ * discovery is export-based: a module-scope registry in the loader's realm is
+ * not the one a hook file writing `@thymian/hooks` would reach. `order` is
+ * stamped at creation and is monotonic within the realm that evaluated the file,
+ * which is what gives composition an order that does not depend on
+ * `Object.keys(namespace)` — an ESM namespace exposes its keys sorted, so export
+ * order is not registration order.
+ */
+export type HookRegistration = Brand & ({
+    kind: 'defineSample';
+    order: number;
+    target: HookTarget;
+    callback: HookCallback;
+} | {
+    kind: 'beforeEach';
+    order: number;
+    target: HookTarget;
+    callback: HookCallback;
+} | {
+    kind: 'afterEach';
+    order: number;
+    target: HookTarget;
+    callback: HookCallback;
+} | {
+    kind: 'authorize';
+    order: number;
+    target: HookTarget | undefined;
+    callback: HookCallback;
+} | {
+    kind: 'beforeAll';
+    order: number;
+    callback: HookCallback;
+} | {
+    kind: 'afterAll';
+    order: number;
+    callback: HookCallback;
+});
+/** What a factory hands to {@link registerHook}: the record minus brand and order. */
+export type HookRegistrationDraft = {
+    kind: 'defineSample';
+    target: HookTarget;
+    callback: HookCallback;
+} | {
+    kind: 'beforeEach';
+    target: HookTarget;
+    callback: HookCallback;
+} | {
+    kind: 'afterEach';
+    target: HookTarget;
+    callback: HookCallback;
+} | {
+    kind: 'authorize';
+    target: HookTarget | undefined;
+    callback: HookCallback;
+} | {
+    kind: 'beforeAll';
+    callback: HookCallback;
+} | {
+    kind: 'afterAll';
+    callback: HookCallback;
+};
+/** Every registration created so far, oldest first. Mutable on purpose. */
+export declare function createdRegistrations(): HookRegistration[];
+/** Freezes a draft into a branded, ordered registration. */
+export declare function registerHook(draft: HookRegistrationDraft): HookRegistration;
+/**
+ * Is this value a registration produced by the hooks runtime?
+ *
+ * The `typeof value !== 'object'` test rejects functions before anything else,
+ * which makes "a function is never invoked to discover a hook" a structural
+ * property of this predicate rather than a discipline to remember. The brand is
+ * compared `=== true`, so a same-keyed symbol carrying some other value cannot
+ * pass by accident, and a plain object that merely has a `kind` string is not a
+ * hook. The read is guarded because a user export may be a Proxy or an accessor
+ * that throws.
+ */
+export declare function isHookRegistration(value: unknown): value is HookRegistration;
+export {};
+//# sourceMappingURL=hook-registration.d.ts.map

package/dist/hooks/hook-registration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-registration.d.ts","sourceRoot":"","sources":["../../src/hooks/hook-registration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAE5E;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,OAAO,MAEtC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAChB,cAAc,GACd,YAAY,GACZ,WAAW,GACX,WAAW,GACX,WAAW,GACX,UAAU,CAAC;AAEf;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,SAAS,QAAQ,EAAE,GAAG,iBAAiB,CAAC;AAE5E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC;AAEzD,KAAK,KAAK,GAAG;IAAE,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAEpD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAClC,CACI;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;CACxB,GACD;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;CACxB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,YAAY,CAAC;CACxB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,YAAY,CAAC;CACxB,GACD;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,CAC9D,CAAC;AAEJ,sFAAsF;AACtF,MAAM,MAAM,qBAAqB,GAC7B;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GACpE;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GAClE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GACjE;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,YAAY,CAAC;CACxB,GACD;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,CAAC;AA8BjD,2EAA2E;AAC3E,wBAAgB,oBAAoB,IAAI,gBAAgB,EAAE,CAIzD;AAED,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,CAc3E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAU5E"}

package/dist/hooks/hook-registration.js

@@ -0,0 +1,69 @@
+/**
+ * The brand every registration carries.
+ *
+ * `Symbol.for` rather than a fresh symbol: the plugin's jiti instance evaluates
+ * the hooks runtime in its own module registry, so a hook file and the loader
+ * hold different module instances of that file. A registry-local symbol would
+ * differ between them; a well-known one is the same symbol in both realms.
+ */
+export const HOOK_REGISTRATION = Symbol.for('@thymian/plugin-sampler.hook-registration');
+let nextOrder = 0;
+/**
+ * Where every registration created in this process is recorded, so the loader
+ * can tell a hook that was *created* from one that was *exported*.
+ *
+ * `beforeEach(...)` written without `export const x =` compiles, runs, creates
+ * a registration — and is then unreachable, because discovery is export-based.
+ * Nothing failed, so nothing was reported: the hook simply never fired.
+ *
+ * On `globalThis` under a well-known symbol, for the same reason
+ * {@link HOOK_REGISTRATION} is: the loader's jiti instance evaluates this
+ * module in its own registry, and evicts it after every scan, so a
+ * module-scope array would be a different array per scan and never the one
+ * the loader itself imported. `globalThis` is the one thing all of those
+ * evaluations share.
+ *
+ * The loader empties it at the start of each scan and reads it per file, so it
+ * holds one scan's worth of registrations rather than the process's.
+ */
+const CREATED_REGISTRATIONS = Symbol.for('@thymian/plugin-sampler.created-registrations');
+/** Every registration created so far, oldest first. Mutable on purpose. */
+export function createdRegistrations() {
+    const channel = globalThis;
+    return (channel[CREATED_REGISTRATIONS] ??= []);
+}
+/** Freezes a draft into a branded, ordered registration. */
+export function registerHook(draft) {
+    const order = nextOrder;
+    nextOrder = order + 1;
+    const registration = Object.freeze({
+        ...draft,
+        order,
+        [HOOK_REGISTRATION]: true,
+    });
+    createdRegistrations().push(registration);
+    return registration;
+}
+/**
+ * Is this value a registration produced by the hooks runtime?
+ *
+ * The `typeof value !== 'object'` test rejects functions before anything else,
+ * which makes "a function is never invoked to discover a hook" a structural
+ * property of this predicate rather than a discipline to remember. The brand is
+ * compared `=== true`, so a same-keyed symbol carrying some other value cannot
+ * pass by accident, and a plain object that merely has a `kind` string is not a
+ * hook. The read is guarded because a user export may be a Proxy or an accessor
+ * that throws.
+ */
+export function isHookRegistration(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        return value[HOOK_REGISTRATION] === true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=hook-registration.js.map

package/dist/hooks/hook-registration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-registration.js","sourceRoot":"","sources":["../../src/hooks/hook-registration.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAkB,MAAM,CAAC,GAAG,CACxD,2CAA2C,CAC5C,CAAC;AA+EF,IAAI,SAAS,GAAG,CAAC,CAAC;AAElB;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,qBAAqB,GAAkB,MAAM,CAAC,GAAG,CACrD,+CAA+C,CAChD,CAAC;AAMF,2EAA2E;AAC3E,MAAM,UAAU,oBAAoB;IAClC,MAAM,OAAO,GAAG,UAAkC,CAAC;IAEnD,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC,KAAK,EAAE,CAAC,CAAC;AACjD,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,YAAY,CAAC,KAA4B;IACvD,MAAM,KAAK,GAAG,SAAS,CAAC;IAExB,SAAS,GAAG,KAAK,GAAG,CAAC,CAAC;IAEtB,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;QACjC,GAAG,KAAK;QACR,KAAK;QACL,CAAC,iBAAiB,CAAC,EAAE,IAAI;KAC1B,CAAqB,CAAC;IAEvB,oBAAoB,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAE1C,OAAO,YAAY,CAAC;AACtB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,CAAC;QACH,OAAQ,KAAsC,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;IAC7E,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC"}

package/dist/hooks/hook-runner.d.ts

@@ -1,18 +1,118 @@
-import type { HttpTestHooks } from '@thymian/core';
-import { type HttpRequest, type HttpResponse, type Logger, type ThymianFormat } from '@thymian/core';
-import type { SamplesStructure } from '../samples-structure/samples-tree-structure.js';
+import { type HttpRequest, type HttpRequestTemplate, type HttpResponse, type HttpTestHooks, type Logger, ThymianFormat, type ThymianHttpTransaction } from '@thymian/core';
+import { TransactionCatalog } from '../selectors/transaction-catalog.js';
+import { type LoadUserHooksResult } from './load-user-hooks.js';
+/** What the runner needs from the rest of the plugin to send a request. */
+export type HookRunnerPorts = {
+    /** The freshly generated request for one transaction. */
+    sampleRequest: (transaction: ThymianHttpTransaction) => Promise<HttpRequestTemplate>;
+    /** Puts a serialized request on the wire. */
+    dispatch: (request: HttpRequest) => Promise<HttpResponse>;
+};
+/**
+ * Runs the user's hooks at the http-testing seams.
+ *
+ * Holds the bindings the loader produced and nothing else: an unbound
+ * Transaction simply has no hooks, which is the pass-through case, so there is
+ * no "not initialized" state to guard against.
+ */
 export declare class HookRunner {
-    private readonly path;
-    private readonly runRequest;
     private readonly logger;
-    private initialized;
-    private hooks;
-    private urlToTransactionId;
+    private readonly ports;
     private format;
-    constructor(path: string, runRequest: (req: HttpRequest) => Promise<HttpResponse>, logger: Logger);
-    init(format: ThymianFormat, samplesStructure?: SamplesStructure): Promise<void>;
+    private catalog;
+    private byTransactionId;
+    private globalAuthorize;
+    private readonly runScoped;
+    /**
+     * The origin this run is actually talking to — a `--target-url` override or
+     * a configured target, same as the server the description names when
+     * neither is set — so a run-scoped hook's seed goes where the run goes
+     * rather than where the description points.
+     *
+     * Captured once, from the very first request. "Before the run" has no
+     * meaning until something decides when the run starts, and the sampler's
+     * first observation of a run is its first request, so this is captured in
+     * lockstep with {@link RunScopedHooks.start}'s latch, in
+     * {@link beforeEachRequest}.
+     *
+     * **One origin per run**, which is a simplification the CLI does not
+     * currently expose: a format assembled from several descriptions may name
+     * different servers per transaction, and a `beforeAll` seed would still be
+     * sent to whichever origin the first request happened to use rather than to
+     * its own transaction's server. Per-request hooks are unaffected — they read
+     * the origin off the request in front of them. Reset on {@link load}, so the
+     * value never outlives the run that observed it.
+     */
+    private runOrigin;
+    constructor(logger: Logger, ports: HookRunnerPorts);
+    /** Adopt a newly loaded format and the hooks bound against it. */
+    load(format: ThymianFormat, catalog: TransactionCatalog, hooks?: LoadUserHooksResult): void;
+    /**
+     * Teardown, on `core.close`. A no-op when no request was ever sent, so a
+     * non-test command never runs somebody's teardown.
+     */
+    close(): Promise<void>;
+    /**
+     * The `utils` a hook with no request to shape gets: the run-scoped pair. A
+     * nested request is available, because a `beforeAll` seeding the API is the
+     * reason `utils.request` exists. `dir` comes from the registration's own
+     * file, not the process's working directory, so a run-scoped hook's file
+     * helpers resolve the same way a per-Transaction hook's do.
+     */
+    private readonly utilsFactory;
+    /**
+     * Shape one request draft with its Transaction's `defineSample` hook, if it
+     * has one. This is what `RequestSampler` calls at generation time; the sampler
+     * itself knows nothing about hooks.
+     *
+     * Runs through the same attribution wrapper as every other kind: a throwing
+     * `defineSample` used to escape here as a raw error with no pointer to the
+     * hook that threw it, misattributed by whatever generic handler caught it
+     * further up.
+     */
+    readonly shapeSample: (draft: HttpRequestTemplate, transactionId: string) => Promise<void>;
+    private hooksFor;
+    private callContext;
+    beforeEachRequest(hook: HttpTestHooks['beforeRequest']['arg']): Promise<HttpTestHooks['beforeRequest']['return']>;
     afterEachResponse(hook: HttpTestHooks['afterResponse']['arg']): Promise<HttpTestHooks['afterResponse']['return']>;
     authorize(hook: HttpTestHooks['authorize']['arg']): Promise<HttpTestHooks['authorize']['return']>;
-    beforeEachRequest(hook: HttpTestHooks['beforeRequest']['arg']): Promise<HttpTestHooks['beforeRequest']['return']>;
+    /**
+     * Which authorize hook supplies this Transaction's credentials.
+     *
+     * A targeted hook wins over the global one for the Transactions it covers, and
+     * within each tier the last registration wins, so a later file can override an
+     * earlier one. Exactly one hook runs: authorization is "who am I", and
+     * composing two answers would mean two sets of credentials on one request.
+     *
+     * Whether it runs at all is not decided here — core runs this seam only when
+     * the run option and the request's own `authorize` flag agree — so a
+     * registered hook is necessary but not sufficient, which is what makes
+     * "force on" need both.
+     */
+    private authorizeFor;
+    /**
+     * The chain a hook of `transaction` runs with: the Transaction's own Selector,
+     * so a hook that seeds itself is caught on the first step.
+     */
+    private chainFor;
+    /**
+     * Run a kind's hooks in order over one value, and translate whatever comes
+     * back into the shape the http-testing seam expects.
+     *
+     * Every hook **mutates `value` in place**; the callback's return value is
+     * deliberately discarded (see {@link invokeHook}).
+     */
+    private compose;
+    /**
+     * Send a request to another Transaction, addressed by its Selector.
+     *
+     * By default the nested request runs the target's own
+     * `beforeEach → authorize → afterEach` pipeline, so seeding behaves like the
+     * real run rather than like a second, quieter client. `runHooks: false` sends
+     * the generated request as-is, which is also the way out of a cycle.
+     */
+    private runNested;
+    /** Whether the target's operation declares a response with this status. */
+    private declaresStatus;
 }
 //# sourceMappingURL=hook-runner.d.ts.map

package/dist/hooks/hook-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hook-runner.d.ts","sourceRoot":"","sources":["../../src/hooks/hook-runner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAsB,aAAa,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,MAAM,EAEX,KAAK,aAAa,EAEnB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAEV,gBAAgB,EACjB,MAAM,gDAAgD,CAAC;AAOxD,qBAAa,UAAU;IAOnB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,MAAM;IARzB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,kBAAkB,CAA8B;IACxD,OAAO,CAAC,MAAM,CAAiB;gBAGZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,CAAC,EACvD,MAAM,EAAE,MAAM;IAG3B,IAAI,CACR,MAAM,EAAE,aAAa,EACrB,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,IAAI,CAAC;IAqBV,iBAAiB,CACrB,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC,KAAK,CAAC,GAC1C,OAAO,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,CAAC;IAgE9C,SAAS,CACb,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,GACtC,OAAO,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,CAAC;IAoE1C,iBAAiB,CACrB,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC,KAAK,CAAC,GAC1C,OAAO,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,CAAC;CA+DrD"}
+{"version":3,"file":"hook-runner.d.ts","sourceRoot":"","sources":["../../src/hooks/hook-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EAEjB,KAAK,aAAa,EAClB,KAAK,MAAM,EAEX,aAAa,EACb,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAoBzE,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,sBAAsB,CAAC;AAgB9B,2EAA2E;AAC3E,MAAM,MAAM,eAAe,GAAG;IAC5B,yDAAyD;IACzD,aAAa,EAAE,CACb,WAAW,EAAE,sBAAsB,KAChC,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAClC,6CAA6C;IAC7C,QAAQ,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;CAC3D,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,UAAU;IAgCnB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAhCxB,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,OAAO,CAEb;IACF,OAAO,CAAC,eAAe,CAAoD;IAC3E,OAAO,CAAC,eAAe,CAAwC;IAC/D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAiB;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,SAAS,CAAqB;gBAGnB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,eAAe;IAKzC,kEAAkE;IAClE,IAAI,CACF,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,kBAAkB,EAC3B,KAAK,CAAC,EAAE,mBAAmB,GAC1B,IAAI;IAYP;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAS3B;IAEF;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,GAClB,OAAO,mBAAmB,EAC1B,eAAe,MAAM,KACpB,OAAO,CAAC,IAAI,CAAC,CAqBd;IAEF,OAAO,CAAC,QAAQ;IAQhB,OAAO,CAAC,WAAW;IA4Bb,iBAAiB,CACrB,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC,KAAK,CAAC,GAC1C,OAAO,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,CAAC;IAsB9C,iBAAiB,CACrB,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC,KAAK,CAAC,GAC1C,OAAO,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,QAAQ,CAAC,CAAC;IAa9C,SAAS,CACb,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,GACtC,OAAO,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,CAAC;IAchD;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,YAAY;IASpB;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAYhB;;;;;;OAMG;YACW,OAAO;IAyCrB;;;;;;;OAOG;YACW,SAAS;IAiJvB,2EAA2E;IAC3E,OAAO,CAAC,cAAc;CAQvB"}