spec-controller 0.1.0-alpha.1

package/dist/mutation-ratchet/reconcile.d.ts

@@ -0,0 +1,82 @@
+/**
+ * THE COMPOSITION — one gate's run reconciled against its record, with every term a project owns
+ * arriving from that project (@SCN-RAT-014, 3F-2804).
+ *
+ * FIVE TERMS, AND FOUR OF THEM ARE WHY THIS MODULE EXISTS RATHER THAN A CALLER WIRING THE PIECES
+ * TOGETHER ITSELF. The reader, the report and the verdict below were each built generic, and the
+ * reference implementation this library was lifted from was generic in all of them too — right up
+ * to the point where something had to say WHICH tree, WHICH file, WHICH report and WHAT to type
+ * next. Those four answers were written into the code there, and they are the four that arrive
+ * here as a request instead.
+ *
+ * THE ROOT IS THE CONSUMER'S WORKSPACE, NEVER THIS MODULE'S OWN LOCATION, and that is the term
+ * that fails silently rather than loudly. A module finding the tree from where it is installed
+ * agrees with its caller for exactly as long as it sits beside that caller's code — which it does
+ * in the repository it was written in, and stops doing the day it is installed as a dependency,
+ * when it resolves into its own directory inside a package folder and finds nothing there. There
+ * is no way to notice from inside: the paths are well-formed, the reads fail as absent files, and
+ * a gate that measured perfectly reads as a gate that never ran. So the root arrives, and every
+ * path below is joined onto it.
+ *
+ * THE RECORD FILE IS DEFAULTED AND THE REPORT PATH IS NOT, and the asymmetry is a ruling rather
+ * than an oversight. Where a mutation sweep drops its output is a RUNNER'S convention, so a
+ * default there would be this module naming a runner — the exact leak the Rule above it forbids.
+ * The record's name is owned by whoever owns the record, so a conventional default costs its
+ * owner nothing and a caller who wants another writes one.
+ *
+ * AND THE BANK-IT INSTRUCTION IS CARRIED WHOLE, because the two verdicts that ask for a record to
+ * be banked have to say what to type, and what to type is a sentence only the calling project can
+ * write. Left to this module it would be somebody's script name, sitting inside a message, reached
+ * only on the runs nobody reads twice.
+ *
+ * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY, and @SCN-RAT-014
+ * asserts that over this module's own bytes rather than trusting it.
+ */
+import { type MutationVerdict } from "./verdict.js";
+/**
+ * The name a record is filed under when its caller does not choose one.
+ *
+ * A DEFAULT, NEVER A CONSTANT THE READER GOES LOOKING FOR. Which file holds a project's bars is
+ * that project's own fact, and a caller naming its own is answered by that name — this is only
+ * what stands in when none is given, and it is exported so a caller happy with the convention does
+ * not have to respell it and get one character of it wrong.
+ */
+export declare const RECORD_FILE = "quality-thresholds.yml";
+/**
+ * One reconciliation, as the calling project states it.
+ *
+ * EVERY FIELD IS A TERM THE PROJECT OWNS. There is nothing else here — no setting, no mode, no
+ * threshold of this module's own. The bar is in the project's record and the run is in the
+ * project's report; what this asks for is where those two are and what to call things.
+ */
+export interface RatchetRequest {
+    /** The gate to reconcile, as the project's own record names it. */
+    readonly gate: string;
+    /**
+     * The CONSUMER'S workspace — the tree the record and the report both sit in.
+     *
+     * Never this module's own installed location, which is the same tree only by coincidence and
+     * only until the day this ships as something another repository installs.
+     */
+    readonly root: string;
+    /**
+     * Where the gate's run left its report, relative to that root.
+     *
+     * REQUIRED, AND THAT IS THE RULING. A default here would be a runner's output convention wearing
+     * this module's name.
+     */
+    readonly reportPath: string;
+    /** What the project's own people type to bank a measurement, carried into the verdicts that ask. */
+    readonly bankCommand: string;
+    /** Where the project's record sits, relative to that root. Defaults to {@link RECORD_FILE}. */
+    readonly recordFile?: string;
+}
+/**
+ * Reconcile one gate's run against the bar its project's record states.
+ *
+ * @param request the five terms the calling project owns
+ * @returns the verdict, red or green, carrying the line its reader gets
+ * @throws MalformedRecordError when the record cannot be read as a bar, or holds no such gate
+ */
+export declare function reconcileGate(request: RatchetRequest): MutationVerdict;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/mutation-ratchet/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAOH,OAAO,EAA6B,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/E;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,2BAA2B,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oGAAoG;IACpG,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,+FAA+F;IAC/F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAWtE"}

package/dist/mutation-ratchet/reconcile.js

@@ -0,0 +1,67 @@
+/**
+ * THE COMPOSITION — one gate's run reconciled against its record, with every term a project owns
+ * arriving from that project (@SCN-RAT-014, 3F-2804).
+ *
+ * FIVE TERMS, AND FOUR OF THEM ARE WHY THIS MODULE EXISTS RATHER THAN A CALLER WIRING THE PIECES
+ * TOGETHER ITSELF. The reader, the report and the verdict below were each built generic, and the
+ * reference implementation this library was lifted from was generic in all of them too — right up
+ * to the point where something had to say WHICH tree, WHICH file, WHICH report and WHAT to type
+ * next. Those four answers were written into the code there, and they are the four that arrive
+ * here as a request instead.
+ *
+ * THE ROOT IS THE CONSUMER'S WORKSPACE, NEVER THIS MODULE'S OWN LOCATION, and that is the term
+ * that fails silently rather than loudly. A module finding the tree from where it is installed
+ * agrees with its caller for exactly as long as it sits beside that caller's code — which it does
+ * in the repository it was written in, and stops doing the day it is installed as a dependency,
+ * when it resolves into its own directory inside a package folder and finds nothing there. There
+ * is no way to notice from inside: the paths are well-formed, the reads fail as absent files, and
+ * a gate that measured perfectly reads as a gate that never ran. So the root arrives, and every
+ * path below is joined onto it.
+ *
+ * THE RECORD FILE IS DEFAULTED AND THE REPORT PATH IS NOT, and the asymmetry is a ruling rather
+ * than an oversight. Where a mutation sweep drops its output is a RUNNER'S convention, so a
+ * default there would be this module naming a runner — the exact leak the Rule above it forbids.
+ * The record's name is owned by whoever owns the record, so a conventional default costs its
+ * owner nothing and a caller who wants another writes one.
+ *
+ * AND THE BANK-IT INSTRUCTION IS CARRIED WHOLE, because the two verdicts that ask for a record to
+ * be banked have to say what to type, and what to type is a sentence only the calling project can
+ * write. Left to this module it would be somebody's script name, sitting inside a message, reached
+ * only on the runs nobody reads twice.
+ *
+ * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY, and @SCN-RAT-014
+ * asserts that over this module's own bytes rather than trusting it.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { gateRecordFor, parseGateRecords } from "./record.js";
+import { readMutationReport } from "./report.js";
+import { noMeasurement, verdictFor } from "./verdict.js";
+/**
+ * The name a record is filed under when its caller does not choose one.
+ *
+ * A DEFAULT, NEVER A CONSTANT THE READER GOES LOOKING FOR. Which file holds a project's bars is
+ * that project's own fact, and a caller naming its own is answered by that name — this is only
+ * what stands in when none is given, and it is exported so a caller happy with the convention does
+ * not have to respell it and get one character of it wrong.
+ */
+export const RECORD_FILE = "quality-thresholds.yml";
+/**
+ * Reconcile one gate's run against the bar its project's record states.
+ *
+ * @param request the five terms the calling project owns
+ * @returns the verdict, red or green, carrying the line its reader gets
+ * @throws MalformedRecordError when the record cannot be read as a bar, or holds no such gate
+ */
+export function reconcileGate(request) {
+    const recordFile = request.recordFile ?? RECORD_FILE;
+    const records = parseGateRecords(readFileSync(join(request.root, recordFile), "utf8"), recordFile);
+    const record = gateRecordFor(request.gate, records, recordFile);
+    const read = readMutationReport(request.gate, join(request.root, request.reportPath));
+    // A refusal is carried through as the verdict it implies rather than as an absence: a report that
+    // is not there is a gate that produced no score, which is not a gate that passed.
+    return read.ok
+        ? verdictFor(record, read.measurement, request.bankCommand)
+        : noMeasurement(request.gate, read.reason);
+}
+//# sourceMappingURL=reconcile.js.map

package/dist/mutation-ratchet/reconcile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.js","sourceRoot":"","sources":["../../src/mutation-ratchet/reconcile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,UAAU,EAAwB,MAAM,cAAc,CAAC;AAE/E;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,wBAAwB,CAAC;AAgCpD;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,OAAuB;IACnD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,WAAW,CAAC;IACrD,MAAM,OAAO,GAAG,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,EAAE,UAAU,CAAC,CAAC;IACnG,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAChE,MAAM,IAAI,GAAG,kBAAkB,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC;IAEtF,kGAAkG;IAClG,kFAAkF;IAClF,OAAO,IAAI,CAAC,EAAE;QACZ,CAAC,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,WAAW,CAAC;QAC3D,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;AAC/C,CAAC"}

package/dist/mutation-ratchet/record.d.ts

@@ -0,0 +1,210 @@
+/**
+ * A GATE'S RECORD — the pair of counts it last banked, and the allowance stated against them
+ * (@SCN-RAT-001, 3F-2790).
+ *
+ * THE RECORD IS TWO COUNTS, NEVER A BARE SCORE, and that is the load-bearing choice this whole
+ * module exists to make possible. A mutation score is detected over total, so it falls for two
+ * entirely unrelated reasons: a mutant this suite used to kill now survives, which is the fault
+ * the gate exists for; or new mutable code arrived carrying survivors with it, which is no fault
+ * at all. One number reds on both, and the only cheap way out of a red for the second is to widen
+ * the bar — which is how a floor loses its teeth. Keeping `detected` and `total` apart is what
+ * lets the verdict tell them apart: kills lost is stated directly, and a growing population moves
+ * `total` while leaving `detected` alone.
+ *
+ * NOTHING HERE NAMES A PROJECT, A CHECK, A RUNNER, A WORKFLOW OR A REPOSITORY. The record's text
+ * arrives as a string and the name it is filed under arrives beside it, because which file holds a
+ * project's bars, and what its gates are called, are that project's own facts. This module has an
+ * opinion about the SHAPE of a record and none about whose it is.
+ *
+ * MALFORMED MEANS NO BAR, NEVER A DEFAULTED ONE. Every refusal below is a record a lenient reader
+ * answers with a bar nobody wrote — an absent section read as "no gates to enforce", a gate that
+ * measured nothing read as scoring zero, an allowance nobody justified read as justified. The bar
+ * is then enforced as though somebody had written it, and the only symptom is a build that has
+ * quietly stopped being able to red. So each one is refused by name, and the refusal says which
+ * record it read and where in that record the fault is (@SCN-RAT-002, 3F-2792).
+ *
+ * IT IS NOT A STATIC CHECK, and takes no `static-check:` prefix. A static check is a pure function
+ * of the checked-out tree; the record this reads feeds a reconciler that judges a MEASUREMENT,
+ * which by construction is not in the tree — the standing ruling every scheduled-sweep reader in
+ * this portfolio already carries.
+ */
+/**
+ * The section of a record file that holds every gate's counts.
+ *
+ * EXPORTED SO THE RECORDER CANNOT HOLD A SECOND COPY OF IT. `ratchet.ts` finds the same section in
+ * the same text in order to rewrite two of its lines, and two spellings of one name is the
+ * agreeing-until-somebody-edits-one shape this whole library exists to remove.
+ *
+ * The SECTION name is this module's, and the gate names inside it are the project's. A record file
+ * is a project's own document and may hold whatever else that project keeps in it; what this module
+ * asks of it is one section, under one name, so a project can file its mutation bars beside the
+ * rest of its policy rather than in a file of their own.
+ */
+export declare const MUTATION_GATES = "mutation-gates";
+/**
+ * The field a refusal names when the fault is the ASK rather than a field of a gate's block — a
+ * gate the record does not hold at all.
+ *
+ * EXPORTED FOR THE SAME REASON AS THE SECTION NAME: `ratchet.ts` refuses the same way when it is
+ * asked to raise a gate no block is written for, and a refusal a reader has to recognise in two
+ * spellings is one they will eventually parse wrongly.
+ */
+export declare const WHOLE_GATE = "<gate>";
+/**
+ * Raised when a record cannot be read as a bar.
+ *
+ * IT NAMES THE SECTION, THE GATE AND THE FIELD, because a record file is a wall of near-identical
+ * gate blocks and a bare "invalid config" over one of them leaves a reader opening the file and
+ * reading every block to find out which. The four together are enough to put a cursor on the line.
+ *
+ * ONE TYPE FOR EVERY FAULT, INCLUDING THE ONES THIS MODULE DOES NOT DETECT ITSELF. A caller is
+ * told to catch this and nothing else, so anything it does not cover is something that caller
+ * sails past — which is why the YAML parser's own errors are normalised into it rather than left
+ * to travel under their own name. That is what makes "a malformed record fails loudly" a property
+ * of the reader rather than a property of the field checks alone.
+ */
+export declare class MalformedRecordError extends Error {
+    /** The name the record was filed under, as the caller handed it over. */
+    readonly recordFile: string;
+    /** The section the fault sits in, or `<document>` when it sits above every section. */
+    readonly section: string;
+    /** The gate the fault sits under, or a placeholder when the fault is the section itself. */
+    readonly key: string;
+    /** The field the fault sits at. */
+    readonly field: string;
+    constructor(
+    /** The name the record was filed under, as the caller handed it over. */
+    recordFile: string, 
+    /** The section the fault sits in, or `<document>` when it sits above every section. */
+    section: string, 
+    /** The gate the fault sits under, or a placeholder when the fault is the section itself. */
+    key: string, 
+    /** The field the fault sits at. */
+    field: string, detail: string);
+}
+/**
+ * The allowance a record STATES against a gate's counts — how many kills may be lost before the
+ * gate reds, and why that many.
+ *
+ * COUNTED IN MUTANTS, WITH ITS REASON, and the unit is the point. A mutant is the unit the fault
+ * arrives in, so the arithmetic downstream is exact rather than a rounding argument; and a
+ * non-zero allowance that cannot say why it exists is head-room rather than tolerance, which is
+ * why the reason travels with the number rather than in a comment beside it.
+ */
+export interface GateAllowance {
+    /** Whole mutants of tolerance. Zero seats the floor exactly on the record. */
+    readonly mutants: number;
+    /** Why the allowance exists. */
+    readonly reason: string;
+}
+/** One gate's last-banked measurement, and the allowance stated against it. */
+export interface GateRecord {
+    /** The gate's name, as the record files it — the project's own word, never this module's. */
+    readonly gate: string;
+    /** Mutants the suite detected. */
+    readonly detected: number;
+    /** Every mutant the gate measured, detected or not. */
+    readonly total: number;
+    readonly allowance: GateAllowance;
+}
+/** A mutation score, as a percentage, computed from counts rather than read off a report. */
+export declare function scoreOf(detected: number, total: number): number;
+/** A percentage, at the one precision every figure in this library is stated to. */
+export declare function pct(value: number): string;
+/**
+ * `detected/total (score%)` — the one shape every count pair in this library is stated in.
+ *
+ * BOTH HALVES, ALWAYS, AND THE SCORE BESIDE THEM. A message naming only the figure that moved
+ * leaves its reader unable to see WHICH of the two moved, which is the single distinction this
+ * library exists to make.
+ *
+ * IT LIVES HERE, BESIDE THE COUNTS, BECAUSE TWO READERS STATE IT. The reconciler prints it in every
+ * verdict and the recorder prints it in its refusal, and one sentence spelled twice is the
+ * agreeing-until-somebody-edits-one shape this library was built to remove.
+ */
+export declare function counts(detected: number, total: number): string;
+/**
+ * Whether one pair of counts scores strictly ABOVE another.
+ *
+ * CROSS-MULTIPLIED RATHER THAN DIVIDED, so the comparison is exact. Two scores equal as ratios can
+ * differ in their last bit once each has been through a division, and a pair that did not move would
+ * then read as one that did. The counts are whole and small enough that the products are exact.
+ *
+ * ONE FUNCTION READ BOTH WAYS ROUND, WHICH IS WHAT LEAVES EQUAL UNCLAIMED. Above and below are the
+ * same two products with the arguments swapped, so no run can be claimed by both, and — the case
+ * that matters — none can be claimed by neither. Two comparisons reached by different arithmetic
+ * could each answer `false` for a run that is genuinely one or the other, and the run would fall out
+ * of every reader here at once.
+ */
+export declare function scoreRoseOver(detected: number, total: number, overDetected: number, overTotal: number): boolean;
+/**
+ * The failing floor: the record's counts with its allowance spent out of the DETECTED count.
+ *
+ * SPENT FROM THE NUMERATOR, not subtracted from the score, because the allowance is counted in
+ * mutants and a mutant is worth a different number of points in every gate — the same allowance
+ * taken off two scores would mean two different things in two gates of different sizes.
+ *
+ * A REPORTED FIGURE, NOT THE DECISION VARIABLE. The verdict decides on COUNTS — fewer kills than
+ * the record less its allowance — and prints this floor beside it so a reader has the bar in the
+ * units the sweep speaks. The two agree exactly while the mutant population is unchanged, and part
+ * company the moment it moves: a grown population drags the measured score below this floor with
+ * no kill lost at all, and that case is green. Reading this floor AS the gate would put the
+ * judgement back on the score, which is the confusion the counts model exists to prevent.
+ */
+export declare function floorOf(record: GateRecord): number;
+/**
+ * The failing floor in MUTANTS: the record's kills with its allowance spent out of them.
+ *
+ * `floorOf`'s TWIN WITHOUT THE DIVISION, and the division is the whole difference. A percentage is
+ * two facts folded into one, and folding them is what makes a floor fall when new mutable code
+ * arrives carrying survivors — no kill lost, and the bar missed anyway. Subtracting the allowance
+ * and stopping leaves a whole number of mutants that moves only when a mutant this suite used to
+ * kill stops dying, which is the one fact a bar on this axis is about.
+ *
+ * `total` NEVER ENTERS IT, and that is the population-independence rather than a simplification.
+ * A reader holding this number can be handed a run over any population at all and still be asking
+ * the only question worth asking of it.
+ *
+ * HERE RATHER THAN AT ITS CALLER, for the reason `floorOf` is here: how an allowance is spent is a
+ * fact about the record, and a caller computing `detected - slack` itself would be a second place
+ * holding it — agreeing until the day one of them is edited.
+ */
+export declare function killFloorOf(record: GateRecord): number;
+/** The score the record itself states — what the ratchet raises and the verdict compares against. */
+export declare function recordedScoreOf(record: GateRecord): number;
+/**
+ * Read every gate's record out of a record file's text.
+ *
+ * @param text the record file's own bytes, as authored
+ * @param recordFile the name the record is filed under, so a refusal can say which file it read
+ * @throws MalformedRecordError when the text cannot be read as a bar — one type for every fault,
+ *   the YAML parser's own included, so a caller told to catch this catches all of them.
+ */
+export declare function parseGateRecords(text: string, recordFile: string): Map<string, GateRecord>;
+/**
+ * The bar the record holds for one named gate, refused when the record holds no such gate.
+ *
+ * A GATE WITH NO RECORD IS THE ONE FAULT IN THIS MODULE THAT LOOKS LIKE NOTHING AT ALL. Every
+ * refusal above is a record somebody wrote badly, sitting in the file a reader would go and open.
+ * This one is a record that reads perfectly, asked for a gate it never held — a gate name mistyped
+ * where the caller states it. The lenient answer is not a wrong bar but NO bar, which reads
+ * downstream as a gate with nothing to enforce, and it greens for as long as the typo survives.
+ * Nothing about the record is wrong, so nobody is ever sent to look at it (@SCN-RAT-003, 3F-2793).
+ *
+ * AND THE REFUSAL LISTS THE GATES THE RECORD DOES HOLD. A record's gates are near-neighbours by
+ * construction — a project names them after the scopes it is quarantining from each other — so a
+ * refusal naming only the gate that was asked for sends its reader to open the file and compare
+ * spellings by eye. Listing what is held turns the typo into a one-line diagnosis.
+ *
+ * UNDER THE ONE REFUSAL TYPE, like every fault above it. A caller is told to catch
+ * `MalformedRecordError` and nothing else, so an unrecorded gate raised under a second type is a
+ * fault that caller sails straight past — the very hole the YAML parser's own errors are
+ * normalised to close.
+ *
+ * @param gate the gate to resolve, as the caller names it — never a name this module knows
+ * @param records every gate the record holds, as `parseGateRecords` read them
+ * @param recordFile the name the record is filed under, so a refusal can say which file it read
+ * @throws MalformedRecordError when the record holds no such gate, listing the gates it does hold
+ */
+export declare function gateRecordFor(gate: string, records: Map<string, GateRecord>, recordFile: string): GateRecord;
+//# sourceMappingURL=record.d.ts.map

package/dist/mutation-ratchet/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/mutation-ratchet/record.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAkB/C;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,WAAW,CAAC;AAEnC;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAE3C,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,MAAM;IAC3B,uFAAuF;IACvF,QAAQ,CAAC,OAAO,EAAE,MAAM;IACxB,4FAA4F;IAC5F,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM;;IAPtB,yEAAyE;IAChE,UAAU,EAAE,MAAM;IAC3B,uFAAuF;IAC9E,OAAO,EAAE,MAAM;IACxB,4FAA4F;IACnF,GAAG,EAAE,MAAM;IACpB,mCAAmC;IAC1B,KAAK,EAAE,MAAM,EACtB,MAAM,EAAE,MAAM;CAKjB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,+EAA+E;AAC/E,MAAM,WAAW,UAAU;IACzB,6FAA6F;IAC7F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;CACnC;AAED,6FAA6F;AAC7F,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,oFAAoF;AACpF,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,GAChB,OAAO,CAET;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAElD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAEtD;AAED,qGAAqG;AACrG,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE1D;AAiLD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAI1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAChC,UAAU,EAAE,MAAM,GACjB,UAAU,CAYZ"}