@kensio/yulin 1.20.1 → 1.20.3

package/dist/service/stepfunctions/retry/sim-states-error-equals.js

@@ -0,0 +1,69 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+import { simStatesAllErrors } from "./sim-states-error-name.js";
+/**
+ * Read the entries of a state's `Retry` or `Catch`.
+ *
+ * Both fields are an ordered array of entries, and both say what they handle
+ * the same way. What each entry then does with a match is what tells them
+ * apart, so that is read by the caller.
+ *
+ * Answers with nothing where the state carries neither field.
+ */
+export function readSimStatesHandlers(named, state, field, noun) {
+    // The field is one of the two this reads.
+    // oxlint-disable-next-line security/detect-object-injection
+    const declared = state[field];
+    if (declared === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(declared)) {
+        throw new SimStatesInvalidDefinition(`The ${field} of the ${named} is not an array of ${noun}s.`);
+    }
+    const entries = declared.map((entry) => readEntry(named, field, noun, entry));
+    checkAllErrorsLast(named, field, noun, entries);
+    return entries;
+}
+/**
+ * Read one entry, whose `ErrorEquals` says what it handles.
+ */
+function readEntry(named, field, noun, entry) {
+    if (!isRecord(entry)) {
+        throw new SimStatesInvalidDefinition(`A ${noun} in the ${field} of the ${named} is not an object.`);
+    }
+    const declared = entry["ErrorEquals"];
+    const errors = Array.isArray(declared)
+        ? declared.filter((error) => typeof error === "string")
+        : [];
+    if (!Array.isArray(declared) ||
+        errors.length !== declared.length ||
+        errors.length === 0) {
+        throw new SimStatesInvalidDefinition(`A ${noun} in the ${field} of the ${named} has no ` +
+            "ErrorEquals naming the errors it handles.");
+    }
+    checkAllErrorsAlone(named, field, noun, errors);
+    return { ErrorEquals: errors, written: entry };
+}
+/**
+ * `States.ALL` matches anything, so it names nothing alongside it.
+ */
+function checkAllErrorsAlone(named, field, noun, errors) {
+    if (errors.includes(simStatesAllErrors) && errors.length > 1) {
+        throw new SimStatesInvalidDefinition(`A ${noun} in the ${field} of the ${named} names ` +
+            `${simStatesAllErrors} alongside ${errors.filter((error) => error !== simStatesAllErrors).join(", ")}. ` +
+            `${simStatesAllErrors} matches anything, so it stands on its own.`);
+    }
+}
+/**
+ * `States.ALL` comes last, since nothing written after it could ever match.
+ */
+function checkAllErrorsLast(named, field, noun, entries) {
+    const at = entries.findIndex((entry) => entry.ErrorEquals.includes(simStatesAllErrors));
+    if (at !== -1 && at < entries.length - 1) {
+        throw new SimStatesInvalidDefinition(`The ${field} of the ${named} names ` +
+            `${simStatesAllErrors} in a ${noun} that is not the last one. ` +
+            `${simStatesAllErrors} matches anything, so nothing after it could ` +
+            "ever be reached.");
+    }
+}
+//# sourceMappingURL=sim-states-error-equals.js.map

package/dist/service/stepfunctions/retry/sim-states-error-equals.js.map

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

package/dist/service/stepfunctions/retry/sim-states-error-handling.d.ts

@@ -0,0 +1,31 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesState } from "../definition/sim-states-state.js";
+import type { SimStatesCatcher } from "./sim-states-catcher.js";
+import type { SimStatesRetrier } from "./sim-states-retrier.js";
+/**
+ * What a state says about failing.
+ *
+ * A `Task` state, a `Parallel` state and a `Map` state all carry these two,
+ * and all read them the same way. The retriers come first and the catchers
+ * after them.
+ */
+export interface SimStatesErrorHandling {
+    readonly Retry?: readonly SimStatesRetrier[];
+    readonly Catch?: readonly SimStatesCatcher[];
+}
+/**
+ * The `Retry` and `Catch` a state carries, where its type has them.
+ *
+ * Every other state type fails the walk it is in, since there is nothing on
+ * it to say otherwise.
+ */
+export declare function simStatesErrorHandling(state: SimStatesState): SimStatesErrorHandling | undefined;
+/**
+ * The `Retry` and `Catch` a state was written with, as the objects a failure
+ * is handled by.
+ *
+ * A state carrying neither is left carrying neither, since the two fields are
+ * spread over the state as it was written.
+ */
+export declare function parseSimStatesErrorHandling(named: string, state: Record<string, JSONValue>): SimStatesErrorHandling;
+//# sourceMappingURL=sim-states-error-handling.d.ts.map

package/dist/service/stepfunctions/retry/sim-states-error-handling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-error-handling.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-error-handling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAExE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAGhE;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,GACpB,sBAAsB,GAAG,SAAS,CAepC;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAC/B,sBAAsB,CAQxB"}

package/dist/service/stepfunctions/retry/sim-states-error-handling.js

@@ -0,0 +1,40 @@
+import { parseSimStatesCatchers } from "./sim-states-catch-parse.js";
+import { parseSimStatesRetriers } from "./sim-states-retry-parse.js";
+/**
+ * The `Retry` and `Catch` a state carries, where its type has them.
+ *
+ * Every other state type fails the walk it is in, since there is nothing on
+ * it to say otherwise.
+ */
+export function simStatesErrorHandling(state) {
+    switch (state.Type) {
+        case "Task":
+        case "Parallel":
+        case "Map": {
+            return state;
+        }
+        case "Choice":
+        case "Fail":
+        case "Pass":
+        case "Succeed":
+        case "Wait": {
+            return undefined;
+        }
+    }
+}
+/**
+ * The `Retry` and `Catch` a state was written with, as the objects a failure
+ * is handled by.
+ *
+ * A state carrying neither is left carrying neither, since the two fields are
+ * spread over the state as it was written.
+ */
+export function parseSimStatesErrorHandling(named, state) {
+    const retriers = parseSimStatesRetriers(named, state);
+    const catchers = parseSimStatesCatchers(named, state);
+    return {
+        ...(retriers !== undefined && { Retry: retriers }),
+        ...(catchers !== undefined && { Catch: catchers }),
+    };
+}
+//# sourceMappingURL=sim-states-error-handling.js.map

package/dist/service/stepfunctions/retry/sim-states-error-handling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-error-handling.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-error-handling.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAGrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAcrE;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAAqB;IAErB,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,MAAM,CAAC;QACZ,KAAK,UAAU,CAAC;QAChB,KAAK,KAAK,EAAE,CAAC;YACX,OAAO,KAAK,CAAC;QACf,CAAC;QACD,KAAK,QAAQ,CAAC;QACd,KAAK,MAAM,CAAC;QACZ,KAAK,MAAM,CAAC;QACZ,KAAK,SAAS,CAAC;QACf,KAAK,MAAM,EAAE,CAAC;YACZ,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CACzC,KAAa,EACb,KAAgC;IAEhC,MAAM,QAAQ,GAAG,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACtD,MAAM,QAAQ,GAAG,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAEtD,OAAO;QACL,GAAG,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;QAClD,GAAG,CAAC,QAAQ,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;KACnD,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/retry/sim-states-error-name.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The name that matches whatever a state failed with.
+ */
+export declare const simStatesAllErrors = "States.ALL";
+/**
+ * The failure a task runs past its `TimeoutSeconds` or `HeartbeatSeconds` with.
+ */
+export declare const simStatesTimeoutError = "States.Timeout";
+/**
+ * The failure a state that could not run on the data it was given ends with.
+ *
+ * Real Step Functions neither retries nor catches this one, whatever a retrier
+ * names, and neither does this.
+ */
+export declare const simStatesRuntimeError = "States.Runtime";
+/**
+ * The failure a `Parallel` state one of whose branches failed ends with.
+ */
+export declare const simStatesBranchFailedError = "States.BranchFailed";
+/**
+ * Whether one retrier's or catcher's `ErrorEquals` names an error.
+ *
+ * Amazon States Language matches on the error name alone, so a catcher naming
+ * `States.TaskFailed` catches a task that failed and leaves everything else to
+ * the catcher after it. `States.ALL` matches anything, apart from the one error
+ * nothing matches.
+ */
+export declare function simStatesErrorMatches(errorEquals: readonly string[], error: string): boolean;
+//# sourceMappingURL=sim-states-error-name.d.ts.map

package/dist/service/stepfunctions/retry/sim-states-error-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-error-name.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-error-name.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,0BAA0B,wBAAwB,CAAC;AAEhE;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,KAAK,EAAE,MAAM,GACZ,OAAO,CAQT"}

package/dist/service/stepfunctions/retry/sim-states-error-name.js

@@ -0,0 +1,34 @@
+/**
+ * The name that matches whatever a state failed with.
+ */
+export const simStatesAllErrors = "States.ALL";
+/**
+ * The failure a task runs past its `TimeoutSeconds` or `HeartbeatSeconds` with.
+ */
+export const simStatesTimeoutError = "States.Timeout";
+/**
+ * The failure a state that could not run on the data it was given ends with.
+ *
+ * Real Step Functions neither retries nor catches this one, whatever a retrier
+ * names, and neither does this.
+ */
+export const simStatesRuntimeError = "States.Runtime";
+/**
+ * The failure a `Parallel` state one of whose branches failed ends with.
+ */
+export const simStatesBranchFailedError = "States.BranchFailed";
+/**
+ * Whether one retrier's or catcher's `ErrorEquals` names an error.
+ *
+ * Amazon States Language matches on the error name alone, so a catcher naming
+ * `States.TaskFailed` catches a task that failed and leaves everything else to
+ * the catcher after it. `States.ALL` matches anything, apart from the one error
+ * nothing matches.
+ */
+export function simStatesErrorMatches(errorEquals, error) {
+    if (error === simStatesRuntimeError) {
+        return false;
+    }
+    return errorEquals.some((named) => named === simStatesAllErrors || named === error);
+}
+//# sourceMappingURL=sim-states-error-name.js.map

package/dist/service/stepfunctions/retry/sim-states-error-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-error-name.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-error-name.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAE/C;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,gBAAgB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,gBAAgB,CAAC;AAEtD;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,qBAAqB,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CACnC,WAA8B,EAC9B,KAAa;IAEb,IAAI,KAAK,KAAK,qBAAqB,EAAE,CAAC;QACpC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,WAAW,CAAC,IAAI,CACrB,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,kBAAkB,IAAI,KAAK,KAAK,KAAK,CAC3D,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/retry/sim-states-recover.d.ts

@@ -0,0 +1,31 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesFailOutcome, SimStatesStateOutcome } from "../execution/sim-states-state-outcome.js";
+import type { SimStatesAttemptState } from "./sim-states-attempt-state.js";
+import type { SimStatesErrorHandling } from "./sim-states-error-handling.js";
+interface SimStatesRecoverProperties {
+    /**
+     * The `Retry` and `Catch` of the state that failed.
+     */
+    readonly handling: SimStatesErrorHandling;
+    /**
+     * The raw input the state was given, which is what a catcher's `ResultPath`
+     * writes the error into.
+     */
+    readonly input: JSONValue;
+    readonly failure: SimStatesFailOutcome;
+    readonly attempt: SimStatesAttemptState;
+    readonly now: Date;
+}
+/**
+ * What a state's `Retry` and `Catch` make of a failure.
+ *
+ * The retriers are tried first and the catchers after them. A failure neither
+ * retried nor caught is left as it was, and ends the execution.
+ *
+ * A task that ran out of time skips the retriers. The deadline covers the
+ * state and not one attempt at it, and another attempt would find the clock
+ * past it again.
+ */
+export declare function simStatesRecover(properties: SimStatesRecoverProperties): SimStatesStateOutcome;
+export {};
+//# sourceMappingURL=sim-states-recover.d.ts.map

package/dist/service/stepfunctions/retry/sim-states-recover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-recover.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-recover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAI3E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E,UAAU,0BAA0B;IAClC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAE1C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAE1B,QAAQ,CAAC,OAAO,EAAE,oBAAoB,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,0BAA0B,GACrC,qBAAqB,CAYvB"}

package/dist/service/stepfunctions/retry/sim-states-recover.js

@@ -0,0 +1,23 @@
+import { simStatesCatchOutcome } from "./sim-states-catch-outcome.js";
+import { simStatesTimeoutError } from "./sim-states-error-name.js";
+import { simStatesRetryOutcome } from "./sim-states-retry-outcome.js";
+/**
+ * What a state's `Retry` and `Catch` make of a failure.
+ *
+ * The retriers are tried first and the catchers after them. A failure neither
+ * retried nor caught is left as it was, and ends the execution.
+ *
+ * A task that ran out of time skips the retriers. The deadline covers the
+ * state and not one attempt at it, and another attempt would find the clock
+ * past it again.
+ */
+export function simStatesRecover(properties) {
+    const { attempt, failure, handling, input, now } = properties;
+    const retry = failure.error === simStatesTimeoutError
+        ? undefined
+        : simStatesRetryOutcome(handling.Retry ?? [], failure, attempt, now);
+    return (retry ??
+        simStatesCatchOutcome(handling.Catch ?? [], failure, input) ??
+        failure);
+}
+//# sourceMappingURL=sim-states-recover.js.map

package/dist/service/stepfunctions/retry/sim-states-recover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-recover.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-recover.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAoBtE;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAAsC;IAEtC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,UAAU,CAAC;IAC9D,MAAM,KAAK,GACT,OAAO,CAAC,KAAK,KAAK,qBAAqB;QACrC,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,qBAAqB,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IAEzE,OAAO,CACL,KAAK;QACL,qBAAqB,CAAC,QAAQ,CAAC,KAAK,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC;QAC3D,OAAO,CACR,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/retry/sim-states-recovered.d.ts

@@ -0,0 +1,22 @@
+import type { SimStatesStateOutcome } from "../execution/sim-states-state-outcome.js";
+import type { SimStatesStateEntry } from "../execution/sim-states-walk.js";
+import type { SimStatesAttemptState } from "./sim-states-attempt-state.js";
+interface SimStatesRecoveredProperties {
+    readonly entry: SimStatesStateEntry;
+    /**
+     * What running the state produced, which is only handled where it failed.
+     */
+    readonly ran: SimStatesStateOutcome;
+    readonly attempt: SimStatesAttemptState;
+    readonly now: Date;
+}
+/**
+ * What the state's own `Retry` and `Catch` make of a failure.
+ *
+ * A state whose type carries neither is left as it was, and its failure ends
+ * the walk. A catcher whose `ResultPath` has nowhere to write fails the walk
+ * the way any other data-flow field that cannot be applied does.
+ */
+export declare function simStatesRecovered(properties: SimStatesRecoveredProperties): SimStatesStateOutcome;
+export {};
+//# sourceMappingURL=sim-states-recovered.d.ts.map

package/dist/service/stepfunctions/retry/sim-states-recovered.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-recovered.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-recovered.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAI3E,UAAU,4BAA4B;IACpC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;IAEpC;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,qBAAqB,CAAC;IAEpC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,4BAA4B,GACvC,qBAAqB,CAwBvB"}

package/dist/service/stepfunctions/retry/sim-states-recovered.js

@@ -0,0 +1,33 @@
+import { simStatesFailureFrom } from "../execution/sim-states-failure.js";
+import { simStatesErrorHandling } from "./sim-states-error-handling.js";
+import { simStatesRecover } from "./sim-states-recover.js";
+/**
+ * What the state's own `Retry` and `Catch` make of a failure.
+ *
+ * A state whose type carries neither is left as it was, and its failure ends
+ * the walk. A catcher whose `ResultPath` has nowhere to write fails the walk
+ * the way any other data-flow field that cannot be applied does.
+ */
+export function simStatesRecovered(properties) {
+    const { attempt, entry, now, ran } = properties;
+    if (ran.kind !== "fail") {
+        return ran;
+    }
+    const handling = simStatesErrorHandling(entry.state);
+    if (handling === undefined) {
+        return ran;
+    }
+    try {
+        return simStatesRecover({
+            handling,
+            input: entry.input,
+            failure: ran,
+            attempt,
+            now,
+        });
+    }
+    catch (error) {
+        return simStatesFailureFrom(error);
+    }
+}
+//# sourceMappingURL=sim-states-recovered.js.map

package/dist/service/stepfunctions/retry/sim-states-recovered.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-recovered.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-recovered.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAI1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAc3D;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,UAAwC;IAExC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,UAAU,CAAC;IAEhD,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QACxB,OAAO,GAAG,CAAC;IACb,CAAC;IAED,MAAM,QAAQ,GAAG,sBAAsB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAErD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,CAAC;QACH,OAAO,gBAAgB,CAAC;YACtB,QAAQ;YACR,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,OAAO,EAAE,GAAG;YACZ,OAAO;YACP,GAAG;SACJ,CAAC,CAAC;IACL,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,oBAAoB,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;AACH,CAAC"}

package/dist/service/stepfunctions/retry/sim-states-retrier.d.ts

@@ -0,0 +1,35 @@
+/**
+ * One entry in a state's `Retry`.
+ *
+ * The four fields that shape the wait are optional, and the defaults below are
+ * the ones Amazon States Language gives them.
+ */
+export interface SimStatesRetrier {
+    readonly ErrorEquals: readonly string[];
+    readonly IntervalSeconds?: number;
+    readonly MaxAttempts?: number;
+    readonly BackoffRate?: number;
+    readonly MaxDelaySeconds?: number;
+}
+/**
+ * What a retrier means where it says nothing.
+ *
+ * `MaxAttempts` counts retries rather than runs, so the default lets a task run
+ * four times: once, and then three more.
+ */
+export declare const simStatesRetryIntervalSeconds = 1;
+export declare const simStatesRetryMaxAttempts = 3;
+export declare const simStatesRetryBackoffRate = 2;
+/**
+ * How many retries one retrier allows.
+ */
+export declare function simStatesRetriesAllowed(retrier: SimStatesRetrier): number;
+/**
+ * How long to wait before the next retry this retrier takes.
+ *
+ * The wait grows by `BackoffRate` for each retry already taken, so the first
+ * one waits `IntervalSeconds` and each one after it waits longer.
+ * `MaxDelaySeconds` caps how long that can get.
+ */
+export declare function simStatesRetryDelaySeconds(retrier: SimStatesRetrier, taken: number): number;
+//# sourceMappingURL=sim-states-retrier.d.ts.map

package/dist/service/stepfunctions/retry/sim-states-retrier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-retrier.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-retrier.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAC3C,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAEzE;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,MAAM,GACZ,MAAM,CAQR"}

package/dist/service/stepfunctions/retry/sim-states-retrier.js

@@ -0,0 +1,31 @@
+/**
+ * What a retrier means where it says nothing.
+ *
+ * `MaxAttempts` counts retries rather than runs, so the default lets a task run
+ * four times: once, and then three more.
+ */
+export const simStatesRetryIntervalSeconds = 1;
+export const simStatesRetryMaxAttempts = 3;
+export const simStatesRetryBackoffRate = 2;
+/**
+ * How many retries one retrier allows.
+ */
+export function simStatesRetriesAllowed(retrier) {
+    return retrier.MaxAttempts ?? simStatesRetryMaxAttempts;
+}
+/**
+ * How long to wait before the next retry this retrier takes.
+ *
+ * The wait grows by `BackoffRate` for each retry already taken, so the first
+ * one waits `IntervalSeconds` and each one after it waits longer.
+ * `MaxDelaySeconds` caps how long that can get.
+ */
+export function simStatesRetryDelaySeconds(retrier, taken) {
+    const interval = retrier.IntervalSeconds ?? simStatesRetryIntervalSeconds;
+    const backoff = retrier.BackoffRate ?? simStatesRetryBackoffRate;
+    const delay = interval * backoff ** taken;
+    return retrier.MaxDelaySeconds === undefined
+        ? delay
+        : Math.min(delay, retrier.MaxDelaySeconds);
+}
+//# sourceMappingURL=sim-states-retrier.js.map

package/dist/service/stepfunctions/retry/sim-states-retrier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-retrier.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-retrier.ts"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC;AAC/C,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAC3C,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAE3C;;GAEG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAyB;IAC/D,OAAO,OAAO,CAAC,WAAW,IAAI,yBAAyB,CAAC;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B,CACxC,OAAyB,EACzB,KAAa;IAEb,MAAM,QAAQ,GAAG,OAAO,CAAC,eAAe,IAAI,6BAA6B,CAAC;IAC1E,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,IAAI,yBAAyB,CAAC;IACjE,MAAM,KAAK,GAAG,QAAQ,GAAG,OAAO,IAAI,KAAK,CAAC;IAE1C,OAAO,OAAO,CAAC,eAAe,KAAK,SAAS;QAC1C,CAAC,CAAC,KAAK;QACP,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;AAC/C,CAAC"}

package/dist/service/stepfunctions/retry/sim-states-retry-outcome.d.ts

@@ -0,0 +1,12 @@
+import type { SimStatesFailOutcome, SimStatesRetryOutcome } from "../execution/sim-states-state-outcome.js";
+import { type SimStatesAttemptState } from "./sim-states-attempt-state.js";
+import { type SimStatesRetrier } from "./sim-states-retrier.js";
+/**
+ * The next attempt a retrier asks for, where one matches and has attempts left.
+ *
+ * The retriers are tried in the order they were written and the first one
+ * naming the error takes it. Each keeps its own count, the way Amazon States
+ * Language counts them.
+ */
+export declare function simStatesRetryOutcome(retriers: readonly SimStatesRetrier[], failure: SimStatesFailOutcome, attempt: SimStatesAttemptState, now: Date): SimStatesRetryOutcome | undefined;
+//# sourceMappingURL=sim-states-retry-outcome.d.ts.map

package/dist/service/stepfunctions/retry/sim-states-retry-outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-retry-outcome.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-retry-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EACtB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACL,KAAK,gBAAgB,EAGtB,MAAM,yBAAyB,CAAC;AAIjC;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,SAAS,gBAAgB,EAAE,EACrC,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,qBAAqB,EAC9B,GAAG,EAAE,IAAI,GACR,qBAAqB,GAAG,SAAS,CAuBnC"}

package/dist/service/stepfunctions/retry/sim-states-retry-outcome.js

@@ -0,0 +1,44 @@
+import { simStatesRetriesTaken, simStatesRetryTaken, } from "./sim-states-attempt-state.js";
+import { simStatesErrorMatches } from "./sim-states-error-name.js";
+import { simStatesRetriesAllowed, simStatesRetryDelaySeconds, } from "./sim-states-retrier.js";
+const millisecondsInASecond = 1000;
+/**
+ * The next attempt a retrier asks for, where one matches and has attempts left.
+ *
+ * The retriers are tried in the order they were written and the first one
+ * naming the error takes it. Each keeps its own count, the way Amazon States
+ * Language counts them.
+ */
+export function simStatesRetryOutcome(retriers, failure, attempt, now) {
+    const matched = retriers
+        .map((retrier, index) => ({ retrier, index }))
+        .find(({ retrier }) => simStatesErrorMatches(retrier.ErrorEquals, failure.error));
+    if (matched === undefined) {
+        return undefined;
+    }
+    const { retrier, index } = matched;
+    const taken = simStatesRetriesTaken(attempt, index);
+    if (taken >= simStatesRetriesAllowed(retrier)) {
+        return undefined;
+    }
+    return {
+        kind: "retry",
+        until: dueAt(retrier, taken, attempt, now),
+        attempt: simStatesRetryTaken(attempt, index),
+    };
+}
+/**
+ * When the next attempt runs.
+ *
+ * A wait running past the state's deadline is cut short at it. The task gives
+ * up when it said it would, and not at the attempt it never made.
+ */
+function dueAt(retrier, taken, attempt, now) {
+    const delay = simStatesRetryDelaySeconds(retrier, taken);
+    const due = new Date(now.getTime() + delay * millisecondsInASecond);
+    const { deadline } = attempt;
+    return deadline !== undefined && deadline.at.getTime() < due.getTime()
+        ? deadline.at
+        : due;
+}
+//# sourceMappingURL=sim-states-retry-outcome.js.map

package/dist/service/stepfunctions/retry/sim-states-retry-outcome.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-retry-outcome.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-retry-outcome.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAEL,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,yBAAyB,CAAC;AAEjC,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,QAAqC,EACrC,OAA6B,EAC7B,OAA8B,EAC9B,GAAS;IAET,MAAM,OAAO,GAAG,QAAQ;SACrB,GAAG,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;SAC7C,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CACpB,qBAAqB,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,KAAK,CAAC,CAC1D,CAAC;IAEJ,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC;IACnC,MAAM,KAAK,GAAG,qBAAqB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAEpD,IAAI,KAAK,IAAI,uBAAuB,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,IAAI,EAAE,OAAO;QACb,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC;QAC1C,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC;KAC7C,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAS,KAAK,CACZ,OAAyB,EACzB,KAAa,EACb,OAA8B,EAC9B,GAAS;IAET,MAAM,KAAK,GAAG,0BAA0B,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACzD,MAAM,GAAG,GAAG,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,KAAK,GAAG,qBAAqB,CAAC,CAAC;IACpE,MAAM,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IAE7B,OAAO,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE;QACpE,CAAC,CAAC,QAAQ,CAAC,EAAE;QACb,CAAC,CAAC,GAAG,CAAC;AACV,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesRetrier } from "./sim-states-retrier.js";
+/**
+ * Read a state's `Retry`, refusing anything this cannot run.
+ *
+ * The retriers are read when the state machine is created, so a state that
+ * runs is one whose intervals and attempt counts are already known to be good.
+ * Answers with nothing where the state carries no `Retry`.
+ */
+export declare function parseSimStatesRetriers(named: string, state: Record<string, JSONValue>): readonly SimStatesRetrier[] | undefined;
+//# sourceMappingURL=sim-states-retry-parse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-retry-parse.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-retry-parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAUlE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAWhE;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAC/B,SAAS,gBAAgB,EAAE,GAAG,SAAS,CAIzC"}

package/dist/service/stepfunctions/retry/sim-states-retry-parse.js

@@ -0,0 +1,76 @@
+import { SimStatesInvalidDefinition, SimStatesUnsimulatedInput, } from "../error/sim-step-functions.error.js";
+import { simStatesMaximumWaitSeconds } from "../wait/sim-states-wait-fields.js";
+import { readSimStatesHandlers, } from "./sim-states-error-equals.js";
+/**
+ * The field of a retrier this simulator has no implementation for.
+ *
+ * Jitter spreads retries over the interval rather than taking all of it, and a
+ * simulated retry is one a test asserts a clock advance against. An interval
+ * that varies is one such a test cannot be written for.
+ */
+const jitterField = "JitterStrategy";
+/**
+ * Read a state's `Retry`, refusing anything this cannot run.
+ *
+ * The retriers are read when the state machine is created, so a state that
+ * runs is one whose intervals and attempt counts are already known to be good.
+ * Answers with nothing where the state carries no `Retry`.
+ */
+export function parseSimStatesRetriers(named, state) {
+    return readSimStatesHandlers(named, state, "Retry", "retrier")?.map((entry) => readRetrier(named, entry));
+}
+/**
+ * Read one retrier's `ErrorEquals` and the four fields that shape its wait.
+ */
+function readRetrier(named, entry) {
+    const { written } = entry;
+    if (Object.hasOwn(written, jitterField)) {
+        throw new SimStatesUnsimulatedInput(`A retrier in the ${named} carries ${jitterField}, ` +
+            "which this simulator does not run. Jitter makes the wait between " +
+            "attempts vary, and a test advancing a clock over that wait needs it " +
+            "not to.");
+    }
+    return {
+        ErrorEquals: entry.ErrorEquals,
+        ...wholeNumber(named, written, "IntervalSeconds", 1),
+        ...wholeNumber(named, written, "MaxDelaySeconds", 1),
+        ...wholeNumber(named, written, "MaxAttempts", 0),
+        ...backoffRate(named, written),
+    };
+}
+/**
+ * Read one of the three whole-number fields, where the retrier carries it.
+ */
+function wholeNumber(named, written, field, least) {
+    // The field is one of the three named above.
+    // oxlint-disable-next-line security/detect-object-injection
+    const value = written[field];
+    if (value === undefined) {
+        return {};
+    }
+    if (typeof value !== "number" ||
+        !Number.isSafeInteger(value) ||
+        value < least ||
+        value > simStatesMaximumWaitSeconds) {
+        throw new SimStatesInvalidDefinition(`A retrier in the ${named} has a ${field} of ` +
+            `${JSON.stringify(value)}. It is a whole number from ` +
+            `${String(least)} to ${String(simStatesMaximumWaitSeconds)}.`);
+    }
+    return { [field]: value };
+}
+/**
+ * Read `BackoffRate`, which multiplies the wait for each retry already taken.
+ */
+function backoffRate(named, written) {
+    const value = written["BackoffRate"];
+    if (value === undefined) {
+        return {};
+    }
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+        throw new SimStatesInvalidDefinition(`A retrier in the ${named} has a BackoffRate of ` +
+            `${JSON.stringify(value)}. It is at least 1, since a wait that ` +
+            "shrank would retry faster the longer a failure went on.");
+    }
+    return { BackoffRate: value };
+}
+//# sourceMappingURL=sim-states-retry-parse.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-retry-parse.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/retry/sim-states-retry-parse.ts"],"names":[],"mappings":"AACA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,GAC1B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAEL,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AAGtC;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,gBAAgB,CAAC;AAErC;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAAa,EACb,KAAgC;IAEhC,OAAO,qBAAqB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAC5E,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAC1B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAClB,KAAa,EACb,KAA4B;IAE5B,MAAM,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IAE1B,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,yBAAyB,CACjC,oBAAoB,KAAK,YAAY,WAAW,IAAI;YAClD,mEAAmE;YACnE,sEAAsE;YACtE,SAAS,CACZ,CAAC;IACJ,CAAC;IAED,OAAO;QACL,WAAW,EAAE,KAAK,CAAC,WAAW;QAC9B,GAAG,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC,CAAC;QACpD,GAAG,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC,CAAC;QACpD,GAAG,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;QAChD,GAAG,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC;KAC/B,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAClB,KAAa,EACb,OAAkC,EAClC,KAA4D,EAC5D,KAAa;IAEb,6CAA6C;IAC7C,4DAA4D;IAC5D,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAE7B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;QAC5B,KAAK,GAAG,KAAK;QACb,KAAK,GAAG,2BAA2B,EACnC,CAAC;QACD,MAAM,IAAI,0BAA0B,CAClC,oBAAoB,KAAK,UAAU,KAAK,MAAM;YAC5C,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,8BAA8B;YACtD,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,2BAA2B,CAAC,GAAG,CAChE,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC;AAC5B,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAClB,KAAa,EACb,OAAkC;IAElC,MAAM,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAErC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACtE,MAAM,IAAI,0BAA0B,CAClC,oBAAoB,KAAK,wBAAwB;YAC/C,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,wCAAwC;YAChE,yDAAyD,CAC5D,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AAChC,CAAC"}