@overkill-dev/engine 0.0.1 → 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Overkill contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/assertion-protocol/assertion-evaluation.d.ts

@@ -0,0 +1,13 @@
+import { type ComparisonResult } from '../compare/comparison.ts';
+import type { SerializedValue } from '../compare/serialized-value.ts';
+import type { Diff, DiffPathSegment } from '../diff/diff-shape.ts';
+export type AssertionOutcome = {
+    readonly actual: SerializedValue;
+    readonly diff: Diff | null;
+    readonly expected: SerializedValue;
+    readonly passed: boolean;
+    readonly path: readonly DiffPathSegment[];
+};
+export declare const assertionOutcome: (actual: unknown, expected: unknown, passed: boolean) => AssertionOutcome;
+export declare function comparisonOutcome(comparison: ComparisonResult): AssertionOutcome;
+//# sourceMappingURL=assertion-evaluation.d.ts.map

package/assertion-protocol/assertion-evaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-evaluation.d.ts","sourceRoot":"","sources":["../../../../source/assertion-protocol/assertion-evaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAqB,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,eAAe,EAAE,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,KAAK,gBACnE,CAAC;AAEtB,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,gBAAgB,GAAG,gBAAgB,CAEhF"}

package/assertion-protocol/assertion-evaluation.js

@@ -0,0 +1,6 @@
+import { serializedOutcome } from "../compare/comparison.js";
+export const assertionOutcome = serializedOutcome;
+export function comparisonOutcome(comparison) {
+    return comparison;
+}
+//# sourceMappingURL=assertion-evaluation.js.map

package/assertion-protocol/assertion-evaluation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-evaluation.js","sourceRoot":"","sources":["../../../../source/assertion-protocol/assertion-evaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAYpF,MAAM,CAAC,MAAM,gBAAgB,GACzB,iBAAiB,CAAC;AAEtB,MAAM,UAAU,iBAAiB,CAAC,UAA4B;IAC1D,OAAO,UAAU,CAAC;AACtB,CAAC"}

package/assertion-protocol/assertion-node-shape.d.ts

@@ -0,0 +1,71 @@
+import type { SerializedValue } from '../compare/serialized-value.ts';
+import type { Diff, DiffPathSegment } from '../diff/diff-shape.ts';
+import type { ThrownErrorRecord } from './thrown-error-record.ts';
+export declare const assertionSources: readonly ["assert", "require"];
+export type NonEmptyReadonlyArray<Item> = readonly [Item, ...(readonly Item[])];
+export type AssertionSource = (typeof assertionSources)[number];
+type PrimitiveValueByType = {
+    readonly bigint: bigint;
+    readonly boolean: boolean;
+    readonly null: null;
+    readonly number: number;
+    readonly string: string;
+    readonly symbol: symbol;
+    readonly undefined: undefined;
+};
+type PrimitiveValue = PrimitiveValueByType[keyof PrimitiveValueByType];
+type IsAny<Value> = 0 extends Value & 1 ? true : false;
+type DeepComparableKnownValue<Value> = [Extract<Value, PrimitiveValue>] extends [never] ? Value : never;
+type DeepComparableUnknownValue<Value> = unknown extends Value ? unknown : DeepComparableKnownValue<Value>;
+export type DeepComparable<Value = unknown> = IsAny<Value> extends true ? never : DeepComparableUnknownValue<Value>;
+export type AssertionOptions = {
+    readonly message: string;
+};
+export type SourceLocation = {
+    readonly column: number | null;
+    readonly file: string;
+    readonly line: number | null;
+};
+export type SourceLocationProvider = () => SourceLocation;
+export type ResolvableSourceLocation = SourceLocation | SourceLocationProvider;
+type FailedCheckBase = {
+    readonly actual: SerializedValue;
+    readonly diff: Diff | null;
+    readonly expected: SerializedValue;
+    readonly id: string;
+    readonly location: SourceLocation;
+    readonly path: readonly DiffPathSegment[];
+    readonly source: AssertionSource;
+    readonly summary: string;
+};
+export type FailedLeafCheck = FailedCheckBase & {
+    readonly kind: 'leaf';
+};
+export type FailedCompositeCheck = FailedCheckBase & {
+    readonly children: NonEmptyReadonlyArray<FailedCheck>;
+    readonly kind: 'composite';
+};
+export type FailedForeignCheck = FailedCheckBase & {
+    readonly error: ThrownErrorRecord;
+    readonly kind: 'foreign';
+    readonly label: string;
+};
+export type FailedCheck = FailedCompositeCheck | FailedForeignCheck | FailedLeafCheck;
+export type InstanceConstructor = abstract new (...args: never[]) => unknown;
+export type ActualAssertionNode<Source extends AssertionSource, Check extends string> = {
+    readonly actual: unknown;
+    readonly check: Check;
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly source: Source;
+};
+export type ExpectedAssertionNode<Source extends AssertionSource, Check extends string> = {
+    readonly actual: unknown;
+    readonly check: Check;
+    readonly expected: unknown;
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly source: Source;
+};
+export {};
+//# sourceMappingURL=assertion-node-shape.d.ts.map

package/assertion-protocol/assertion-node-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-node-shape.d.ts","sourceRoot":"","sources":["../../../../source/assertion-protocol/assertion-node-shape.ts"],"names":[],"mappings":"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"}

package/assertion-protocol/assertion-node.d.ts

@@ -0,0 +1,97 @@
+import { type FalseAssertionNode, type TrueAssertionNode } from './assertions/boolean.ts';
+import { type EmptinessAssertionNode, type LengthAssertionNode } from './assertions/collection.ts';
+import { type DeepEqualAssertionNode, type EqualAssertionNode, type NotDeepEqualAssertionNode, type NotEqualAssertionNode } from './assertions/equality.ts';
+import { type FailAssertionNode } from './assertions/fail.ts';
+import { type BetweenAssertionNode, type NumericComparisonAssertionNode } from './assertions/numeric.ts';
+import { type ArrayContainsPartialAssertionNode, type MembersPartialDeepEqualAssertionNode, type PartialDeepEqualAssertionNode } from './assertions/partial.ts';
+import { type DefinedAssertionNode, type NotNullAssertionNode, type NullAssertionNode, type UndefinedAssertionNode } from './assertions/presence.ts';
+import { type MatchAssertionNode, type StringContainsAssertionNode } from './assertions/string.ts';
+import { type HasPropertyAssertionNode, type InstanceOfAssertionNode, type TypeAssertionNode } from './assertions/type-shape.ts';
+import type { AssertionSource, NonEmptyReadonlyArray, ResolvableSourceLocation } from './assertion-node-shape.ts';
+type ForeignAssertionErrorRecord = {
+    readonly message: string;
+    readonly name: string;
+    readonly stack: string | null;
+    readonly thrown: unknown;
+};
+type RequireAssertionNodeByName = {
+    readonly defined: DefinedAssertionNode<'require'>;
+    readonly hasProperty: HasPropertyAssertionNode<'require'>;
+    readonly instanceOf: InstanceOfAssertionNode<'require'>;
+    readonly notNull: NotNullAssertionNode<'require'>;
+    readonly null: NullAssertionNode<'require'>;
+    readonly type: TypeAssertionNode<'require'>;
+};
+type BuiltInAssertAssertionNodeByName<Source extends AssertionSource> = {
+    readonly arrayContainsPartial: ArrayContainsPartialAssertionNode<Source>;
+    readonly between: BetweenAssertionNode<Source>;
+    readonly deepEqual: DeepEqualAssertionNode<Source>;
+    readonly defined: DefinedAssertionNode<Source>;
+    readonly emptiness: EmptinessAssertionNode<Source>;
+    readonly equal: EqualAssertionNode<Source>;
+    readonly fail: FailAssertionNode<Source>;
+    readonly false: FalseAssertionNode<Source>;
+    readonly hasProperty: HasPropertyNode<Source>;
+    readonly instanceOf: InstanceOfAssertionNode<Source>;
+    readonly length: LengthAssertionNode<Source>;
+    readonly match: MatchAssertionNode<Source>;
+    readonly membersPartialDeepEqual: MembersPartialDeepEqualAssertionNode<Source>;
+    readonly notDeepEqual: NotDeepEqualAssertionNode<Source>;
+    readonly notEqual: NotEqualAssertionNode<Source>;
+    readonly notNull: NotNullAssertionNode<Source>;
+    readonly null: NullAssertionNode<Source>;
+    readonly numericComparison: NumericComparisonAssertionNode<Source>;
+    readonly partialDeepEqual: PartialDeepEqualAssertionNode<Source>;
+    readonly stringContains: StringContainsAssertionNode<Source>;
+    readonly true: TrueAssertionNode<Source>;
+    readonly type: TypeAssertionNode<Source>;
+    readonly undefined: UndefinedAssertionNode<Source>;
+};
+type HasPropertyNode<Source extends AssertionSource> = HasPropertyAssertionNode<Source>;
+export type BuiltInAssertAssertionNode<Source extends AssertionSource = 'assert'> = BuiltInAssertAssertionNodeByName<Source>[keyof BuiltInAssertAssertionNodeByName<Source>];
+type ForeignAssertionResultByOutcome = {
+    readonly fail: {
+        readonly error: ForeignAssertionErrorRecord;
+        readonly passed: false;
+    };
+    readonly pass: {
+        readonly passed: true;
+    };
+};
+export type ForeignAssertionResult = ForeignAssertionResultByOutcome[keyof ForeignAssertionResultByOutcome];
+export type ForeignAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly check: 'foreign';
+    readonly label: string;
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly result: ForeignAssertionResult;
+    readonly source: Source;
+    readonly summary: string;
+};
+type CompositeAssertionChildNodeByKind<Source extends AssertionSource> = {
+    readonly builtIn: BuiltInAssertAssertionNode<Source>;
+    readonly foreign: ForeignAssertionNode<Source>;
+};
+export type CompositeAssertionChildNode<Source extends AssertionSource = AssertionSource> = CompositeAssertionChildNodeByKind<Source>[keyof CompositeAssertionChildNodeByKind<Source>];
+export type CompositeAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly actual: unknown;
+    readonly check: 'composite';
+    readonly children: NonEmptyReadonlyArray<CompositeAssertionChildNode<Source>>;
+    readonly expected: unknown;
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly name: string;
+    readonly source: Source;
+    readonly summary: string;
+};
+type RequireAssertionNodeByKind = RequireAssertionNodeByName & {
+    readonly composite: CompositeAssertionNode<'require'>;
+};
+export type RequireAssertionNode = RequireAssertionNodeByKind[keyof RequireAssertionNodeByKind];
+export type AssertAssertionNode = BuiltInAssertAssertionNode | CompositeAssertionNode<'assert'>;
+export type AssertionNode = AssertAssertionNode | RequireAssertionNode;
+export type AssertionResult = AssertAssertionNode | NonEmptyReadonlyArray<AssertAssertionNode>;
+type SummarizedAssertionNode = AssertionNode | CompositeAssertionChildNode | CompositeAssertionNode;
+export declare function assertionSummary(assertion: SummarizedAssertionNode): string;
+export {};
+//# sourceMappingURL=assertion-node.d.ts.map

package/assertion-protocol/assertion-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-node.d.ts","sourceRoot":"","sources":["../../../../source/assertion-protocol/assertion-node.ts"],"names":[],"mappings":"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"}

package/assertion-protocol/assertion-node.js

@@ -0,0 +1,33 @@
+import { booleanSummaryByCheck } from "./assertions/boolean.js";
+import { collectionSummaryByCheck } from "./assertions/collection.js";
+import { equalitySummaryByCheck } from "./assertions/equality.js";
+import { failSummaryByCheck } from "./assertions/fail.js";
+import { numericSummaryByCheck } from "./assertions/numeric.js";
+import { partialSummaryByCheck } from "./assertions/partial.js";
+import { presenceSummaryByCheck } from "./assertions/presence.js";
+import { stringSummaryByCheck } from "./assertions/string.js";
+import { typeShapeSummaryByCheck } from "./assertions/type-shape.js";
+const defaultSummaryByCheck = {
+    ...booleanSummaryByCheck,
+    ...collectionSummaryByCheck,
+    ...equalitySummaryByCheck,
+    ...failSummaryByCheck,
+    ...numericSummaryByCheck,
+    ...partialSummaryByCheck,
+    ...presenceSummaryByCheck,
+    ...stringSummaryByCheck,
+    ...typeShapeSummaryByCheck
+};
+function isCompositeAssertion(assertion) {
+    return assertion.check === 'composite';
+}
+export function assertionSummary(assertion) {
+    if (isCompositeAssertion(assertion)) {
+        return assertion.message ?? assertion.summary;
+    }
+    if (assertion.check === 'foreign') {
+        return assertion.message ?? assertion.summary;
+    }
+    return assertion.message ?? defaultSummaryByCheck[assertion.check];
+}
+//# sourceMappingURL=assertion-node.js.map

package/assertion-protocol/assertion-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-node.js","sourceRoot":"","sources":["../../../../source/assertion-protocol/assertion-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAmD,MAAM,yBAAyB,CAAC;AACjH,OAAO,EACH,wBAAwB,EAG3B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACH,sBAAsB,EAKzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAA0B,MAAM,sBAAsB,CAAC;AAClF,OAAO,EACH,qBAAqB,EAGxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACH,qBAAqB,EAIxB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACH,sBAAsB,EAKzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACH,oBAAoB,EAGvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACH,uBAAuB,EAI1B,MAAM,4BAA4B,CAAC;AA6GpC,MAAM,qBAAqB,GAAkE;IACzF,GAAG,qBAAqB;IACxB,GAAG,wBAAwB;IAC3B,GAAG,sBAAsB;IACzB,GAAG,kBAAkB;IACrB,GAAG,qBAAqB;IACxB,GAAG,qBAAqB;IACxB,GAAG,sBAAsB;IACzB,GAAG,oBAAoB;IACvB,GAAG,uBAAuB;CAC7B,CAAC;AAIF,SAAS,oBAAoB,CACzB,SAAkC;IAElC,OAAO,SAAS,CAAC,KAAK,KAAK,WAAW,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,SAAkC;IAC/D,IAAI,oBAAoB,CAAC,SAAS,CAAC,EAAE,CAAC;QAClC,OAAO,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC;IAClD,CAAC;IAED,IAAI,SAAS,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAChC,OAAO,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC;IAClD,CAAC;IAED,OAAO,SAAS,CAAC,OAAO,IAAI,qBAAqB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AACvE,CAAC"}

package/assertion-protocol/assertion-reference.d.ts

@@ -0,0 +1,73 @@
+import type { CompositeAssertionChildNode } from './assertion-node.ts';
+import type { AssertionSource, NonEmptyReadonlyArray, ResolvableSourceLocation } from './assertion-node-shape.ts';
+declare const assertionReferenceIdentity: unique symbol;
+declare const assertionReferenceRecordIdentity: unique symbol;
+declare const compositeGroupIdentity: unique symbol;
+export type CompositeAssertionSummaryContext = {
+    readonly name: string;
+    readonly source: AssertionSource;
+};
+export type CompositeAssertionGroup<Source extends AssertionSource = AssertionSource> = {
+    readonly [compositeGroupIdentity]: true;
+    readonly children: NonEmptyReadonlyArray<CompositeAssertionChildNode<Source>>;
+};
+type CompositeAssertionReturnByKind<Source extends AssertionSource> = {
+    readonly child: CompositeAssertionChildNode<Source>;
+    readonly group: CompositeAssertionGroup<Source>;
+};
+export type CompositeAssertionReturn<Source extends AssertionSource = AssertionSource> = CompositeAssertionReturnByKind<Source>[keyof CompositeAssertionReturnByKind<Source>];
+type PromiseCompositeAssertionReturn = Promise<CompositeAssertionReturn<'assert'>>;
+export type AssertCompositeAssertionReturn = CompositeAssertionReturn<'assert'> | PromiseCompositeAssertionReturn;
+type SyncAssertionReturn = ReturnType<() => void>;
+export type CompositeAssertionSummaryFormatter<Arguments extends readonly unknown[]> = (context: CompositeAssertionSummaryContext, ...parameters: Arguments) => string;
+export type NarrowingCompositeAssertionSummaryFormatter<Actual, Arguments extends readonly unknown[]> = (context: CompositeAssertionSummaryContext, actual: Actual, ...parameters: Arguments) => string;
+export type CompositeAssertionRunnerInput<Arguments extends readonly unknown[], Source extends AssertionSource> = {
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly parameters: Arguments;
+    readonly source: Source;
+};
+export type CompositeAssertionReferenceRecord<Arguments extends readonly unknown[] = readonly unknown[], Result extends AssertCompositeAssertionReturn = AssertCompositeAssertionReturn> = {
+    readonly formatSummary: CompositeAssertionSummaryFormatter<Arguments> | null;
+    readonly kind: 'composite';
+    readonly name: string;
+    readonly run: (input: CompositeAssertionRunnerInput<Arguments, 'assert'>) => Result;
+};
+export type NarrowingCompositeAssertionReferenceRecord<Actual = unknown, Narrowed extends Actual = Actual, Arguments extends readonly unknown[] = readonly unknown[]> = {
+    readonly formatSummary: NarrowingCompositeAssertionSummaryFormatter<Actual, Arguments> | null;
+    readonly kind: 'narrowing-composite';
+    readonly name: string;
+    readonly narrows: (actual: Actual, ...parameters: Arguments) => actual is Narrowed;
+};
+export type AssertionReferenceRecord = CompositeAssertionReferenceRecord | NarrowingCompositeAssertionReferenceRecord;
+export type CompositeAssertionReference<Arguments extends readonly unknown[] = readonly unknown[], Result extends AssertCompositeAssertionReturn = AssertCompositeAssertionReturn> = {
+    readonly [assertionReferenceIdentity]: true;
+    readonly [assertionReferenceRecordIdentity]: CompositeAssertionReferenceRecord<Arguments, Result>;
+};
+export type NarrowingCompositeAssertionReference<Actual = unknown, Narrowed extends Actual = Actual, Arguments extends readonly unknown[] = readonly unknown[]> = {
+    readonly [assertionReferenceIdentity]: true;
+    readonly [assertionReferenceRecordIdentity]: NarrowingCompositeAssertionReferenceRecord<Actual, Narrowed, Arguments>;
+};
+export type AssertionReference = CompositeAssertionReference | NarrowingCompositeAssertionReference;
+type NarrowingReferenceArguments<Actual, Arguments extends readonly unknown[]> = readonly [
+    actual: Actual,
+    ...parameters: Arguments
+];
+type ReferenceArguments<Reference> = Reference extends NarrowingCompositeAssertionReference<infer Actual, infer Narrowed, infer Arguments> ? NarrowingReferenceArguments<Actual | Narrowed, Arguments> : never;
+type ReferenceReturn<Result> = Result extends Promise<CompositeAssertionReturn<'assert'>> ? Promise<void> : SyncAssertionReturn;
+type ReadonlyParameters<Arguments extends readonly unknown[]> = readonly [...Arguments];
+export type AssertReferenceArguments<Reference> = Reference extends CompositeAssertionReference<infer Arguments> ? ReadonlyParameters<Arguments> : ReferenceArguments<Reference>;
+export type AssertReferenceReturn<Reference> = Reference extends CompositeAssertionReference<infer Arguments, infer Result> ? Arguments extends readonly unknown[] ? ReferenceReturn<Result> : never : SyncAssertionReturn;
+export declare function createAssertionReferenceRecord<Arguments extends readonly unknown[], Result extends AssertCompositeAssertionReturn>(record: CompositeAssertionReferenceRecord<Arguments, Result>): CompositeAssertionReference<Arguments, Result>;
+export declare function createAssertionReferenceRecord<Actual, Narrowed extends Actual, Arguments extends readonly unknown[]>(record: NarrowingCompositeAssertionReferenceRecord<Actual, Narrowed, Arguments>): NarrowingCompositeAssertionReference<Actual, Narrowed, Arguments>;
+export declare function createCompositeAssertionReferenceRecord<Arguments extends readonly unknown[], Result extends AssertCompositeAssertionReturn>(record: CompositeAssertionReferenceRecord<Arguments, Result>): CompositeAssertionReference<Arguments, Result>;
+export declare function createNarrowingCompositeAssertionReferenceRecord<Actual, Narrowed extends Actual, Arguments extends readonly unknown[]>(record: NarrowingCompositeAssertionReferenceRecord<Actual, Narrowed, Arguments>): NarrowingCompositeAssertionReference<Actual, Narrowed, Arguments>;
+export declare function getAssertionReferenceRecord(reference: AssertionReference): AssertionReferenceRecord;
+export declare function getCompositeAssertionReferenceRecord<Arguments extends readonly unknown[], Result extends AssertCompositeAssertionReturn>(reference: CompositeAssertionReference<Arguments, Result>): CompositeAssertionReferenceRecord<Arguments, Result>;
+export declare function getNarrowingAssertionReferenceRecord<Actual, Narrowed extends Actual, Arguments extends readonly unknown[]>(reference: NarrowingCompositeAssertionReference<Actual, Narrowed, Arguments>): NarrowingCompositeAssertionReferenceRecord<Actual, Narrowed, Arguments>;
+export declare function isAssertionReference(value: unknown): value is AssertionReference;
+export declare function isNarrowingAssertionReference(value: unknown): value is NarrowingCompositeAssertionReference;
+export declare function isCompositeAssertionGroup<Source extends AssertionSource>(value: unknown): value is CompositeAssertionGroup<Source>;
+export declare function createCompositeAssertionGroup<Source extends AssertionSource>(children: NonEmptyReadonlyArray<CompositeAssertionChildNode<Source>>): CompositeAssertionGroup<Source>;
+export {};
+//# sourceMappingURL=assertion-reference.d.ts.map

package/assertion-protocol/assertion-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-reference.d.ts","sourceRoot":"","sources":["../../../../source/assertion-protocol/assertion-reference.ts"],"names":[],"mappings":"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"}

package/assertion-protocol/assertion-reference.js

@@ -0,0 +1,49 @@
+const assertionReferenceIdentity = Symbol.for('OverkillAssertionReference');
+const assertionReferenceRecordIdentity = Symbol.for('OverkillAssertionReferenceRecord');
+const compositeGroupIdentity = Symbol.for('OverkillCompositeGroup');
+function ensureAssertionName(name) {
+    if (name.trim().length === 0) {
+        throw new TypeError('Assertion reference name must not be empty.');
+    }
+}
+export function createAssertionReferenceRecord(record) {
+    ensureAssertionName(record.name);
+    if (record.kind === 'composite') {
+        return {
+            [assertionReferenceIdentity]: true,
+            [assertionReferenceRecordIdentity]: record
+        };
+    }
+    return {
+        [assertionReferenceIdentity]: true,
+        [assertionReferenceRecordIdentity]: record
+    };
+}
+export function createCompositeAssertionReferenceRecord(record) {
+    return createAssertionReferenceRecord({ ...record });
+}
+export function createNarrowingCompositeAssertionReferenceRecord(record) {
+    return createAssertionReferenceRecord({ ...record });
+}
+export function getAssertionReferenceRecord(reference) {
+    return reference[assertionReferenceRecordIdentity];
+}
+export function getCompositeAssertionReferenceRecord(reference) {
+    return reference[assertionReferenceRecordIdentity];
+}
+export function getNarrowingAssertionReferenceRecord(reference) {
+    return reference[assertionReferenceRecordIdentity];
+}
+export function isAssertionReference(value) {
+    return typeof value === 'object' && value !== null && Object.hasOwn(value, assertionReferenceIdentity);
+}
+export function isNarrowingAssertionReference(value) {
+    return isAssertionReference(value) && getAssertionReferenceRecord(value).kind === 'narrowing-composite';
+}
+export function isCompositeAssertionGroup(value) {
+    return typeof value === 'object' && value !== null && Object.hasOwn(value, compositeGroupIdentity);
+}
+export function createCompositeAssertionGroup(children) {
+    return { [compositeGroupIdentity]: true, children };
+}
+//# sourceMappingURL=assertion-reference.js.map

package/assertion-protocol/assertion-reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-reference.js","sourceRoot":"","sources":["../../../../source/assertion-protocol/assertion-reference.ts"],"names":[],"mappings":"AASA,MAAM,0BAA0B,GAAkB,MAAM,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;AAC3F,MAAM,gCAAgC,GAAkB,MAAM,CAAC,GAAG,CAAC,kCAAkC,CAAC,CAAC;AACvG,MAAM,sBAAsB,GAAkB,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;AAyHnF,SAAS,mBAAmB,CAAC,IAAY;IACrC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,SAAS,CAAC,6CAA6C,CAAC,CAAC;IACvE,CAAC;AACL,CAAC;AAaD,MAAM,UAAU,8BAA8B,CAAC,MAAgC;IAC3E,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAEjC,IAAI,MAAM,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QAC9B,OAAO;YACH,CAAC,0BAA0B,CAAC,EAAE,IAAI;YAClC,CAAC,gCAAgC,CAAC,EAAE,MAAM;SAC7C,CAAC;IACN,CAAC;IAED,OAAO;QACH,CAAC,0BAA0B,CAAC,EAAE,IAAI;QAClC,CAAC,gCAAgC,CAAC,EAAE,MAAM;KAC7C,CAAC;AACN,CAAC;AAED,MAAM,UAAU,uCAAuC,CAGrD,MAA4D;IAC1D,OAAO,8BAA8B,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,gDAAgD,CAK5D,MAA+E;IAE/E,OAAO,8BAA8B,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;AACzD,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAC,SAA6B;IACrE,OAAO,SAAS,CAAC,gCAAgC,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,oCAAoC,CAIhD,SAAyD;IAEzD,OAAO,SAAS,CAAC,gCAAgC,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,oCAAoC,CAKhD,SAA4E;IAE5E,OAAO,SAAS,CAAC,gCAAgC,CAAC,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,KAAc;IAC/C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,0BAA0B,CAAC,CAAC;AAC3G,CAAC;AAED,MAAM,UAAU,6BAA6B,CAAC,KAAc;IACxD,OAAO,oBAAoB,CAAC,KAAK,CAAC,IAAI,2BAA2B,CAAC,KAAK,CAAC,CAAC,IAAI,KAAK,qBAAqB,CAAC;AAC5G,CAAC;AAED,MAAM,UAAU,yBAAyB,CACrC,KAAc;IAEd,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,sBAAsB,CAAC,CAAC;AACvG,CAAC;AAED,MAAM,UAAU,6BAA6B,CACzC,QAAoE;IAEpE,OAAO,EAAE,CAAC,sBAAsB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AACxD,CAAC"}

package/assertion-protocol/assertions/boolean.d.ts

@@ -0,0 +1,11 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { ActualAssertionNode, AssertionSource } from '../assertion-node-shape.ts';
+export type TrueAssertionNode<Source extends AssertionSource = AssertionSource> = ActualAssertionNode<Source, 'true'>;
+export type FalseAssertionNode<Source extends AssertionSource = AssertionSource> = ActualAssertionNode<Source, 'false'>;
+export declare const booleanSummaryByCheck: {
+    readonly false: "Expected value to be false.";
+    readonly true: "Expected value to be true.";
+};
+export declare function evaluateFalse(assertion: FalseAssertionNode): AssertionOutcome;
+export declare function evaluateTrue(assertion: TrueAssertionNode): AssertionOutcome;
+//# sourceMappingURL=boolean.d.ts.map

package/assertion-protocol/assertions/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAEvF,MAAM,MAAM,iBAAiB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtH,MAAM,MAAM,kBAAkB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAExH,eAAO,MAAM,qBAAqB;;;CAGxB,CAAC;AAEX,wBAAgB,aAAa,CAAC,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,CAE7E;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE3E"}

package/assertion-protocol/assertions/boolean.js

@@ -0,0 +1,12 @@
+import { assertionOutcome } from "../assertion-evaluation.js";
+export const booleanSummaryByCheck = {
+    false: 'Expected value to be false.',
+    true: 'Expected value to be true.'
+};
+export function evaluateFalse(assertion) {
+    return assertionOutcome(assertion.actual, false, assertion.actual === false);
+}
+export function evaluateTrue(assertion) {
+    return assertionOutcome(assertion.actual, true, assertion.actual === true);
+}
+//# sourceMappingURL=boolean.js.map

package/assertion-protocol/assertions/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAOrF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACjC,KAAK,EAAE,6BAA6B;IACpC,IAAI,EAAE,4BAA4B;CAC5B,CAAC;AAEX,MAAM,UAAU,aAAa,CAAC,SAA6B;IACvD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;AACjF,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,SAA4B;IACrD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC;AAC/E,CAAC"}

package/assertion-protocol/assertions/collection.d.ts

@@ -0,0 +1,22 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { ActualAssertionNode, AssertionSource, ResolvableSourceLocation } from '../assertion-node-shape.ts';
+export type LengthAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly actual: unknown;
+    readonly check: 'length';
+    readonly expectedLength: number;
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly source: Source;
+};
+export type EmptinessAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly [Check in 'empty' | 'not-empty']: ActualAssertionNode<Source, Check>;
+}['empty' | 'not-empty'];
+export declare const collectionSummaryByCheck: {
+    readonly empty: "Expected collection to be empty.";
+    readonly length: "Expected collection length to match.";
+    readonly 'not-empty': "Expected collection not to be empty.";
+};
+export declare function evaluateEmpty(assertion: EmptinessAssertionNode): AssertionOutcome;
+export declare function evaluateLength(assertion: LengthAssertionNode): AssertionOutcome;
+export declare function evaluateNotEmpty(assertion: EmptinessAssertionNode): AssertionOutcome;
+//# sourceMappingURL=collection.d.ts.map

package/assertion-protocol/assertions/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAGjH,MAAM,MAAM,mBAAmB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IAChF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IACnF,QAAQ,EAAE,KAAK,IAAI,OAAO,GAAG,WAAW,GAAG,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC;CAChF,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;AAEzB,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX,wBAAgB,aAAa,CAAC,SAAS,EAAE,sBAAsB,GAAG,gBAAgB,CAQjF;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,mBAAmB,GAAG,gBAAgB,CAS/E;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,sBAAsB,GAAG,gBAAgB,CAQpF"}

package/assertion-protocol/assertions/collection.js

@@ -0,0 +1,21 @@
+import { assertionOutcome } from "../assertion-evaluation.js";
+import { collectionCount } from "../collection-count.js";
+export const collectionSummaryByCheck = {
+    empty: 'Expected collection to be empty.',
+    length: 'Expected collection length to match.',
+    'not-empty': 'Expected collection not to be empty.'
+};
+export function evaluateEmpty(assertion) {
+    const count = collectionCount(assertion.actual, 1);
+    return assertionOutcome(count.supported ? count.count : assertion.actual, 0, count.supported && count.count === 0);
+}
+export function evaluateLength(assertion) {
+    const count = collectionCount(assertion.actual, assertion.expectedLength + 1);
+    const validLength = Number.isSafeInteger(assertion.expectedLength) && assertion.expectedLength >= 0;
+    return assertionOutcome(count.supported ? count.count : assertion.actual, assertion.expectedLength, validLength && count.supported && count.count === assertion.expectedLength);
+}
+export function evaluateNotEmpty(assertion) {
+    const count = collectionCount(assertion.actual, 1);
+    return assertionOutcome(count.supported ? count.count : assertion.actual, 'more than 0', count.supported && count.count > 0);
+}
+//# sourceMappingURL=collection.js.map

package/assertion-protocol/assertions/collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAErF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAezD,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACpC,KAAK,EAAE,kCAAkC;IACzC,MAAM,EAAE,sCAAsC;IAC9C,WAAW,EAAE,sCAAsC;CAC7C,CAAC;AAEX,MAAM,UAAU,aAAa,CAAC,SAAiC;IAC3D,MAAM,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAEnD,OAAO,gBAAgB,CACnB,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,EAChD,CAAC,EACD,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC,CACvC,CAAC;AACN,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,SAA8B;IACzD,MAAM,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,cAAc,GAAG,CAAC,CAAC,CAAC;IAC9E,MAAM,WAAW,GAAG,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,SAAS,CAAC,cAAc,IAAI,CAAC,CAAC;IAEpG,OAAO,gBAAgB,CACnB,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,EAChD,SAAS,CAAC,cAAc,EACxB,WAAW,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,cAAc,CAC7E,CAAC;AACN,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,SAAiC;IAC9D,MAAM,KAAK,GAAG,eAAe,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IAEnD,OAAO,gBAAgB,CACnB,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,EAChD,aAAa,EACb,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,KAAK,GAAG,CAAC,CACrC,CAAC;AACN,CAAC"}

package/assertion-protocol/assertions/dispatch.d.ts

@@ -0,0 +1,88 @@
+import type { AssertionOutcome } from '../assertion-evaluation.ts';
+import { type FalseAssertionNode, type TrueAssertionNode } from './boolean.ts';
+import { type EmptinessAssertionNode, type LengthAssertionNode } from './collection.ts';
+import { type DeepEqualAssertionNode, type EqualAssertionNode, type NotDeepEqualAssertionNode, type NotEqualAssertionNode } from './equality.ts';
+import { type FailAssertionNode } from './fail.ts';
+import { type BetweenAssertionNode, type NumericComparisonAssertionNode } from './numeric.ts';
+import { type ArrayContainsPartialAssertionNode, type MembersPartialDeepEqualAssertionNode, type PartialDeepEqualAssertionNode } from './partial.ts';
+import { type DefinedAssertionNode, type NotNullAssertionNode, type NullAssertionNode, type UndefinedAssertionNode } from './presence.ts';
+import { type MatchAssertionNode, type StringContainsAssertionNode } from './string.ts';
+import { type HasPropertyAssertionNode, type InstanceOfAssertionNode, type TypeAssertionNode } from './type-shape.ts';
+export type AssertionNodeByCheck = {
+    readonly array: Extract<TypeAssertionNode, {
+        readonly check: 'array';
+    }>;
+    readonly 'array-contains-partial': ArrayContainsPartialAssertionNode;
+    readonly between: BetweenAssertionNode;
+    readonly boolean: Extract<TypeAssertionNode, {
+        readonly check: 'boolean';
+    }>;
+    readonly 'deep-equal': DeepEqualAssertionNode;
+    readonly defined: DefinedAssertionNode;
+    readonly empty: Extract<EmptinessAssertionNode, {
+        readonly check: 'empty';
+    }>;
+    readonly 'ends-with': Extract<StringContainsAssertionNode, {
+        readonly check: 'ends-with';
+    }>;
+    readonly equal: EqualAssertionNode;
+    readonly fail: FailAssertionNode;
+    readonly false: FalseAssertionNode;
+    readonly function: Extract<TypeAssertionNode, {
+        readonly check: 'function';
+    }>;
+    readonly 'greater-than': Extract<NumericComparisonAssertionNode, {
+        readonly check: 'greater-than';
+    }>;
+    readonly 'greater-than-or-equal': Extract<NumericComparisonAssertionNode, {
+        readonly check: 'greater-than-or-equal';
+    }>;
+    readonly 'has-property': HasPropertyAssertionNode;
+    readonly includes: Extract<StringContainsAssertionNode, {
+        readonly check: 'includes';
+    }>;
+    readonly 'instance-of': InstanceOfAssertionNode;
+    readonly length: LengthAssertionNode;
+    readonly 'less-than': Extract<NumericComparisonAssertionNode, {
+        readonly check: 'less-than';
+    }>;
+    readonly 'less-than-or-equal': Extract<NumericComparisonAssertionNode, {
+        readonly check: 'less-than-or-equal';
+    }>;
+    readonly match: Extract<MatchAssertionNode, {
+        readonly check: 'match';
+    }>;
+    readonly 'members-partial-deep-equal': MembersPartialDeepEqualAssertionNode;
+    readonly 'not-deep-equal': NotDeepEqualAssertionNode;
+    readonly 'not-empty': Extract<EmptinessAssertionNode, {
+        readonly check: 'not-empty';
+    }>;
+    readonly 'not-equal': NotEqualAssertionNode;
+    readonly 'not-match': Extract<MatchAssertionNode, {
+        readonly check: 'not-match';
+    }>;
+    readonly 'not-null': NotNullAssertionNode;
+    readonly null: NullAssertionNode;
+    readonly number: Extract<TypeAssertionNode, {
+        readonly check: 'number';
+    }>;
+    readonly object: Extract<TypeAssertionNode, {
+        readonly check: 'object';
+    }>;
+    readonly 'partial-deep-equal': PartialDeepEqualAssertionNode;
+    readonly 'starts-with': Extract<StringContainsAssertionNode, {
+        readonly check: 'starts-with';
+    }>;
+    readonly string: Extract<TypeAssertionNode, {
+        readonly check: 'string';
+    }>;
+    readonly true: TrueAssertionNode;
+    readonly undefined: UndefinedAssertionNode;
+};
+type AssertionCheck = keyof AssertionNodeByCheck;
+export type AssertionEvaluatorByCheck = {
+    readonly [Check in AssertionCheck]: (assertion: AssertionNodeByCheck[Check]) => AssertionOutcome;
+};
+export declare const assertionEvaluatorByCheck: AssertionEvaluatorByCheck;
+export {};
+//# sourceMappingURL=dispatch.d.ts.map

package/assertion-protocol/assertions/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/dispatch.ts"],"names":[],"mappings":"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"}