openalgo-script 0.4.0 → 0.6.0

package/dist/core/backtest/deliver.d.ts

@@ -0,0 +1,93 @@
+/**
+ * A case's rows and this engine's frames, and the destination between them.
+ *
+ * Both directions are here because they are one correspondence: a case names an
+ * order by an ordinal and an engine knows it by an id, so `Delivery` reads an
+ * ordinal into the id of the intent the run placed, and `framedAs` writes an id
+ * back out as the ordinal a case file prints. Split between two files, the two
+ * halves of it drift, and a suite whose rows say one thing and whose records
+ * say another is one nobody can read.
+ *
+ * `conformance.md` section 3: `frames.csv` supplies order frames the way
+ * `bars.csv` supplies bars, so a strategy case asserts the fold against input
+ * the engine did not choose. `simulate.ts` is the other destination this module
+ * has, the one that reads a bar and works out what a venue would have said.
+ * This one works nothing out. It holds the rows a case supplied, hands over the
+ * ones each boundary names, and the whole of its behaviour is the mapping
+ * between a row and a frame.
+ *
+ * **An ordinal is what a case can name, and an id is not.** A row names the nth
+ * intent the run placed, because no case can know the id an engine minted, so
+ * the intents are counted here in the order the run handed them over and the
+ * ordinal is read against that count. A row naming an ordinal the run never
+ * placed is delivered all the same, carrying an id no run mints: step 1 of
+ * `stdlib.md` 17.8 refuses a frame naming no row of the ledger, and that
+ * refusal is the ledger's to make. A destination that dropped the row instead
+ * would answer nothing at all where section 3 hands an engine a frame about an
+ * order its ledger does not hold, and the case would pass by the frame never
+ * having arrived.
+ *
+ * **What a row does not carry, this does not invent.** `host-interface.md` 7.2
+ * lets a frame say which instrument and product the destination booked the
+ * order under, and the file has no column for either, so neither is stated and
+ * the row keeps what its placement put there. The instant is the one the file
+ * does carry: a row states one or states `none`, and one that states none
+ * leaves `updatedAt` where the placement put it, which is what the fold does
+ * with a frame whose destination stated no instant.
+ */
+import type { OrderFrame, OrderIntent, RoutedEffect } from '../engine/index.js';
+import type { RecordedFrame } from './record.js';
+/** One frame, the boundary it was handed over at, and the row it came from. */
+export interface Delivered {
+    readonly frame: OrderFrame;
+    readonly afterBar: number;
+    /**
+     * The row a case supplied, or null where the run's own destination answered
+     * the frame and there is no row until the record is written.
+     */
+    readonly row: RecordedFrame | null;
+}
+/** Where a run's orders go, and what it is told between two of its bars. */
+export interface Destination {
+    /** Step 9: what the strategy decided, on the bar it decided it. */
+    route(effect: RoutedEffect, barIndex: number): void;
+    /** What this destination hands over at the boundary after `barIndex`. */
+    answers(barIndex: number): readonly Delivered[];
+    /** Every intent it was handed, in the order it was handed them. */
+    readonly intents: readonly OrderIntent[];
+}
+/**
+ * A destination holding one case's frames, ready at the boundaries they name.
+ *
+ * Built before the run rather than during it, because the rows are input: what
+ * a boundary hands over was decided by whoever wrote the case and not by
+ * anything this run does. The one thing it learns as the run goes is which
+ * intent an ordinal names, which only the run can say.
+ */
+export declare class Delivery implements Destination {
+    readonly intents: OrderIntent[];
+    /** The rows of each boundary, in file order, which section 3 fixes as the delivery order. */
+    private readonly rows;
+    constructor(frames: readonly RecordedFrame[]);
+    /** Nothing is decided by an order arriving here: it is counted, and that is all. */
+    route(effect: RoutedEffect): void;
+    answers(barIndex: number): readonly Delivered[];
+}
+/**
+ * The ordinal of every intent, which is how a case names one.
+ *
+ * One, two, three in the order the run placed them, because no engine can know
+ * the id another minted and a case that named one would only ever be readable
+ * by the engine that wrote it.
+ */
+export declare function ordinalsOf(intents: readonly OrderIntent[]): ReadonlyMap<number, number>;
+/**
+ * One delivered frame, in the columns a case file prints.
+ *
+ * The instant travels with it. `stdlib.md` 17.7 folds `updatedAt` from a
+ * frame's `time`, so a driver that dropped the field here wrote a record whose
+ * ledger no engine could fold from the record's own frames: it would have
+ * nothing to move that field to and would leave it at `placedAt`.
+ */
+export declare function framedAs(frame: OrderFrame, afterBar: number, ordinals: ReadonlyMap<number, number>): RecordedFrame;
+//# sourceMappingURL=deliver.d.ts.map

package/dist/core/backtest/deliver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliver.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/deliver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,+EAA+E;AAC/E,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAAC;CACpC;AAED,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,mEAAmE;IACnE,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACpD,yEAAyE;IACzE,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE,CAAC;IAChD,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;CAC1C;AAcD;;;;;;;GAOG;AACH,qBAAa,QAAS,YAAW,WAAW;IAC1C,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,CAAM;IACrC,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsC;gBAE/C,MAAM,EAAE,SAAS,aAAa,EAAE;IAQ5C,oFAAoF;IACpF,KAAK,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAIjC,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,SAAS,EAAE;CAQhD;AAeD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAMvF;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACpC,aAAa,CAWf"}

package/dist/core/backtest/deliver.js

@@ -0,0 +1,94 @@
+/**
+ * An id no run mints, which a row naming no intent of this run is delivered
+ * under.
+ *
+ * Ids are counted from one by the ledger that mints them, so nothing below one
+ * can name a row and the fold refuses the frame by the rule it refuses every
+ * other unknown one by. The alternative was an id of a real row chosen by some
+ * rule of this file's own, which would fold a case's frame into whichever order
+ * happened to be near it.
+ */
+const NO_INTENT = -1;
+/**
+ * A destination holding one case's frames, ready at the boundaries they name.
+ *
+ * Built before the run rather than during it, because the rows are input: what
+ * a boundary hands over was decided by whoever wrote the case and not by
+ * anything this run does. The one thing it learns as the run goes is which
+ * intent an ordinal names, which only the run can say.
+ */
+export class Delivery {
+    intents = [];
+    /** The rows of each boundary, in file order, which section 3 fixes as the delivery order. */
+    rows = new Map();
+    constructor(frames) {
+        for (const row of frames) {
+            const at = this.rows.get(row.afterBar);
+            if (at === undefined)
+                this.rows.set(row.afterBar, [row]);
+            else
+                at.push(row);
+        }
+    }
+    /** Nothing is decided by an order arriving here: it is counted, and that is all. */
+    route(effect) {
+        for (const intent of effect.intents)
+            this.intents.push(intent);
+    }
+    answers(barIndex) {
+        const due = this.rows.get(barIndex) ?? [];
+        return due.map((row) => ({
+            frame: frameOf(row, this.intents[row.intent - 1]),
+            afterBar: barIndex,
+            row,
+        }));
+    }
+}
+/** One row of a case, as the frame `host-interface.md` 7.2 describes. */
+function frameOf(row, intent) {
+    return {
+        intentId: intent?.intentId ?? NO_INTENT,
+        status: row.status,
+        filledQty: row.filledQty,
+        avgFillPrice: row.avgFillPrice,
+        orderRef: row.orderRef,
+        text: row.text,
+        time: row.time,
+    };
+}
+/**
+ * The ordinal of every intent, which is how a case names one.
+ *
+ * One, two, three in the order the run placed them, because no engine can know
+ * the id another minted and a case that named one would only ever be readable
+ * by the engine that wrote it.
+ */
+export function ordinalsOf(intents) {
+    const out = new Map();
+    for (const intent of intents) {
+        if (!out.has(intent.intentId))
+            out.set(intent.intentId, out.size + 1);
+    }
+    return out;
+}
+/**
+ * One delivered frame, in the columns a case file prints.
+ *
+ * The instant travels with it. `stdlib.md` 17.7 folds `updatedAt` from a
+ * frame's `time`, so a driver that dropped the field here wrote a record whose
+ * ledger no engine could fold from the record's own frames: it would have
+ * nothing to move that field to and would leave it at `placedAt`.
+ */
+export function framedAs(frame, afterBar, ordinals) {
+    return {
+        afterBar,
+        intent: ordinals.get(frame.intentId) ?? 0,
+        status: frame.status,
+        filledQty: frame.filledQty,
+        avgFillPrice: frame.avgFillPrice ?? null,
+        orderRef: frame.orderRef ?? null,
+        text: frame.text ?? null,
+        time: frame.time ?? null,
+    };
+}
+//# sourceMappingURL=deliver.js.map

package/dist/core/backtest/deliver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliver.js","sourceRoot":"","sources":["../../../src/core/backtest/deliver.ts"],"names":[],"mappings":"AA6DA;;;;;;;;;GASG;AACH,MAAM,SAAS,GAAG,CAAC,CAAC,CAAC;AAErB;;;;;;;GAOG;AACH,MAAM,OAAO,QAAQ;IACV,OAAO,GAAkB,EAAE,CAAC;IACrC,6FAA6F;IAC5E,IAAI,GAAG,IAAI,GAAG,EAA2B,CAAC;IAE3D,YAAY,MAAgC;QAC1C,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YACzB,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,EAAE,KAAK,SAAS;gBAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;;gBACpD,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpB,CAAC;IACH,CAAC;IAED,oFAAoF;IACpF,KAAK,CAAC,MAAoB;QACxB,KAAK,MAAM,MAAM,IAAI,MAAM,CAAC,OAAO;YAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,CAAC,QAAgB;QACtB,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC1C,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YACvB,KAAK,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACjD,QAAQ,EAAE,QAAQ;YAClB,GAAG;SACJ,CAAC,CAAC,CAAC;IACN,CAAC;CACF;AAED,yEAAyE;AACzE,SAAS,OAAO,CAAC,GAAkB,EAAE,MAA+B;IAClE,OAAO;QACL,QAAQ,EAAE,MAAM,EAAE,QAAQ,IAAI,SAAS;QACvC,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,SAAS,EAAE,GAAG,CAAC,SAAS;QACxB,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,QAAQ,EAAE,GAAG,CAAC,QAAQ;QACtB,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,IAAI,EAAE,GAAG,CAAC,IAAI;KACf,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAC,OAA+B;IACxD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC;YAAE,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IACxE,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CACtB,KAAiB,EACjB,QAAgB,EAChB,QAAqC;IAErC,OAAO;QACL,QAAQ;QACR,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC;QACzC,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,IAAI;QACxC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;QAChC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,IAAI;QACxB,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,IAAI;KACzB,CAAC;AACJ,CAAC"}

package/dist/core/backtest/drive.d.ts

@@ -1,29 +1,122 @@
 import type { Diagnostic } from '../diagnostics/index.js';
 import type { CompiledProgram } from '../emit/index.js';
-import type { RecordedBar, RunRecord } from './record.js';
+import type { Drawing, Grid, Instrument, RequestProvider, Value } from '../engine/index.js';
+import type { RecordedBar, RecordedFrame, RunRecord } from './record.js';
+import type { LogLine } from './walk.js';
 import type { BacktestSettings } from './settings.js';
 /** What a run came to, or why it could not be carried out at all. */
 export type BacktestResult = {
     readonly ok: true;
     readonly record: RunRecord;
+    readonly rows?: readonly (readonly Value[])[];
+    readonly log?: readonly LogLine[];
+    readonly surface?: Surface;
 } | {
     readonly ok: false;
     readonly diagnostic: Diagnostic;
 };
+/** The drawing objects and the grids the last bar left, `conformance.md` section 4. */
+export interface Surface {
+    readonly drawings: readonly Drawing[];
+    readonly tables: readonly Grid[];
+}
+/**
+ * The facts of `host-interface.md` 4.1 that the contract does not hold.
+ *
+ * The contract already states six of the twelve, the ones the money is priced
+ * under, and a fact stated in two places is a fact that can disagree with
+ * itself: a tick size the engine rounds to and a different one the venue
+ * worsens a fill by is a run under two instruments. So the other six are
+ * stated here and the six the contract holds cannot be, which the compiler
+ * enforces rather than a check at run time.
+ */
+export type InstrumentFacts = Omit<Instrument, 'symbol' | 'exchange' | 'tickSize' | 'lotSize' | 'pointValue' | 'currency'>;
 /** The few choices a driver has that are not settings of the run itself. */
 export interface DriveOptions {
     /** Whether the bars travel in the record. Inline is the conformance form. */
     readonly form?: 'inline' | 'referenced';
+    /**
+     * What the host states about the instrument beside the contract, so the
+     * record it produces is a conformance case.
+     *
+     * A case holds `instrument.json`, which `conformance.md` section 2 says is
+     * the record of `host-interface.md` 4.1, and that page requires one fact of
+     * every host: `hasVolume`, because no derivation recovers it (4.2). The
+     * engine reads the record and does not refuse a run without it, so a caller
+     * that leaves this out gets a record that replays and reruns like any other
+     * and cannot become a case, exactly as one without `sourceText` cannot.
+     *
+     * A session stated without a timezone is refused at load, OS6012, by the
+     * same rule that refuses it for any host.
+     */
+    readonly instrument?: InstrumentFacts;
+    /**
+     * The script's own text, so the record it produces is a conformance case.
+     *
+     * A compiled program identifies its source and cannot reproduce it, and a
+     * case has to hold `script.os`. A caller holding only a program leaves this
+     * out and gets a record that replays and reruns like any other; the one
+     * thing it cannot do is be handed to somebody else's engine as a case.
+     *
+     * It is checked against the program's own source hash, so text from a
+     * different revision than the one that was compiled is refused rather than
+     * written into a case that could never make its own expected output.
+     */
+    readonly sourceText?: string;
+    /**
+     * Whether to hand back every channel's value on every bar that ran, beside
+     * the record rather than inside it.
+     *
+     * A conformance case that asserts `values` compares one value per bar per
+     * plot, and the record holds none of them: it is the reproducible run, and a
+     * curve per plot is bytes it would carry for every run to serve the few cases
+     * that ask. So the rows are asked for, and a run that does not ask pays
+     * nothing. A bar that failed has no row, as in the second engine.
+     */
+    readonly rows?: boolean;
+    /** Whether to hand back every line `print` wrote, beside the record, for the same reason. */
+    readonly log?: boolean;
+    /** Whether to hand back the drawing objects and grids the last bar left, for the same reason. */
+    readonly surface?: boolean;
+    /**
+     * Bars for another instrument, `host-interface.md` 5, for a run whose host
+     * serves them.
+     *
+     * Left out, the run holds the chart's own bars and nothing else: a read of
+     * the chart's instrument at a coarser interval is folded from them, and a
+     * program that reads another instrument declares a capability this host does
+     * not have and is refused at load by name. Given, the host serves duty 3 and
+     * the engine asks it once per read, before bar 0.
+     */
+    readonly requestBars?: RequestProvider;
 }
 /**
- * One run, from a compiled program to a record of it.
+ * One run against a simulated destination, from a compiled program to a record.
  *
- * A refusal before the first bar comes back as a refusal and not as a record:
- * a program that would not load, a setting that cannot be applied and a window
- * holding no bars are all runs that did not happen, and a record of one would
- * be a document asserting figures nothing computed. A failure during a bar is
- * the other way round: the run happened, it stopped, and the record carries
- * both what it did and the diagnostic that stopped it.
+ * The frames are the destination's own: it is handed the orders, it reads the
+ * bars, and what it answers is what the engine folds. A run whose frames
+ * somebody else is supplying is `backtestSupplied` below.
  */
 export declare function backtest(program: CompiledProgram, bars: readonly RecordedBar[], settings: BacktestSettings, options?: DriveOptions): BacktestResult;
+/**
+ * One run over the frames somebody else supplied, which this engine does not
+ * choose and does not add to.
+ *
+ * `conformance.md` section 3 gives a case a `frames.csv` that supplies order
+ * frames the way `bars.csv` supplies bars, so that a case asserts the fold
+ * against input the engine did not choose. Every other argument is `backtest`'s
+ * and means there what it means here. A row is delivered at the boundary it
+ * names and folded before the next bar, and the record carries the rows it was
+ * handed rather than a second spelling of them.
+ *
+ * **Nothing is invented.** No fill is priced off a bar, no order rests and no
+ * schedule is read, so an order the frames say nothing about stays where its
+ * placement left it, which is what a case saying nothing about it means.
+ *
+ * **A record made here is a record of this run and not of a simulated one.**
+ * `rerun` puts a record's program back on a simulated destination, because a
+ * record does not say which of the two answered it, so a rerun of one of these
+ * reproduces it only where that destination would answer these same frames.
+ */
+export declare function backtestSupplied(program: CompiledProgram, bars: readonly RecordedBar[], settings: BacktestSettings, frames: readonly RecordedFrame[], options?: DriveOptions): BacktestResult;
 //# sourceMappingURL=drive.d.ts.map

package/dist/core/backtest/drive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/drive.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAiBxD,OAAO,KAAK,EACV,WAAW,EAIX,SAAS,EACV,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,qEAAqE;AACrE,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAE5D,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;CACzC;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,YAAiB,GACzB,cAAc,CAgDhB"}
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../src/core/backtest/drive.ts"],"names":[],"mappings":"AAqCA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,OAAO,KAAK,EACV,OAAO,EAEP,IAAI,EACJ,UAAU,EAGV,eAAe,EAEf,KAAK,EACN,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAiB,SAAS,EAAE,MAAM,aAAa,CAAC;AAIxF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,qEAAqE;AACrE,MAAM,MAAM,cAAc,GACtB;IACE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,CAAC;IAC9C,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B,GACD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAE5D,uFAAuF;AACvF,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAChC,UAAU,EACV,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,UAAU,CAC3E,CAAC;AAEF,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;IACxC;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;IACtC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;;OASG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,6FAA6F;IAC7F,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,iGAAiG;IACjG,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;CACxC;AAGD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,YAAiB,GACzB,cAAc,CAahB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,OAAO,GAAE,YAAiB,GACzB,cAAc,CAEhB"}