@kensio/yulin 1.20.0 → 1.20.1

package/dist/service/stepfunctions/choice/sim-states-choice-test-parse.js

@@ -0,0 +1,72 @@
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+import { SimStatesAllTest, SimStatesAnyTest, SimStatesNotTest, } from "./sim-states-choice-group-test.js";
+import { asSimStatesRuleRecord, readSimStatesRuleOperator, } from "./sim-states-choice-rule-record.js";
+import { parseSimStatesComparisonTest } from "./sim-states-comparison-parse.js";
+import { findSimStatesComparison } from "./sim-states-comparisons.js";
+const booleanOperators = new Set(["And", "Or", "Not"]);
+/**
+ * Read a rule nested inside an `And`, an `Or` or a `Not`.
+ *
+ * Only a top-level rule says where the execution goes, so a nested one
+ * carrying `Next` is refused rather than quietly ignored.
+ */
+function parseNestedTest(stateName, operator, rule) {
+    const record = asSimStatesRuleRecord(stateName, rule);
+    if (Object.hasOwn(record, "Next")) {
+        throw new SimStatesInvalidDefinition(`A rule inside the ${operator} of the Choice state ${stateName} ` +
+            "carries Next. Only the rule at the top of a Choices entry says " +
+            "where the execution goes.");
+    }
+    return parseSimStatesChoiceTest(stateName, record);
+}
+/**
+ * Read the one test a rule makes.
+ */
+export function parseSimStatesChoiceTest(stateName, record) {
+    const operator = readSimStatesRuleOperator(stateName, record);
+    // The operator was read off this record's own keys, so it holds a value.
+    // oxlint-disable-next-line security/detect-object-injection
+    const written = record[operator];
+    if (booleanOperators.has(operator)) {
+        checkNoVariable(stateName, operator, record);
+        return parseBooleanTest(stateName, operator, written);
+    }
+    const comparison = findSimStatesComparison(operator);
+    if (comparison === undefined) {
+        throw new SimStatesInvalidDefinition(`A rule in the Choice state ${stateName} tests with ${operator}, which ` +
+            "is not a comparator Amazon States Language defines.");
+    }
+    return parseSimStatesComparisonTest({
+        stateName,
+        record,
+        comparison,
+        written,
+    });
+}
+/**
+ * Read an `And`, an `Or` or a `Not` and the rules it holds.
+ */
+function parseBooleanTest(stateName, operator, written) {
+    if (operator === "Not") {
+        return new SimStatesNotTest(parseNestedTest(stateName, operator, written));
+    }
+    if (!Array.isArray(written) || written.length === 0) {
+        throw new SimStatesInvalidDefinition(`The ${operator} in a rule of the Choice state ${stateName} is not a ` +
+            "non-empty array of rules.");
+    }
+    const tests = written.map((nested) => parseNestedTest(stateName, operator, nested));
+    if (operator === "And") {
+        return new SimStatesAllTest(tests);
+    }
+    return new SimStatesAnyTest(tests);
+}
+/**
+ * An `And`, an `Or` or a `Not` tests rules rather than a value of its own.
+ */
+function checkNoVariable(stateName, operator, record) {
+    if (Object.hasOwn(record, "Variable")) {
+        throw new SimStatesInvalidDefinition(`The ${operator} in a rule of the Choice state ${stateName} carries a ` +
+            "Variable. The rules it holds carry their own.");
+    }
+}
+//# sourceMappingURL=sim-states-choice-test-parse.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-test-parse.js.map

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

package/dist/service/stepfunctions/choice/sim-states-choice-test.d.ts

@@ -0,0 +1,33 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesPathSegment } from "../data/sim-states-path-segment.js";
+import type { SimStatesChoiceOperand } from "./sim-states-choice-operand.js";
+import type { SimStatesComparison } from "./sim-states-comparison.js";
+/**
+ * One test a `Choice` rule makes against the state's input.
+ */
+export interface SimStatesChoiceTest {
+    holds(input: JSONValue): boolean;
+}
+interface SimStatesVariableTestProperties {
+    readonly path: string;
+    readonly segments: readonly SimStatesPathSegment[];
+    readonly comparison: SimStatesComparison;
+    readonly operand: SimStatesChoiceOperand;
+}
+/**
+ * A comparison of the value at a `Variable` path against an operand.
+ */
+export declare class SimStatesVariableTest implements SimStatesChoiceTest {
+    #private;
+    constructor(properties: SimStatesVariableTestProperties);
+    /**
+     * Compare, failing the execution where the field being compared is absent.
+     *
+     * Real Step Functions fails a `Choice` state whose `Variable` selects
+     * nothing, which is why `IsPresent` exists. The data-test comparators answer
+     * for an absent field of their own accord.
+     */
+    holds(input: JSONValue): boolean;
+}
+export {};
+//# sourceMappingURL=sim-states-choice-test.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-choice-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-test.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-test.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAC7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC;CAClC;AAED,UAAU,+BAA+B;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,sBAAsB,CAAC;CAC1C;AAED;;GAEG;AACH,qBAAa,qBAAsB,YAAW,mBAAmB;;IAM/D,YAAY,UAAU,EAAE,+BAA+B,EAKtD;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAY/B;CACF"}

package/dist/service/stepfunctions/choice/sim-states-choice-test.js

@@ -0,0 +1,34 @@
+import { selectSimStatesPath } from "../data/sim-states-path-segment.js";
+import { SimStatesRuntimeFailure } from "../error/sim-step-functions.error.js";
+/**
+ * A comparison of the value at a `Variable` path against an operand.
+ */
+export class SimStatesVariableTest {
+    #path;
+    #segments;
+    #comparison;
+    #operand;
+    constructor(properties) {
+        this.#path = properties.path;
+        this.#segments = properties.segments;
+        this.#comparison = properties.comparison;
+        this.#operand = properties.operand;
+    }
+    /**
+     * Compare, failing the execution where the field being compared is absent.
+     *
+     * Real Step Functions fails a `Choice` state whose `Variable` selects
+     * nothing, which is why `IsPresent` exists. The data-test comparators answer
+     * for an absent field of their own accord.
+     */
+    holds(input) {
+        const value = selectSimStatesPath(input, this.#segments);
+        if (value === undefined && this.#comparison.needsValue) {
+            throw new SimStatesRuntimeFailure(`A Choice rule compares ${this.#path} with ` +
+                `${this.#comparison.name}, and the state's input holds nothing ` +
+                "there. Test it with IsPresent first where it may be absent.");
+        }
+        return this.#comparison.holds(value, this.#operand.valueIn(input));
+    }
+}
+//# sourceMappingURL=sim-states-choice-test.js.map

package/dist/service/stepfunctions/choice/sim-states-choice-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-choice-test.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-choice-test.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAkB/E;;GAEG;AACH,MAAM,OAAO,qBAAqB;IACvB,KAAK,CAAS;IACd,SAAS,CAAkC;IAC3C,WAAW,CAAsB;IACjC,QAAQ,CAAyB;IAE1C,YAAY,UAA2C;QACrD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,QAAQ,CAAC;QACrC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC;QACzC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,KAAgB;QACpB,MAAM,KAAK,GAAG,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAEzD,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;YACvD,MAAM,IAAI,uBAAuB,CAC/B,0BAA0B,IAAI,CAAC,KAAK,QAAQ;gBAC1C,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,wCAAwC;gBAChE,6DAA6D,CAChE,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IACrE,CAAC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-comparison-families.d.ts

@@ -0,0 +1,26 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import { SimStatesComparison, type SimStatesOperandType } from "./sim-states-comparison.js";
+/**
+ * Read a JSON value as a string, or as nothing where it is not one.
+ */
+export declare function readString(value: JSONValue | undefined): string | undefined;
+/**
+ * Read a JSON value as a number, or as nothing where it is not one.
+ */
+export declare function readNumber(value: JSONValue | undefined): number | undefined;
+/**
+ * The five ordering comparators over one JSON type.
+ *
+ * A value of the wrong type on either side answers false rather than failing.
+ * `StringEquals` against a number is a comparison that does not hold, and a
+ * rule the input does not match is the ordinary case in a `Choice` state.
+ */
+export declare function orderedComparisons<T>(prefix: string, operandType: SimStatesOperandType, read: (value: JSONValue | undefined) => T | undefined): SimStatesComparison[];
+/**
+ * One data-test comparator, such as `IsString`.
+ *
+ * These are the comparators that answer for a `Variable` selecting nothing,
+ * which is what makes `IsPresent` usable as the first test in an `And`.
+ */
+export declare function dataTest(name: string, describes: (variable: JSONValue | undefined) => boolean): SimStatesComparison;
+//# sourceMappingURL=sim-states-comparison-families.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-comparison-families.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-families.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-families.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EACL,mBAAmB,EACnB,KAAK,oBAAoB,EAC1B,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAM3E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAM3E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,oBAAoB,EACjC,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,KAAK,CAAC,GAAG,SAAS,GACpD,mBAAmB,EAAE,CA6BvB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,KAAK,OAAO,GACtD,mBAAmB,CAQrB"}

package/dist/service/stepfunctions/choice/sim-states-comparison-families.js

@@ -0,0 +1,65 @@
+import { SimStatesComparison, } from "./sim-states-comparison.js";
+/**
+ * Read a JSON value as a string, or as nothing where it is not one.
+ */
+export function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Read a JSON value as a number, or as nothing where it is not one.
+ */
+export function readNumber(value) {
+    if (typeof value !== "number") {
+        return undefined;
+    }
+    return value;
+}
+/**
+ * The five ordering comparators over one JSON type.
+ *
+ * A value of the wrong type on either side answers false rather than failing.
+ * `StringEquals` against a number is a comparison that does not hold, and a
+ * rule the input does not match is the ordinary case in a `Choice` state.
+ */
+export function orderedComparisons(prefix, operandType, read) {
+    const comparison = (suffix, holds) => new SimStatesComparison({
+        name: `${prefix}${suffix}`,
+        operandType,
+        needsValue: true,
+        operandIsPath: false,
+        holds: (variable, operand) => {
+            const left = read(variable);
+            const right = read(operand);
+            if (left === undefined || right === undefined) {
+                return false;
+            }
+            return holds(left, right);
+        },
+    });
+    return [
+        comparison("Equals", (left, right) => left === right),
+        comparison("LessThan", (left, right) => left < right),
+        comparison("GreaterThan", (left, right) => left > right),
+        comparison("LessThanEquals", (left, right) => left <= right),
+        comparison("GreaterThanEquals", (left, right) => left >= right),
+    ];
+}
+/**
+ * One data-test comparator, such as `IsString`.
+ *
+ * These are the comparators that answer for a `Variable` selecting nothing,
+ * which is what makes `IsPresent` usable as the first test in an `And`.
+ */
+export function dataTest(name, describes) {
+    return new SimStatesComparison({
+        name,
+        operandType: "boolean",
+        needsValue: false,
+        operandIsPath: false,
+        holds: (variable, operand) => describes(variable) === operand,
+    });
+}
+//# sourceMappingURL=sim-states-comparison-families.js.map

package/dist/service/stepfunctions/choice/sim-states-comparison-families.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-families.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-families.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,GAEpB,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,KAA4B;IACrD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,KAA4B;IACrD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,WAAiC,EACjC,IAAqD;IAErD,MAAM,UAAU,GAAG,CACjB,MAAc,EACd,KAAqC,EAChB,EAAE,CACvB,IAAI,mBAAmB,CAAC;QACtB,IAAI,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE;QAC1B,WAAW;QACX,UAAU,EAAE,IAAI;QAChB,aAAa,EAAE,KAAK;QACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE;YACpC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;YAE5B,IAAI,IAAI,KAAK,SAAS,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC9C,OAAO,KAAK,CAAC;YACf,CAAC;YAED,OAAO,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC,CAAC;IAEL,OAAO;QACL,UAAU,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,KAAK,KAAK,CAAC;QACrD,UAAU,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK,CAAC;QACrD,UAAU,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK,CAAC;QACxD,UAAU,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,IAAI,KAAK,CAAC;QAC5D,UAAU,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,IAAI,KAAK,CAAC;KAChE,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CACtB,IAAY,EACZ,SAAuD;IAEvD,OAAO,IAAI,mBAAmB,CAAC;QAC7B,IAAI;QACJ,WAAW,EAAE,SAAS;QACtB,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,KAAK;QACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,OAAO;KACvE,CAAC,CAAC;AACL,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.d.ts

@@ -0,0 +1,15 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import { type SimStatesChoiceTest } from "./sim-states-choice-test.js";
+import type { SimStatesComparison } from "./sim-states-comparison.js";
+interface SimStatesComparisonTestProperties {
+    readonly stateName: string;
+    readonly record: Record<string, JSONValue>;
+    readonly comparison: SimStatesComparison;
+    readonly written: JSONValue;
+}
+/**
+ * Read a comparison of the value at a `Variable` path against an operand.
+ */
+export declare function parseSimStatesComparisonTest(properties: SimStatesComparisonTestProperties): SimStatesChoiceTest;
+export {};
+//# sourceMappingURL=sim-states-comparison-parse.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-parse.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAQlE,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,UAAU,iCAAiC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,iCAAiC,GAC5C,mBAAmB,CAmBrB"}

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.js

@@ -0,0 +1,43 @@
+import { parseSimStatesReferencePath } from "../data/sim-states-reference-path.js";
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+import { SimStatesLiteralOperand, SimStatesPathOperand, } from "./sim-states-choice-operand.js";
+import { SimStatesVariableTest, } from "./sim-states-choice-test.js";
+/**
+ * Read a comparison of the value at a `Variable` path against an operand.
+ */
+export function parseSimStatesComparisonTest(properties) {
+    const { stateName, record, comparison, written } = properties;
+    const variable = record["Variable"];
+    if (typeof variable !== "string") {
+        throw new SimStatesInvalidDefinition(`A ${comparison.name} rule in the Choice state ${stateName} has no ` +
+            "Variable naming the value to compare.");
+    }
+    checkOperandType(stateName, comparison, written);
+    return new SimStatesVariableTest({
+        path: variable,
+        segments: parseSimStatesReferencePath(variable),
+        comparison,
+        operand: readOperand(comparison, written),
+    });
+}
+/**
+ * Read a comparator's operand, either as written or as a path to read it from.
+ */
+function readOperand(comparison, written) {
+    if (typeof written === "string" && comparison.operandIsPath) {
+        return new SimStatesPathOperand(written, parseSimStatesReferencePath(written));
+    }
+    return new SimStatesLiteralOperand(written);
+}
+/**
+ * Check that a comparator's operand is the kind of value it compares.
+ */
+function checkOperandType(stateName, comparison, written) {
+    if (typeof written === comparison.operandType) {
+        return;
+    }
+    throw new SimStatesInvalidDefinition(`A ${comparison.name} rule in the Choice state ${stateName} compares ` +
+        `against ${JSON.stringify(written)}, and ${comparison.name} takes a ` +
+        `${comparison.operandType}.`);
+}
+//# sourceMappingURL=sim-states-comparison-parse.js.map

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-parse.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-parse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAEL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAEL,qBAAqB,GACtB,MAAM,6BAA6B,CAAC;AAUrC;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAC1C,UAA6C;IAE7C,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;IAC9D,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAEpC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,MAAM,IAAI,0BAA0B,CAClC,KAAK,UAAU,CAAC,IAAI,6BAA6B,SAAS,UAAU;YAClE,uCAAuC,CAC1C,CAAC;IACJ,CAAC;IAED,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAEjD,OAAO,IAAI,qBAAqB,CAAC;QAC/B,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,2BAA2B,CAAC,QAAQ,CAAC;QAC/C,UAAU;QACV,OAAO,EAAE,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC;KAC1C,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAClB,UAA+B,EAC/B,OAAkB;IAElB,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,UAAU,CAAC,aAAa,EAAE,CAAC;QAC5D,OAAO,IAAI,oBAAoB,CAC7B,OAAO,EACP,2BAA2B,CAAC,OAAO,CAAC,CACrC,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,uBAAuB,CAAC,OAAO,CAAC,CAAC;AAC9C,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB,CACvB,SAAiB,EACjB,UAA+B,EAC/B,OAAkB;IAElB,IAAI,OAAO,OAAO,KAAK,UAAU,CAAC,WAAW,EAAE,CAAC;QAC9C,OAAO;IACT,CAAC;IAED,MAAM,IAAI,0BAA0B,CAClC,KAAK,UAAU,CAAC,IAAI,6BAA6B,SAAS,YAAY;QACpE,WAAW,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,UAAU,CAAC,IAAI,WAAW;QACrE,GAAG,UAAU,CAAC,WAAW,GAAG,CAC/B,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-comparison.d.ts

@@ -0,0 +1,49 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+/**
+ * What the definition writes as a comparator's operand.
+ */
+export type SimStatesOperandType = "string" | "number" | "boolean";
+interface SimStatesComparisonProperties {
+    readonly name: string;
+    readonly operandType: SimStatesOperandType;
+    readonly needsValue: boolean;
+    readonly operandIsPath: boolean;
+    readonly holds: SimStatesComparisonHolds;
+}
+export type SimStatesComparisonHolds = (variable: JSONValue | undefined, operand: JSONValue) => boolean;
+/**
+ * One `Choice` comparator, such as `NumericGreaterThan`.
+ *
+ * A comparator knows what its operand has to be, so a definition writing the
+ * wrong kind is refused when the state machine is created rather than
+ * answering false at every rule it appears in.
+ */
+export declare class SimStatesComparison {
+    #private;
+    readonly name: string;
+    readonly operandType: SimStatesOperandType;
+    /**
+     * Whether the rule's `Variable` has to select something.
+     *
+     * The data-test comparators, `IsPresent` and its siblings, are the ones that
+     * answer for a field that is not there. Every other comparator fails the
+     * execution instead, as real Step Functions does.
+     */
+    readonly needsValue: boolean;
+    /** Whether the operand is a Reference Path into the state's input. */
+    readonly operandIsPath: boolean;
+    constructor(properties: SimStatesComparisonProperties);
+    /**
+     * Whether the value at the rule's `Variable` compares as the rule asks.
+     */
+    holds(variable: JSONValue | undefined, operand: JSONValue): boolean;
+    /**
+     * The same comparator with its operand read from the state's input.
+     *
+     * Every comparator taking an operand has a `Path` twin, which compares two
+     * places in the same document instead of a place and a literal.
+     */
+    readingItsOperandFromAPath(): SimStatesComparison;
+}
+export {};
+//# sourceMappingURL=sim-states-comparison.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnE,UAAU,6BAA6B;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,wBAAwB,CAAC;CAC1C;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,OAAO,EAAE,SAAS,KACf,OAAO,CAAC;AAEb;;;;;;GAMG;AACH,qBAAa,mBAAmB;;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAIhC,YAAY,UAAU,EAAE,6BAA6B,EAMpD;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,OAAO,CAElE;IAED;;;;;OAKG;IACH,0BAA0B,IAAI,mBAAmB,CAQhD;CACF"}

package/dist/service/stepfunctions/choice/sim-states-comparison.js

@@ -0,0 +1,51 @@
+/**
+ * One `Choice` comparator, such as `NumericGreaterThan`.
+ *
+ * A comparator knows what its operand has to be, so a definition writing the
+ * wrong kind is refused when the state machine is created rather than
+ * answering false at every rule it appears in.
+ */
+export class SimStatesComparison {
+    name;
+    operandType;
+    /**
+     * Whether the rule's `Variable` has to select something.
+     *
+     * The data-test comparators, `IsPresent` and its siblings, are the ones that
+     * answer for a field that is not there. Every other comparator fails the
+     * execution instead, as real Step Functions does.
+     */
+    needsValue;
+    /** Whether the operand is a Reference Path into the state's input. */
+    operandIsPath;
+    #holds;
+    constructor(properties) {
+        this.name = properties.name;
+        this.operandType = properties.operandType;
+        this.needsValue = properties.needsValue;
+        this.operandIsPath = properties.operandIsPath;
+        this.#holds = properties.holds;
+    }
+    /**
+     * Whether the value at the rule's `Variable` compares as the rule asks.
+     */
+    holds(variable, operand) {
+        return this.#holds(variable, operand);
+    }
+    /**
+     * The same comparator with its operand read from the state's input.
+     *
+     * Every comparator taking an operand has a `Path` twin, which compares two
+     * places in the same document instead of a place and a literal.
+     */
+    readingItsOperandFromAPath() {
+        return new SimStatesComparison({
+            name: `${this.name}Path`,
+            operandType: "string",
+            needsValue: this.needsValue,
+            operandIsPath: true,
+            holds: this.#holds,
+        });
+    }
+}
+//# sourceMappingURL=sim-states-comparison.js.map

package/dist/service/stepfunctions/choice/sim-states-comparison.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison.ts"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AACH,MAAM,OAAO,mBAAmB;IACrB,IAAI,CAAS;IACb,WAAW,CAAuB;IAC3C;;;;;;OAMG;IACM,UAAU,CAAU;IAC7B,sEAAsE;IAC7D,aAAa,CAAU;IAEvB,MAAM,CAA2B;IAE1C,YAAY,UAAyC;QACnD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;QAC9C,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAA+B,EAAE,OAAkB;QACvD,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,0BAA0B;QACxB,OAAO,IAAI,mBAAmB,CAAC;YAC7B,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,MAAM;YACxB,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,aAAa,EAAE,IAAI;YACnB,KAAK,EAAE,IAAI,CAAC,MAAM;SACnB,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-comparisons.d.ts

@@ -0,0 +1,6 @@
+import { SimStatesComparison } from "./sim-states-comparison.js";
+/**
+ * The comparator of a name, or nothing where no comparator has it.
+ */
+export declare function findSimStatesComparison(name: string): SimStatesComparison | undefined;
+//# sourceMappingURL=sim-states-comparisons.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-comparisons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparisons.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparisons.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AA2EjE;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,GACX,mBAAmB,GAAG,SAAS,CAEjC"}

package/dist/service/stepfunctions/choice/sim-states-comparisons.js

@@ -0,0 +1,64 @@
+import { readSimStatesTimestamp } from "../data/sim-states-timestamp.js";
+import { SimStatesComparison } from "./sim-states-comparison.js";
+import { dataTest, orderedComparisons, readNumber, readString, } from "./sim-states-comparison-families.js";
+import { simStatesGlobMatches } from "./sim-states-glob.js";
+/**
+ * `StringMatches`, which is the one comparator taking a wildcard pattern.
+ *
+ * Amazon States Language gives it no `Path` twin, so neither does this.
+ */
+const stringMatches = new SimStatesComparison({
+    name: "StringMatches",
+    operandType: "string",
+    needsValue: true,
+    operandIsPath: false,
+    holds: (variable, operand) => {
+        const value = readString(variable);
+        const pattern = readString(operand);
+        if (value === undefined || pattern === undefined) {
+            return false;
+        }
+        return simStatesGlobMatches(pattern, value);
+    },
+});
+const booleanEquals = new SimStatesComparison({
+    name: "BooleanEquals",
+    operandType: "boolean",
+    needsValue: true,
+    operandIsPath: false,
+    holds: (variable, operand) => typeof variable === "boolean" && variable === operand,
+});
+/**
+ * Every comparator a `Choice` rule can be written with.
+ *
+ * Each comparator taking an operand has a `Path` twin reading that operand
+ * from the state's input. The data tests take a boolean the definition writes
+ * out, and have none.
+ */
+function allComparisons() {
+    const compared = [
+        ...orderedComparisons("String", "string", readString),
+        ...orderedComparisons("Numeric", "number", readNumber),
+        ...orderedComparisons("Timestamp", "string", readSimStatesTimestamp),
+        booleanEquals,
+    ];
+    return [
+        ...compared,
+        ...compared.map((comparison) => comparison.readingItsOperandFromAPath()),
+        stringMatches,
+        dataTest("IsPresent", (variable) => variable !== undefined),
+        dataTest("IsNull", (variable) => variable === null),
+        dataTest("IsBoolean", (variable) => typeof variable === "boolean"),
+        dataTest("IsNumeric", (variable) => typeof variable === "number"),
+        dataTest("IsString", (variable) => typeof variable === "string"),
+        dataTest("IsTimestamp", (variable) => readSimStatesTimestamp(variable) !== undefined),
+    ];
+}
+const comparisons = new Map(allComparisons().map((comparison) => [comparison.name, comparison]));
+/**
+ * The comparator of a name, or nothing where no comparator has it.
+ */
+export function findSimStatesComparison(name) {
+    return comparisons.get(name);
+}
+//# sourceMappingURL=sim-states-comparisons.js.map

package/dist/service/stepfunctions/choice/sim-states-comparisons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparisons.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparisons.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EACL,QAAQ,EACR,kBAAkB,EAClB,UAAU,EACV,UAAU,GACX,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;;;GAIG;AACH,MAAM,aAAa,GAAG,IAAI,mBAAmB,CAAC;IAC5C,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,QAAQ;IACrB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,KAAK;IACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE;QACpC,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QACnC,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;QAEpC,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACjD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,oBAAoB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,aAAa,GAAG,IAAI,mBAAmB,CAAC;IAC5C,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,SAAS;IACtB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,KAAK;IACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE,CACpC,OAAO,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,OAAO;CACxD,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,SAAS,cAAc;IACrB,MAAM,QAAQ,GAAG;QACf,GAAG,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC;QACrD,GAAG,kBAAkB,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC;QACtD,GAAG,kBAAkB,CAAC,WAAW,EAAE,QAAQ,EAAE,sBAAsB,CAAC;QACpE,aAAa;KACd,CAAC;IAEF,OAAO;QACL,GAAG,QAAQ;QACX,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,0BAA0B,EAAE,CAAC;QACxE,aAAa;QACb,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,SAAS,CAAC;QAC3D,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,IAAI,CAAC;QACnD,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,QAAQ,KAAK,SAAS,CAAC;QAClE,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,QAAQ,KAAK,QAAQ,CAAC;QACjE,QAAQ,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,QAAQ,KAAK,QAAQ,CAAC;QAChE,QAAQ,CACN,aAAa,EACb,CAAC,QAAQ,EAAE,EAAE,CAAC,sBAAsB,CAAC,QAAQ,CAAC,KAAK,SAAS,CAC7D;KACF,CAAC;AACJ,CAAC;AAED,MAAM,WAAW,GAAG,IAAI,GAAG,CACzB,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CACpE,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAY;IAEZ,OAAO,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-glob.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Whether a string matches a `StringMatches` pattern.
+ *
+ * The pattern language is the one Amazon States Language defines for
+ * `StringMatches`. `*` stands for any run of characters, and a backslash
+ * escapes the character after it, so `\*` is a literal asterisk and `\\` a
+ * literal backslash.
+ *
+ * The match is done by walking both strings. A pattern comes out of a state
+ * machine definition, and turning one into a regular expression would put the
+ * definition's author in charge of how long the match takes.
+ */
+export declare function simStatesGlobMatches(pattern: string, value: string): boolean;
+//# sourceMappingURL=sim-states-glob.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-glob.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-glob.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE5E"}

package/dist/service/stepfunctions/choice/sim-states-glob.js

@@ -0,0 +1,73 @@
+const wildcard = { wildcard: true };
+/**
+ * Whether a string matches a `StringMatches` pattern.
+ *
+ * The pattern language is the one Amazon States Language defines for
+ * `StringMatches`. `*` stands for any run of characters, and a backslash
+ * escapes the character after it, so `\*` is a literal asterisk and `\\` a
+ * literal backslash.
+ *
+ * The match is done by walking both strings. A pattern comes out of a state
+ * machine definition, and turning one into a regular expression would put the
+ * definition's author in charge of how long the match takes.
+ */
+export function simStatesGlobMatches(pattern, value) {
+    return matchTokens(readGlobTokens(pattern), value);
+}
+/**
+ * Split a pattern into the steps it is made of, resolving its escapes.
+ */
+function readGlobTokens(pattern) {
+    const tokens = [];
+    for (let index = 0; index < pattern.length; index++) {
+        const character = pattern.charAt(index);
+        if (character === "\\" && index + 1 < pattern.length) {
+            index += 1;
+            tokens.push({ char: pattern.charAt(index) });
+            continue;
+        }
+        if (character === "*") {
+            tokens.push(wildcard);
+            continue;
+        }
+        // A trailing backslash escapes nothing and stands for itself.
+        tokens.push({ char: character });
+    }
+    return tokens;
+}
+/**
+ * Match the tokens against a value, backtracking to the last wildcard.
+ *
+ * Each wildcard remembers where it started matching. Where the rest of the
+ * pattern then fails, that wildcard takes one more character and the match
+ * carries on from there, which is the whole of the backtracking this pattern
+ * language needs.
+ */
+function matchTokens(tokens, value) {
+    let token = 0;
+    let character = 0;
+    let lastWildcard = -1;
+    let resumeAt = 0;
+    while (character < value.length) {
+        const current = tokens.at(token);
+        if (current !== undefined && "wildcard" in current) {
+            lastWildcard = token;
+            resumeAt = character;
+            token += 1;
+            continue;
+        }
+        if (current !== undefined && current.char === value.charAt(character)) {
+            token += 1;
+            character += 1;
+            continue;
+        }
+        if (lastWildcard === -1) {
+            return false;
+        }
+        token = lastWildcard + 1;
+        resumeAt += 1;
+        character = resumeAt;
+    }
+    return tokens.slice(token).every((rest) => "wildcard" in rest);
+}
+//# sourceMappingURL=sim-states-glob.js.map

package/dist/service/stepfunctions/choice/sim-states-glob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-glob.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-glob.ts"],"names":[],"mappings":"AAOA,MAAM,QAAQ,GAAuB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAe,EAAE,KAAa;IACjE,OAAO,WAAW,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AACrD,CAAC;AAED;;GAEG;AACH,SAAS,cAAc,CAAC,OAAe;IACrC,MAAM,MAAM,GAAyB,EAAE,CAAC;IAExC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACpD,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAExC,IAAI,SAAS,KAAK,IAAI,IAAI,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;YACrD,KAAK,IAAI,CAAC,CAAC;YACX,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC7C,SAAS;QACX,CAAC;QAED,IAAI,SAAS,KAAK,GAAG,EAAE,CAAC;YACtB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtB,SAAS;QACX,CAAC;QAED,8DAA8D;QAC9D,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,WAAW,CAClB,MAAqC,EACrC,KAAa;IAEb,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC;IACtB,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,OAAO,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAEjC,IAAI,OAAO,KAAK,SAAS,IAAI,UAAU,IAAI,OAAO,EAAE,CAAC;YACnD,YAAY,GAAG,KAAK,CAAC;YACrB,QAAQ,GAAG,SAAS,CAAC;YACrB,KAAK,IAAI,CAAC,CAAC;YACX,SAAS;QACX,CAAC;QAED,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YACtE,KAAK,IAAI,CAAC,CAAC;YACX,SAAS,IAAI,CAAC,CAAC;YACf,SAAS;QACX,CAAC;QAED,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;YACxB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,KAAK,GAAG,YAAY,GAAG,CAAC,CAAC;QACzB,QAAQ,IAAI,CAAC,CAAC;QACd,SAAS,GAAG,QAAQ,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC;AACjE,CAAC"}