@overkill-dev/engine 0.0.1 → 0.0.2

package/assertion-protocol/assertions/dispatch.js

@@ -0,0 +1,47 @@
+import { evaluateFalse, evaluateTrue } from "./boolean.js";
+import { evaluateEmpty, evaluateLength, evaluateNotEmpty } from "./collection.js";
+import { evaluateDeepEqual, evaluateEqual, evaluateNotDeepEqual, evaluateNotEqual } from "./equality.js";
+import { evaluateFail } from "./fail.js";
+import { evaluateBetween, evaluateGreaterThan, evaluateGreaterThanOrEqual, evaluateLessThan, evaluateLessThanOrEqual } from "./numeric.js";
+import { evaluateArrayContainsPartial, evaluateMembersPartialDeepEqual, evaluatePartialDeepEqual } from "./partial.js";
+import { evaluateDefined, evaluateNotNull, evaluateNull, evaluateUndefined } from "./presence.js";
+import { evaluateEndsWith, evaluateIncludes, evaluateMatch, evaluateNotMatch, evaluateStartsWith } from "./string.js";
+import { evaluateArray, evaluateBoolean, evaluateFunction, evaluateHasProperty, evaluateInstanceOf, evaluateNumber, evaluateObject, evaluateString } from "./type-shape.js";
+export const assertionEvaluatorByCheck = {
+    array: evaluateArray,
+    'array-contains-partial': evaluateArrayContainsPartial,
+    between: evaluateBetween,
+    boolean: evaluateBoolean,
+    'deep-equal': evaluateDeepEqual,
+    defined: evaluateDefined,
+    empty: evaluateEmpty,
+    'ends-with': evaluateEndsWith,
+    equal: evaluateEqual,
+    fail: evaluateFail,
+    false: evaluateFalse,
+    function: evaluateFunction,
+    'greater-than': evaluateGreaterThan,
+    'greater-than-or-equal': evaluateGreaterThanOrEqual,
+    'has-property': evaluateHasProperty,
+    includes: evaluateIncludes,
+    'instance-of': evaluateInstanceOf,
+    length: evaluateLength,
+    'less-than': evaluateLessThan,
+    'less-than-or-equal': evaluateLessThanOrEqual,
+    match: evaluateMatch,
+    'members-partial-deep-equal': evaluateMembersPartialDeepEqual,
+    'not-deep-equal': evaluateNotDeepEqual,
+    'not-empty': evaluateNotEmpty,
+    'not-equal': evaluateNotEqual,
+    'not-match': evaluateNotMatch,
+    'not-null': evaluateNotNull,
+    null: evaluateNull,
+    number: evaluateNumber,
+    object: evaluateObject,
+    'partial-deep-equal': evaluatePartialDeepEqual,
+    'starts-with': evaluateStartsWith,
+    string: evaluateString,
+    true: evaluateTrue,
+    undefined: evaluateUndefined
+};
+//# sourceMappingURL=dispatch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/dispatch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,YAAY,EAAmD,MAAM,cAAc,CAAC;AAC5G,OAAO,EACH,aAAa,EACb,cAAc,EACd,gBAAgB,EAGnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACH,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAKnB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAA0B,MAAM,WAAW,CAAC;AACjE,OAAO,EACH,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,gBAAgB,EAChB,uBAAuB,EAG1B,MAAM,cAAc,CAAC;AACtB,OAAO,EACH,4BAA4B,EAC5B,+BAA+B,EAC/B,wBAAwB,EAI3B,MAAM,cAAc,CAAC;AACtB,OAAO,EACH,eAAe,EACf,eAAe,EACf,YAAY,EACZ,iBAAiB,EAKpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACH,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAGrB,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,cAAc,EAIjB,MAAM,iBAAiB,CAAC;AAiDzB,MAAM,CAAC,MAAM,yBAAyB,GAA8B;IAChE,KAAK,EAAE,aAAa;IACpB,wBAAwB,EAAE,4BAA4B;IACtD,OAAO,EAAE,eAAe;IACxB,OAAO,EAAE,eAAe;IACxB,YAAY,EAAE,iBAAiB;IAC/B,OAAO,EAAE,eAAe;IACxB,KAAK,EAAE,aAAa;IACpB,WAAW,EAAE,gBAAgB;IAC7B,KAAK,EAAE,aAAa;IACpB,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,aAAa;IACpB,QAAQ,EAAE,gBAAgB;IAC1B,cAAc,EAAE,mBAAmB;IACnC,uBAAuB,EAAE,0BAA0B;IACnD,cAAc,EAAE,mBAAmB;IACnC,QAAQ,EAAE,gBAAgB;IAC1B,aAAa,EAAE,kBAAkB;IACjC,MAAM,EAAE,cAAc;IACtB,WAAW,EAAE,gBAAgB;IAC7B,oBAAoB,EAAE,uBAAuB;IAC7C,KAAK,EAAE,aAAa;IACpB,4BAA4B,EAAE,+BAA+B;IAC7D,gBAAgB,EAAE,oBAAoB;IACtC,WAAW,EAAE,gBAAgB;IAC7B,WAAW,EAAE,gBAAgB;IAC7B,WAAW,EAAE,gBAAgB;IAC7B,UAAU,EAAE,eAAe;IAC3B,IAAI,EAAE,YAAY;IAClB,MAAM,EAAE,cAAc;IACtB,MAAM,EAAE,cAAc;IACtB,oBAAoB,EAAE,wBAAwB;IAC9C,aAAa,EAAE,kBAAkB;IACjC,MAAM,EAAE,cAAc;IACtB,IAAI,EAAE,YAAY;IAClB,SAAS,EAAE,iBAAiB;CAC/B,CAAC"}

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

@@ -0,0 +1,17 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { AssertionSource, ExpectedAssertionNode } from '../assertion-node-shape.ts';
+export type EqualAssertionNode<Source extends AssertionSource = AssertionSource> = ExpectedAssertionNode<Source, 'equal'>;
+export type NotEqualAssertionNode<Source extends AssertionSource = AssertionSource> = ExpectedAssertionNode<Source, 'not-equal'>;
+export type DeepEqualAssertionNode<Source extends AssertionSource = AssertionSource> = ExpectedAssertionNode<Source, 'deep-equal'>;
+export type NotDeepEqualAssertionNode<Source extends AssertionSource = AssertionSource> = ExpectedAssertionNode<Source, 'not-deep-equal'>;
+export declare const equalitySummaryByCheck: {
+    readonly 'deep-equal': "Expected values to be deeply equal.";
+    readonly equal: "Expected values to be equal.";
+    readonly 'not-deep-equal': "Expected values not to be deeply equal.";
+    readonly 'not-equal': "Expected values not to be equal.";
+};
+export declare function evaluateDeepEqual(assertion: DeepEqualAssertionNode): AssertionOutcome;
+export declare function evaluateEqual(assertion: EqualAssertionNode): AssertionOutcome;
+export declare function evaluateNotDeepEqual(assertion: NotDeepEqualAssertionNode): AssertionOutcome;
+export declare function evaluateNotEqual(assertion: NotEqualAssertionNode): AssertionOutcome;
+//# sourceMappingURL=equality.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equality.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/equality.ts"],"names":[],"mappings":"AAKA,OAAO,EAAuC,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACxG,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEzF,MAAM,MAAM,kBAAkB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,qBAAqB,CACpG,MAAM,EACN,OAAO,CACV,CAAC;AAEF,MAAM,MAAM,qBAAqB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,qBAAqB,CACvG,MAAM,EACN,WAAW,CACd,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,qBAAqB,CACxG,MAAM,EACN,YAAY,CACf,CAAC;AAEF,MAAM,MAAM,yBAAyB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,qBAAqB,CAC3G,MAAM,EACN,gBAAgB,CACnB,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;CAKzB,CAAC;AAEX,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,sBAAsB,GAAG,gBAAgB,CAErF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,CAM7E;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,yBAAyB,GAAG,gBAAgB,CAM3F;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,qBAAqB,GAAG,gBAAgB,CAEnF"}

package/assertion-protocol/assertions/equality.js

@@ -0,0 +1,24 @@
+import { compareDeepValues, compareEqualValues, compareStringEquality } from "../../compare/comparison.js";
+import { assertionOutcome, comparisonOutcome } from "../assertion-evaluation.js";
+export const equalitySummaryByCheck = {
+    'deep-equal': 'Expected values to be deeply equal.',
+    equal: 'Expected values to be equal.',
+    'not-deep-equal': 'Expected values not to be deeply equal.',
+    'not-equal': 'Expected values not to be equal.'
+};
+export function evaluateDeepEqual(assertion) {
+    return comparisonOutcome(compareDeepValues(assertion.actual, assertion.expected));
+}
+export function evaluateEqual(assertion) {
+    if (typeof assertion.actual === 'string' && typeof assertion.expected === 'string') {
+        return comparisonOutcome(compareStringEquality(assertion.actual, assertion.expected));
+    }
+    return comparisonOutcome(compareEqualValues(assertion.actual, assertion.expected));
+}
+export function evaluateNotDeepEqual(assertion) {
+    return assertionOutcome(assertion.actual, assertion.expected, !compareDeepValues(assertion.actual, assertion.expected).passed);
+}
+export function evaluateNotEqual(assertion) {
+    return assertionOutcome(assertion.actual, assertion.expected, !Object.is(assertion.actual, assertion.expected));
+}
+//# sourceMappingURL=equality.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equality.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/equality.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACxB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAyB,MAAM,4BAA4B,CAAC;AAuBxG,MAAM,CAAC,MAAM,sBAAsB,GAAG;IAClC,YAAY,EAAE,qCAAqC;IACnD,KAAK,EAAE,8BAA8B;IACrC,gBAAgB,EAAE,yCAAyC;IAC3D,WAAW,EAAE,kCAAkC;CACzC,CAAC;AAEX,MAAM,UAAU,iBAAiB,CAAC,SAAiC;IAC/D,OAAO,iBAAiB,CAAC,iBAAiB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AACtF,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,SAA6B;IACvD,IAAI,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,IAAI,OAAO,SAAS,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjF,OAAO,iBAAiB,CAAC,qBAAqB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC1F,CAAC;IAED,OAAO,iBAAiB,CAAC,kBAAkB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AACvF,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,SAAoC;IACrE,OAAO,gBAAgB,CACnB,SAAS,CAAC,MAAM,EAChB,SAAS,CAAC,QAAQ,EAClB,CAAC,iBAAiB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,MAAM,CAClE,CAAC;AACN,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,SAAgC;IAC7D,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AACpH,CAAC"}

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

@@ -0,0 +1,13 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { AssertionSource, ResolvableSourceLocation } from '../assertion-node-shape.ts';
+export type FailAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly check: 'fail';
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly source: Source;
+};
+export declare const failSummaryByCheck: {
+    readonly fail: "Assertion failed.";
+};
+export declare function evaluateFail(assertion: FailAssertionNode): AssertionOutcome;
+//# sourceMappingURL=fail.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/fail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAE5F,MAAM,MAAM,iBAAiB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IAC9E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,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,eAAO,MAAM,kBAAkB;;CAErB,CAAC;AAEX,wBAAgB,YAAY,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE3E"}

package/assertion-protocol/assertions/fail.js

@@ -0,0 +1,8 @@
+import { assertionOutcome } from "../assertion-evaluation.js";
+export const failSummaryByCheck = {
+    fail: 'Assertion failed.'
+};
+export function evaluateFail(assertion) {
+    return assertionOutcome(assertion.check, 'pass', false);
+}
+//# sourceMappingURL=fail.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fail.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/fail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAUrF,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAC9B,IAAI,EAAE,mBAAmB;CACnB,CAAC;AAEX,MAAM,UAAU,YAAY,CAAC,SAA4B;IACrD,OAAO,gBAAgB,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;AAC5D,CAAC"}

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

@@ -0,0 +1,29 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { AssertionSource, ExpectedAssertionNode, ResolvableSourceLocation } from '../assertion-node-shape.ts';
+type NumericComparisonCheck = 'greater-than' | 'greater-than-or-equal' | 'less-than' | 'less-than-or-equal';
+export type NumericComparisonAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly [Check in NumericComparisonCheck]: ExpectedAssertionNode<Source, Check>;
+}[NumericComparisonCheck];
+export type BetweenAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly actual: unknown;
+    readonly check: 'between';
+    readonly location: ResolvableSourceLocation;
+    readonly maximum: number;
+    readonly message: string | null;
+    readonly minimum: number;
+    readonly source: Source;
+};
+export declare const numericSummaryByCheck: {
+    readonly between: "Expected number to be between the bounds.";
+    readonly 'greater-than': "Expected number to be greater than the threshold.";
+    readonly 'greater-than-or-equal': "Expected number to be greater than or equal to the threshold.";
+    readonly 'less-than': "Expected number to be less than the threshold.";
+    readonly 'less-than-or-equal': "Expected number to be less than or equal to the threshold.";
+};
+export declare function evaluateBetween(assertion: BetweenAssertionNode): AssertionOutcome;
+export declare function evaluateGreaterThan(assertion: NumericComparisonAssertionNode): AssertionOutcome;
+export declare function evaluateGreaterThanOrEqual(assertion: NumericComparisonAssertionNode): AssertionOutcome;
+export declare function evaluateLessThan(assertion: NumericComparisonAssertionNode): AssertionOutcome;
+export declare function evaluateLessThanOrEqual(assertion: NumericComparisonAssertionNode): AssertionOutcome;
+export {};
+//# sourceMappingURL=numeric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/numeric.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEnH,KAAK,sBAAsB,GAAG,cAAc,GAAG,uBAAuB,GAAG,WAAW,GAAG,oBAAoB,CAAC;AAE5G,MAAM,MAAM,8BAA8B,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IAC3F,QAAQ,EAAE,KAAK,IAAI,sBAAsB,GAAG,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC;CACnF,CAAC,sBAAsB,CAAC,CAAC;AAE1B,MAAM,MAAM,oBAAoB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IACjF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;CAMxB,CAAC;AAMX,wBAAgB,eAAe,CAAC,SAAS,EAAE,oBAAoB,GAAG,gBAAgB,CAOjF;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,8BAA8B,GAAG,gBAAgB,CAM/F;AAED,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,8BAA8B,GAAG,gBAAgB,CAMtG;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,8BAA8B,GAAG,gBAAgB,CAM5F;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,8BAA8B,GAAG,gBAAgB,CAMnG"}

package/assertion-protocol/assertions/numeric.js

@@ -0,0 +1,43 @@
+import { assertionOutcome } from "../assertion-evaluation.js";
+export const numericSummaryByCheck = {
+    between: 'Expected number to be between the bounds.',
+    'greater-than': 'Expected number to be greater than the threshold.',
+    'greater-than-or-equal': 'Expected number to be greater than or equal to the threshold.',
+    'less-than': 'Expected number to be less than the threshold.',
+    'less-than-or-equal': 'Expected number to be less than or equal to the threshold.'
+};
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+export function evaluateBetween(assertion) {
+    const expected = `${assertion.minimum}..${assertion.maximum}`;
+    const passed = isFiniteNumber(assertion.actual) &&
+        assertion.actual >= assertion.minimum &&
+        assertion.actual <= assertion.maximum;
+    return assertionOutcome(assertion.actual, expected, passed);
+}
+export function evaluateGreaterThan(assertion) {
+    const passed = isFiniteNumber(assertion.actual) &&
+        isFiniteNumber(assertion.expected) &&
+        assertion.actual > assertion.expected;
+    return assertionOutcome(assertion.actual, `> ${assertion.expected}`, passed);
+}
+export function evaluateGreaterThanOrEqual(assertion) {
+    const passed = isFiniteNumber(assertion.actual) &&
+        isFiniteNumber(assertion.expected) &&
+        assertion.actual >= assertion.expected;
+    return assertionOutcome(assertion.actual, `>= ${assertion.expected}`, passed);
+}
+export function evaluateLessThan(assertion) {
+    const passed = isFiniteNumber(assertion.actual) &&
+        isFiniteNumber(assertion.expected) &&
+        assertion.actual < assertion.expected;
+    return assertionOutcome(assertion.actual, `< ${assertion.expected}`, passed);
+}
+export function evaluateLessThanOrEqual(assertion) {
+    const passed = isFiniteNumber(assertion.actual) &&
+        isFiniteNumber(assertion.expected) &&
+        assertion.actual <= assertion.expected;
+    return assertionOutcome(assertion.actual, `<= ${assertion.expected}`, passed);
+}
+//# sourceMappingURL=numeric.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/numeric.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAmBrF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACjC,OAAO,EAAE,2CAA2C;IACpD,cAAc,EAAE,mDAAmD;IACnE,uBAAuB,EAAE,+DAA+D;IACxF,WAAW,EAAE,gDAAgD;IAC7D,oBAAoB,EAAE,4DAA4D;CAC5E,CAAC;AAEX,SAAS,cAAc,CAAC,KAAc;IAClC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,SAA+B;IAC3D,MAAM,QAAQ,GAAG,GAAG,SAAS,CAAC,OAAO,KAAK,SAAS,CAAC,OAAO,EAAE,CAAC;IAC9D,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC;QAC3C,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,OAAO;QACrC,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,OAAO,CAAC;IAE1C,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AAChE,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,SAAyC;IACzE,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC;QAC3C,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC;QAClC,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC;IAE1C,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,SAAS,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;AACjF,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,SAAyC;IAChF,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC;QAC3C,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC;QAClC,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC;IAE3C,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,SAAS,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;AAClF,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,SAAyC;IACtE,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC;QAC3C,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC;QAClC,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC;IAE1C,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,SAAS,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;AACjF,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,SAAyC;IAC7E,MAAM,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC;QAC3C,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC;QAClC,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC,QAAQ,CAAC;IAE3C,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,SAAS,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;AAClF,CAAC"}

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

@@ -0,0 +1,14 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { AssertionSource, ExpectedAssertionNode } from '../assertion-node-shape.ts';
+export type PartialDeepEqualAssertionNode<Source extends AssertionSource = AssertionSource> = ExpectedAssertionNode<Source, 'partial-deep-equal'>;
+export type ArrayContainsPartialAssertionNode<Source extends AssertionSource = AssertionSource> = ExpectedAssertionNode<Source, 'array-contains-partial'>;
+export type MembersPartialDeepEqualAssertionNode<Source extends AssertionSource = AssertionSource> = ExpectedAssertionNode<Source, 'members-partial-deep-equal'>;
+export declare const partialSummaryByCheck: {
+    readonly 'array-contains-partial': "Expected array to contain a partial member.";
+    readonly 'members-partial-deep-equal': "Expected array to contain the partial members.";
+    readonly 'partial-deep-equal': "Expected value to partially match.";
+};
+export declare function evaluateArrayContainsPartial(assertion: ArrayContainsPartialAssertionNode): AssertionOutcome;
+export declare function evaluateMembersPartialDeepEqual(assertion: MembersPartialDeepEqualAssertionNode): AssertionOutcome;
+export declare function evaluatePartialDeepEqual(assertion: PartialDeepEqualAssertionNode): AssertionOutcome;
+//# sourceMappingURL=partial.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"partial.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/partial.ts"],"names":[],"mappings":"AAKA,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACtF,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAEzF,MAAM,MAAM,6BAA6B,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,qBAAqB,CAC/G,MAAM,EACN,oBAAoB,CACvB,CAAC;AAEF,MAAM,MAAM,iCAAiC,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,qBAAqB,CACnH,MAAM,EACN,wBAAwB,CAC3B,CAAC;AAEF,MAAM,MAAM,oCAAoC,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAC7F,qBAAqB,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAC;AAEhE,eAAO,MAAM,qBAAqB;;;;CAIxB,CAAC;AAEX,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,iCAAiC,GAAG,gBAAgB,CAE3G;AAED,wBAAgB,+BAA+B,CAAC,SAAS,EAAE,oCAAoC,GAAG,gBAAgB,CAEjH;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,6BAA6B,GAAG,gBAAgB,CAEnG"}

package/assertion-protocol/assertions/partial.js

@@ -0,0 +1,17 @@
+import { compareArrayContainsPartial, compareMembersPartialDeepEqual, comparePartialValue } from "../../compare/comparison.js";
+import { comparisonOutcome } from "../assertion-evaluation.js";
+export const partialSummaryByCheck = {
+    'array-contains-partial': 'Expected array to contain a partial member.',
+    'members-partial-deep-equal': 'Expected array to contain the partial members.',
+    'partial-deep-equal': 'Expected value to partially match.'
+};
+export function evaluateArrayContainsPartial(assertion) {
+    return comparisonOutcome(compareArrayContainsPartial(assertion.actual, assertion.expected));
+}
+export function evaluateMembersPartialDeepEqual(assertion) {
+    return comparisonOutcome(compareMembersPartialDeepEqual(assertion.actual, assertion.expected));
+}
+export function evaluatePartialDeepEqual(assertion) {
+    return comparisonOutcome(comparePartialValue(assertion.actual, assertion.expected));
+}
+//# sourceMappingURL=partial.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"partial.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/partial.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,2BAA2B,EAC3B,8BAA8B,EAC9B,mBAAmB,EACtB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAyB,MAAM,4BAA4B,CAAC;AAgBtF,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACjC,wBAAwB,EAAE,6CAA6C;IACvE,4BAA4B,EAAE,gDAAgD;IAC9E,oBAAoB,EAAE,oCAAoC;CACpD,CAAC;AAEX,MAAM,UAAU,4BAA4B,CAAC,SAA4C;IACrF,OAAO,iBAAiB,CAAC,2BAA2B,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AAChG,CAAC;AAED,MAAM,UAAU,+BAA+B,CAAC,SAA+C;IAC3F,OAAO,iBAAiB,CAAC,8BAA8B,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AACnG,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,SAAwC;IAC7E,OAAO,iBAAiB,CAAC,mBAAmB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;AACxF,CAAC"}

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

@@ -0,0 +1,17 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { ActualAssertionNode, AssertionSource } from '../assertion-node-shape.ts';
+export type DefinedAssertionNode<Source extends AssertionSource = AssertionSource> = ActualAssertionNode<Source, 'defined'>;
+export type NullAssertionNode<Source extends AssertionSource = AssertionSource> = ActualAssertionNode<Source, 'null'>;
+export type NotNullAssertionNode<Source extends AssertionSource = AssertionSource> = ActualAssertionNode<Source, 'not-null'>;
+export type UndefinedAssertionNode<Source extends AssertionSource = AssertionSource> = ActualAssertionNode<Source, 'undefined'>;
+export declare const presenceSummaryByCheck: {
+    readonly defined: "Expected value to be defined.";
+    readonly 'not-null': "Expected value not to be null.";
+    readonly null: "Expected value to be null.";
+    readonly undefined: "Expected value to be undefined.";
+};
+export declare function evaluateDefined(assertion: DefinedAssertionNode): AssertionOutcome;
+export declare function evaluateNotNull(assertion: NotNullAssertionNode): AssertionOutcome;
+export declare function evaluateNull(assertion: NullAssertionNode): AssertionOutcome;
+export declare function evaluateUndefined(assertion: UndefinedAssertionNode): AssertionOutcome;
+//# sourceMappingURL=presence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presence.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/presence.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,oBAAoB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,mBAAmB,CACpG,MAAM,EACN,SAAS,CACZ,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtH,MAAM,MAAM,oBAAoB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,mBAAmB,CACpG,MAAM,EACN,UAAU,CACb,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI,mBAAmB,CACtG,MAAM,EACN,WAAW,CACd,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;CAKzB,CAAC;AAEX,wBAAgB,eAAe,CAAC,SAAS,EAAE,oBAAoB,GAAG,gBAAgB,CAMjF;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,oBAAoB,GAAG,gBAAgB,CAEjF;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE3E;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,sBAAsB,GAAG,gBAAgB,CAErF"}

package/assertion-protocol/assertions/presence.js

@@ -0,0 +1,20 @@
+import { assertionOutcome } from "../assertion-evaluation.js";
+export const presenceSummaryByCheck = {
+    defined: 'Expected value to be defined.',
+    'not-null': 'Expected value not to be null.',
+    null: 'Expected value to be null.',
+    undefined: 'Expected value to be undefined.'
+};
+export function evaluateDefined(assertion) {
+    return assertionOutcome(assertion.actual, 'non-nullish value', assertion.actual !== null && assertion.actual !== undefined);
+}
+export function evaluateNotNull(assertion) {
+    return assertionOutcome(assertion.actual, 'not null', assertion.actual !== null);
+}
+export function evaluateNull(assertion) {
+    return assertionOutcome(assertion.actual, null, assertion.actual === null);
+}
+export function evaluateUndefined(assertion) {
+    return assertionOutcome(assertion.actual, undefined, assertion.actual === undefined);
+}
+//# sourceMappingURL=presence.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presence.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/presence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAoBrF,MAAM,CAAC,MAAM,sBAAsB,GAAG;IAClC,OAAO,EAAE,+BAA+B;IACxC,UAAU,EAAE,gCAAgC;IAC5C,IAAI,EAAE,4BAA4B;IAClC,SAAS,EAAE,iCAAiC;CACtC,CAAC;AAEX,MAAM,UAAU,eAAe,CAAC,SAA+B;IAC3D,OAAO,gBAAgB,CACnB,SAAS,CAAC,MAAM,EAChB,mBAAmB,EACnB,SAAS,CAAC,MAAM,KAAK,IAAI,IAAI,SAAS,CAAC,MAAM,KAAK,SAAS,CAC9D,CAAC;AACN,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,SAA+B;IAC3D,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC;AACrF,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;AAED,MAAM,UAAU,iBAAiB,CAAC,SAAiC;IAC/D,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC;AACzF,CAAC"}

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

@@ -0,0 +1,28 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { AssertionSource, ExpectedAssertionNode, ResolvableSourceLocation } from '../assertion-node-shape.ts';
+export type MatchAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly [Check in 'match' | 'not-match']: {
+        readonly actual: unknown;
+        readonly check: Check;
+        readonly location: ResolvableSourceLocation;
+        readonly message: string | null;
+        readonly pattern: RegExp;
+        readonly source: Source;
+    };
+}['match' | 'not-match'];
+export type StringContainsAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly [Check in 'ends-with' | 'includes' | 'starts-with']: ExpectedAssertionNode<Source, Check>;
+}['ends-with' | 'includes' | 'starts-with'];
+export declare const stringSummaryByCheck: {
+    readonly 'ends-with': "Expected string to end with the value.";
+    readonly includes: "Expected string to include the value.";
+    readonly match: "Expected string to match the pattern.";
+    readonly 'not-match': "Expected string not to match the pattern.";
+    readonly 'starts-with': "Expected string to start with the value.";
+};
+export declare function evaluateEndsWith(assertion: StringContainsAssertionNode): AssertionOutcome;
+export declare function evaluateIncludes(assertion: StringContainsAssertionNode): AssertionOutcome;
+export declare function evaluateMatch(assertion: MatchAssertionNode): AssertionOutcome;
+export declare function evaluateNotMatch(assertion: MatchAssertionNode): AssertionOutcome;
+export declare function evaluateStartsWith(assertion: StringContainsAssertionNode): AssertionOutcome;
+//# sourceMappingURL=string.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,KAAK,EAAE,eAAe,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEnH,MAAM,MAAM,kBAAkB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IAC/E,QAAQ,EAAE,KAAK,IAAI,OAAO,GAAG,WAAW,GAAG;QACvC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;QACzB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;QACtB,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAC;QAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;KAC3B;CACJ,CAAC,OAAO,GAAG,WAAW,CAAC,CAAC;AAEzB,MAAM,MAAM,2BAA2B,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IACxF,QAAQ,EAAE,KAAK,IAAI,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,qBAAqB,CAAC,MAAM,EAAE,KAAK,CAAC;CACrG,CAAC,WAAW,GAAG,UAAU,GAAG,aAAa,CAAC,CAAC;AAE5C,eAAO,MAAM,oBAAoB;;;;;;CAMvB,CAAC;AAEX,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,2BAA2B,GAAG,gBAAgB,CAMzF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,2BAA2B,GAAG,gBAAgB,CAMzF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,CAM7E;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,kBAAkB,GAAG,gBAAgB,CAMhF;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,2BAA2B,GAAG,gBAAgB,CAM3F"}

package/assertion-protocol/assertions/string.js

@@ -0,0 +1,33 @@
+import { assertionOutcome } from "../assertion-evaluation.js";
+export const stringSummaryByCheck = {
+    'ends-with': 'Expected string to end with the value.',
+    includes: 'Expected string to include the value.',
+    match: 'Expected string to match the pattern.',
+    'not-match': 'Expected string not to match the pattern.',
+    'starts-with': 'Expected string to start with the value.'
+};
+export function evaluateEndsWith(assertion) {
+    const passed = typeof assertion.actual === 'string' &&
+        typeof assertion.expected === 'string' &&
+        assertion.actual.endsWith(assertion.expected);
+    return assertionOutcome(assertion.actual, assertion.expected, passed);
+}
+export function evaluateIncludes(assertion) {
+    const passed = typeof assertion.actual === 'string' &&
+        typeof assertion.expected === 'string' &&
+        assertion.actual.includes(assertion.expected);
+    return assertionOutcome(assertion.actual, assertion.expected, passed);
+}
+export function evaluateMatch(assertion) {
+    return assertionOutcome(assertion.actual, assertion.pattern, typeof assertion.actual === 'string' && assertion.pattern.test(assertion.actual));
+}
+export function evaluateNotMatch(assertion) {
+    return assertionOutcome(assertion.actual, assertion.pattern, typeof assertion.actual === 'string' && !assertion.pattern.test(assertion.actual));
+}
+export function evaluateStartsWith(assertion) {
+    const passed = typeof assertion.actual === 'string' &&
+        typeof assertion.expected === 'string' &&
+        assertion.actual.startsWith(assertion.expected);
+    return assertionOutcome(assertion.actual, assertion.expected, passed);
+}
+//# sourceMappingURL=string.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAkBrF,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAChC,WAAW,EAAE,wCAAwC;IACrD,QAAQ,EAAE,uCAAuC;IACjD,KAAK,EAAE,uCAAuC;IAC9C,WAAW,EAAE,2CAA2C;IACxD,aAAa,EAAE,0CAA0C;CACnD,CAAC;AAEX,MAAM,UAAU,gBAAgB,CAAC,SAAsC;IACnE,MAAM,MAAM,GAAG,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ;QAC/C,OAAO,SAAS,CAAC,QAAQ,KAAK,QAAQ;QACtC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAElD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC1E,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,SAAsC;IACnE,MAAM,MAAM,GAAG,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ;QAC/C,OAAO,SAAS,CAAC,QAAQ,KAAK,QAAQ;QACtC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAElD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC1E,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,SAA6B;IACvD,OAAO,gBAAgB,CACnB,SAAS,CAAC,MAAM,EAChB,SAAS,CAAC,OAAO,EACjB,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,IAAI,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CACnF,CAAC;AACN,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,SAA6B;IAC1D,OAAO,gBAAgB,CACnB,SAAS,CAAC,MAAM,EAChB,SAAS,CAAC,OAAO,EACjB,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CACpF,CAAC;AACN,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,SAAsC;IACrE,MAAM,MAAM,GAAG,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ;QAC/C,OAAO,SAAS,CAAC,QAAQ,KAAK,QAAQ;QACtC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAEpD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC1E,CAAC"}

package/assertion-protocol/assertions/type-shape.d.ts

@@ -0,0 +1,42 @@
+import { type AssertionOutcome } from '../assertion-evaluation.ts';
+import type { ActualAssertionNode, AssertionSource, InstanceConstructor, ResolvableSourceLocation } from '../assertion-node-shape.ts';
+type TypeAssertionCheck = 'array' | 'boolean' | 'function' | 'number' | 'object' | 'string';
+export type TypeAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly [Check in TypeAssertionCheck]: ActualAssertionNode<Source, Check>;
+}[TypeAssertionCheck];
+export type InstanceOfAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly actual: unknown;
+    readonly check: 'instance-of';
+    readonly expected: InstanceConstructor;
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly source: Source;
+};
+export type HasPropertyAssertionNode<Source extends AssertionSource = AssertionSource> = {
+    readonly actual: unknown;
+    readonly check: 'has-property';
+    readonly key: PropertyKey;
+    readonly location: ResolvableSourceLocation;
+    readonly message: string | null;
+    readonly source: Source;
+};
+export declare const typeShapeSummaryByCheck: {
+    readonly array: "Expected value to be an array.";
+    readonly boolean: "Expected value to be a boolean.";
+    readonly function: "Expected value to be a function.";
+    readonly 'has-property': "Expected object to have the own property.";
+    readonly 'instance-of': "Expected value to be an instance of the constructor.";
+    readonly number: "Expected value to be a number.";
+    readonly object: "Expected value to be an object.";
+    readonly string: "Expected value to be a string.";
+};
+export declare function evaluateArray(assertion: TypeAssertionNode): AssertionOutcome;
+export declare function evaluateBoolean(assertion: TypeAssertionNode): AssertionOutcome;
+export declare function evaluateFunction(assertion: TypeAssertionNode): AssertionOutcome;
+export declare function evaluateHasProperty(assertion: HasPropertyAssertionNode): AssertionOutcome;
+export declare function evaluateInstanceOf(assertion: InstanceOfAssertionNode): AssertionOutcome;
+export declare function evaluateNumber(assertion: TypeAssertionNode): AssertionOutcome;
+export declare function evaluateObject(assertion: TypeAssertionNode): AssertionOutcome;
+export declare function evaluateString(assertion: TypeAssertionNode): AssertionOutcome;
+export {};
+//# sourceMappingURL=type-shape.d.ts.map

package/assertion-protocol/assertions/type-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-shape.d.ts","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/type-shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACrF,OAAO,KAAK,EACR,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,wBAAwB,EAC3B,MAAM,4BAA4B,CAAC;AAGpC,KAAK,kBAAkB,GAAG,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE5F,MAAM,MAAM,iBAAiB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IAC9E,QAAQ,EAAE,KAAK,IAAI,kBAAkB,GAAG,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC;CAC7E,CAAC,kBAAkB,CAAC,CAAC;AAEtB,MAAM,MAAM,uBAAuB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IACpF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC;IACvC,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,wBAAwB,CAAC,MAAM,SAAS,eAAe,GAAG,eAAe,IAAI;IACrF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,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,eAAO,MAAM,uBAAuB;;;;;;;;;CAS1B,CAAC;AAUX,wBAAgB,aAAa,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE5E;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE9E;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE/E;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,wBAAwB,GAAG,gBAAgB,CAMzF;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,uBAAuB,GAAG,gBAAgB,CAEvF;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE7E;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE7E;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,GAAG,gBAAgB,CAE7E"}

package/assertion-protocol/assertions/type-shape.js

@@ -0,0 +1,43 @@
+import { assertionOutcome } from "../assertion-evaluation.js";
+import { isPlainObject } from "../partial-matching.js";
+export const typeShapeSummaryByCheck = {
+    array: 'Expected value to be an array.',
+    boolean: 'Expected value to be a boolean.',
+    function: 'Expected value to be a function.',
+    'has-property': 'Expected object to have the own property.',
+    'instance-of': 'Expected value to be an instance of the constructor.',
+    number: 'Expected value to be a number.',
+    object: 'Expected value to be an object.',
+    string: 'Expected value to be a string.'
+};
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isSupportedObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function evaluateArray(assertion) {
+    return assertionOutcome(assertion.actual, 'array', Array.isArray(assertion.actual));
+}
+export function evaluateBoolean(assertion) {
+    return assertionOutcome(assertion.actual, 'boolean', typeof assertion.actual === 'boolean');
+}
+export function evaluateFunction(assertion) {
+    return assertionOutcome(assertion.actual, 'function', typeof assertion.actual === 'function');
+}
+export function evaluateHasProperty(assertion) {
+    return assertionOutcome(assertion.actual, `own property ${String(assertion.key)}`, isSupportedObject(assertion.actual) && Object.hasOwn(assertion.actual, assertion.key));
+}
+export function evaluateInstanceOf(assertion) {
+    return assertionOutcome(assertion.actual, assertion.expected, assertion.actual instanceof assertion.expected);
+}
+export function evaluateNumber(assertion) {
+    return assertionOutcome(assertion.actual, 'finite number', isFiniteNumber(assertion.actual));
+}
+export function evaluateObject(assertion) {
+    return assertionOutcome(assertion.actual, 'plain object', isPlainObject(assertion.actual));
+}
+export function evaluateString(assertion) {
+    return assertionOutcome(assertion.actual, 'string', typeof assertion.actual === 'string');
+}
+//# sourceMappingURL=type-shape.js.map

package/assertion-protocol/assertions/type-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-shape.js","sourceRoot":"","sources":["../../../../../source/assertion-protocol/assertions/type-shape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAyB,MAAM,4BAA4B,CAAC;AAOrF,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA0BvD,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACnC,KAAK,EAAE,gCAAgC;IACvC,OAAO,EAAE,iCAAiC;IAC1C,QAAQ,EAAE,kCAAkC;IAC5C,cAAc,EAAE,2CAA2C;IAC3D,aAAa,EAAE,sDAAsD;IACrE,MAAM,EAAE,gCAAgC;IACxC,MAAM,EAAE,iCAAiC;IACzC,MAAM,EAAE,gCAAgC;CAClC,CAAC;AAEX,SAAS,cAAc,CAAC,KAAc;IAClC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC/D,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAc;IACrC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACvD,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,SAA4B;IACtD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;AACxF,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,SAA4B;IACxD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,SAAS,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC;AAChG,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,SAA4B;IACzD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,SAAS,CAAC,MAAM,KAAK,UAAU,CAAC,CAAC;AAClG,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,SAAmC;IACnE,OAAO,gBAAgB,CACnB,SAAS,CAAC,MAAM,EAChB,gBAAgB,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,EACvC,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CACxF,CAAC;AACN,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,SAAkC;IACjE,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,EAAE,SAAS,CAAC,MAAM,YAAY,SAAS,CAAC,QAAQ,CAAC,CAAC;AAClH,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,SAA4B;IACvD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,eAAe,EAAE,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;AACjG,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,SAA4B;IACvD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,cAAc,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;AAC/F,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,SAA4B;IACvD,OAAO,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC;AAC9F,CAAC"}

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

@@ -0,0 +1,6 @@
+export type CountedCollection = {
+    readonly count: number;
+    readonly supported: boolean;
+};
+export declare function collectionCount(value: unknown, limit: number): CountedCollection;
+//# sourceMappingURL=collection-count.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collection-count.d.ts","sourceRoot":"","sources":["../../../../source/assertion-protocol/collection-count.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC/B,CAAC;AA8CF,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAYhF"}

package/assertion-protocol/collection-count.js

@@ -0,0 +1,42 @@
+import { isPlainObject, ownKeys } from "./partial-matching.js";
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function hasIteratorProvider(value) {
+    return typeof Reflect.get(value, Symbol.iterator) === 'function';
+}
+function iterableItems(value) {
+    if (!isObject(value) || !hasIteratorProvider(value)) {
+        return null;
+    }
+    return value[Symbol.iterator]();
+}
+function countIterator(iterator, limit) {
+    let count = 0;
+    let item = iterator.next();
+    while (item.done !== true && count < limit) {
+        count += 1;
+        item = iterator.next();
+    }
+    return count;
+}
+function knownCollectionCount(value) {
+    if (typeof value === 'string' || Array.isArray(value)) {
+        return value.length;
+    }
+    if (value instanceof Map || value instanceof Set) {
+        return value.size;
+    }
+    return isPlainObject(value) ? ownKeys(value).length : null;
+}
+export function collectionCount(value, limit) {
+    const knownCount = knownCollectionCount(value);
+    if (knownCount !== null) {
+        return { count: knownCount, supported: true };
+    }
+    const iterator = iterableItems(value);
+    return iterator === null
+        ? { count: 0, supported: false }
+        : { count: countIterator(iterator, limit), supported: true };
+}
+//# sourceMappingURL=collection-count.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collection-count.js","sourceRoot":"","sources":["../../../../source/assertion-protocol/collection-count.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAO/D,SAAS,QAAQ,CAAC,KAAc;IAC5B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACvD,CAAC;AAMD,SAAS,mBAAmB,CAAC,KAA8B;IACvD,OAAO,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,UAAU,CAAC;AACrE,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACjC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;QAClD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,OAAO,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;AACpC,CAAC;AAED,SAAS,aAAa,CAAC,QAA2B,EAAE,KAAa;IAC7D,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAE3B,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,CAAC;QACzC,KAAK,IAAI,CAAC,CAAC;QACX,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAED,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,SAAS,oBAAoB,CAAC,KAAc;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,OAAO,KAAK,CAAC,MAAM,CAAC;IACxB,CAAC;IAED,IAAI,KAAK,YAAY,GAAG,IAAI,KAAK,YAAY,GAAG,EAAE,CAAC;QAC/C,OAAO,KAAK,CAAC,IAAI,CAAC;IACtB,CAAC;IAED,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAc,EAAE,KAAa;IACzD,MAAM,UAAU,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAE/C,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACtB,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;IAClD,CAAC;IAED,MAAM,QAAQ,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IAEtC,OAAO,QAAQ,KAAK,IAAI;QACpB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE;QAChC,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AACrE,CAAC"}

package/assertion-protocol/evaluation.d.ts

@@ -0,0 +1,32 @@
+import { type AssertionNode, type CompositeAssertionChildNode } from './assertion-node.ts';
+import type { FailedCheck } from './assertion-node-shape.ts';
+type DeepAssertionCheckByName = {
+    readonly arrayContainsPartial: 'array-contains-partial';
+    readonly deepEqual: 'deep-equal';
+    readonly membersPartialDeepEqual: 'members-partial-deep-equal';
+    readonly notDeepEqual: 'not-deep-equal';
+    readonly partialDeepEqual: 'partial-deep-equal';
+};
+type DeepAssertionCheck = DeepAssertionCheckByName[keyof DeepAssertionCheckByName];
+type DeepAssertionOperandRole = 'actual' | 'expected';
+type PrimitiveValueTypeByName = {
+    readonly bigint: 'bigint';
+    readonly boolean: 'boolean';
+    readonly null: 'null';
+    readonly number: 'number';
+    readonly string: 'string';
+    readonly symbol: 'symbol';
+    readonly undefined: 'undefined';
+};
+type PrimitiveValueType = PrimitiveValueTypeByName[keyof PrimitiveValueTypeByName];
+export type InvalidDeepAssertionOperand = {
+    readonly check: DeepAssertionCheck;
+    readonly index: number | null;
+    readonly role: DeepAssertionOperandRole;
+    readonly type: PrimitiveValueType;
+};
+export declare function invalidDeepAssertionOperand(assertion: AssertionNode | CompositeAssertionChildNode): InvalidDeepAssertionOperand | null;
+export declare function evaluateAssertion(assertion: AssertionNode | CompositeAssertionChildNode, id: number | string): FailedCheck | null;
+export declare function assertionPasses(assertion: AssertionNode): boolean;
+export {};
+//# sourceMappingURL=evaluation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation.d.ts","sourceRoot":"","sources":["../../../../source/assertion-protocol/evaluation.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,aAAa,EAElB,KAAK,2BAA2B,EAGnC,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAmB,WAAW,EAAyB,MAAM,2BAA2B,CAAC;AAIrG,KAAK,wBAAwB,GAAG;IAC5B,QAAQ,CAAC,oBAAoB,EAAE,wBAAwB,CAAC;IACxD,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,uBAAuB,EAAE,4BAA4B,CAAC;IAC/D,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,gBAAgB,EAAE,oBAAoB,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG,wBAAwB,CAAC,MAAM,wBAAwB,CAAC,CAAC;AAEnF,KAAK,wBAAwB,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEtD,KAAK,wBAAwB,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC;CACnC,CAAC;AAEF,KAAK,kBAAkB,GAAG,wBAAwB,CAAC,MAAM,wBAAwB,CAAC,CAAC;AAEnF,MAAM,MAAM,2BAA2B,GAAG;IACtC,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;CACrC,CAAC;AAiHF,wBAAgB,2BAA2B,CACvC,SAAS,EAAE,aAAa,GAAG,2BAA2B,GACvD,2BAA2B,GAAG,IAAI,CAgBpC;AAsGD,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,aAAa,GAAG,2BAA2B,EACtD,EAAE,EAAE,MAAM,GAAG,MAAM,GACpB,WAAW,GAAG,IAAI,CAYpB;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAEjE"}