@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/util/typeCheckTests.d.ts

@@ -0,0 +1,60 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { MakeNominal, Covariant, Contravariant, Invariant, requireTrue, requireFalse, isAssignableTo, areSafelyAssignable, isAny, eitherIsAny, isStrictSubset } from "./typeCheck";
+/**
+ * Checks that typeCheck's constraints work as intended.
+ * Since typescript does type erasure, these tests have to be compile time checks.
+ */
+declare class Empty1 {
+}
+declare class Empty2 {
+}
+declare class Nominal1 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Nominal2 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Derived1 extends Nominal1 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Derived2 extends Nominal1 {
+    protected _typeCheck?: MakeNominal;
+}
+declare class Generic<_T> {
+}
+declare class GenericCovariant<out T> {
+    protected _typeCheck?: Covariant<T>;
+}
+declare class GenericContravariant<in T> {
+    protected _typeCheck?: Contravariant<T>;
+}
+declare class GenericInvariant<in out T> {
+    protected _typeCheck?: Invariant<T>;
+}
+declare class GenericMulti<in out T, out K> {
+    protected _typeCheck?: Invariant<T> & Covariant<K>;
+}
+interface GenericCovariantInterface<out T> {
+    _typeCheck?: Covariant<T>;
+}
+interface GenericContravariantInterface<in T> {
+    _typeCheck?: Contravariant<T>;
+}
+interface GenericInvariantInterface<in out T> {
+    _typeCheck?: Invariant<T>;
+}
+declare class GenericInvariantImplementation<T> implements GenericInvariantInterface<T> {
+}
+/**
+ * Import this into a context where you want to be sure the TypeCheck library is functioning properly.
+ *
+ * It's functionality depends on compiler settings (requires several of the strict options),
+ * and could break with compiler version changes.
+ * Thus for maximal confidence everything is working correctly, you need to import this.
+ */
+export type EnforceTypeCheckTests = requireTrue<isAssignableTo<GenericInvariantImplementation<number>, GenericInvariantInterface<number>>> | requireTrue<true> | requireFalse<false> | requireTrue<isAssignableTo<Empty1, Empty1>> | requireTrue<isAssignableTo<Empty1, Empty2>> | requireTrue<isAssignableTo<Nominal1, Nominal1>> | requireFalse<isAssignableTo<Nominal1, Nominal2>> | requireTrue<isAssignableTo<Derived1, Nominal1>> | requireFalse<isAssignableTo<Derived1, Derived2>> | requireTrue<isAssignableTo<Generic<Nominal1>, Generic<Nominal2>>> | requireTrue<isAssignableTo<any, Nominal1>> | requireTrue<isAssignableTo<Nominal1, any>> | requireFalse<isAssignableTo<unknown, Nominal1>> | requireTrue<isAssignableTo<Nominal1, unknown>> | requireTrue<isAssignableTo<never, Nominal1>> | requireFalse<isAssignableTo<Nominal1, never>> | requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Nominal2>>> | requireTrue<isAssignableTo<GenericCovariant<Derived1>, GenericCovariant<Nominal1>>> | requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Derived1>>> | requireFalse<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Nominal2>>> | requireFalse<isAssignableTo<GenericContravariant<Derived1>, GenericContravariant<Nominal1>>> | requireTrue<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Derived1>>> | requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Nominal2>>> | requireFalse<isAssignableTo<GenericInvariant<Derived1>, GenericInvariant<Nominal1>>> | requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Derived1>>> | requireFalse<isAssignableTo<GenericMulti<Nominal1, number>, GenericMulti<Derived1, number>>> | requireFalse<isAssignableTo<GenericMulti<number, Nominal1>, GenericMulti<number, Derived1>>> | requireTrue<isAssignableTo<GenericMulti<number, Derived1>, GenericMulti<number, Nominal1>>> | requireFalse<isAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Nominal2>>> | requireTrue<isAssignableTo<GenericCovariantInterface<Derived1>, GenericCovariantInterface<Nominal1>>> | requireFalse<isAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Derived1>>> | requireFalse<isAssignableTo<GenericContravariantInterface<Nominal1>, GenericContravariantInterface<Nominal2>>> | requireFalse<isAssignableTo<GenericContravariantInterface<Derived1>, GenericContravariantInterface<Nominal1>>> | requireTrue<isAssignableTo<GenericContravariantInterface<Nominal1>, GenericContravariantInterface<Derived1>>> | requireFalse<isAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Nominal2>>> | requireFalse<isAssignableTo<GenericInvariantInterface<Derived1>, GenericInvariantInterface<Nominal1>>> | requireFalse<isAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Derived1>>> | requireTrue<eitherIsAny<any, Nominal1>> | requireTrue<eitherIsAny<Nominal1, any>> | requireTrue<eitherIsAny<any, any>> | requireFalse<eitherIsAny<Nominal1, Nominal1>> | requireTrue<areSafelyAssignable<Nominal1, Nominal1>> | requireFalse<areSafelyAssignable<unknown, Nominal1>> | requireFalse<areSafelyAssignable<any, any>> | requireTrue<areSafelyAssignable<unknown, unknown>> | requireFalse<areSafelyAssignable<any, Nominal1>> | requireFalse<areSafelyAssignable<Nominal1, any>> | requireFalse<areSafelyAssignable<unknown, any>> | requireTrue<isAny<any>> | requireFalse<isAny<unknown>> | requireFalse<isAny<Nominal1>> | requireFalse<isAny<never>> | requireFalse<isAny<{}>> | requireFalse<isAny<boolean>> | requireFalse<isAny<number | undefined>> | requireFalse<isAny<1 & "x">> | requireFalse<isAny<(1 & 2) | {}>> | requireTrue<isStrictSubset<1, 1 | 2>> | requireTrue<isStrictSubset<[1, true], [1 | 2, true]>> | requireTrue<isStrictSubset<[1, true], [1 | 2, true | false]>> | requireTrue<isStrictSubset<[1, true], [1, true | false]>> | requireTrue<isStrictSubset<[1, true], [1, true] | [1 | false]>> | requireFalse<isStrictSubset<1, 1>> | requireFalse<isStrictSubset<1, 2>> | requireFalse<isStrictSubset<[1, true], [1, true]>> | requireFalse<isStrictSubset<1 | 2, 1>>;
+export {};
+//# sourceMappingURL=typeCheckTests.d.ts.map

package/dist/util/typeCheckTests.d.ts.map

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

package/dist/util/typeCheckTests.js

@@ -0,0 +1,7 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=typeCheckTests.js.map

package/dist/util/typeCheckTests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeCheckTests.js","sourceRoot":"","sources":["../../src/util/typeCheckTests.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// These tests include making sure some banned types (like `{}`) work correctly,\n// and are authored with awareness of the issues with these types.\n\n/* eslint-disable @typescript-eslint/ban-types */\n/* eslint-disable @typescript-eslint/no-extraneous-class */\n\nimport {\n\tMakeNominal,\n\tCovariant,\n\tContravariant,\n\tInvariant,\n\trequireTrue,\n\trequireFalse,\n\tisAssignableTo,\n\tareSafelyAssignable,\n\tisAny,\n\teitherIsAny,\n\tisStrictSubset,\n} from \"./typeCheck\";\n\n/**\n * Checks that typeCheck's constraints work as intended.\n * Since typescript does type erasure, these tests have to be compile time checks.\n */\n\ndeclare class Empty1 {}\ndeclare class Empty2 {}\n\ndeclare class Nominal1 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Nominal2 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Derived1 extends Nominal1 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Derived2 extends Nominal1 {\n\tprotected _typeCheck?: MakeNominal;\n}\n\ndeclare class Generic<_T> {}\n\ndeclare class GenericCovariant<out T> {\n\tprotected _typeCheck?: Covariant<T>;\n}\n\ndeclare class GenericContravariant<in T> {\n\tprotected _typeCheck?: Contravariant<T>;\n}\n\ndeclare class GenericInvariant<in out T> {\n\tprotected _typeCheck?: Invariant<T>;\n}\n\ndeclare class GenericMulti<in out T, out K> {\n\tprotected _typeCheck?: Invariant<T> & Covariant<K>;\n}\n\ninterface GenericCovariantInterface<out T> {\n\t_typeCheck?: Covariant<T>;\n}\n\ninterface GenericContravariantInterface<in T> {\n\t_typeCheck?: Contravariant<T>;\n}\n\ninterface GenericInvariantInterface<in out T> {\n\t_typeCheck?: Invariant<T>;\n}\n\n// Check that interface can be implemented without needing extra members\ndeclare class GenericInvariantImplementation<T> implements GenericInvariantInterface<T> {}\n\n/**\n * Import this into a context where you want to be sure the TypeCheck library is functioning properly.\n *\n * It's functionality depends on compiler settings (requires several of the strict options),\n * and could break with compiler version changes.\n * Thus for maximal confidence everything is working correctly, you need to import this.\n */\nexport type EnforceTypeCheckTests =\n\t// Add dummy use of type checking types above\n\t| requireTrue<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericInvariantImplementation<number>,\n\t\t\t\tGenericInvariantInterface<number>\n\t\t\t>\n\t  >\n\n\t// Positive tests\n\t| requireTrue<true>\n\t| requireFalse<false>\n\n\t// test isAssignableTo for normal types\n\t| requireTrue<isAssignableTo<Empty1, Empty1>>\n\t| requireTrue<isAssignableTo<Empty1, Empty2>>\n\t| requireTrue<isAssignableTo<Nominal1, Nominal1>>\n\t| requireFalse<isAssignableTo<Nominal1, Nominal2>>\n\t| requireTrue<isAssignableTo<Derived1, Nominal1>>\n\t| requireFalse<isAssignableTo<Derived1, Derived2>>\n\t| requireTrue<isAssignableTo<Generic<Nominal1>, Generic<Nominal2>>>\n\n\t// test isAssignableTo for any\n\t| requireTrue<isAssignableTo<any, Nominal1>>\n\t| requireTrue<isAssignableTo<Nominal1, any>>\n\n\t// test isAssignableTo for unknown: all types are assignable to unknown\n\t| requireFalse<isAssignableTo<unknown, Nominal1>>\n\t| requireTrue<isAssignableTo<Nominal1, unknown>>\n\n\t// test isAssignableTo for never: all types are assignable from never\n\t| requireTrue<isAssignableTo<never, Nominal1>>\n\t| requireFalse<isAssignableTo<Nominal1, never>>\n\n\t// test Covariant\n\t| requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Nominal2>>>\n\t| requireTrue<isAssignableTo<GenericCovariant<Derived1>, GenericCovariant<Nominal1>>>\n\t| requireFalse<isAssignableTo<GenericCovariant<Nominal1>, GenericCovariant<Derived1>>>\n\n\t// test Contravariant\n\t| requireFalse<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Nominal2>>>\n\t| requireFalse<isAssignableTo<GenericContravariant<Derived1>, GenericContravariant<Nominal1>>>\n\t| requireTrue<isAssignableTo<GenericContravariant<Nominal1>, GenericContravariant<Derived1>>>\n\n\t// test Invariant\n\t| requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Nominal2>>>\n\t| requireFalse<isAssignableTo<GenericInvariant<Derived1>, GenericInvariant<Nominal1>>>\n\t| requireFalse<isAssignableTo<GenericInvariant<Nominal1>, GenericInvariant<Derived1>>>\n\n\t// test Multiple parameters\n\t| requireFalse<isAssignableTo<GenericMulti<Nominal1, number>, GenericMulti<Derived1, number>>>\n\t| requireFalse<isAssignableTo<GenericMulti<number, Nominal1>, GenericMulti<number, Derived1>>>\n\t| requireTrue<isAssignableTo<GenericMulti<number, Derived1>, GenericMulti<number, Nominal1>>>\n\n\t// test Covariant Interface\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Nominal2>>\n\t  >\n\t| requireTrue<\n\t\t\tisAssignableTo<GenericCovariantInterface<Derived1>, GenericCovariantInterface<Nominal1>>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericCovariantInterface<Nominal1>, GenericCovariantInterface<Derived1>>\n\t  >\n\n\t// test Contravariant Interface\n\t| requireFalse<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericContravariantInterface<Nominal1>,\n\t\t\t\tGenericContravariantInterface<Nominal2>\n\t\t\t>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericContravariantInterface<Derived1>,\n\t\t\t\tGenericContravariantInterface<Nominal1>\n\t\t\t>\n\t  >\n\t| requireTrue<\n\t\t\tisAssignableTo<\n\t\t\t\tGenericContravariantInterface<Nominal1>,\n\t\t\t\tGenericContravariantInterface<Derived1>\n\t\t\t>\n\t  >\n\n\t// test Invariant Interface\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Nominal2>>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericInvariantInterface<Derived1>, GenericInvariantInterface<Nominal1>>\n\t  >\n\t| requireFalse<\n\t\t\tisAssignableTo<GenericInvariantInterface<Nominal1>, GenericInvariantInterface<Derived1>>\n\t  >\n\n\t// test eitherIsAny\n\t| requireTrue<eitherIsAny<any, Nominal1>>\n\t| requireTrue<eitherIsAny<Nominal1, any>>\n\t| requireTrue<eitherIsAny<any, any>>\n\t| requireFalse<eitherIsAny<Nominal1, Nominal1>>\n\n\t// areSafelyAssignable tests\n\t| requireTrue<areSafelyAssignable<Nominal1, Nominal1>>\n\t| requireFalse<areSafelyAssignable<unknown, Nominal1>>\n\t| requireFalse<areSafelyAssignable<any, any>>\n\t| requireTrue<areSafelyAssignable<unknown, unknown>>\n\t| requireFalse<areSafelyAssignable<any, Nominal1>>\n\t| requireFalse<areSafelyAssignable<Nominal1, any>>\n\t| requireFalse<areSafelyAssignable<unknown, any>>\n\n\t// test isAny\n\t| requireTrue<isAny<any>>\n\t| requireFalse<isAny<unknown>>\n\t| requireFalse<isAny<Nominal1>>\n\t| requireFalse<isAny<never>>\n\t| requireFalse<isAny<{}>>\n\t| requireFalse<isAny<boolean>>\n\t| requireFalse<isAny<number | undefined>>\n\t| requireFalse<isAny<1 & \"x\">>\n\t| requireFalse<isAny<(1 & 2) | {}>>\n\n\t// test isStrictSubset\n\t| requireTrue<isStrictSubset<1, 1 | 2>>\n\t| requireTrue<isStrictSubset<[1, true], [1 | 2, true]>>\n\t| requireTrue<isStrictSubset<[1, true], [1 | 2, true | false]>>\n\t| requireTrue<isStrictSubset<[1, true], [1, true | false]>>\n\t| requireTrue<isStrictSubset<[1, true], [1, true] | [1 | false]>>\n\t| requireFalse<isStrictSubset<1, 1>>\n\t| requireFalse<isStrictSubset<1, 2>>\n\t| requireFalse<isStrictSubset<[1, true], [1, true]>>\n\t| requireFalse<isStrictSubset<1 | 2, 1>>;\n\n// negative tests (should not build)\n// @ts-expect-error negative test\ntype _falseIsTrue = requireTrue<false>;\n// @ts-expect-error negative test\ntype _trueIsFalse = requireFalse<true>;\n// @ts-expect-error negative test\ntype _booleanIsTrue = requireTrue<boolean>;\n// @ts-expect-error negative test\ntype _booleanIsFalse = requireFalse<boolean>;\n// @ts-expect-error negative test\ntype _emptyNotAssignable = requireFalse<isAssignableTo<Empty1, Empty2>>;\n// @ts-expect-error negative test\ntype _numberAssignableToString = requireTrue<isAssignableTo<number, string>>;\n// @ts-expect-error negative test\ntype _anyNotAny = requireFalse<isAny<any>>;\n"]}

package/dist/util/typeUtils.d.ts

@@ -0,0 +1,129 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * Utilities for manipulating types.
+ */
+/**
+ * Return a type thats equivalent to the input, but with different IntelliSense.
+ * This tends to convert unions and intersections into objects.
+ * @internal
+ */
+export type FlattenKeys<T> = [{
+    [Property in keyof T]: T[Property];
+}][_InlineTrick];
+/**
+ * Remove all fields which permit undefined from `T`.
+ * @internal
+ */
+export type RequiredFields<T> = [
+    {
+        [P in keyof T as undefined extends T[P] ? never : P]: T[P];
+    }
+][_InlineTrick];
+/**
+ * Extract fields which permit undefined but can also hold other types.
+ * @internal
+ */
+export type OptionalFields<T> = [
+    {
+        [P in keyof T as undefined extends T[P] ? T[P] extends undefined ? never : P : never]?: T[P];
+    }
+][_InlineTrick];
+/**
+ * Converts properties of an object which permit undefined into optional properties.
+ * Removes fields which only allow undefined.
+ *
+ * @remarks
+ * This version does not flatten the resulting type.
+ * This version exists because some cases recursive types need to avoid this
+ * flattening since it causes complication issues.
+ *
+ * See also `AllowOptional`.
+ * @internal
+ */
+export type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];
+/**
+ * Converts properties of an object which permit undefined into optional properties.
+ * Removes fields which only allow undefined.
+ * @internal
+ */
+export type AllowOptional<T> = [FlattenKeys<RequiredFields<T> & OptionalFields<T>>][_InlineTrick];
+/**
+ * Use for trick to "inline" generic types.
+ *
+ * @remarks
+ * The TypeScript compiler can be convinced to inline a generic type
+ * (so the result of evaluating the generic type show up in IntelliSense and error messages instead of just the invocation of the generic type)
+ * by creating an object with a field, and returning the type of that field.
+ *
+ * For example:
+ * ```typescript
+ * type MyGeneric<T1, T2> = {x: T1 extends [] ? T1 : T2 };
+ * type MyGenericExpanded<T1, T2> = [{x: T1 extends [] ? T1 : T2 }][_InlineTrick]
+ *
+ * // Type is MyGeneric<5, string>
+ * const foo: MyGeneric<5, string> = {x: "x"}
+ * // Type is {x: "x"}
+ * const foo2: MyGenericExpanded<5, string> = {x: "x"}
+ * ```
+ *
+ * This constant is defined to provide a way to find this documentation from types which use this pattern,
+ * and to locate types which use this pattern in case they need updating for compiler changes.
+ * @internal
+ */
+export type _InlineTrick = 0;
+/**
+ * Use for trick to prevent self reference error `ts(2456)`.
+ *
+ * Prefix a type expression with `K extends _RecursiveTrick ? _RecursiveTrick : ` for some K to break the cycle.
+ *
+ * @remarks
+ * The TypeScript compiler handles some cases of recursive types, but not others.
+ * Sometimes adding an otherwise needless conditional can make a type compile.
+ * Use this type in such cases.
+ *
+ *For example:
+ * ```typescript
+ * // The TypeScript compiler can't handle this case
+ * type Broken<T> = FlattenKeys<
+ *	{
+ * 		[K in keyof T]: 0;
+ * 	} & {
+ * 		[K in keyof T]: Broken<T[K]>;
+ * 	}
+ * >;
+ *
+ * // Adding `K extends _RecursiveTrick ? _RecursiveTrick :` makes it compile, and has no effect on the type produced.
+ * type Works<T> = FlattenKeys<
+ * 	{
+ * 		[K in keyof T]: 0;
+ * 	} & {
+ * 		// Trick added here. Since `k` never extends `never`, the second conditional option is always taken,
+ * 		// making this equivalent to the broken version, except this one compiles.
+ * 		[K in keyof T]: K extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;
+ * 	}
+ * >;
+ * ```
+ *
+ * This trick appears to start working in TypeScript 4.1 and is confirmed to still work in 5.0.4.
+ *
+ * This constant is defined to provide a way to find this documentation from types which use this pattern,
+ * and to locate types which use this pattern in case they need updating for compiler changes.
+ * @internal
+ */
+export type _RecursiveTrick = never;
+/**
+ * Alternative to the built in Record type which does not permit unexpected members,
+ * and is readonly.
+ *
+ * @privateRemarks
+ * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.
+ * The cause for this is unclear, but empirically it was the case when this comment was written.
+ * @beta
+ */
+export type RestrictiveReadonlyRecord<K extends symbol | string, T> = {
+    readonly [P in symbol | string]: P extends K ? T : never;
+};
+//# sourceMappingURL=typeUtils.d.ts.map

package/dist/util/typeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.d.ts","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC;KAAG,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;CAAE,CAAC,CAAC,YAAY,CAAC,CAAC;AAEpF;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC/B;SACE,CAAC,IAAI,MAAM,CAAC,IAAI,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC1D;CACD,CAAC,YAAY,CAAC,CAAC;AAEhB;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC/B;SACE,CAAC,IAAI,MAAM,CAAC,IAAI,SAAS,SAAS,CAAC,CAAC,CAAC,CAAC,GACpC,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,GACrB,KAAK,GACL,CAAC,GACF,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;KAChB;CACD,CAAC,YAAY,CAAC,CAAC;AAEhB;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,yBAAyB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAEjG;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,CAAC;AA8BpC;;;;;;;;GAQG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI;IACrE,QAAQ,EAAE,CAAC,IAAI,MAAM,GAAG,MAAM,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CACxD,CAAC"}

package/dist/util/typeUtils.js

@@ -0,0 +1,11 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// This block is kept here to ensure the above example behaves as documented, and can be copied into the example to update it as needed.
+{
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+}
+//# sourceMappingURL=typeUtils.js.map

package/dist/util/typeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeUtils.js","sourceRoot":"","sources":["../../src/util/typeUtils.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AA6HH,wIAAwI;AACxI;IAwBC,qDAAqD;CACrD","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * Utilities for manipulating types.\n */\n\n/**\n * Return a type thats equivalent to the input, but with different IntelliSense.\n * This tends to convert unions and intersections into objects.\n * @internal\n */\nexport type FlattenKeys<T> = [{ [Property in keyof T]: T[Property] }][_InlineTrick];\n\n/**\n * Remove all fields which permit undefined from `T`.\n * @internal\n */\nexport type RequiredFields<T> = [\n\t{\n\t\t[P in keyof T as undefined extends T[P] ? never : P]: T[P];\n\t},\n][_InlineTrick];\n\n/**\n * Extract fields which permit undefined but can also hold other types.\n * @internal\n */\nexport type OptionalFields<T> = [\n\t{\n\t\t[P in keyof T as undefined extends T[P]\n\t\t\t? T[P] extends undefined\n\t\t\t\t? never\n\t\t\t\t: P\n\t\t\t: never]?: T[P];\n\t},\n][_InlineTrick];\n\n/**\n * Converts properties of an object which permit undefined into optional properties.\n * Removes fields which only allow undefined.\n *\n * @remarks\n * This version does not flatten the resulting type.\n * This version exists because some cases recursive types need to avoid this\n * flattening since it causes complication issues.\n *\n * See also `AllowOptional`.\n * @internal\n */\n// export type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];\nexport type AllowOptionalNotFlattened<T> = [RequiredFields<T> & OptionalFields<T>][_InlineTrick];\n\n/**\n * Converts properties of an object which permit undefined into optional properties.\n * Removes fields which only allow undefined.\n * @internal\n */\nexport type AllowOptional<T> = [FlattenKeys<RequiredFields<T> & OptionalFields<T>>][_InlineTrick];\n\n/**\n * Use for trick to \"inline\" generic types.\n *\n * @remarks\n * The TypeScript compiler can be convinced to inline a generic type\n * (so the result of evaluating the generic type show up in IntelliSense and error messages instead of just the invocation of the generic type)\n * by creating an object with a field, and returning the type of that field.\n *\n * For example:\n * ```typescript\n * type MyGeneric<T1, T2> = {x: T1 extends [] ? T1 : T2 };\n * type MyGenericExpanded<T1, T2> = [{x: T1 extends [] ? T1 : T2 }][_InlineTrick]\n *\n * // Type is MyGeneric<5, string>\n * const foo: MyGeneric<5, string> = {x: \"x\"}\n * // Type is {x: \"x\"}\n * const foo2: MyGenericExpanded<5, string> = {x: \"x\"}\n * ```\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n * @internal\n */\nexport type _InlineTrick = 0;\n\n/**\n * Use for trick to prevent self reference error `ts(2456)`.\n *\n * Prefix a type expression with `K extends _RecursiveTrick ? _RecursiveTrick : ` for some K to break the cycle.\n *\n * @remarks\n * The TypeScript compiler handles some cases of recursive types, but not others.\n * Sometimes adding an otherwise needless conditional can make a type compile.\n * Use this type in such cases.\n *\n *For example:\n * ```typescript\n * // The TypeScript compiler can't handle this case\n * type Broken<T> = FlattenKeys<\n *\t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t[K in keyof T]: Broken<T[K]>;\n * \t}\n * >;\n *\n * // Adding `K extends _RecursiveTrick ? _RecursiveTrick :` makes it compile, and has no effect on the type produced.\n * type Works<T> = FlattenKeys<\n * \t{\n * \t\t[K in keyof T]: 0;\n * \t} & {\n * \t\t// Trick added here. Since `k` never extends `never`, the second conditional option is always taken,\n * \t\t// making this equivalent to the broken version, except this one compiles.\n * \t\t[K in keyof T]: K extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n * \t}\n * >;\n * ```\n *\n * This trick appears to start working in TypeScript 4.1 and is confirmed to still work in 5.0.4.\n *\n * This constant is defined to provide a way to find this documentation from types which use this pattern,\n * and to locate types which use this pattern in case they need updating for compiler changes.\n * @internal\n */\nexport type _RecursiveTrick = never;\n\n// This block is kept here to ensure the above example behaves as documented, and can be copied into the example to update it as needed.\n{\n\t/* eslint-disable @typescript-eslint/no-unused-vars */\n\n\t// @ts-expect-error The TypeScript compiler can't handle this case\n\ttype Broken<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// @ts-expect-error Same error as above.\n\t\t\t[K in keyof T]: Broken<T[K]>;\n\t\t}\n\t>;\n\n\t// Adding `K extends _RecursiveTrick ? _RecursiveTrick:` OR `T extends _RecursiveTrick ? _RecursiveTrick :` makes it compile and has no effect on the type produced.\n\ttype Works<T> = FlattenKeys<\n\t\t{\n\t\t\t[K in keyof T]: 0;\n\t\t} & {\n\t\t\t// Trick added here. Since `K` never extends `never`, the second conditional option is always taken,\n\t\t\t// making this equivalent to the broken version, except this one compiles.\n\t\t\t[K in keyof T]: T extends _RecursiveTrick ? _RecursiveTrick : Works<T[K]>;\n\t\t}\n\t>;\n\n\t/* eslint-enable @typescript-eslint/no-unused-vars */\n}\n\n/**\n * Alternative to the built in Record type which does not permit unexpected members,\n * and is readonly.\n *\n * @privateRemarks\n * `number` is not allowed as a key here since doing so causes the compiler to reject recursive schema.\n * The cause for this is unclear, but empirically it was the case when this comment was written.\n * @beta\n */\nexport type RestrictiveReadonlyRecord<K extends symbol | string, T> = {\n\treadonly [P in symbol | string]: P extends K ? T : never;\n};\n"]}

package/dist/util/utils.d.ts

@@ -0,0 +1,287 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import structuredClone from "@ungap/structured-clone";
+import { StableId } from "@fluidframework/id-compressor";
+/**
+ * Subset of Map interface.
+ */
+export interface MapGetSet<K, V> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+}
+/**
+ * Make all transitive properties in T readonly
+ */
+export type RecursiveReadonly<T> = {
+    readonly [P in keyof T]: RecursiveReadonly<T[P]>;
+};
+/**
+ * Remove `readonly` from all fields.
+ */
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * Make all field required and omits fields whose ony valid value would be `undefined`.
+ * This is analogous to `Required<T>` except it tolerates 'optional undefined'.
+ */
+export type Populated<T> = {
+    [P in keyof T as Exclude<P, T[P] extends undefined ? P : never>]-?: T[P];
+};
+/**
+ * Casts a readonly object to a mutable one.
+ * Better than casting to `Mutable<Foo>` because it doesn't risk casting a non-`Foo` to a `Mutable<Foo>`.
+ * @param readonly - The object with readonly fields.
+ * @returns The same object but with a type that makes all fields mutable.
+ */
+export declare function asMutable<T>(readonly: T): Mutable<T>;
+export declare const clone: typeof structuredClone;
+/**
+ * @internal
+ */
+export declare function fail(message: string): never;
+/**
+ * Checks whether or not the given object is a `readonly` array.
+ *
+ * Note that this does NOT indicate if a given array should be treated as readonly.
+ * This instead indicates if an object is an Array, and is typed to tolerate the readonly case.
+ */
+export declare function isReadonlyArray<T>(x: readonly T[] | unknown): x is readonly T[];
+/**
+ * Creates and populates a new array.
+ * @param size - The size of the array to be created.
+ * @param filler - Callback for populating the array with a value for a given index
+ */
+export declare function makeArray<T>(size: number, filler: (index: number) => T): T[];
+/**
+ * Compares two sets using callbacks.
+ * Early returns on first false comparison.
+ *
+ * @param a - One Set.
+ * @param b - The other Set.
+ * @param aExtra - Called for items in `a` but not `b`.
+ * @param bExtra - Called for items in `b` but not `a`.
+ * @param same - Called for items in `a` and `b`.
+ * @returns false iff any of the call backs returned false.
+ */
+export declare function compareSets<T>({ a, b, aExtra, bExtra, same, }: {
+    a: ReadonlySet<T> | ReadonlyMap<T, unknown>;
+    b: ReadonlySet<T> | ReadonlyMap<T, unknown>;
+    aExtra?: (t: T) => boolean;
+    bExtra?: (t: T) => boolean;
+    same?: (t: T) => boolean;
+}): boolean;
+/**
+ * Retrieve a value from a map with the given key, or create a new entry if the key is not in the map.
+ * @param map - The map to query/update
+ * @param key - The key to lookup in the map
+ * @param defaultValue - a function which returns a default value. This is called and used to set an initial value for the given key in the map if none exists
+ * @returns either the existing value for the given key, or the newly-created value (the result of `defaultValue`)
+ */
+export declare function getOrCreate<K, V>(map: MapGetSet<K, V>, key: K, defaultValue: (key: K) => V): V;
+/**
+ * Utility for dictionaries whose values are lists.
+ * Gets the list associated with the provided key, if it exists.
+ * Otherwise, creates an entry with an empty list, and returns that list.
+ */
+export declare function getOrAddEmptyToMap<K, V>(map: MapGetSet<K, V[]>, key: K): V[];
+/**
+ * Map one iterable to another by transforming each element one at a time
+ * @param iterable - the iterable to transform
+ * @param map - the transformation function to run on each element of the iterable
+ * @returns a new iterable of elements which have been transformed by the `map` function
+ */
+export declare function mapIterable<T, U>(iterable: Iterable<T>, map: (t: T) => U): Iterable<U>;
+/**
+ * Returns an iterable of tuples containing pairs of elements from the given iterables
+ * @param iterableA - an iterable to zip together with `iterableB`
+ * @param iterableB - an iterable to zip together with `iterableA`
+ * @returns in iterable of tuples of elements zipped together from `iterableA` and `iterableB`.
+ * If the input iterables are of different lengths, then the extra elements in the longer will be ignored.
+ */
+export declare function zipIterables<T, U>(iterableA: Iterable<T>, iterableB: Iterable<U>): Iterable<[T, U]>;
+/**
+ * Use for Json compatible data.
+ *
+ * Note that this does not robustly forbid non json comparable data via type checking,
+ * but instead mostly restricts access to it.
+ * @internal
+ */
+export type JsonCompatible = string | number | boolean | null | JsonCompatible[] | JsonCompatibleObject;
+/**
+ * Use for Json object compatible data.
+ *
+ * Note that this does not robustly forbid non json comparable data via type checking,
+ * but instead mostly restricts access to it.
+ * @internal
+ */
+export type JsonCompatibleObject = {
+    [P in string]?: JsonCompatible;
+};
+/**
+ * Use for readonly view of Json compatible data.
+ *
+ * Note that this does not robustly forbid non json comparable data via type checking,
+ * but instead mostly restricts access to it.
+ * @internal
+ */
+export type JsonCompatibleReadOnly = string | number | boolean | null | readonly JsonCompatibleReadOnly[] | {
+    readonly [P in string]?: JsonCompatibleReadOnly;
+};
+/**
+ * @remarks TODO: Audit usage of this type in schemas, evaluating whether it is necessary and performance
+ * of alternatives.
+ *
+ * True "arbitrary serializable data" is probably fine, but some persisted types declarations might be better
+ * expressed using composition of schemas for runtime validation, even if we don't think making the types
+ * generic is worth the maintenance cost.
+ */
+export declare const JsonCompatibleReadOnlySchema: import("@sinclair/typebox").TAny;
+/**
+ * Returns if a particular json compatible value is an object.
+ * Does not include `null` or arrays.
+ */
+export declare function isJsonObject(value: JsonCompatibleReadOnly): value is {
+    readonly [P in string]?: JsonCompatibleReadOnly;
+};
+/**
+ * Verifies that the supplied indices are valid within the supplied array.
+ * @param startIndex - The starting index in the range. Must be in [0, length).
+ * @param endIndex - The ending index in the range. Must be within (start, length].
+ * @param array - The array the indices refer to
+ */
+export declare function assertValidRangeIndices(startIndex: number, endIndex: number, array: {
+    readonly length: number;
+}): void;
+export declare function assertValidIndex(index: number, array: {
+    readonly length: number;
+}, allowOnePastEnd?: boolean): void;
+export declare function assertValidRange({ start, end }: {
+    start: number;
+    end: number;
+}, array: {
+    readonly length: number;
+}): void;
+export declare function assertNonNegativeSafeInteger(index: number): void;
+/**
+ * Assume that `TInput` is a `TAssumeToBe`.
+ *
+ * @remarks
+ * This is useful in generic code when it is impractical (or messy)
+ * to to convince the compiler that a generic type `TInput` will extend `TAssumeToBe`.
+ * In these cases `TInput` can be replaced with `Assume<TInput, TAssumeToBe>` to allow compilation of the generic code.
+ * When the generic code is parameterized with a concrete type, if that type actually does extend `TAssumeToBe`,
+ * it will behave like `TInput` was used directly.
+ *
+ * @internal
+ */
+export type Assume<TInput, TAssumeToBe> = [TInput] extends [TAssumeToBe] ? TInput : TAssumeToBe;
+/**
+ * Runs `f` with {@link generateStableId} altered to return sequential StableIds starting as a fixed seed.
+ * Used to make test logic that uses {@link generateStableId} deterministic.
+ *
+ * @remarks Only use this function for testing purposes.
+ *
+ * @example
+ *
+ * ```typescript
+ * function f() {
+ *    const id = generateStableId();
+ *    ...
+ * }
+ * const result = useDeterministicStableId(f());
+ * ```
+ */
+export declare function useDeterministicStableId<T>(f: () => T): T;
+export declare function useAsyncDeterministicStableId<T>(f: () => Promise<T>): Promise<T>;
+/**
+ * Generates a random StableId.
+ *
+ * For test usage desiring deterministic results, see {@link useDeterministicStableId}.
+ */
+export declare function generateStableId(): StableId;
+/**
+ * Convert an object into a Map.
+ *
+ * This function must only be used with objects specifically intended to encode map like information.
+ * The only time such objects should be used is for encoding maps as object literals to allow for developer ergonomics or JSON compatibility.
+ * Even those two use-cases need to be carefully considered as using objects as maps can have a lot of issues
+ * (including but not limited to unintended access to __proto__ and other non-owned keys).
+ * This function helps these few cases get into using an actual map in as safe of was as is practical.
+ */
+export declare function objectToMap<MapKey extends string | number | symbol, MapValue>(objectMap: Record<MapKey, MapValue>): Map<MapKey, MapValue>;
+/**
+ * Convert an object used as a map into a new object used like a map.
+ *
+ * @remarks
+ * This function must only be used with objects specifically intended to encode map like information.
+ * The only time such objects should be used is for encoding maps as object literals to allow for developer ergonomics or JSON compatibility.
+ * Even those two use-cases need to be carefully considered as using objects as maps can have a lot of issues
+ * (including but not limited to unintended access to __proto__ and other non-owned keys).
+ * {@link objectToMap} helps these few cases get into using an actual map in as safe of a way as is practical.
+ */
+export declare function transformObjectMap<MapKey extends string | number | symbol, MapValue, NewMapValue>(objectMap: Record<MapKey, MapValue>, transformer: (value: MapValue, key: MapKey) => NewMapValue): Record<MapKey, MapValue>;
+/**
+ * Make an inverted copy of a map.
+ *
+ * @returns a map which can look up the keys from the values of the original map.
+ */
+export declare function invertMap<Key, Value>(input: Map<Key, Value>): Map<Value, Key>;
+/**
+ * Returns the value from `set` if it contains exactly one item, otherwise `undefined`.
+ * @internal
+ */
+export declare function oneFromSet<T>(set: ReadonlySet<T> | undefined): T | undefined;
+/**
+ * Type with a name describing what it is.
+ * Typically used with values (like schema) that can be stored in a map, but in some representations have their name/key as a field.
+ * @internal
+ */
+export interface Named<TName> {
+    readonly name: TName;
+}
+/**
+ * Order {@link Named} objects by their name.
+ * @internal
+ */
+export declare function compareNamed(a: Named<string>, b: Named<string>): -1 | 0 | 1;
+/**
+ * Placeholder for `Symbol.dispose`.
+ *
+ * Replace this with `Symbol.dispose` when it is available.
+ * @beta
+ */
+export declare const disposeSymbol: unique symbol;
+/**
+ * An object with an explicit lifetime that can be ended.
+ * @privateRemarks
+ * TODO: align this with core-utils/IDisposable and {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#using-declarations-and-explicit-resource-management| TypeScript's Disposable}.
+ * @beta
+ */
+export interface IDisposable {
+    /**
+     * Call to end the lifetime of this object.
+     *
+     * It is invalid to use this object after this,
+     * except for operations which explicitly document they are valid after disposal.
+     *
+     * @remarks
+     * May cleanup resources retained by this object.
+     * Often includes un-registering from events and thus preventing other objects from retaining a reference to this indefinably.
+     *
+     * Usually the only operations allowed after disposal are querying if an object is already disposed,
+     * but this can vary between implementations.
+     */
+    [disposeSymbol](): void;
+}
+/**
+ * Capitalize a string.
+ */
+export declare function capitalize<S extends string>(s: S): Capitalize<S>;
+/**
+ * Compares strings lexically to form a strict partial ordering.
+ */
+export declare function compareStrings<T extends string>(a: T, b: T): number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/util/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/util/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,eAAe,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAGN,QAAQ,EACR,MAAM,+BAA+B,CAAC;AAEvC;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,EAAE,CAAC;IAC9B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAC3B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IAClC,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAChD,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAE5D;;;GAGG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACxE,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEpD;AAED,eAAO,MAAM,KAAK,wBAAkB,CAAC;AAErC;;GAEG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAE3C;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,GAAG,OAAO,GAAG,CAAC,IAAI,SAAS,CAAC,EAAE,CAK/E;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,EAAE,CAM5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAC9B,CAAC,EACD,CAAC,EACD,MAAM,EACN,MAAM,EACN,IAAI,GACJ,EAAE;IACF,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;IAC5C,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAC3B,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;IAC3B,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CACzB,GAAG,OAAO,CAoBV;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAO9F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAO5E;AAED;;;;;GAKG;AACH,wBAAiB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAIvF;AAED;;;;;;GAMG;AACH,wBAAiB,YAAY,CAAC,CAAC,EAAE,CAAC,EACjC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,GACpB,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAUlB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GACvB,MAAM,GACN,MAAM,GACN,OAAO,GAEP,IAAI,GACJ,cAAc,EAAE,GAChB,oBAAoB,CAAC;AAExB;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,cAAc;CAAE,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAC/B,MAAM,GACN,MAAM,GACN,OAAO,GAEP,IAAI,GACJ,SAAS,sBAAsB,EAAE,GACjC;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,sBAAsB;CAAE,CAAC;AAEvD;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,kCAAa,CAAC;AAEvD;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,sBAAsB,GAC3B,KAAK,IAAI;IAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,EAAE,sBAAsB;CAAE,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,QAKlC;AAED,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAClC,eAAe,GAAE,OAAe,QAQhC;AAED,wBAAgB,gBAAgB,CAC/B,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAC9C,KAAK,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,QAMlC;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,QAGzD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,EAAE,WAAW,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,GAAG,MAAM,GAAG,WAAW,CAAC;AAOhG;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAazD;AAED,wBAAsB,6BAA6B,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAatF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CAc3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,QAAQ,EAC5E,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GACjC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAQvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,WAAW,EAChG,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,EACnC,WAAW,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,KAAK,WAAW,GACxD,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAa1B;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAI7E;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS,CAU5E;AAED;;;;GAIG;AACH,MAAM,WAAW,KAAK,CAAC,KAAK;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACrB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAQ3E;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,OAAO,MAA6C,CAAC;AAEjF;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC3B;;;;;;;;;;;;OAYG;IACH,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAUhE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAEnE"}