@kensio/yulin 0.35.0 → 0.37.0

package/dist/util/clock/sim-clock-mode.js

@@ -0,0 +1,58 @@
+/**
+ * Simulated time stopped at an instant, moving only when something moves it.
+ */
+export class SimFrozenClockMode {
+    isFrozen = true;
+    instant;
+    constructor(instant) {
+        this.instant = new Date(instant);
+    }
+    /**
+     * Get the instant this mode is stopped at.
+     */
+    now() {
+        return new Date(this.instant);
+    }
+    /**
+     * Stay stopped: freezing an already frozen clock changes nothing.
+     */
+    freeze() {
+        return this;
+    }
+    /**
+     * Run again from the frozen instant, keeping it as the offset from the clock
+     * underneath, so no simulated time is gained or lost by resuming.
+     */
+    resume(base) {
+        return new SimRunningClockMode(this.instant.getTime() - base.now().getTime());
+    }
+}
+/**
+ * Simulated time passing by itself, shifted from the clock underneath.
+ */
+export class SimRunningClockMode {
+    isFrozen = false;
+    offsetMs;
+    constructor(offsetMs = 0) {
+        this.offsetMs = offsetMs;
+    }
+    /**
+     * Get the time the clock underneath reports, shifted by this offset.
+     */
+    now(base) {
+        return new Date(base.now().getTime() + this.offsetMs);
+    }
+    /**
+     * Stop at whatever simulated time currently reads.
+     */
+    freeze(base) {
+        return new SimFrozenClockMode(this.now(base));
+    }
+    /**
+     * Keep running: resuming an already running clock changes nothing.
+     */
+    resume() {
+        return this;
+    }
+}
+//# sourceMappingURL=sim-clock-mode.js.map

package/dist/util/clock/sim-clock-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-clock-mode.js","sourceRoot":"","sources":["../../../src/util/clock/sim-clock-mode.ts"],"names":[],"mappings":"AAqCA;;GAEG;AACH,MAAM,OAAO,kBAAkB;IACb,QAAQ,GAAG,IAAI,CAAC;IAEf,OAAO,CAAO;IAE/B,YAAY,OAAa;QACvB,IAAI,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,GAAG;QACD,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,IAAc;QACnB,OAAO,IAAI,mBAAmB,CAC5B,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAC9C,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,mBAAmB;IACd,QAAQ,GAAG,KAAK,CAAC;IAEhB,QAAQ,CAAS;IAElC,YAAY,QAAQ,GAAG,CAAC;QACtB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,IAAc;QAChB,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAc;QACnB,OAAO,IAAI,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/util/clock/sim-clock.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Source of the current time inside one simulated environment.
+ *
+ * Every simulated timestamp comes from a clock rather than a direct `new Date()`,
+ * so a simulation's sense of time belongs to its own SimAws instance rather than
+ * to the process running it. That keeps instances independent: controlling time
+ * in one simulation cannot disturb another, or the real clock.
+ */
+export interface SimClock {
+    /**
+     * Get the current time in this simulation.
+     */
+    now(): Date;
+}
+/**
+ * Clock that reports the real system time.
+ *
+ * This is the default, so a simulation runs in step with the host clock until
+ * something deliberately replaces it.
+ */
+export declare class SimRealClock implements SimClock {
+    /**
+     * Get the current real system time.
+     */
+    now(): Date;
+}
+/**
+ * Clock stopped at a fixed instant.
+ *
+ * Useful wherever a test wants timestamps it can assert on exactly, without
+ * reaching for a library that replaces the clock for the whole process.
+ */
+export declare class SimFixedClock implements SimClock {
+    private readonly instant;
+    constructor(instant: Date);
+    /**
+     * Get the fixed instant this clock reports.
+     */
+    now(): Date;
+}
+//# sourceMappingURL=sim-clock.d.ts.map

package/dist/util/clock/sim-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-clock.d.ts","sourceRoot":"","sources":["../../../src/util/clock/sim-clock.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,GAAG,IAAI,IAAI,CAAC;CACb;AAED;;;;;GAKG;AACH,qBAAa,YAAa,YAAW,QAAQ;IAC3C;;OAEG;IACH,GAAG,IAAI,IAAI,CAEV;CACF;AAED;;;;;GAKG;AACH,qBAAa,aAAc,YAAW,QAAQ;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAO;IAE/B,YAAY,OAAO,EAAE,IAAI,EAExB;IAED;;OAEG;IACH,GAAG,IAAI,IAAI,CAEV;CACF"}

package/dist/util/clock/sim-clock.js

@@ -0,0 +1,33 @@
+/**
+ * Clock that reports the real system time.
+ *
+ * This is the default, so a simulation runs in step with the host clock until
+ * something deliberately replaces it.
+ */
+export class SimRealClock {
+    /**
+     * Get the current real system time.
+     */
+    now() {
+        return new Date();
+    }
+}
+/**
+ * Clock stopped at a fixed instant.
+ *
+ * Useful wherever a test wants timestamps it can assert on exactly, without
+ * reaching for a library that replaces the clock for the whole process.
+ */
+export class SimFixedClock {
+    instant;
+    constructor(instant) {
+        this.instant = new Date(instant);
+    }
+    /**
+     * Get the fixed instant this clock reports.
+     */
+    now() {
+        return new Date(this.instant);
+    }
+}
+//# sourceMappingURL=sim-clock.js.map

package/dist/util/clock/sim-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-clock.js","sourceRoot":"","sources":["../../../src/util/clock/sim-clock.ts"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,MAAM,OAAO,YAAY;IACvB;;OAEG;IACH,GAAG;QACD,OAAO,IAAI,IAAI,EAAE,CAAC;IACpB,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,OAAO,aAAa;IACP,OAAO,CAAO;IAE/B,YAAY,OAAa;QACvB,IAAI,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,GAAG;QACD,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;CACF"}

package/dist/util/clock/sim-controllable-clock.d.ts

@@ -0,0 +1,55 @@
+import { type SimClock } from "./sim-clock.js";
+import { SimDuration, type SimDurationInput } from "./sim-duration.js";
+interface SimControllableClockProperties {
+    /**
+     * The clock this one is measured against, defaulting to the real system
+     * clock. Freezing and offsetting are applied on top of it, so a simulation
+     * given a clock of its own stays controllable.
+     */
+    readonly base?: SimClock | undefined;
+}
+/**
+ * A clock whose time can be moved.
+ *
+ * This is what lets a test exercise behaviour that only happens once time
+ * passes, without waiting for it and without replacing the clock for the whole
+ * process. Control belongs to one clock instance, so moving time here cannot
+ * disturb another simulation, or the real clock.
+ *
+ * Moving time deliberately freezes it. Having asked for a specific instant, a
+ * test should get to assert on that instant rather than on that instant plus
+ * however long the assertion took to run. `resume()` is the way back to time
+ * passing by itself.
+ */
+export declare class SimControllableClock implements SimClock {
+    private readonly base;
+    private mode;
+    constructor(properties?: SimControllableClockProperties);
+    /**
+     * Get the current simulated time.
+     */
+    now(): Date;
+    /**
+     * Whether simulated time is currently standing still.
+     */
+    get isFrozen(): boolean;
+    /**
+     * Stop simulated time where it currently reads.
+     */
+    freeze(): void;
+    /**
+     * Let simulated time pass by itself again, carrying on from where it stopped
+     * rather than snapping back to the clock underneath.
+     */
+    resume(): void;
+    /**
+     * Set simulated time to an instant, and stop there.
+     */
+    setTo(instant: Date): void;
+    /**
+     * Move simulated time forward by a duration, and stop there.
+     */
+    advanceBy(duration: SimDuration | SimDurationInput): void;
+}
+export {};
+//# sourceMappingURL=sim-controllable-clock.d.ts.map

package/dist/util/clock/sim-controllable-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-controllable-clock.d.ts","sourceRoot":"","sources":["../../../src/util/clock/sim-controllable-clock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAgB,MAAM,gBAAgB,CAAC;AAM7D,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEvE,UAAU,8BAA8B;IACtC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACtC;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAqB,YAAW,QAAQ;IACnD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,IAAI,CAA2C;IAEvD,YAAY,UAAU,GAAE,8BAAmC,EAE1D;IAED;;OAEG;IACH,GAAG,IAAI,IAAI,CAEV;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED;;OAEG;IACH,MAAM,IAAI,IAAI,CAEb;IAED;;;OAGG;IACH,MAAM,IAAI,IAAI,CAEb;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAEzB;IAED;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,gBAAgB,GAAG,IAAI,CAIxD;CACF"}

package/dist/util/clock/sim-controllable-clock.js

@@ -0,0 +1,62 @@
+import { SimRealClock } from "./sim-clock.js";
+import { SimFrozenClockMode, SimRunningClockMode, } from "./sim-clock-mode.js";
+import { SimDuration } from "./sim-duration.js";
+/**
+ * A clock whose time can be moved.
+ *
+ * This is what lets a test exercise behaviour that only happens once time
+ * passes, without waiting for it and without replacing the clock for the whole
+ * process. Control belongs to one clock instance, so moving time here cannot
+ * disturb another simulation, or the real clock.
+ *
+ * Moving time deliberately freezes it. Having asked for a specific instant, a
+ * test should get to assert on that instant rather than on that instant plus
+ * however long the assertion took to run. `resume()` is the way back to time
+ * passing by itself.
+ */
+export class SimControllableClock {
+    base;
+    mode = new SimRunningClockMode();
+    constructor(properties = {}) {
+        this.base = properties.base ?? new SimRealClock();
+    }
+    /**
+     * Get the current simulated time.
+     */
+    now() {
+        return this.mode.now(this.base);
+    }
+    /**
+     * Whether simulated time is currently standing still.
+     */
+    get isFrozen() {
+        return this.mode.isFrozen;
+    }
+    /**
+     * Stop simulated time where it currently reads.
+     */
+    freeze() {
+        this.mode = this.mode.freeze(this.base);
+    }
+    /**
+     * Let simulated time pass by itself again, carrying on from where it stopped
+     * rather than snapping back to the clock underneath.
+     */
+    resume() {
+        this.mode = this.mode.resume(this.base);
+    }
+    /**
+     * Set simulated time to an instant, and stop there.
+     */
+    setTo(instant) {
+        this.mode = new SimFrozenClockMode(instant);
+    }
+    /**
+     * Move simulated time forward by a duration, and stop there.
+     */
+    advanceBy(duration) {
+        const milliseconds = SimDuration.of(duration).toMilliseconds();
+        this.setTo(new Date(this.now().getTime() + milliseconds));
+    }
+}
+//# sourceMappingURL=sim-controllable-clock.js.map

package/dist/util/clock/sim-controllable-clock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-controllable-clock.js","sourceRoot":"","sources":["../../../src/util/clock/sim-controllable-clock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EACL,kBAAkB,EAElB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAyB,MAAM,mBAAmB,CAAC;AAWvE;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,oBAAoB;IACd,IAAI,CAAW;IACxB,IAAI,GAAiB,IAAI,mBAAmB,EAAE,CAAC;IAEvD,YAAY,UAAU,GAAmC,EAAE;QACzD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,IAAI,IAAI,YAAY,EAAE,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,GAAG;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,MAAM;QACJ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAa;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,QAAwC;QAChD,MAAM,YAAY,GAAG,WAAW,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,cAAc,EAAE,CAAC;QAE/D,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,YAAY,CAAC,CAAC,CAAC;IAC5D,CAAC;CACF"}

package/dist/util/clock/sim-duration.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A length of time, written the way a test wants to say it.
+ *
+ * Every component is optional and they add together, so `{ hours: 1, minutes: 30 }`
+ * is ninety minutes. This is the literal a caller writes; SimDuration is what the
+ * simulator works with.
+ */
+export interface SimDurationInput {
+    readonly days?: number;
+    readonly hours?: number;
+    readonly minutes?: number;
+    readonly seconds?: number;
+    readonly milliseconds?: number;
+}
+/**
+ * Thrown for a duration that cannot describe an amount of elapsed time.
+ */
+export declare class SimInvalidDuration extends Error {
+    constructor(component: keyof SimDurationInput, value: number);
+}
+/**
+ * An amount of elapsed simulated time.
+ *
+ * Durations are never negative. Time passing is a forward-only idea, and a
+ * simulation that wants to be at an earlier instant sets its clock to that
+ * instant rather than advancing by a negative amount.
+ */
+export declare class SimDuration {
+    private readonly milliseconds;
+    private constructor();
+    /**
+     * Build a duration from the components a caller wrote, or pass one through.
+     */
+    static of(duration: SimDuration | SimDurationInput): SimDuration;
+    /**
+     * Build a duration from a plain number of milliseconds.
+     */
+    static ofMilliseconds(milliseconds: number): SimDuration;
+    /**
+     * Get this duration as a number of milliseconds, for Date arithmetic.
+     */
+    toMilliseconds(): number;
+}
+//# sourceMappingURL=sim-duration.d.ts.map

package/dist/util/clock/sim-duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-duration.d.ts","sourceRoot":"","sources":["../../../src/util/clock/sim-duration.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAOD;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,SAAS,EAAE,MAAM,gBAAgB,EAAE,KAAK,EAAE,MAAM,EAK3D;CACF;AAiCD;;;;;;GAMG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC,OAAO,eAEN;IAED;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,WAAW,GAAG,gBAAgB,GAAG,WAAW,CAM/D;IAED;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,CAEvD;IAED;;OAEG;IACH,cAAc,IAAI,MAAM,CAEvB;CACF"}

package/dist/util/clock/sim-duration.js

@@ -0,0 +1,69 @@
+const millisecondsPerSecond = 1000;
+const millisecondsPerMinute = 60 * millisecondsPerSecond;
+const millisecondsPerHour = 60 * millisecondsPerMinute;
+const millisecondsPerDay = 24 * millisecondsPerHour;
+/**
+ * Thrown for a duration that cannot describe an amount of elapsed time.
+ */
+export class SimInvalidDuration extends Error {
+    constructor(component, value) {
+        super(`Invalid simulated duration: ${component} must be a finite number of zero or more, got ${String(value)}`);
+        this.name = "SimInvalidDuration";
+    }
+}
+/**
+ * Measure one component of a duration, refusing anything that cannot describe
+ * an amount of elapsed time.
+ */
+function componentMilliseconds(component, value, perUnit) {
+    const amount = value ?? 0;
+    if (!Number.isFinite(amount) || amount < 0) {
+        throw new SimInvalidDuration(component, amount);
+    }
+    return amount * perUnit;
+}
+/**
+ * Add up the components of a duration.
+ */
+function totalMilliseconds(duration) {
+    return (componentMilliseconds("days", duration.days, millisecondsPerDay) +
+        componentMilliseconds("hours", duration.hours, millisecondsPerHour) +
+        componentMilliseconds("minutes", duration.minutes, millisecondsPerMinute) +
+        componentMilliseconds("seconds", duration.seconds, millisecondsPerSecond) +
+        componentMilliseconds("milliseconds", duration.milliseconds, 1));
+}
+/**
+ * An amount of elapsed simulated time.
+ *
+ * Durations are never negative. Time passing is a forward-only idea, and a
+ * simulation that wants to be at an earlier instant sets its clock to that
+ * instant rather than advancing by a negative amount.
+ */
+export class SimDuration {
+    milliseconds;
+    constructor(milliseconds) {
+        this.milliseconds = milliseconds;
+    }
+    /**
+     * Build a duration from the components a caller wrote, or pass one through.
+     */
+    static of(duration) {
+        if (duration instanceof this) {
+            return duration;
+        }
+        return new this(totalMilliseconds(duration));
+    }
+    /**
+     * Build a duration from a plain number of milliseconds.
+     */
+    static ofMilliseconds(milliseconds) {
+        return this.of({ milliseconds });
+    }
+    /**
+     * Get this duration as a number of milliseconds, for Date arithmetic.
+     */
+    toMilliseconds() {
+        return this.milliseconds;
+    }
+}
+//# sourceMappingURL=sim-duration.js.map

package/dist/util/clock/sim-duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-duration.js","sourceRoot":"","sources":["../../../src/util/clock/sim-duration.ts"],"names":[],"mappings":"AAeA,MAAM,qBAAqB,GAAG,IAAI,CAAC;AACnC,MAAM,qBAAqB,GAAG,EAAE,GAAG,qBAAqB,CAAC;AACzD,MAAM,mBAAmB,GAAG,EAAE,GAAG,qBAAqB,CAAC;AACvD,MAAM,kBAAkB,GAAG,EAAE,GAAG,mBAAmB,CAAC;AAEpD;;GAEG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,SAAiC,EAAE,KAAa;QAC1D,KAAK,CACH,+BAA+B,SAAS,iDAAiD,MAAM,CAAC,KAAK,CAAC,EAAE,CACzG,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AAED;;;GAGG;AACH,SAAS,qBAAqB,CAC5B,SAAiC,EACjC,KAAyB,EACzB,OAAe;IAEf,MAAM,MAAM,GAAG,KAAK,IAAI,CAAC,CAAC;IAE1B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,kBAAkB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;IAED,OAAO,MAAM,GAAG,OAAO,CAAC;AAC1B,CAAC;AAED;;GAEG;AACH,SAAS,iBAAiB,CAAC,QAA0B;IACnD,OAAO,CACL,qBAAqB,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;QAChE,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC,KAAK,EAAE,mBAAmB,CAAC;QACnE,qBAAqB,CAAC,SAAS,EAAE,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;QACzE,qBAAqB,CAAC,SAAS,EAAE,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;QACzE,qBAAqB,CAAC,cAAc,EAAE,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC,CAChE,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,OAAO,WAAW;IACL,YAAY,CAAS;IAEtC,YAAoB,YAAoB;QACtC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,QAAwC;QAChD,IAAI,QAAQ,YAAY,IAAI,EAAE,CAAC;YAC7B,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED,OAAO,IAAI,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,YAAoB;QACxC,OAAO,IAAI,CAAC,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;CACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/yulin",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "description": "AWS system behaviour simulation for isolated unit testing",
   "repository": {
     "type": "git",
@@ -80,6 +80,7 @@
   "author": "Kensio Software",
   "license": "Apache-2.0",
   "devDependencies": {
+    "@aws-crypto/sha256-js": "^5.2.0",
     "@aws-sdk/client-acm": "^3.1086.0",
     "@aws-sdk/client-cloudformation": "^3.1086.0",
     "@aws-sdk/client-cloudfront": "^3.1086.0",
@@ -91,6 +92,7 @@
     "@aws-sdk/client-sts": "^3.1086.0",
     "@eslint/js": "^10.0.1",
     "@kensio/smartass": "^1.34.0",
+    "@smithy/signature-v4": "^5.6.10",
     "@smithy/smithy-client": "^4.14.8",
     "@smithy/types": "^4.16.1",
     "@types/eslint-plugin-security": "^3.0.1",