hein 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/index.js

@@ -1,575 +1,8 @@
-import { any, assert_exports, createEvaluation, deepEqual, deepHasProperty, deepNotHasProperty, endsWith, equal, greaterThan, greaterThanEqual, hasKeys, hasMembers, hasProperty, hasSize, inBallpark, includes, instanceOf, isAfter, isBefore, isBetween, isEmpty, isType, lessThan, lessThanEqual, match, notAfter, notBefore, notBetween, notDeepEqual, notEndsWith, notEqual, notGreaterThan, notGreaterThanEqual, notHasKeys, notHasMembers, notHasProperty, notHasSize, notInBallpark, notIncludes, notInstanceOf, notIsEmpty, notIsType, notLessThan, notLessThanEqual, notMatch, notRejects, notRoundTo, notStartsWith, notThrows, rejects, roundTo, startsWith, throws } from "./assert-kFXp7i_B.js";
-import { AssertionError, AssertionError as AssertionError$1, format } from "hein-assertion-utils";
-import isPlainObject from "lodash/isPlainObject.js";
-import omit from "lodash/omit.js";
-import mapValues from "lodash/mapValues.js";
-
-//#region src/mixins.ts
-const mixins = {};
-const use = (plugins) => {
-	Object.assign(mixins, plugins);
-};
-
-//#endregion
-//#region src/utils/chain.ts
-const registerProperty = (object, name, value) => {
-	Object.defineProperty(object, name, {
-		enumerable: true,
-		get() {
-			return value();
-		}
-	});
-	return object;
-};
-const registerMethod = (object, name, value) => {
-	Object.defineProperty(object, name, { value });
-	return object;
-};
-
-//#endregion
-//#region src/utils/get-size.ts
-const getSize = (value) => {
-	if (Array.isArray(value)) return value.length;
-	if (isPlainObject(value)) return Object.keys(value).length;
-	if (value instanceof Map) return value.size;
-	if (value instanceof Set) return value.size;
-	if (typeof value === "string") return value.length;
-	return 0;
-};
-
-//#endregion
-//#region src/expect/after.ts
-use({ after: {
-	type: "method",
-	value: ({ value, inverted }) => (date) => {
-		if (inverted) notAfter(value, date);
-		else isAfter(value, date);
-	}
-} });
-
-//#endregion
-//#region src/expect/ballpark.ts
-use({ ballpark: {
-	type: "method",
-	value: ({ value, inverted }) => (ballpark, multiplier = .1) => {
-		if (inverted) notInBallpark(value, ballpark, multiplier);
-		else inBallpark(value, ballpark, multiplier);
-	}
-} });
-
-//#endregion
-//#region src/expect/before.ts
-use({ before: {
-	type: "method",
-	value: ({ value, inverted }) => (date) => {
-		if (inverted) notBefore(value, date);
-		else isBefore(value, date);
-	}
-} });
-
-//#endregion
-//#region src/expect/between.ts
-use({ between: {
-	type: "method",
-	value: ({ value, inverted }) => (start, end, inclusive = true) => {
-		if (inverted) notBetween(value, start, end, { inclusive });
-		else isBetween(value, start, end, { inclusive });
-	}
-} });
-
-//#endregion
-//#region src/expect/empty.ts
-use({ empty: {
-	type: "method",
-	value: ({ value, inverted }) => (message) => {
-		if (inverted) notIsEmpty(value, message);
-		else isEmpty(value, message);
-	}
-} });
-
-//#endregion
-//#region src/expect/end-with.ts
-use({ endWith: {
-	type: "method",
-	value: ({ value, inverted }) => (end) => {
-		if (inverted) notEndsWith(value, end);
-		else endsWith(value, end);
-	}
-} });
-
-//#endregion
-//#region src/expect/eql.ts
-use({
-	partially: {
-		type: "property",
-		value: () => ({ partial: true })
-	},
-	eql: {
-		type: "method",
-		value: ({ value, inverted, partial }) => (other, message) => {
-			if (inverted) notDeepEqual(value, other, partial, message);
-			else deepEqual(value, other, partial, message);
-		}
-	}
-});
-
-//#endregion
-//#region src/expect/equal-shorthand.ts
-use(Object.fromEntries(Object.entries({
-	false: false,
-	true: true
-}).map(([key, expectValue]) => {
-	return [key, {
-		type: "method",
-		value: ({ inverted, value }) => () => {
-			if (inverted) {
-				const message = format("Expected {{= it.value }} to not be {{= it.key }}", {
-					key,
-					value
-				}, true);
-				notEqual(value, expectValue, message);
-			} else {
-				const message = format("Expected {{= it.value }} to be {{= it.key }}", {
-					key,
-					value
-				}, true);
-				equal(value, expectValue, message);
-			}
-		}
-	}];
-})));
-
-//#endregion
-//#region src/expect/equal.ts
-use({
-	equal: {
-		type: "method",
-		value: ({ value, inverted, deep }) => (other, message) => {
-			if (deep) {
-				if (inverted) notDeepEqual(value, other, message);
-				else deepEqual(value, other, message);
-				return;
-			}
-			if (inverted) notEqual(value, other, message);
-			else equal(value, other, message);
-		}
-	},
-	eq: {
-		type: "alias",
-		value: "equal"
-	}
-});
-
-//#endregion
-//#region src/expect/excluding.ts
-use({ excluding: {
-	type: "method",
-	value: (state) => (...keys) => {
-		return expectChain({
-			...state,
-			value: omit(state.value, keys)
-		});
-	}
-} });
-
-//#endregion
-//#region src/expect/greater-than-equal.ts
-use({
-	greaterThanOrEqual: {
-		type: "method",
-		value: ({ value, inverted }) => (other) => {
-			if (inverted) notGreaterThanEqual(value, other);
-			else greaterThanEqual(value, other);
-		}
-	},
-	gte: {
-		type: "alias",
-		value: "greaterThanOrEqual"
-	},
-	atLeast: {
-		type: "alias",
-		value: "greaterThanOrEqual"
-	}
-});
-
-//#endregion
-//#region src/expect/greater-than.ts
-use({
-	greaterThan: {
-		type: "method",
-		value: ({ value, inverted }) => (other) => {
-			if (inverted) notGreaterThan(value, other);
-			else greaterThan(value, other);
-		}
-	},
-	gt: {
-		type: "alias",
-		value: "greaterThan"
-	},
-	above: {
-		type: "alias",
-		value: "greaterThan"
-	}
-});
-
-//#endregion
-//#region src/expect/has-property.ts
-use({ property: {
-	type: "method",
-	value: ({ value, inverted, deep }) => (...args) => {
-		if (deep) {
-			if (inverted) return deepNotHasProperty(value, ...args);
-			return deepHasProperty(value, ...args);
-		}
-		if (inverted) return notHasProperty(value, ...args);
-		return hasProperty(value, ...args);
-	}
-} });
-
-//#endregion
-//#region src/expect/include.ts
-use({
-	include: {
-		type: "method",
-		value: ({ value, inverted }) => (...elements) => {
-			if (inverted) notIncludes(value, ...elements);
-			else includes(value, ...elements);
-		}
-	},
-	contain: {
-		type: "alias",
-		value: "include"
-	}
-});
-
-//#endregion
-//#region src/expect/instance-of-shorthand.ts
-const constructors = [
-	Date,
-	Map,
-	Set,
-	WeakMap,
-	WeakSet
-];
-use(Object.fromEntries(constructors.map((constructor) => {
-	return [constructor.name, {
-		type: "method",
-		value: ({ inverted, value }) => () => {
-			if (inverted) notInstanceOf(value, constructor);
-			else instanceOf(value, constructor);
-		}
-	}];
-})));
-
-//#endregion
-//#region src/expect/instance-of.ts
-use({ instanceOf: {
-	type: "method",
-	value: ({ value, inverted }) => (constructor) => {
-		if (inverted) notInstanceOf(value, constructor);
-		else instanceOf(value, constructor);
-	}
-} });
-
-//#endregion
-//#region src/expect/keys.ts
-use({ keys: {
-	type: "method",
-	value: ({ value, inverted }) => (keys) => {
-		if (inverted) notHasKeys(value, keys);
-		else hasKeys(value, keys);
-	}
-} });
-
-//#endregion
-//#region src/expect/length.ts
-use({
-	sizeOf: {
-		type: "alias",
-		value: "lengthOf"
-	},
-	lengthOf: {
-		type: "method",
-		value: ({ value, inverted }) => (length, message) => {
-			if (inverted) notHasSize(value, length, message);
-			else hasSize(value, length, message);
-		}
-	}
-});
-
-//#endregion
-//#region src/expect/less-than-equal.ts
-use({
-	lessThanOrEqual: {
-		type: "method",
-		value: ({ value, inverted }) => (other) => {
-			if (inverted) notLessThanEqual(value, other);
-			else lessThanEqual(value, other);
-		}
-	},
-	lte: {
-		type: "alias",
-		value: "lessThanOrEqual"
-	},
-	atMost: {
-		type: "alias",
-		value: "lessThanOrEqual"
-	}
-});
-
-//#endregion
-//#region src/expect/less-than.ts
-use({
-	lessThan: {
-		type: "method",
-		value: ({ value, inverted }) => (other) => {
-			if (inverted) notLessThan(value, other);
-			else lessThan(value, other);
-		}
-	},
-	lt: {
-		type: "alias",
-		value: "lessThan"
-	},
-	below: {
-		type: "alias",
-		value: "lessThan"
-	}
-});
-
-//#endregion
-//#region src/expect/match.ts
-use({ match: {
-	type: "method",
-	value: ({ value, inverted }) => (regex) => {
-		if (inverted) notMatch(value, regex);
-		else match(value, regex);
-	}
-} });
-
-//#endregion
-//#region src/expect/members.ts
-use({
-	members: {
-		type: "method",
-		value: ({ value, inverted, same, deep, ordered, partial }) => (other, message) => {
-			if (inverted) notHasMembers(value, other, {
-				deep,
-				same,
-				ordered,
-				partial
-			}, message);
-			else hasMembers(value, other, {
-				deep,
-				same,
-				ordered,
-				partial
-			}, message);
-		}
-	},
-	same: {
-		type: "property",
-		value: (state) => {
-			state.same = true;
-			return state;
-		}
-	},
-	ordered: {
-		type: "property",
-		value: (state) => {
-			state.ordered = true;
-			return state;
-		}
-	}
-});
-
-//#endregion
-//#region src/expect/reject.ts
-use({ reject: {
-	type: "method",
-	value: ({ value, inverted }) => (...args) => {
-		return inverted ? notRejects(value, ...args) : rejects(value, ...args);
-	}
-} });
-
-//#endregion
-//#region src/expect/round-to.ts
-use({ roundTo: {
-	type: "method",
-	value: ({ value, inverted }) => (target, decimal = 0) => {
-		if (inverted) notRoundTo(value, target, decimal);
-		else roundTo(value, target, decimal);
-	}
-} });
-
-//#endregion
-//#region src/expect/start-with.ts
-use({ startWith: {
-	type: "method",
-	value: ({ value, inverted }) => (start) => {
-		if (inverted) notStartsWith(value, start);
-		else startsWith(value, start);
-	}
-} });
-
-//#endregion
-//#region src/expect/throw.ts
-use({ throw: {
-	type: "method",
-	value: ({ value, inverted }) => (...args) => {
-		return inverted ? notThrows(value, ...args) : throws(value, ...args);
-	}
-} });
-
-//#endregion
-//#region src/expect/type-shorthand.ts
-use(Object.fromEntries([
-	"NaN",
-	"array",
-	"bigint",
-	"boolean",
-	"function",
-	"null",
-	"number",
-	"object",
-	"string",
-	"symbol",
-	"undefined"
-].map((type) => {
-	return [type, {
-		type: "method",
-		value: ({ value, inverted }) => () => {
-			if (inverted) notIsType(value, type);
-			else isType(value, type);
-		}
-	}];
-})));
-
-//#endregion
-//#region src/expect/type.ts
-use({ type: {
-	type: "method",
-	value: ({ value, inverted }) => (type) => {
-		if (inverted) notIsType(value, type);
-		else isType(value, type);
-	}
-} });
-
-//#endregion
-//#region src/utils/fail.ts
-/**
-* Throw an AssertionError
-* @param {string} message - The message to pass to the AssertionError
-*/
-const fail = (message = "Fail") => {
-	throw new AssertionError$1(void 0, void 0, message);
-};
-
-//#endregion
-//#region src/expect.ts
-use({
-	to: {
-		type: "property",
-		value: () => null
-	},
-	be: {
-		type: "property",
-		value: () => null
-	},
-	a: {
-		type: "property",
-		value: () => null
-	},
-	an: {
-		type: "property",
-		value: () => null
-	},
-	and: {
-		type: "property",
-		value: ({ value, every,...rest }) => {
-			const values = mapValues(rest, () => {});
-			return {
-				value,
-				every,
-				...values
-			};
-		}
-	},
-	have: {
-		type: "property",
-		value: () => null
-	},
-	in: {
-		type: "property",
-		value: () => null
-	},
-	not: {
-		type: "property",
-		value: (state) => ({
-			...state,
-			inverted: !state.inverted
-		})
-	},
-	of: {
-		type: "property",
-		value: () => null
-	},
-	length: {
-		type: "property",
-		value: (state) => ({
-			...state,
-			getProperty: getSize
-		})
-	},
-	deep: {
-		type: "property",
-		value: (state) => ({
-			...state,
-			deep: true
-		})
-	},
-	every: {
-		type: "property",
-		value: (state) => ({
-			...state,
-			every: true
-		})
-	}
-});
-const expectChain = (state) => {
-	const chain = {};
-	for (const [key, v] of Object.entries(mixins)) {
-		const definition = v.type === "alias" ? mixins[v.value] : v;
-		if (definition.type === "property") registerProperty(chain, key, () => {
-			const newState = definition.value(state);
-			return expectChain({
-				...state,
-				...newState
-			});
-		});
-		else if (definition.type === "method") registerMethod(chain, key, (...args) => {
-			if (state.getProperty) definition.value({
-				value: state.getProperty(state.value),
-				inverted: state.inverted
-			})(...args);
-			else if (state.every) for (const value of state.value) definition.value({
-				...state,
-				value
-			})(...args);
-			else {
-				const result = definition.value({ ...state })(...args);
-				if (result) return result;
-			}
-			return expectChain(state);
-		});
-	}
-	return chain;
-};
-const expect = ((actual) => {
-	return expectChain({ value: actual });
-});
-expect.fail = fail;
-
-//#endregion
-export { AssertionError, any, assert_exports as assert, createEvaluation, expect, expectChain, fail, use };
-//# sourceMappingURL=index.js.map
+import { any, createEvaluation } from "./utils/match.js";
+import { assert_exports } from "./assert.js";
+import { use } from "./mixins.js";
+import { fail } from "./utils/fail.js";
+import { expect, expectChain } from "./expect.js";
+import { AssertionError } from "hein-assertion-utils";
+
+export { AssertionError, any, assert_exports as assert, createEvaluation, expect, expectChain, fail, use };

package/dist/mixins.cjs

@@ -0,0 +1,11 @@
+
+//#region src/mixins.ts
+const mixins = {};
+const use = (plugins) => {
+	Object.assign(mixins, plugins);
+};
+
+//#endregion
+exports.mixins = mixins;
+exports.use = use;
+//# sourceMappingURL=mixins.cjs.map

package/dist/mixins.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixins.cjs","names":["mixins: Record<string, Property | Method | Alias>"],"sources":["../src/mixins.ts"],"sourcesContent":["export interface State<T> {\n    inverted?: boolean;\n    value?: T;\n    getProperty?: (value: T) => any;\n    deep?: boolean;\n    same?: boolean;\n    ordered?: boolean;\n    partial?: boolean;\n\n    every?: boolean;\n}\n\nexport interface Property {\n    type: 'property';\n    value: (state: State<any>) => Partial<State<any>> | null;\n}\n\ntype MethodCallback = (state: State<any>) => (...args: any[]) => void;\n\nexport interface Method {\n    type: 'method';\n    value: MethodCallback;\n}\n\nexport interface Alias {\n    type: 'alias';\n    value: string;\n}\n\nexport const mixins: Record<string, Property | Method | Alias> = {};\n\nexport const use = (plugins: Record<string, Property | Method | Alias>) => {\n    Object.assign(mixins, plugins);\n};\n"],"mappings":";;AA6BA,MAAaA,SAAoD,EAAE;AAEnE,MAAa,OAAO,YAAuD;AACvE,QAAO,OAAO,QAAQ,QAAQ"}

package/dist/mixins.d.cts

@@ -0,0 +1,28 @@
+//#region src/mixins.d.ts
+interface State<T> {
+  inverted?: boolean;
+  value?: T;
+  getProperty?: (value: T) => any;
+  deep?: boolean;
+  same?: boolean;
+  ordered?: boolean;
+  partial?: boolean;
+  every?: boolean;
+}
+interface Property {
+  type: 'property';
+  value: (state: State<any>) => Partial<State<any>> | null;
+}
+type MethodCallback = (state: State<any>) => (...args: any[]) => void;
+interface Method {
+  type: 'method';
+  value: MethodCallback;
+}
+interface Alias {
+  type: 'alias';
+  value: string;
+}
+declare const use: (plugins: Record<string, Property | Method | Alias>) => void;
+//#endregion
+export { Alias, Method, Property, State, use };
+//# sourceMappingURL=mixins.d.cts.map

package/dist/mixins.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixins.d.cts","names":[],"sources":["../src/mixins.ts"],"sourcesContent":[],"mappings":";UAAiB;EAAA,QAAK,CAAA,EAAA,OAAA;EAAA,KAAA,CAAA,EAEV,CAFU;aAEV,CAAA,EAAA,CAAA,KAAA,EACc,CADd,EAAA,GAAA,GAAA;MACc,CAAA,EAAA,OAAA;EAAC,IAAA,CAAA,EAAA,OAAA;EASV,OAAA,CAAA,EAAA,OAAQ;EAAA,OAAA,CAAA,EAAA,OAAA;OAEN,CAAA,EAAA,OAAA;;AAAe,UAFjB,QAAA,CAEiB;EAAO,IAAA,EAAA,UAAA;EAGpC,KAAA,EAAA,CAAA,KAAA,EAHc,KAGA,CAAA,GAAA,CAAA,EAAA,GAHe,OAGC,CAHO,KAGP,CAAA,GAAA,CAAA,CAAA,GAAA,IAAA;AAEnC;AAKA,KAPK,cAAA,GAOiB,CAAA,KAAA,EAPQ,KAOR,CAAA,GAAA,CAAA,EAAA,GAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,IAAA;AAOT,UAZI,MAAA,CAchB;EAAA,IAAA,EAAA,QAAA;OAF2C,EAVjC,cAUiC;;AAAoB,UAP/C,KAAA,CAO+C;MAAnC,EAAA,OAAA;EAAM,KAAA,EAAA,MAAA;;cAAtB,eAAgB,eAAe,WAAW,SAAS"}

package/dist/mixins.d.ts

@@ -0,0 +1,28 @@
+//#region src/mixins.d.ts
+interface State<T> {
+  inverted?: boolean;
+  value?: T;
+  getProperty?: (value: T) => any;
+  deep?: boolean;
+  same?: boolean;
+  ordered?: boolean;
+  partial?: boolean;
+  every?: boolean;
+}
+interface Property {
+  type: 'property';
+  value: (state: State<any>) => Partial<State<any>> | null;
+}
+type MethodCallback = (state: State<any>) => (...args: any[]) => void;
+interface Method {
+  type: 'method';
+  value: MethodCallback;
+}
+interface Alias {
+  type: 'alias';
+  value: string;
+}
+declare const use: (plugins: Record<string, Property | Method | Alias>) => void;
+//#endregion
+export { Alias, Method, Property, State, use };
+//# sourceMappingURL=mixins.d.ts.map

package/dist/mixins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixins.d.ts","names":[],"sources":["../src/mixins.ts"],"sourcesContent":[],"mappings":";UAAiB;EAAA,QAAK,CAAA,EAAA,OAAA;EAAA,KAAA,CAAA,EAEV,CAFU;aAEV,CAAA,EAAA,CAAA,KAAA,EACc,CADd,EAAA,GAAA,GAAA;MACc,CAAA,EAAA,OAAA;EAAC,IAAA,CAAA,EAAA,OAAA;EASV,OAAA,CAAA,EAAA,OAAQ;EAAA,OAAA,CAAA,EAAA,OAAA;OAEN,CAAA,EAAA,OAAA;;AAAe,UAFjB,QAAA,CAEiB;EAAO,IAAA,EAAA,UAAA;EAGpC,KAAA,EAAA,CAAA,KAAA,EAHc,KAGA,CAAA,GAAA,CAAA,EAAA,GAHe,OAGC,CAHO,KAGP,CAAA,GAAA,CAAA,CAAA,GAAA,IAAA;AAEnC;AAKA,KAPK,cAAA,GAOiB,CAAA,KAAA,EAPQ,KAOR,CAAA,GAAA,CAAA,EAAA,GAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,IAAA;AAOT,UAZI,MAAA,CAchB;EAAA,IAAA,EAAA,QAAA;OAF2C,EAVjC,cAUiC;;AAAoB,UAP/C,KAAA,CAO+C;MAAnC,EAAA,OAAA;EAAM,KAAA,EAAA,MAAA;;cAAtB,eAAgB,eAAe,WAAW,SAAS"}

package/dist/mixins.js

@@ -0,0 +1,9 @@
+//#region src/mixins.ts
+const mixins = {};
+const use = (plugins) => {
+	Object.assign(mixins, plugins);
+};
+
+//#endregion
+export { mixins, use };
+//# sourceMappingURL=mixins.js.map

package/dist/mixins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixins.js","names":["mixins: Record<string, Property | Method | Alias>"],"sources":["../src/mixins.ts"],"sourcesContent":["export interface State<T> {\n    inverted?: boolean;\n    value?: T;\n    getProperty?: (value: T) => any;\n    deep?: boolean;\n    same?: boolean;\n    ordered?: boolean;\n    partial?: boolean;\n\n    every?: boolean;\n}\n\nexport interface Property {\n    type: 'property';\n    value: (state: State<any>) => Partial<State<any>> | null;\n}\n\ntype MethodCallback = (state: State<any>) => (...args: any[]) => void;\n\nexport interface Method {\n    type: 'method';\n    value: MethodCallback;\n}\n\nexport interface Alias {\n    type: 'alias';\n    value: string;\n}\n\nexport const mixins: Record<string, Property | Method | Alias> = {};\n\nexport const use = (plugins: Record<string, Property | Method | Alias>) => {\n    Object.assign(mixins, plugins);\n};\n"],"mappings":";AA6BA,MAAaA,SAAoD,EAAE;AAEnE,MAAa,OAAO,YAAuD;AACvE,QAAO,OAAO,QAAQ,QAAQ"}

package/dist/utils/chain.cjs

@@ -0,0 +1,20 @@
+
+//#region src/utils/chain.ts
+const registerProperty = (object, name, value) => {
+	Object.defineProperty(object, name, {
+		enumerable: true,
+		get() {
+			return value();
+		}
+	});
+	return object;
+};
+const registerMethod = (object, name, value) => {
+	Object.defineProperty(object, name, { value });
+	return object;
+};
+
+//#endregion
+exports.registerMethod = registerMethod;
+exports.registerProperty = registerProperty;
+//# sourceMappingURL=chain.cjs.map

package/dist/utils/chain.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.cjs","names":[],"sources":["../../src/utils/chain.ts"],"sourcesContent":["export const registerProperty = <T, U extends string, V extends () => any>(object: T, name: U, value: V) => {\n    Object.defineProperty(object, name, {\n        enumerable: true,\n        get() {\n            return value();\n        }\n    });\n    return object as T & Record<U, V>;\n};\n\nexport const registerMethod = <T, U extends string, V>(object: T, name: U, value: V) => {\n    Object.defineProperty(object, name, {\n        value\n    });\n    return object as T & Record<U, V>;\n};\n"],"mappings":";;AAAA,MAAa,oBAA8D,QAAW,MAAS,UAAa;AACxG,QAAO,eAAe,QAAQ,MAAM;EAChC,YAAY;EACZ,MAAM;AACF,UAAO,OAAO;;EAErB,CAAC;AACF,QAAO;;AAGX,MAAa,kBAA0C,QAAW,MAAS,UAAa;AACpF,QAAO,eAAe,QAAQ,MAAM,EAChC,OACH,CAAC;AACF,QAAO"}