@plugjs/expect5 0.4.2 → 0.4.3

package/dist/expectation/expect.cjs

@@ -23,122 +23,107 @@ __export(expect_exports, {
   expect: () => expect
 });
 module.exports = __toCommonJS(expect_exports);
-var import_types = require("./types.cjs");
+var import_async = require("./async.cjs");
 var import_basic = require("./basic.cjs");
 var import_include = require("./include.cjs");
 var import_throwing = require("./throwing.cjs");
-var import_void = require("./void.cjs");
-var expectations = {
-  // basic expectations
-  toBeA: new import_basic.ToBeA(),
-  toBeCloseTo: new import_basic.ToBeCloseTo(),
-  toBeError: new import_basic.ToBeError(),
-  toBeGreaterThan: new import_basic.ToBeGreaterThan(),
-  toBeGreaterThanOrEqual: new import_basic.ToBeGreaterThanOrEqual(),
-  toBeInstanceOf: new import_basic.ToBeInstanceOf(),
-  toBeLessThan: new import_basic.ToBeLessThan(),
-  toBeLessThanOrEqual: new import_basic.ToBeLessThanOrEqual(),
-  toBeWithinRange: new import_basic.ToBeWithinRange(),
-  toEqual: new import_basic.ToEqual(),
-  toHaveLength: new import_basic.ToHaveLength(),
-  toHaveProperty: new import_basic.ToHaveProperty(),
-  toHaveSize: new import_basic.ToHaveSize(),
-  toMatch: new import_basic.ToMatch(),
-  toStrictlyEqual: new import_basic.ToStrictlyEqual(),
+var import_trivial = require("./trivial.cjs");
+var import_types = require("./types.cjs");
+var asyncExpectations = {
+  toBeResolved: import_async.toBeResolved,
+  toBeRejected: import_async.toBeRejected,
+  toBeRejectedWithError: import_async.toBeRejectedWithError
+};
+var syncExpectations = {
+  // basic
+  toBeA: import_basic.toBeA,
+  toBeCloseTo: import_basic.toBeCloseTo,
+  toBeError: import_basic.toBeError,
+  toBeGreaterThan: import_basic.toBeGreaterThan,
+  toBeGreaterThanOrEqual: import_basic.toBeGreaterThanOrEqual,
+  toBeInstanceOf: import_basic.toBeInstanceOf,
+  toBeLessThan: import_basic.toBeLessThan,
+  toBeLessThanOrEqual: import_basic.toBeLessThanOrEqual,
+  toBeWithinRange: import_basic.toBeWithinRange,
+  toEqual: import_basic.toEqual,
+  toHaveLength: import_basic.toHaveLength,
+  toHaveProperty: import_basic.toHaveProperty,
+  toHaveSize: import_basic.toHaveSize,
+  toMatch: import_basic.toMatch,
+  toStrictlyEqual: import_basic.toStrictlyEqual,
   // include
-  toInclude: new import_include.ToInclude(),
-  toMatchContents: new import_include.ToMatchContents(),
+  toInclude: import_include.toInclude,
+  toMatchContents: import_include.toMatchContents,
   // throwing
-  toThrow: new import_throwing.ToThrow(),
-  toThrowError: new import_throwing.ToThrowError(),
-  // void expectations
-  toBeDefined: new import_void.ToBeDefined(),
-  toBeFalse: new import_void.ToBeFalse(),
-  toBeFalsy: new import_void.ToBeFalsy(),
-  toBeNaN: new import_void.ToBeNaN(),
-  toBeNegativeInfinity: new import_void.ToBeNegativeInfinity(),
-  toBeNull: new import_void.ToBeNull(),
-  toBePositiveInfinity: new import_void.ToBePositiveInfinity(),
-  toBeTrue: new import_void.ToBeTrue(),
-  toBeTruthy: new import_void.ToBeTruthy(),
-  toBeUndefined: new import_void.ToBeUndefined()
+  toThrow: import_throwing.toThrow,
+  toThrowError: import_throwing.toThrowError,
+  // trivial
+  toBeDefined: import_trivial.toBeDefined,
+  toBeFalse: import_trivial.toBeFalse,
+  toBeFalsy: import_trivial.toBeFalsy,
+  toBeNaN: import_trivial.toBeNaN,
+  toBeNegativeInfinity: import_trivial.toBeNegativeInfinity,
+  toBeNull: import_trivial.toBeNull,
+  toBeNullable: import_trivial.toBeNullable,
+  toBePositiveInfinity: import_trivial.toBePositiveInfinity,
+  toBeTrue: import_trivial.toBeTrue,
+  toBeTruthy: import_trivial.toBeTruthy,
+  toBeUndefined: import_trivial.toBeUndefined
 };
-var ExpectationsImpl = class {
-  constructor(value, _positiveExpectations) {
+var allExpectations = {
+  ...asyncExpectations,
+  ...syncExpectations
+};
+var ExpectationsContextImpl = class {
+  constructor(value, negative, expects, negated, parent) {
     this.value = value;
-    if (_positiveExpectations) {
-      this._negative = true;
-      this._positiveExpectations = _positiveExpectations;
-      this._negativeExpectations = this;
-    } else {
-      this._negative = false;
-      this._positiveExpectations = this;
-      this._negativeExpectations = new ExpectationsImpl(value, this);
-    }
-  }
-  _positiveExpectations;
-  _negativeExpectations;
-  _negative;
-  /* == NEW EXPECTATIONS ==================================================== */
-  forProperty(prop) {
-    this.toBeDefined();
-    const child = new ExpectationsImpl(this.value[prop]);
-    child.parent = { context: this, prop };
-    return child;
+    this.negative = negative;
+    this.expects = expects;
+    this.negated = negated;
+    this.parent = parent;
   }
   forValue(value) {
     return new ExpectationsImpl(value);
   }
-  /* == NEGATION ============================================================ */
-  negated(negative) {
-    return negative ? this._negativeExpectations : this._positiveExpectations;
-  }
-  get not() {
-    return this._negative ? this._positiveExpectations : this._negativeExpectations;
-  }
-  /* == ASYNCHRONOUS EXPECTATIONS =========================================== */
-  toBeResolved(assert) {
-    return Promise.resolve().then(() => {
-      this._positiveExpectations.toHaveProperty("then", (a) => a.toBeA("function"));
-      return Promise.allSettled([Promise.resolve(this.value)]);
-    }).then(([settlement]) => {
-      if (settlement.status === "fulfilled") {
-        if (this._negative)
-          throw new import_types.ExpectationError(this, true, "to be resolved");
-        if (assert)
-          assert(new ExpectationsImpl(settlement.value));
-      } else if (!this._negative) {
-        throw new import_types.ExpectationError(this, false, "to be resolved");
-      }
-      return this._positiveExpectations;
-    });
-  }
-  toBeRejected(assert) {
-    return Promise.resolve().then(() => {
-      this._positiveExpectations.toHaveProperty("then", (a) => a.toBeA("function"));
-      return Promise.allSettled([Promise.resolve(this.value)]);
-    }).then(([settlement]) => {
-      if (settlement.status === "rejected") {
-        if (this._negative)
-          throw new import_types.ExpectationError(this, true, "to be rejected");
-        if (assert)
-          assert(new ExpectationsImpl(settlement.reason));
-      } else if (!this._negative) {
-        throw new import_types.ExpectationError(this, false, "to be rejected");
-      }
-      return this._positiveExpectations;
-    });
+  forProperty(prop) {
+    this.expects.toBeDefined();
+    const value = this.value[prop];
+    const parent = { context: this, prop };
+    return new ExpectationsImpl(value, parent);
   }
-  toBeRejectedWithError(...args) {
-    return this.toBeRejected((assert) => assert.toBeError(...args));
+};
+var ExpectationsImpl = class {
+  _context;
+  value;
+  not;
+  constructor(value, parent, positives) {
+    this.value = value;
+    if (positives) {
+      this.not = positives;
+      this._context = new ExpectationsContextImpl(
+        value,
+        true,
+        positives,
+        this,
+        parent
+      );
+    } else {
+      this._context = new ExpectationsContextImpl(
+        value,
+        false,
+        this,
+        this,
+        parent
+      );
+      this.not = new ExpectationsImpl(value, parent, this);
+    }
   }
   static {
-    for (const [key, value] of Object.entries(expectations)) {
+    for (const [key, value] of Object.entries(allExpectations)) {
       const expectation = value;
       const fn = function(...args) {
         try {
-          expectation.expect(this._positiveExpectations, this._negative, ...args);
-          return this._positiveExpectations;
+          return expectation.call(this._context, ...args);
         } catch (error) {
           if (error instanceof import_types.ExpectationError)
             Error.captureStackTrace(error, fn);
@@ -150,7 +135,7 @@ var ExpectationsImpl = class {
     }
   }
 };
-var ExpectationsMatcherImpl = class {
+var MatcherImpl = class {
   _matchers;
   _positiveBuilder;
   _negativeBuilder;
@@ -164,24 +149,25 @@ var ExpectationsMatcherImpl = class {
     } else {
       this._negative = false;
       this._positiveBuilder = this;
-      this._negativeBuilder = new ExpectationsMatcherImpl(this._matchers, this);
+      this._negativeBuilder = new MatcherImpl(this._matchers, this);
     }
   }
   get not() {
     return this._negative ? this._positiveBuilder : this._negativeBuilder;
   }
   expect(value) {
-    const expectations2 = new ExpectationsImpl(value);
+    const expectations = expect(value);
     for (const [expectation, negative, args] of this._matchers) {
-      expectations2.negated(negative)[expectation](...args);
+      const expect2 = negative ? expectations.not : expectations;
+      expect2[expectation](...args);
     }
   }
   static {
     Object.defineProperty(this.prototype, import_types.matcherMarker, { value: import_types.matcherMarker });
-    for (const key in expectations) {
+    for (const key in syncExpectations) {
       Object.defineProperty(this.prototype, key, {
         value: function(...args) {
-          return new ExpectationsMatcherImpl([
+          return new MatcherImpl([
             ...this._matchers,
             [key, this._negative, args]
           ]);
@@ -194,12 +180,12 @@ var expect = (value) => {
   return new ExpectationsImpl(value);
 };
 Object.defineProperty(expect, "not", {
-  get: () => new ExpectationsMatcherImpl([]).not
+  get: () => new MatcherImpl([]).not
 });
-for (const name in expectations) {
+for (const name in syncExpectations) {
   Object.defineProperty(expect, name, {
     value: function(...args) {
-      const builder = new ExpectationsMatcherImpl([]);
+      const builder = new MatcherImpl([]);
       return builder[name](...args);
     }
   });

package/dist/expectation/expect.cjs.map

@@ -1,6 +1,6 @@
 {
   "version": 3,
   "sources": ["../../src/expectation/expect.ts"],
-  "mappings": "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",
-  "names": ["expectations"]
+  "mappings": "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",
+  "names": ["expect"]
 }

package/dist/expectation/expect.d.ts

@@ -1,140 +1,113 @@
-import { ToBeA, ToBeCloseTo, ToBeError, ToBeGreaterThan, ToBeGreaterThanOrEqual, ToBeInstanceOf, ToBeLessThan, ToBeLessThanOrEqual, ToBeWithinRange, ToEqual, ToHaveLength, ToHaveProperty, ToHaveSize, ToMatch, ToStrictlyEqual } from './basic';
-import { ToInclude, ToMatchContents } from './include';
-import { ToThrow, ToThrowError } from './throwing';
-import { ToBeDefined, ToBeFalse, ToBeFalsy, ToBeNaN, ToBeNegativeInfinity, ToBeNull, ToBePositiveInfinity, ToBeTrue, ToBeTruthy, ToBeUndefined } from './void';
-import type { Constructor, StringMatcher } from './types';
-/** Singleton with all imported (known) expectations */
-declare const expectations: {
-    readonly toBeA: ToBeA;
-    readonly toBeCloseTo: ToBeCloseTo;
-    readonly toBeError: ToBeError;
-    readonly toBeGreaterThan: ToBeGreaterThan;
-    readonly toBeGreaterThanOrEqual: ToBeGreaterThanOrEqual;
-    readonly toBeInstanceOf: ToBeInstanceOf;
-    readonly toBeLessThan: ToBeLessThan;
-    readonly toBeLessThanOrEqual: ToBeLessThanOrEqual;
-    readonly toBeWithinRange: ToBeWithinRange;
-    readonly toEqual: ToEqual;
-    readonly toHaveLength: ToHaveLength;
-    readonly toHaveProperty: ToHaveProperty;
-    readonly toHaveSize: ToHaveSize;
-    readonly toMatch: ToMatch;
-    readonly toStrictlyEqual: ToStrictlyEqual;
-    readonly toInclude: ToInclude;
-    readonly toMatchContents: ToMatchContents;
-    readonly toThrow: ToThrow;
-    readonly toThrowError: ToThrowError;
-    readonly toBeDefined: ToBeDefined;
-    readonly toBeFalse: ToBeFalse;
-    readonly toBeFalsy: ToBeFalsy;
-    readonly toBeNaN: ToBeNaN;
-    readonly toBeNegativeInfinity: ToBeNegativeInfinity;
-    readonly toBeNull: ToBeNull;
-    readonly toBePositiveInfinity: ToBePositiveInfinity;
-    readonly toBeTrue: ToBeTrue;
-    readonly toBeTruthy: ToBeTruthy;
-    readonly toBeUndefined: ToBeUndefined;
+import { toBeRejected, toBeRejectedWithError, toBeResolved } from './async';
+import { toBeA, toBeCloseTo, toBeError, toBeGreaterThan, toBeGreaterThanOrEqual, toBeInstanceOf, toBeLessThan, toBeLessThanOrEqual, toBeWithinRange, toEqual, toHaveLength, toHaveProperty, toHaveSize, toMatch, toStrictlyEqual } from './basic';
+import { toInclude, toMatchContents } from './include';
+import { toThrow, toThrowError } from './throwing';
+import { toBeDefined, toBeFalse, toBeFalsy, toBeNaN, toBeNegativeInfinity, toBeNull, toBeNullable, toBePositiveInfinity, toBeTrue, toBeTruthy, toBeUndefined } from './trivial';
+declare const asyncExpectations: {
+    readonly toBeResolved: typeof toBeResolved;
+    readonly toBeRejected: typeof toBeRejected;
+    readonly toBeRejectedWithError: typeof toBeRejectedWithError;
 };
-/** The type of our imported expectations */
-type ExpectationsByName = typeof expectations;
-/** Infer expectations parameter from {@link Expectation} type */
-type ExpectationParameters<E> = E extends Expectation ? Parameters<E['expect']> extends [any, any, ...infer P] ? P : never : never;
-/** Infer return parameter from {@link Expectation} type */
-type ExpectationReturn<E, T> = E extends Expectation ? Expectations<T> : never;
-/** Infer expectation functions from imported {@link Expectation} instances */
-type ImportedExpectations<T = unknown> = {
-    [k in keyof ExpectationsByName]: (...args: ExpectationParameters<ExpectationsByName[k]>) => ExpectationReturn<ExpectationsByName[k], T>;
+type AsyncExpectations = typeof asyncExpectations;
+declare const syncExpectations: {
+    readonly toBeA: typeof toBeA;
+    readonly toBeCloseTo: typeof toBeCloseTo;
+    readonly toBeError: typeof toBeError;
+    readonly toBeGreaterThan: typeof toBeGreaterThan;
+    readonly toBeGreaterThanOrEqual: typeof toBeGreaterThanOrEqual;
+    readonly toBeInstanceOf: typeof toBeInstanceOf;
+    readonly toBeLessThan: typeof toBeLessThan;
+    readonly toBeLessThanOrEqual: typeof toBeLessThanOrEqual;
+    readonly toBeWithinRange: typeof toBeWithinRange;
+    readonly toEqual: typeof toEqual;
+    readonly toHaveLength: typeof toHaveLength;
+    readonly toHaveProperty: typeof toHaveProperty;
+    readonly toHaveSize: typeof toHaveSize;
+    readonly toMatch: typeof toMatch;
+    readonly toStrictlyEqual: typeof toStrictlyEqual;
+    readonly toInclude: typeof toInclude;
+    readonly toMatchContents: typeof toMatchContents;
+    readonly toThrow: typeof toThrow;
+    readonly toThrowError: typeof toThrowError;
+    readonly toBeDefined: typeof toBeDefined;
+    readonly toBeFalse: typeof toBeFalse;
+    readonly toBeFalsy: typeof toBeFalsy;
+    readonly toBeNaN: typeof toBeNaN;
+    readonly toBeNegativeInfinity: typeof toBeNegativeInfinity;
+    readonly toBeNull: typeof toBeNull;
+    readonly toBeNullable: typeof toBeNullable;
+    readonly toBePositiveInfinity: typeof toBePositiveInfinity;
+    readonly toBeTrue: typeof toBeTrue;
+    readonly toBeTruthy: typeof toBeTruthy;
+    readonly toBeUndefined: typeof toBeUndefined;
 };
-/** An interface describing all expectations returned by `expect(...)` */
-export interface Expectations<T = unknown> extends ImportedExpectations<T> {
-    /**
-     * The parent of this instance, if and only if this is a child derived from
-     * a property of the parent instance's value.
-     */
-    parent?: ExpectationsParent;
-    /** The value this {@link Expectations} instance operates on */
-    value: T;
-    /** The _negated_ expectations of _this_ {@link Expectations} instance. */
-    not: Expectations<T>;
-    /**
-     * Programmatically return _positive_ or _negative_ {@link Expectations}
-     * for the value wrapped by this instance.
-     */
-    negated(negative: boolean): Expectations<T>;
-    /** Create an {@link Expectations} associated with a property of this value */
-    forProperty(prop: string | number | symbol): Expectations;
-    /** Create a new {@link Expectations} instance for the specified value */
-    forValue<T = unknown>(value: T): Expectations<T>;
-    /** Expect the value to be a _resolved_ {@link Promise} */
-    toBeResolved(): Promise<ExpectationsImpl<T>>;
-    /**
-     * Expect the value to be a _resolved_ {@link Promise}, and assert the
-     * resolved result with the specified callback
-     */
-    toBeResolved(assert: (resultExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
-    /** Expect the value to be a _rejected_ {@link Promise} */
-    toBeRejected(): Promise<ExpectationsImpl<T>>;
-    /**
-     * Expect the value to be a _rejected_ {@link Promise}, and assert the
-     * rejected reason with the specified callback
-     */
-    toBeRejected(assert?: (rejectionExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
-    /** Expect the value to be a {@link Promise} _rejected_ by an {@link Error} */
-    toBeRejectedWithError(): Promise<Expectations<T>>;
-    /**
-     * Expect the value to be a {@link Promise} _rejected_ by an {@link Error}
-     * with the specified _message_
-     */
-    toBeRejectedWithError(message: StringMatcher): Promise<Expectations<T>>;
-    /**
-     * Expect the value to be a {@link Promise} _rejected_ by an {@link Error}
-     * of the specified _type_
-     */
-    toBeRejectedWithError(constructor: Constructor<Error>): Promise<Expectations<T>>;
-    /**
-     * Expect the value to be a {@link Promise} _rejected_ by an {@link Error}
-     * of the specified _type_ and with the specified _message_
-     */
-    toBeRejectedWithError(constructor: Constructor<Error>, message: StringMatcher): Promise<Expectations<T>>;
-}
-/** Parent expectations */
-export interface ExpectationsParent {
-    context: Expectations;
-    prop: string | number | symbol;
-}
-/** Basic definition of an {@link Expectation} as an object */
-export interface Expectation {
-    expect(context: Expectations, negative: boolean, ...args: any[]): void;
-}
-/** Empty interface: the `class` below won't complain about missing stuff */
-interface ExpectationsImpl<T = unknown> extends Expectations<T> {
+type SyncExpectations = typeof syncExpectations;
+type AllExpectations = SyncExpectations & AsyncExpectations;
+/** Combine the arguments of a number of overloads (tuples) */
+type OverloadArguments<T> = T extends readonly [infer T, ...infer Rest] ? [
+    T,
+    ...OverloadArguments<Rest>
+] : T extends readonly [] ? [] : T extends readonly (infer T)[] ? unknown extends T ? never : T extends undefined ? [] : [
+    T
+] : never;
+/**
+ * Remap `Functions` (a record of functions) inferring arguments and forcing
+ * return type to `Result`
+ */
+type OverloadFunctions<Functions, Result> = {
+    [k in keyof Functions]: Functions[k] extends {
+        (...args: infer A0): any;
+        (...args: infer A1): any;
+        (...args: infer A2): any;
+        (...args: infer A3): any;
+        (...args: infer A4): any;
+        (...args: infer A5): any;
+    } ? (...args: OverloadArguments<A0 | A1 | A2 | A3 | A4 | A5>) => Result : Functions[k] extends {
+        (...args: infer A0): any;
+        (...args: infer A1): any;
+        (...args: infer A2): any;
+        (...args: infer A3): any;
+        (...args: infer A4): any;
+    } ? (...args: OverloadArguments<A0 | A1 | A2 | A3 | A4>) => Result : Functions[k] extends {
+        (...args: infer A0): any;
+        (...args: infer A1): any;
+        (...args: infer A2): any;
+        (...args: infer A3): any;
+    } ? (...args: OverloadArguments<A0 | A1 | A2 | A3>) => Result : Functions[k] extends {
+        (...args: infer A0): any;
+        (...args: infer A1): any;
+        (...args: infer A2): any;
+    } ? (...args: OverloadArguments<A0 | A1 | A2>) => Result : Functions[k] extends {
+        (...args: infer A0): any;
+        (...args: infer A1): any;
+    } ? (...args: OverloadArguments<A0 | A1>) => Result : Functions[k] extends {
+        (...args: infer A0): any;
+    } ? (...args: OverloadArguments<A0>) => Result : never;
+};
+/**
+ * Expectation functions simply check a _value_, but do not alter the type
+ * returned by each expectation.
+ */
+export interface ExpectationFunctions<T> extends OverloadFunctions<AsyncExpectations, Promise<Expectations<PromiseLike<T>>>>, OverloadFunctions<SyncExpectations, Expectations<T>> {
 }
-/** Implementation of our {@link Expectations} interface */
-declare class ExpectationsImpl<T = unknown> implements Expectations<T> {
+/**
+ * An interface describing all expectations returned by `expect(...)`.
+ *
+ * Each function, upon checking, might return an expectation bound to a
+ * different _type_ (for example `.toBeNull()` returns always
+ * `Expectations<null>`, inferring that `value` is indeed `null`).
+ */
+export interface Expectations<T = unknown> extends AllExpectations {
+    /** The value this {@link Expectations} instance operates on */
     readonly value: T;
-    private readonly _positiveExpectations;
-    private readonly _negativeExpectations;
-    private readonly _negative;
-    constructor(value: T, _positiveExpectations?: ExpectationsImpl<T>);
-    forProperty(prop: string | number | symbol): ExpectationsImpl;
-    forValue<T = unknown>(value: T): ExpectationsImpl<T>;
-    negated(negative: boolean): ExpectationsImpl<T>;
-    get not(): ExpectationsImpl<T>;
-    toBeResolved(assert?: (resultExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
-    toBeRejected(assert?: (reasonExpectations: Expectations) => void): Promise<ExpectationsImpl<T>>;
-    toBeRejectedWithError(...args: [] | [message: StringMatcher] | [constructor: Constructor<Error>] | [constructor: Constructor<Error>, message: StringMatcher]): Promise<ExpectationsImpl<T>>;
+    /** The _negated_ expectations of _this_ {@link Expectations} instance. */
+    readonly not: ExpectationFunctions<T>;
 }
-/** Infer return parameter from {@link Expectation} type */
-type MatcherReturn<E> = E extends Expectation ? ExpectationsMatcher : never;
-/** Infer expectation functions from imported {@link Expectation} instances */
-type ImportedMatchers = {
-    [k in keyof ExpectationsByName]: (...args: ExpectationParameters<ExpectationsByName[k]>) => MatcherReturn<ExpectationsByName[k]>;
-};
 /** An interface describing all expectations returned by `expect(...)` */
-export interface ExpectationsMatcher extends ImportedMatchers {
-    not: ExpectationsMatcher;
+export interface Matchers extends OverloadFunctions<SyncExpectations, Matchers> {
+    not: Matchers;
     expect(value: unknown): void;
 }
 /** The `expect` function exposing expectations and matchers */
-export declare const expect: ExpectationsMatcher & (<T = unknown>(value: T) => Expectations<T>);
+export declare const expect: Matchers & (<T = unknown>(value: T) => Expectations<T>);
 export {};