Recursive utility aliases N=240
Recursive utility alias applications that stress generic instantiation, substitution, and cache reuse.
tsz is 1.4x faster 5804 lines 161 KB
Timing
Files
// Recursive utility alias scale benchmark.
// Varies alias names, type parameters, and wrapper shape while exercising
// recursive mapped/indexed-access/conditional utility applications.
type AliasCompute<TValue> = TValue extends (...args: infer Params) => infer Result
? (...args: Params) => Result
: TValue extends readonly [infer Head, ...infer Tail]
? readonly [AliasCompute<Head>, ...AliasCompute<Tail>]
: TValue extends object
? { [Key in keyof TValue]: AliasCompute<TValue[Key]> }
: TValue;
type NormalizeBox<Input> = Input extends object
? { [Field in keyof Input]: NormalizeBox<Input[Field]> }
: Input;
type DeepReadonlyVariant<Subject> = Subject extends (...args: any[]) => any
? Subject
: Subject extends readonly [infer First, ...infer Rest]
? readonly [DeepReadonlyVariant<First>, ...DeepReadonlyVariant<Rest>]
: Subject extends object
? { readonly [Name in keyof Subject]: DeepReadonlyVariant<Subject[Name]> }
: Subject;
type PickStringKeys<RecordLike> = {
[Member in keyof RecordLike as Member extends string ? Member : never]: RecordLike[Member]
};
type UtilityPipeline<Seed> = AliasCompute<
NormalizeBox<
DeepReadonlyVariant<
PickStringKeys<Seed>
>
>
>;
interface LeafPayload {
id: string;
count: number;
flags: {
enabled: boolean;
labels: readonly ["fast", "safe", "deep"];
};
}
type Variant0<Source0> = UtilityPipeline<{
readonly item0: Source0;
readonly nested0: {
readonly left: Source0;
readonly right: LeafPayload;
readonly tuple: readonly [Source0, LeafPayload, { wrapped: Source0 }];
};
}>;
type Materialized0 = Variant0<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized0: Materialized0;
const recursiveUtilityValue0: string =
materialized0.nested0.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant1<Source1> = UtilityPipeline<{
readonly item1: Source1;
readonly nested1: {
readonly left: Source1;
readonly right: LeafPayload;
readonly tuple: readonly [Source1, LeafPayload, { wrapped: Source1 }];
};
}>;
type Materialized1 = Variant1<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized1: Materialized1;
const recursiveUtilityValue1: string =
materialized1.nested1.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant2<Source2> = UtilityPipeline<{
readonly item2: Source2;
readonly nested2: {
readonly left: Source2;
readonly right: LeafPayload;
readonly tuple: readonly [Source2, LeafPayload, { wrapped: Source2 }];
};
}>;
type Materialized2 = Variant2<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized2: Materialized2;
const recursiveUtilityValue2: string =
materialized2.nested2.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant3<Source3> = UtilityPipeline<{
readonly item3: Source3;
readonly nested3: {
readonly left: Source3;
readonly right: LeafPayload;
readonly tuple: readonly [Source3, LeafPayload, { wrapped: Source3 }];
};
}>;
type Materialized3 = Variant3<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized3: Materialized3;
const recursiveUtilityValue3: string =
materialized3.nested3.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant4<Source4> = UtilityPipeline<{
readonly item4: Source4;
readonly nested4: {
readonly left: Source4;
readonly right: LeafPayload;
readonly tuple: readonly [Source4, LeafPayload, { wrapped: Source4 }];
};
}>;
type Materialized4 = Variant4<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized4: Materialized4;
const recursiveUtilityValue4: string =
materialized4.nested4.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant5<Source5> = UtilityPipeline<{
readonly item5: Source5;
readonly nested5: {
readonly left: Source5;
readonly right: LeafPayload;
readonly tuple: readonly [Source5, LeafPayload, { wrapped: Source5 }];
};
}>;
type Materialized5 = Variant5<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized5: Materialized5;
const recursiveUtilityValue5: string =
materialized5.nested5.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant6<Source6> = UtilityPipeline<{
readonly item6: Source6;
readonly nested6: {
readonly left: Source6;
readonly right: LeafPayload;
readonly tuple: readonly [Source6, LeafPayload, { wrapped: Source6 }];
};
}>;
type Materialized6 = Variant6<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized6: Materialized6;
const recursiveUtilityValue6: string =
materialized6.nested6.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant7<Source7> = UtilityPipeline<{
readonly item7: Source7;
readonly nested7: {
readonly left: Source7;
readonly right: LeafPayload;
readonly tuple: readonly [Source7, LeafPayload, { wrapped: Source7 }];
};
}>;
type Materialized7 = Variant7<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized7: Materialized7;
const recursiveUtilityValue7: string =
materialized7.nested7.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant8<Source8> = UtilityPipeline<{
readonly item8: Source8;
readonly nested8: {
readonly left: Source8;
readonly right: LeafPayload;
readonly tuple: readonly [Source8, LeafPayload, { wrapped: Source8 }];
};
}>;
type Materialized8 = Variant8<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized8: Materialized8;
const recursiveUtilityValue8: string =
materialized8.nested8.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant9<Source9> = UtilityPipeline<{
readonly item9: Source9;
readonly nested9: {
readonly left: Source9;
readonly right: LeafPayload;
readonly tuple: readonly [Source9, LeafPayload, { wrapped: Source9 }];
};
}>;
type Materialized9 = Variant9<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized9: Materialized9;
const recursiveUtilityValue9: string =
materialized9.nested9.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant10<Source10> = UtilityPipeline<{
readonly item10: Source10;
readonly nested10: {
readonly left: Source10;
readonly right: LeafPayload;
readonly tuple: readonly [Source10, LeafPayload, { wrapped: Source10 }];
};
}>;
type Materialized10 = Variant10<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized10: Materialized10;
const recursiveUtilityValue10: string =
materialized10.nested10.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant11<Source11> = UtilityPipeline<{
readonly item11: Source11;
readonly nested11: {
readonly left: Source11;
readonly right: LeafPayload;
readonly tuple: readonly [Source11, LeafPayload, { wrapped: Source11 }];
};
}>;
type Materialized11 = Variant11<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized11: Materialized11;
const recursiveUtilityValue11: string =
materialized11.nested11.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant12<Source12> = UtilityPipeline<{
readonly item12: Source12;
readonly nested12: {
readonly left: Source12;
readonly right: LeafPayload;
readonly tuple: readonly [Source12, LeafPayload, { wrapped: Source12 }];
};
}>;
type Materialized12 = Variant12<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized12: Materialized12;
const recursiveUtilityValue12: string =
materialized12.nested12.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant13<Source13> = UtilityPipeline<{
readonly item13: Source13;
readonly nested13: {
readonly left: Source13;
readonly right: LeafPayload;
readonly tuple: readonly [Source13, LeafPayload, { wrapped: Source13 }];
};
}>;
type Materialized13 = Variant13<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized13: Materialized13;
const recursiveUtilityValue13: string =
materialized13.nested13.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant14<Source14> = UtilityPipeline<{
readonly item14: Source14;
readonly nested14: {
readonly left: Source14;
readonly right: LeafPayload;
readonly tuple: readonly [Source14, LeafPayload, { wrapped: Source14 }];
};
}>;
type Materialized14 = Variant14<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized14: Materialized14;
const recursiveUtilityValue14: string =
materialized14.nested14.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant15<Source15> = UtilityPipeline<{
readonly item15: Source15;
readonly nested15: {
readonly left: Source15;
readonly right: LeafPayload;
readonly tuple: readonly [Source15, LeafPayload, { wrapped: Source15 }];
};
}>;
type Materialized15 = Variant15<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized15: Materialized15;
const recursiveUtilityValue15: string =
materialized15.nested15.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant16<Source16> = UtilityPipeline<{
readonly item16: Source16;
readonly nested16: {
readonly left: Source16;
readonly right: LeafPayload;
readonly tuple: readonly [Source16, LeafPayload, { wrapped: Source16 }];
};
}>;
type Materialized16 = Variant16<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized16: Materialized16;
const recursiveUtilityValue16: string =
materialized16.nested16.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant17<Source17> = UtilityPipeline<{
readonly item17: Source17;
readonly nested17: {
readonly left: Source17;
readonly right: LeafPayload;
readonly tuple: readonly [Source17, LeafPayload, { wrapped: Source17 }];
};
}>;
type Materialized17 = Variant17<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized17: Materialized17;
const recursiveUtilityValue17: string =
materialized17.nested17.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant18<Source18> = UtilityPipeline<{
readonly item18: Source18;
readonly nested18: {
readonly left: Source18;
readonly right: LeafPayload;
readonly tuple: readonly [Source18, LeafPayload, { wrapped: Source18 }];
};
}>;
type Materialized18 = Variant18<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized18: Materialized18;
const recursiveUtilityValue18: string =
materialized18.nested18.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant19<Source19> = UtilityPipeline<{
readonly item19: Source19;
readonly nested19: {
readonly left: Source19;
readonly right: LeafPayload;
readonly tuple: readonly [Source19, LeafPayload, { wrapped: Source19 }];
};
}>;
type Materialized19 = Variant19<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized19: Materialized19;
const recursiveUtilityValue19: string =
materialized19.nested19.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant20<Source20> = UtilityPipeline<{
readonly item20: Source20;
readonly nested20: {
readonly left: Source20;
readonly right: LeafPayload;
readonly tuple: readonly [Source20, LeafPayload, { wrapped: Source20 }];
};
}>;
type Materialized20 = Variant20<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized20: Materialized20;
const recursiveUtilityValue20: string =
materialized20.nested20.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant21<Source21> = UtilityPipeline<{
readonly item21: Source21;
readonly nested21: {
readonly left: Source21;
readonly right: LeafPayload;
readonly tuple: readonly [Source21, LeafPayload, { wrapped: Source21 }];
};
}>;
type Materialized21 = Variant21<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized21: Materialized21;
const recursiveUtilityValue21: string =
materialized21.nested21.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant22<Source22> = UtilityPipeline<{
readonly item22: Source22;
readonly nested22: {
readonly left: Source22;
readonly right: LeafPayload;
readonly tuple: readonly [Source22, LeafPayload, { wrapped: Source22 }];
};
}>;
type Materialized22 = Variant22<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized22: Materialized22;
const recursiveUtilityValue22: string =
materialized22.nested22.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant23<Source23> = UtilityPipeline<{
readonly item23: Source23;
readonly nested23: {
readonly left: Source23;
readonly right: LeafPayload;
readonly tuple: readonly [Source23, LeafPayload, { wrapped: Source23 }];
};
}>;
type Materialized23 = Variant23<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized23: Materialized23;
const recursiveUtilityValue23: string =
materialized23.nested23.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant24<Source24> = UtilityPipeline<{
readonly item24: Source24;
readonly nested24: {
readonly left: Source24;
readonly right: LeafPayload;
readonly tuple: readonly [Source24, LeafPayload, { wrapped: Source24 }];
};
}>;
type Materialized24 = Variant24<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized24: Materialized24;
const recursiveUtilityValue24: string =
materialized24.nested24.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant25<Source25> = UtilityPipeline<{
readonly item25: Source25;
readonly nested25: {
readonly left: Source25;
readonly right: LeafPayload;
readonly tuple: readonly [Source25, LeafPayload, { wrapped: Source25 }];
};
}>;
type Materialized25 = Variant25<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized25: Materialized25;
const recursiveUtilityValue25: string =
materialized25.nested25.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant26<Source26> = UtilityPipeline<{
readonly item26: Source26;
readonly nested26: {
readonly left: Source26;
readonly right: LeafPayload;
readonly tuple: readonly [Source26, LeafPayload, { wrapped: Source26 }];
};
}>;
type Materialized26 = Variant26<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized26: Materialized26;
const recursiveUtilityValue26: string =
materialized26.nested26.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant27<Source27> = UtilityPipeline<{
readonly item27: Source27;
readonly nested27: {
readonly left: Source27;
readonly right: LeafPayload;
readonly tuple: readonly [Source27, LeafPayload, { wrapped: Source27 }];
};
}>;
type Materialized27 = Variant27<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized27: Materialized27;
const recursiveUtilityValue27: string =
materialized27.nested27.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant28<Source28> = UtilityPipeline<{
readonly item28: Source28;
readonly nested28: {
readonly left: Source28;
readonly right: LeafPayload;
readonly tuple: readonly [Source28, LeafPayload, { wrapped: Source28 }];
};
}>;
type Materialized28 = Variant28<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized28: Materialized28;
const recursiveUtilityValue28: string =
materialized28.nested28.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant29<Source29> = UtilityPipeline<{
readonly item29: Source29;
readonly nested29: {
readonly left: Source29;
readonly right: LeafPayload;
readonly tuple: readonly [Source29, LeafPayload, { wrapped: Source29 }];
};
}>;
type Materialized29 = Variant29<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized29: Materialized29;
const recursiveUtilityValue29: string =
materialized29.nested29.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant30<Source30> = UtilityPipeline<{
readonly item30: Source30;
readonly nested30: {
readonly left: Source30;
readonly right: LeafPayload;
readonly tuple: readonly [Source30, LeafPayload, { wrapped: Source30 }];
};
}>;
type Materialized30 = Variant30<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized30: Materialized30;
const recursiveUtilityValue30: string =
materialized30.nested30.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant31<Source31> = UtilityPipeline<{
readonly item31: Source31;
readonly nested31: {
readonly left: Source31;
readonly right: LeafPayload;
readonly tuple: readonly [Source31, LeafPayload, { wrapped: Source31 }];
};
}>;
type Materialized31 = Variant31<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized31: Materialized31;
const recursiveUtilityValue31: string =
materialized31.nested31.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant32<Source32> = UtilityPipeline<{
readonly item32: Source32;
readonly nested32: {
readonly left: Source32;
readonly right: LeafPayload;
readonly tuple: readonly [Source32, LeafPayload, { wrapped: Source32 }];
};
}>;
type Materialized32 = Variant32<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized32: Materialized32;
const recursiveUtilityValue32: string =
materialized32.nested32.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant33<Source33> = UtilityPipeline<{
readonly item33: Source33;
readonly nested33: {
readonly left: Source33;
readonly right: LeafPayload;
readonly tuple: readonly [Source33, LeafPayload, { wrapped: Source33 }];
};
}>;
type Materialized33 = Variant33<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized33: Materialized33;
const recursiveUtilityValue33: string =
materialized33.nested33.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant34<Source34> = UtilityPipeline<{
readonly item34: Source34;
readonly nested34: {
readonly left: Source34;
readonly right: LeafPayload;
readonly tuple: readonly [Source34, LeafPayload, { wrapped: Source34 }];
};
}>;
type Materialized34 = Variant34<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized34: Materialized34;
const recursiveUtilityValue34: string =
materialized34.nested34.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant35<Source35> = UtilityPipeline<{
readonly item35: Source35;
readonly nested35: {
readonly left: Source35;
readonly right: LeafPayload;
readonly tuple: readonly [Source35, LeafPayload, { wrapped: Source35 }];
};
}>;
type Materialized35 = Variant35<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized35: Materialized35;
const recursiveUtilityValue35: string =
materialized35.nested35.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant36<Source36> = UtilityPipeline<{
readonly item36: Source36;
readonly nested36: {
readonly left: Source36;
readonly right: LeafPayload;
readonly tuple: readonly [Source36, LeafPayload, { wrapped: Source36 }];
};
}>;
type Materialized36 = Variant36<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized36: Materialized36;
const recursiveUtilityValue36: string =
materialized36.nested36.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant37<Source37> = UtilityPipeline<{
readonly item37: Source37;
readonly nested37: {
readonly left: Source37;
readonly right: LeafPayload;
readonly tuple: readonly [Source37, LeafPayload, { wrapped: Source37 }];
};
}>;
type Materialized37 = Variant37<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized37: Materialized37;
const recursiveUtilityValue37: string =
materialized37.nested37.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant38<Source38> = UtilityPipeline<{
readonly item38: Source38;
readonly nested38: {
readonly left: Source38;
readonly right: LeafPayload;
readonly tuple: readonly [Source38, LeafPayload, { wrapped: Source38 }];
};
}>;
type Materialized38 = Variant38<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized38: Materialized38;
const recursiveUtilityValue38: string =
materialized38.nested38.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant39<Source39> = UtilityPipeline<{
readonly item39: Source39;
readonly nested39: {
readonly left: Source39;
readonly right: LeafPayload;
readonly tuple: readonly [Source39, LeafPayload, { wrapped: Source39 }];
};
}>;
type Materialized39 = Variant39<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized39: Materialized39;
const recursiveUtilityValue39: string =
materialized39.nested39.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant40<Source40> = UtilityPipeline<{
readonly item40: Source40;
readonly nested40: {
readonly left: Source40;
readonly right: LeafPayload;
readonly tuple: readonly [Source40, LeafPayload, { wrapped: Source40 }];
};
}>;
type Materialized40 = Variant40<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized40: Materialized40;
const recursiveUtilityValue40: string =
materialized40.nested40.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant41<Source41> = UtilityPipeline<{
readonly item41: Source41;
readonly nested41: {
readonly left: Source41;
readonly right: LeafPayload;
readonly tuple: readonly [Source41, LeafPayload, { wrapped: Source41 }];
};
}>;
type Materialized41 = Variant41<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized41: Materialized41;
const recursiveUtilityValue41: string =
materialized41.nested41.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant42<Source42> = UtilityPipeline<{
readonly item42: Source42;
readonly nested42: {
readonly left: Source42;
readonly right: LeafPayload;
readonly tuple: readonly [Source42, LeafPayload, { wrapped: Source42 }];
};
}>;
type Materialized42 = Variant42<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized42: Materialized42;
const recursiveUtilityValue42: string =
materialized42.nested42.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant43<Source43> = UtilityPipeline<{
readonly item43: Source43;
readonly nested43: {
readonly left: Source43;
readonly right: LeafPayload;
readonly tuple: readonly [Source43, LeafPayload, { wrapped: Source43 }];
};
}>;
type Materialized43 = Variant43<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized43: Materialized43;
const recursiveUtilityValue43: string =
materialized43.nested43.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant44<Source44> = UtilityPipeline<{
readonly item44: Source44;
readonly nested44: {
readonly left: Source44;
readonly right: LeafPayload;
readonly tuple: readonly [Source44, LeafPayload, { wrapped: Source44 }];
};
}>;
type Materialized44 = Variant44<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized44: Materialized44;
const recursiveUtilityValue44: string =
materialized44.nested44.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant45<Source45> = UtilityPipeline<{
readonly item45: Source45;
readonly nested45: {
readonly left: Source45;
readonly right: LeafPayload;
readonly tuple: readonly [Source45, LeafPayload, { wrapped: Source45 }];
};
}>;
type Materialized45 = Variant45<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized45: Materialized45;
const recursiveUtilityValue45: string =
materialized45.nested45.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant46<Source46> = UtilityPipeline<{
readonly item46: Source46;
readonly nested46: {
readonly left: Source46;
readonly right: LeafPayload;
readonly tuple: readonly [Source46, LeafPayload, { wrapped: Source46 }];
};
}>;
type Materialized46 = Variant46<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized46: Materialized46;
const recursiveUtilityValue46: string =
materialized46.nested46.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant47<Source47> = UtilityPipeline<{
readonly item47: Source47;
readonly nested47: {
readonly left: Source47;
readonly right: LeafPayload;
readonly tuple: readonly [Source47, LeafPayload, { wrapped: Source47 }];
};
}>;
type Materialized47 = Variant47<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized47: Materialized47;
const recursiveUtilityValue47: string =
materialized47.nested47.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant48<Source48> = UtilityPipeline<{
readonly item48: Source48;
readonly nested48: {
readonly left: Source48;
readonly right: LeafPayload;
readonly tuple: readonly [Source48, LeafPayload, { wrapped: Source48 }];
};
}>;
type Materialized48 = Variant48<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized48: Materialized48;
const recursiveUtilityValue48: string =
materialized48.nested48.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant49<Source49> = UtilityPipeline<{
readonly item49: Source49;
readonly nested49: {
readonly left: Source49;
readonly right: LeafPayload;
readonly tuple: readonly [Source49, LeafPayload, { wrapped: Source49 }];
};
}>;
type Materialized49 = Variant49<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized49: Materialized49;
const recursiveUtilityValue49: string =
materialized49.nested49.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant50<Source50> = UtilityPipeline<{
readonly item50: Source50;
readonly nested50: {
readonly left: Source50;
readonly right: LeafPayload;
readonly tuple: readonly [Source50, LeafPayload, { wrapped: Source50 }];
};
}>;
type Materialized50 = Variant50<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized50: Materialized50;
const recursiveUtilityValue50: string =
materialized50.nested50.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant51<Source51> = UtilityPipeline<{
readonly item51: Source51;
readonly nested51: {
readonly left: Source51;
readonly right: LeafPayload;
readonly tuple: readonly [Source51, LeafPayload, { wrapped: Source51 }];
};
}>;
type Materialized51 = Variant51<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized51: Materialized51;
const recursiveUtilityValue51: string =
materialized51.nested51.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant52<Source52> = UtilityPipeline<{
readonly item52: Source52;
readonly nested52: {
readonly left: Source52;
readonly right: LeafPayload;
readonly tuple: readonly [Source52, LeafPayload, { wrapped: Source52 }];
};
}>;
type Materialized52 = Variant52<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized52: Materialized52;
const recursiveUtilityValue52: string =
materialized52.nested52.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant53<Source53> = UtilityPipeline<{
readonly item53: Source53;
readonly nested53: {
readonly left: Source53;
readonly right: LeafPayload;
readonly tuple: readonly [Source53, LeafPayload, { wrapped: Source53 }];
};
}>;
type Materialized53 = Variant53<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized53: Materialized53;
const recursiveUtilityValue53: string =
materialized53.nested53.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant54<Source54> = UtilityPipeline<{
readonly item54: Source54;
readonly nested54: {
readonly left: Source54;
readonly right: LeafPayload;
readonly tuple: readonly [Source54, LeafPayload, { wrapped: Source54 }];
};
}>;
type Materialized54 = Variant54<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized54: Materialized54;
const recursiveUtilityValue54: string =
materialized54.nested54.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant55<Source55> = UtilityPipeline<{
readonly item55: Source55;
readonly nested55: {
readonly left: Source55;
readonly right: LeafPayload;
readonly tuple: readonly [Source55, LeafPayload, { wrapped: Source55 }];
};
}>;
type Materialized55 = Variant55<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized55: Materialized55;
const recursiveUtilityValue55: string =
materialized55.nested55.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant56<Source56> = UtilityPipeline<{
readonly item56: Source56;
readonly nested56: {
readonly left: Source56;
readonly right: LeafPayload;
readonly tuple: readonly [Source56, LeafPayload, { wrapped: Source56 }];
};
}>;
type Materialized56 = Variant56<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized56: Materialized56;
const recursiveUtilityValue56: string =
materialized56.nested56.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant57<Source57> = UtilityPipeline<{
readonly item57: Source57;
readonly nested57: {
readonly left: Source57;
readonly right: LeafPayload;
readonly tuple: readonly [Source57, LeafPayload, { wrapped: Source57 }];
};
}>;
type Materialized57 = Variant57<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized57: Materialized57;
const recursiveUtilityValue57: string =
materialized57.nested57.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant58<Source58> = UtilityPipeline<{
readonly item58: Source58;
readonly nested58: {
readonly left: Source58;
readonly right: LeafPayload;
readonly tuple: readonly [Source58, LeafPayload, { wrapped: Source58 }];
};
}>;
type Materialized58 = Variant58<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized58: Materialized58;
const recursiveUtilityValue58: string =
materialized58.nested58.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant59<Source59> = UtilityPipeline<{
readonly item59: Source59;
readonly nested59: {
readonly left: Source59;
readonly right: LeafPayload;
readonly tuple: readonly [Source59, LeafPayload, { wrapped: Source59 }];
};
}>;
type Materialized59 = Variant59<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized59: Materialized59;
const recursiveUtilityValue59: string =
materialized59.nested59.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant60<Source60> = UtilityPipeline<{
readonly item60: Source60;
readonly nested60: {
readonly left: Source60;
readonly right: LeafPayload;
readonly tuple: readonly [Source60, LeafPayload, { wrapped: Source60 }];
};
}>;
type Materialized60 = Variant60<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized60: Materialized60;
const recursiveUtilityValue60: string =
materialized60.nested60.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant61<Source61> = UtilityPipeline<{
readonly item61: Source61;
readonly nested61: {
readonly left: Source61;
readonly right: LeafPayload;
readonly tuple: readonly [Source61, LeafPayload, { wrapped: Source61 }];
};
}>;
type Materialized61 = Variant61<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized61: Materialized61;
const recursiveUtilityValue61: string =
materialized61.nested61.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant62<Source62> = UtilityPipeline<{
readonly item62: Source62;
readonly nested62: {
readonly left: Source62;
readonly right: LeafPayload;
readonly tuple: readonly [Source62, LeafPayload, { wrapped: Source62 }];
};
}>;
type Materialized62 = Variant62<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized62: Materialized62;
const recursiveUtilityValue62: string =
materialized62.nested62.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant63<Source63> = UtilityPipeline<{
readonly item63: Source63;
readonly nested63: {
readonly left: Source63;
readonly right: LeafPayload;
readonly tuple: readonly [Source63, LeafPayload, { wrapped: Source63 }];
};
}>;
type Materialized63 = Variant63<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized63: Materialized63;
const recursiveUtilityValue63: string =
materialized63.nested63.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant64<Source64> = UtilityPipeline<{
readonly item64: Source64;
readonly nested64: {
readonly left: Source64;
readonly right: LeafPayload;
readonly tuple: readonly [Source64, LeafPayload, { wrapped: Source64 }];
};
}>;
type Materialized64 = Variant64<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized64: Materialized64;
const recursiveUtilityValue64: string =
materialized64.nested64.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant65<Source65> = UtilityPipeline<{
readonly item65: Source65;
readonly nested65: {
readonly left: Source65;
readonly right: LeafPayload;
readonly tuple: readonly [Source65, LeafPayload, { wrapped: Source65 }];
};
}>;
type Materialized65 = Variant65<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized65: Materialized65;
const recursiveUtilityValue65: string =
materialized65.nested65.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant66<Source66> = UtilityPipeline<{
readonly item66: Source66;
readonly nested66: {
readonly left: Source66;
readonly right: LeafPayload;
readonly tuple: readonly [Source66, LeafPayload, { wrapped: Source66 }];
};
}>;
type Materialized66 = Variant66<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized66: Materialized66;
const recursiveUtilityValue66: string =
materialized66.nested66.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant67<Source67> = UtilityPipeline<{
readonly item67: Source67;
readonly nested67: {
readonly left: Source67;
readonly right: LeafPayload;
readonly tuple: readonly [Source67, LeafPayload, { wrapped: Source67 }];
};
}>;
type Materialized67 = Variant67<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized67: Materialized67;
const recursiveUtilityValue67: string =
materialized67.nested67.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant68<Source68> = UtilityPipeline<{
readonly item68: Source68;
readonly nested68: {
readonly left: Source68;
readonly right: LeafPayload;
readonly tuple: readonly [Source68, LeafPayload, { wrapped: Source68 }];
};
}>;
type Materialized68 = Variant68<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized68: Materialized68;
const recursiveUtilityValue68: string =
materialized68.nested68.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant69<Source69> = UtilityPipeline<{
readonly item69: Source69;
readonly nested69: {
readonly left: Source69;
readonly right: LeafPayload;
readonly tuple: readonly [Source69, LeafPayload, { wrapped: Source69 }];
};
}>;
type Materialized69 = Variant69<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized69: Materialized69;
const recursiveUtilityValue69: string =
materialized69.nested69.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant70<Source70> = UtilityPipeline<{
readonly item70: Source70;
readonly nested70: {
readonly left: Source70;
readonly right: LeafPayload;
readonly tuple: readonly [Source70, LeafPayload, { wrapped: Source70 }];
};
}>;
type Materialized70 = Variant70<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized70: Materialized70;
const recursiveUtilityValue70: string =
materialized70.nested70.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant71<Source71> = UtilityPipeline<{
readonly item71: Source71;
readonly nested71: {
readonly left: Source71;
readonly right: LeafPayload;
readonly tuple: readonly [Source71, LeafPayload, { wrapped: Source71 }];
};
}>;
type Materialized71 = Variant71<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized71: Materialized71;
const recursiveUtilityValue71: string =
materialized71.nested71.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant72<Source72> = UtilityPipeline<{
readonly item72: Source72;
readonly nested72: {
readonly left: Source72;
readonly right: LeafPayload;
readonly tuple: readonly [Source72, LeafPayload, { wrapped: Source72 }];
};
}>;
type Materialized72 = Variant72<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized72: Materialized72;
const recursiveUtilityValue72: string =
materialized72.nested72.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant73<Source73> = UtilityPipeline<{
readonly item73: Source73;
readonly nested73: {
readonly left: Source73;
readonly right: LeafPayload;
readonly tuple: readonly [Source73, LeafPayload, { wrapped: Source73 }];
};
}>;
type Materialized73 = Variant73<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized73: Materialized73;
const recursiveUtilityValue73: string =
materialized73.nested73.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant74<Source74> = UtilityPipeline<{
readonly item74: Source74;
readonly nested74: {
readonly left: Source74;
readonly right: LeafPayload;
readonly tuple: readonly [Source74, LeafPayload, { wrapped: Source74 }];
};
}>;
type Materialized74 = Variant74<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized74: Materialized74;
const recursiveUtilityValue74: string =
materialized74.nested74.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant75<Source75> = UtilityPipeline<{
readonly item75: Source75;
readonly nested75: {
readonly left: Source75;
readonly right: LeafPayload;
readonly tuple: readonly [Source75, LeafPayload, { wrapped: Source75 }];
};
}>;
type Materialized75 = Variant75<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized75: Materialized75;
const recursiveUtilityValue75: string =
materialized75.nested75.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant76<Source76> = UtilityPipeline<{
readonly item76: Source76;
readonly nested76: {
readonly left: Source76;
readonly right: LeafPayload;
readonly tuple: readonly [Source76, LeafPayload, { wrapped: Source76 }];
};
}>;
type Materialized76 = Variant76<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized76: Materialized76;
const recursiveUtilityValue76: string =
materialized76.nested76.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant77<Source77> = UtilityPipeline<{
readonly item77: Source77;
readonly nested77: {
readonly left: Source77;
readonly right: LeafPayload;
readonly tuple: readonly [Source77, LeafPayload, { wrapped: Source77 }];
};
}>;
type Materialized77 = Variant77<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized77: Materialized77;
const recursiveUtilityValue77: string =
materialized77.nested77.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant78<Source78> = UtilityPipeline<{
readonly item78: Source78;
readonly nested78: {
readonly left: Source78;
readonly right: LeafPayload;
readonly tuple: readonly [Source78, LeafPayload, { wrapped: Source78 }];
};
}>;
type Materialized78 = Variant78<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized78: Materialized78;
const recursiveUtilityValue78: string =
materialized78.nested78.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant79<Source79> = UtilityPipeline<{
readonly item79: Source79;
readonly nested79: {
readonly left: Source79;
readonly right: LeafPayload;
readonly tuple: readonly [Source79, LeafPayload, { wrapped: Source79 }];
};
}>;
type Materialized79 = Variant79<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized79: Materialized79;
const recursiveUtilityValue79: string =
materialized79.nested79.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant80<Source80> = UtilityPipeline<{
readonly item80: Source80;
readonly nested80: {
readonly left: Source80;
readonly right: LeafPayload;
readonly tuple: readonly [Source80, LeafPayload, { wrapped: Source80 }];
};
}>;
type Materialized80 = Variant80<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized80: Materialized80;
const recursiveUtilityValue80: string =
materialized80.nested80.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant81<Source81> = UtilityPipeline<{
readonly item81: Source81;
readonly nested81: {
readonly left: Source81;
readonly right: LeafPayload;
readonly tuple: readonly [Source81, LeafPayload, { wrapped: Source81 }];
};
}>;
type Materialized81 = Variant81<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized81: Materialized81;
const recursiveUtilityValue81: string =
materialized81.nested81.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant82<Source82> = UtilityPipeline<{
readonly item82: Source82;
readonly nested82: {
readonly left: Source82;
readonly right: LeafPayload;
readonly tuple: readonly [Source82, LeafPayload, { wrapped: Source82 }];
};
}>;
type Materialized82 = Variant82<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized82: Materialized82;
const recursiveUtilityValue82: string =
materialized82.nested82.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant83<Source83> = UtilityPipeline<{
readonly item83: Source83;
readonly nested83: {
readonly left: Source83;
readonly right: LeafPayload;
readonly tuple: readonly [Source83, LeafPayload, { wrapped: Source83 }];
};
}>;
type Materialized83 = Variant83<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized83: Materialized83;
const recursiveUtilityValue83: string =
materialized83.nested83.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant84<Source84> = UtilityPipeline<{
readonly item84: Source84;
readonly nested84: {
readonly left: Source84;
readonly right: LeafPayload;
readonly tuple: readonly [Source84, LeafPayload, { wrapped: Source84 }];
};
}>;
type Materialized84 = Variant84<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized84: Materialized84;
const recursiveUtilityValue84: string =
materialized84.nested84.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant85<Source85> = UtilityPipeline<{
readonly item85: Source85;
readonly nested85: {
readonly left: Source85;
readonly right: LeafPayload;
readonly tuple: readonly [Source85, LeafPayload, { wrapped: Source85 }];
};
}>;
type Materialized85 = Variant85<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized85: Materialized85;
const recursiveUtilityValue85: string =
materialized85.nested85.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant86<Source86> = UtilityPipeline<{
readonly item86: Source86;
readonly nested86: {
readonly left: Source86;
readonly right: LeafPayload;
readonly tuple: readonly [Source86, LeafPayload, { wrapped: Source86 }];
};
}>;
type Materialized86 = Variant86<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized86: Materialized86;
const recursiveUtilityValue86: string =
materialized86.nested86.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant87<Source87> = UtilityPipeline<{
readonly item87: Source87;
readonly nested87: {
readonly left: Source87;
readonly right: LeafPayload;
readonly tuple: readonly [Source87, LeafPayload, { wrapped: Source87 }];
};
}>;
type Materialized87 = Variant87<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized87: Materialized87;
const recursiveUtilityValue87: string =
materialized87.nested87.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant88<Source88> = UtilityPipeline<{
readonly item88: Source88;
readonly nested88: {
readonly left: Source88;
readonly right: LeafPayload;
readonly tuple: readonly [Source88, LeafPayload, { wrapped: Source88 }];
};
}>;
type Materialized88 = Variant88<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized88: Materialized88;
const recursiveUtilityValue88: string =
materialized88.nested88.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant89<Source89> = UtilityPipeline<{
readonly item89: Source89;
readonly nested89: {
readonly left: Source89;
readonly right: LeafPayload;
readonly tuple: readonly [Source89, LeafPayload, { wrapped: Source89 }];
};
}>;
type Materialized89 = Variant89<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized89: Materialized89;
const recursiveUtilityValue89: string =
materialized89.nested89.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant90<Source90> = UtilityPipeline<{
readonly item90: Source90;
readonly nested90: {
readonly left: Source90;
readonly right: LeafPayload;
readonly tuple: readonly [Source90, LeafPayload, { wrapped: Source90 }];
};
}>;
type Materialized90 = Variant90<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized90: Materialized90;
const recursiveUtilityValue90: string =
materialized90.nested90.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant91<Source91> = UtilityPipeline<{
readonly item91: Source91;
readonly nested91: {
readonly left: Source91;
readonly right: LeafPayload;
readonly tuple: readonly [Source91, LeafPayload, { wrapped: Source91 }];
};
}>;
type Materialized91 = Variant91<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized91: Materialized91;
const recursiveUtilityValue91: string =
materialized91.nested91.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant92<Source92> = UtilityPipeline<{
readonly item92: Source92;
readonly nested92: {
readonly left: Source92;
readonly right: LeafPayload;
readonly tuple: readonly [Source92, LeafPayload, { wrapped: Source92 }];
};
}>;
type Materialized92 = Variant92<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized92: Materialized92;
const recursiveUtilityValue92: string =
materialized92.nested92.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant93<Source93> = UtilityPipeline<{
readonly item93: Source93;
readonly nested93: {
readonly left: Source93;
readonly right: LeafPayload;
readonly tuple: readonly [Source93, LeafPayload, { wrapped: Source93 }];
};
}>;
type Materialized93 = Variant93<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized93: Materialized93;
const recursiveUtilityValue93: string =
materialized93.nested93.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant94<Source94> = UtilityPipeline<{
readonly item94: Source94;
readonly nested94: {
readonly left: Source94;
readonly right: LeafPayload;
readonly tuple: readonly [Source94, LeafPayload, { wrapped: Source94 }];
};
}>;
type Materialized94 = Variant94<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized94: Materialized94;
const recursiveUtilityValue94: string =
materialized94.nested94.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant95<Source95> = UtilityPipeline<{
readonly item95: Source95;
readonly nested95: {
readonly left: Source95;
readonly right: LeafPayload;
readonly tuple: readonly [Source95, LeafPayload, { wrapped: Source95 }];
};
}>;
type Materialized95 = Variant95<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized95: Materialized95;
const recursiveUtilityValue95: string =
materialized95.nested95.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant96<Source96> = UtilityPipeline<{
readonly item96: Source96;
readonly nested96: {
readonly left: Source96;
readonly right: LeafPayload;
readonly tuple: readonly [Source96, LeafPayload, { wrapped: Source96 }];
};
}>;
type Materialized96 = Variant96<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized96: Materialized96;
const recursiveUtilityValue96: string =
materialized96.nested96.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant97<Source97> = UtilityPipeline<{
readonly item97: Source97;
readonly nested97: {
readonly left: Source97;
readonly right: LeafPayload;
readonly tuple: readonly [Source97, LeafPayload, { wrapped: Source97 }];
};
}>;
type Materialized97 = Variant97<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized97: Materialized97;
const recursiveUtilityValue97: string =
materialized97.nested97.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant98<Source98> = UtilityPipeline<{
readonly item98: Source98;
readonly nested98: {
readonly left: Source98;
readonly right: LeafPayload;
readonly tuple: readonly [Source98, LeafPayload, { wrapped: Source98 }];
};
}>;
type Materialized98 = Variant98<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized98: Materialized98;
const recursiveUtilityValue98: string =
materialized98.nested98.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant99<Source99> = UtilityPipeline<{
readonly item99: Source99;
readonly nested99: {
readonly left: Source99;
readonly right: LeafPayload;
readonly tuple: readonly [Source99, LeafPayload, { wrapped: Source99 }];
};
}>;
type Materialized99 = Variant99<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized99: Materialized99;
const recursiveUtilityValue99: string =
materialized99.nested99.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant100<Source100> = UtilityPipeline<{
readonly item100: Source100;
readonly nested100: {
readonly left: Source100;
readonly right: LeafPayload;
readonly tuple: readonly [Source100, LeafPayload, { wrapped: Source100 }];
};
}>;
type Materialized100 = Variant100<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized100: Materialized100;
const recursiveUtilityValue100: string =
materialized100.nested100.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant101<Source101> = UtilityPipeline<{
readonly item101: Source101;
readonly nested101: {
readonly left: Source101;
readonly right: LeafPayload;
readonly tuple: readonly [Source101, LeafPayload, { wrapped: Source101 }];
};
}>;
type Materialized101 = Variant101<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized101: Materialized101;
const recursiveUtilityValue101: string =
materialized101.nested101.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant102<Source102> = UtilityPipeline<{
readonly item102: Source102;
readonly nested102: {
readonly left: Source102;
readonly right: LeafPayload;
readonly tuple: readonly [Source102, LeafPayload, { wrapped: Source102 }];
};
}>;
type Materialized102 = Variant102<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized102: Materialized102;
const recursiveUtilityValue102: string =
materialized102.nested102.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant103<Source103> = UtilityPipeline<{
readonly item103: Source103;
readonly nested103: {
readonly left: Source103;
readonly right: LeafPayload;
readonly tuple: readonly [Source103, LeafPayload, { wrapped: Source103 }];
};
}>;
type Materialized103 = Variant103<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized103: Materialized103;
const recursiveUtilityValue103: string =
materialized103.nested103.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant104<Source104> = UtilityPipeline<{
readonly item104: Source104;
readonly nested104: {
readonly left: Source104;
readonly right: LeafPayload;
readonly tuple: readonly [Source104, LeafPayload, { wrapped: Source104 }];
};
}>;
type Materialized104 = Variant104<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized104: Materialized104;
const recursiveUtilityValue104: string =
materialized104.nested104.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant105<Source105> = UtilityPipeline<{
readonly item105: Source105;
readonly nested105: {
readonly left: Source105;
readonly right: LeafPayload;
readonly tuple: readonly [Source105, LeafPayload, { wrapped: Source105 }];
};
}>;
type Materialized105 = Variant105<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized105: Materialized105;
const recursiveUtilityValue105: string =
materialized105.nested105.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant106<Source106> = UtilityPipeline<{
readonly item106: Source106;
readonly nested106: {
readonly left: Source106;
readonly right: LeafPayload;
readonly tuple: readonly [Source106, LeafPayload, { wrapped: Source106 }];
};
}>;
type Materialized106 = Variant106<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized106: Materialized106;
const recursiveUtilityValue106: string =
materialized106.nested106.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant107<Source107> = UtilityPipeline<{
readonly item107: Source107;
readonly nested107: {
readonly left: Source107;
readonly right: LeafPayload;
readonly tuple: readonly [Source107, LeafPayload, { wrapped: Source107 }];
};
}>;
type Materialized107 = Variant107<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized107: Materialized107;
const recursiveUtilityValue107: string =
materialized107.nested107.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant108<Source108> = UtilityPipeline<{
readonly item108: Source108;
readonly nested108: {
readonly left: Source108;
readonly right: LeafPayload;
readonly tuple: readonly [Source108, LeafPayload, { wrapped: Source108 }];
};
}>;
type Materialized108 = Variant108<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized108: Materialized108;
const recursiveUtilityValue108: string =
materialized108.nested108.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant109<Source109> = UtilityPipeline<{
readonly item109: Source109;
readonly nested109: {
readonly left: Source109;
readonly right: LeafPayload;
readonly tuple: readonly [Source109, LeafPayload, { wrapped: Source109 }];
};
}>;
type Materialized109 = Variant109<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized109: Materialized109;
const recursiveUtilityValue109: string =
materialized109.nested109.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant110<Source110> = UtilityPipeline<{
readonly item110: Source110;
readonly nested110: {
readonly left: Source110;
readonly right: LeafPayload;
readonly tuple: readonly [Source110, LeafPayload, { wrapped: Source110 }];
};
}>;
type Materialized110 = Variant110<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized110: Materialized110;
const recursiveUtilityValue110: string =
materialized110.nested110.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant111<Source111> = UtilityPipeline<{
readonly item111: Source111;
readonly nested111: {
readonly left: Source111;
readonly right: LeafPayload;
readonly tuple: readonly [Source111, LeafPayload, { wrapped: Source111 }];
};
}>;
type Materialized111 = Variant111<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized111: Materialized111;
const recursiveUtilityValue111: string =
materialized111.nested111.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant112<Source112> = UtilityPipeline<{
readonly item112: Source112;
readonly nested112: {
readonly left: Source112;
readonly right: LeafPayload;
readonly tuple: readonly [Source112, LeafPayload, { wrapped: Source112 }];
};
}>;
type Materialized112 = Variant112<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized112: Materialized112;
const recursiveUtilityValue112: string =
materialized112.nested112.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant113<Source113> = UtilityPipeline<{
readonly item113: Source113;
readonly nested113: {
readonly left: Source113;
readonly right: LeafPayload;
readonly tuple: readonly [Source113, LeafPayload, { wrapped: Source113 }];
};
}>;
type Materialized113 = Variant113<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized113: Materialized113;
const recursiveUtilityValue113: string =
materialized113.nested113.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant114<Source114> = UtilityPipeline<{
readonly item114: Source114;
readonly nested114: {
readonly left: Source114;
readonly right: LeafPayload;
readonly tuple: readonly [Source114, LeafPayload, { wrapped: Source114 }];
};
}>;
type Materialized114 = Variant114<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized114: Materialized114;
const recursiveUtilityValue114: string =
materialized114.nested114.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant115<Source115> = UtilityPipeline<{
readonly item115: Source115;
readonly nested115: {
readonly left: Source115;
readonly right: LeafPayload;
readonly tuple: readonly [Source115, LeafPayload, { wrapped: Source115 }];
};
}>;
type Materialized115 = Variant115<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized115: Materialized115;
const recursiveUtilityValue115: string =
materialized115.nested115.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant116<Source116> = UtilityPipeline<{
readonly item116: Source116;
readonly nested116: {
readonly left: Source116;
readonly right: LeafPayload;
readonly tuple: readonly [Source116, LeafPayload, { wrapped: Source116 }];
};
}>;
type Materialized116 = Variant116<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized116: Materialized116;
const recursiveUtilityValue116: string =
materialized116.nested116.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant117<Source117> = UtilityPipeline<{
readonly item117: Source117;
readonly nested117: {
readonly left: Source117;
readonly right: LeafPayload;
readonly tuple: readonly [Source117, LeafPayload, { wrapped: Source117 }];
};
}>;
type Materialized117 = Variant117<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized117: Materialized117;
const recursiveUtilityValue117: string =
materialized117.nested117.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant118<Source118> = UtilityPipeline<{
readonly item118: Source118;
readonly nested118: {
readonly left: Source118;
readonly right: LeafPayload;
readonly tuple: readonly [Source118, LeafPayload, { wrapped: Source118 }];
};
}>;
type Materialized118 = Variant118<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized118: Materialized118;
const recursiveUtilityValue118: string =
materialized118.nested118.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant119<Source119> = UtilityPipeline<{
readonly item119: Source119;
readonly nested119: {
readonly left: Source119;
readonly right: LeafPayload;
readonly tuple: readonly [Source119, LeafPayload, { wrapped: Source119 }];
};
}>;
type Materialized119 = Variant119<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized119: Materialized119;
const recursiveUtilityValue119: string =
materialized119.nested119.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant120<Source120> = UtilityPipeline<{
readonly item120: Source120;
readonly nested120: {
readonly left: Source120;
readonly right: LeafPayload;
readonly tuple: readonly [Source120, LeafPayload, { wrapped: Source120 }];
};
}>;
type Materialized120 = Variant120<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized120: Materialized120;
const recursiveUtilityValue120: string =
materialized120.nested120.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant121<Source121> = UtilityPipeline<{
readonly item121: Source121;
readonly nested121: {
readonly left: Source121;
readonly right: LeafPayload;
readonly tuple: readonly [Source121, LeafPayload, { wrapped: Source121 }];
};
}>;
type Materialized121 = Variant121<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized121: Materialized121;
const recursiveUtilityValue121: string =
materialized121.nested121.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant122<Source122> = UtilityPipeline<{
readonly item122: Source122;
readonly nested122: {
readonly left: Source122;
readonly right: LeafPayload;
readonly tuple: readonly [Source122, LeafPayload, { wrapped: Source122 }];
};
}>;
type Materialized122 = Variant122<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized122: Materialized122;
const recursiveUtilityValue122: string =
materialized122.nested122.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant123<Source123> = UtilityPipeline<{
readonly item123: Source123;
readonly nested123: {
readonly left: Source123;
readonly right: LeafPayload;
readonly tuple: readonly [Source123, LeafPayload, { wrapped: Source123 }];
};
}>;
type Materialized123 = Variant123<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized123: Materialized123;
const recursiveUtilityValue123: string =
materialized123.nested123.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant124<Source124> = UtilityPipeline<{
readonly item124: Source124;
readonly nested124: {
readonly left: Source124;
readonly right: LeafPayload;
readonly tuple: readonly [Source124, LeafPayload, { wrapped: Source124 }];
};
}>;
type Materialized124 = Variant124<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized124: Materialized124;
const recursiveUtilityValue124: string =
materialized124.nested124.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant125<Source125> = UtilityPipeline<{
readonly item125: Source125;
readonly nested125: {
readonly left: Source125;
readonly right: LeafPayload;
readonly tuple: readonly [Source125, LeafPayload, { wrapped: Source125 }];
};
}>;
type Materialized125 = Variant125<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized125: Materialized125;
const recursiveUtilityValue125: string =
materialized125.nested125.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant126<Source126> = UtilityPipeline<{
readonly item126: Source126;
readonly nested126: {
readonly left: Source126;
readonly right: LeafPayload;
readonly tuple: readonly [Source126, LeafPayload, { wrapped: Source126 }];
};
}>;
type Materialized126 = Variant126<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized126: Materialized126;
const recursiveUtilityValue126: string =
materialized126.nested126.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant127<Source127> = UtilityPipeline<{
readonly item127: Source127;
readonly nested127: {
readonly left: Source127;
readonly right: LeafPayload;
readonly tuple: readonly [Source127, LeafPayload, { wrapped: Source127 }];
};
}>;
type Materialized127 = Variant127<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized127: Materialized127;
const recursiveUtilityValue127: string =
materialized127.nested127.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant128<Source128> = UtilityPipeline<{
readonly item128: Source128;
readonly nested128: {
readonly left: Source128;
readonly right: LeafPayload;
readonly tuple: readonly [Source128, LeafPayload, { wrapped: Source128 }];
};
}>;
type Materialized128 = Variant128<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized128: Materialized128;
const recursiveUtilityValue128: string =
materialized128.nested128.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant129<Source129> = UtilityPipeline<{
readonly item129: Source129;
readonly nested129: {
readonly left: Source129;
readonly right: LeafPayload;
readonly tuple: readonly [Source129, LeafPayload, { wrapped: Source129 }];
};
}>;
type Materialized129 = Variant129<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized129: Materialized129;
const recursiveUtilityValue129: string =
materialized129.nested129.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant130<Source130> = UtilityPipeline<{
readonly item130: Source130;
readonly nested130: {
readonly left: Source130;
readonly right: LeafPayload;
readonly tuple: readonly [Source130, LeafPayload, { wrapped: Source130 }];
};
}>;
type Materialized130 = Variant130<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized130: Materialized130;
const recursiveUtilityValue130: string =
materialized130.nested130.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant131<Source131> = UtilityPipeline<{
readonly item131: Source131;
readonly nested131: {
readonly left: Source131;
readonly right: LeafPayload;
readonly tuple: readonly [Source131, LeafPayload, { wrapped: Source131 }];
};
}>;
type Materialized131 = Variant131<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized131: Materialized131;
const recursiveUtilityValue131: string =
materialized131.nested131.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant132<Source132> = UtilityPipeline<{
readonly item132: Source132;
readonly nested132: {
readonly left: Source132;
readonly right: LeafPayload;
readonly tuple: readonly [Source132, LeafPayload, { wrapped: Source132 }];
};
}>;
type Materialized132 = Variant132<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized132: Materialized132;
const recursiveUtilityValue132: string =
materialized132.nested132.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant133<Source133> = UtilityPipeline<{
readonly item133: Source133;
readonly nested133: {
readonly left: Source133;
readonly right: LeafPayload;
readonly tuple: readonly [Source133, LeafPayload, { wrapped: Source133 }];
};
}>;
type Materialized133 = Variant133<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized133: Materialized133;
const recursiveUtilityValue133: string =
materialized133.nested133.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant134<Source134> = UtilityPipeline<{
readonly item134: Source134;
readonly nested134: {
readonly left: Source134;
readonly right: LeafPayload;
readonly tuple: readonly [Source134, LeafPayload, { wrapped: Source134 }];
};
}>;
type Materialized134 = Variant134<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized134: Materialized134;
const recursiveUtilityValue134: string =
materialized134.nested134.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant135<Source135> = UtilityPipeline<{
readonly item135: Source135;
readonly nested135: {
readonly left: Source135;
readonly right: LeafPayload;
readonly tuple: readonly [Source135, LeafPayload, { wrapped: Source135 }];
};
}>;
type Materialized135 = Variant135<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized135: Materialized135;
const recursiveUtilityValue135: string =
materialized135.nested135.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant136<Source136> = UtilityPipeline<{
readonly item136: Source136;
readonly nested136: {
readonly left: Source136;
readonly right: LeafPayload;
readonly tuple: readonly [Source136, LeafPayload, { wrapped: Source136 }];
};
}>;
type Materialized136 = Variant136<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized136: Materialized136;
const recursiveUtilityValue136: string =
materialized136.nested136.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant137<Source137> = UtilityPipeline<{
readonly item137: Source137;
readonly nested137: {
readonly left: Source137;
readonly right: LeafPayload;
readonly tuple: readonly [Source137, LeafPayload, { wrapped: Source137 }];
};
}>;
type Materialized137 = Variant137<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized137: Materialized137;
const recursiveUtilityValue137: string =
materialized137.nested137.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant138<Source138> = UtilityPipeline<{
readonly item138: Source138;
readonly nested138: {
readonly left: Source138;
readonly right: LeafPayload;
readonly tuple: readonly [Source138, LeafPayload, { wrapped: Source138 }];
};
}>;
type Materialized138 = Variant138<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized138: Materialized138;
const recursiveUtilityValue138: string =
materialized138.nested138.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant139<Source139> = UtilityPipeline<{
readonly item139: Source139;
readonly nested139: {
readonly left: Source139;
readonly right: LeafPayload;
readonly tuple: readonly [Source139, LeafPayload, { wrapped: Source139 }];
};
}>;
type Materialized139 = Variant139<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized139: Materialized139;
const recursiveUtilityValue139: string =
materialized139.nested139.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant140<Source140> = UtilityPipeline<{
readonly item140: Source140;
readonly nested140: {
readonly left: Source140;
readonly right: LeafPayload;
readonly tuple: readonly [Source140, LeafPayload, { wrapped: Source140 }];
};
}>;
type Materialized140 = Variant140<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized140: Materialized140;
const recursiveUtilityValue140: string =
materialized140.nested140.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant141<Source141> = UtilityPipeline<{
readonly item141: Source141;
readonly nested141: {
readonly left: Source141;
readonly right: LeafPayload;
readonly tuple: readonly [Source141, LeafPayload, { wrapped: Source141 }];
};
}>;
type Materialized141 = Variant141<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized141: Materialized141;
const recursiveUtilityValue141: string =
materialized141.nested141.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant142<Source142> = UtilityPipeline<{
readonly item142: Source142;
readonly nested142: {
readonly left: Source142;
readonly right: LeafPayload;
readonly tuple: readonly [Source142, LeafPayload, { wrapped: Source142 }];
};
}>;
type Materialized142 = Variant142<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized142: Materialized142;
const recursiveUtilityValue142: string =
materialized142.nested142.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant143<Source143> = UtilityPipeline<{
readonly item143: Source143;
readonly nested143: {
readonly left: Source143;
readonly right: LeafPayload;
readonly tuple: readonly [Source143, LeafPayload, { wrapped: Source143 }];
};
}>;
type Materialized143 = Variant143<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized143: Materialized143;
const recursiveUtilityValue143: string =
materialized143.nested143.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant144<Source144> = UtilityPipeline<{
readonly item144: Source144;
readonly nested144: {
readonly left: Source144;
readonly right: LeafPayload;
readonly tuple: readonly [Source144, LeafPayload, { wrapped: Source144 }];
};
}>;
type Materialized144 = Variant144<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized144: Materialized144;
const recursiveUtilityValue144: string =
materialized144.nested144.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant145<Source145> = UtilityPipeline<{
readonly item145: Source145;
readonly nested145: {
readonly left: Source145;
readonly right: LeafPayload;
readonly tuple: readonly [Source145, LeafPayload, { wrapped: Source145 }];
};
}>;
type Materialized145 = Variant145<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized145: Materialized145;
const recursiveUtilityValue145: string =
materialized145.nested145.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant146<Source146> = UtilityPipeline<{
readonly item146: Source146;
readonly nested146: {
readonly left: Source146;
readonly right: LeafPayload;
readonly tuple: readonly [Source146, LeafPayload, { wrapped: Source146 }];
};
}>;
type Materialized146 = Variant146<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized146: Materialized146;
const recursiveUtilityValue146: string =
materialized146.nested146.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant147<Source147> = UtilityPipeline<{
readonly item147: Source147;
readonly nested147: {
readonly left: Source147;
readonly right: LeafPayload;
readonly tuple: readonly [Source147, LeafPayload, { wrapped: Source147 }];
};
}>;
type Materialized147 = Variant147<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized147: Materialized147;
const recursiveUtilityValue147: string =
materialized147.nested147.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant148<Source148> = UtilityPipeline<{
readonly item148: Source148;
readonly nested148: {
readonly left: Source148;
readonly right: LeafPayload;
readonly tuple: readonly [Source148, LeafPayload, { wrapped: Source148 }];
};
}>;
type Materialized148 = Variant148<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized148: Materialized148;
const recursiveUtilityValue148: string =
materialized148.nested148.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant149<Source149> = UtilityPipeline<{
readonly item149: Source149;
readonly nested149: {
readonly left: Source149;
readonly right: LeafPayload;
readonly tuple: readonly [Source149, LeafPayload, { wrapped: Source149 }];
};
}>;
type Materialized149 = Variant149<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized149: Materialized149;
const recursiveUtilityValue149: string =
materialized149.nested149.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant150<Source150> = UtilityPipeline<{
readonly item150: Source150;
readonly nested150: {
readonly left: Source150;
readonly right: LeafPayload;
readonly tuple: readonly [Source150, LeafPayload, { wrapped: Source150 }];
};
}>;
type Materialized150 = Variant150<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized150: Materialized150;
const recursiveUtilityValue150: string =
materialized150.nested150.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant151<Source151> = UtilityPipeline<{
readonly item151: Source151;
readonly nested151: {
readonly left: Source151;
readonly right: LeafPayload;
readonly tuple: readonly [Source151, LeafPayload, { wrapped: Source151 }];
};
}>;
type Materialized151 = Variant151<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized151: Materialized151;
const recursiveUtilityValue151: string =
materialized151.nested151.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant152<Source152> = UtilityPipeline<{
readonly item152: Source152;
readonly nested152: {
readonly left: Source152;
readonly right: LeafPayload;
readonly tuple: readonly [Source152, LeafPayload, { wrapped: Source152 }];
};
}>;
type Materialized152 = Variant152<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized152: Materialized152;
const recursiveUtilityValue152: string =
materialized152.nested152.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant153<Source153> = UtilityPipeline<{
readonly item153: Source153;
readonly nested153: {
readonly left: Source153;
readonly right: LeafPayload;
readonly tuple: readonly [Source153, LeafPayload, { wrapped: Source153 }];
};
}>;
type Materialized153 = Variant153<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized153: Materialized153;
const recursiveUtilityValue153: string =
materialized153.nested153.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant154<Source154> = UtilityPipeline<{
readonly item154: Source154;
readonly nested154: {
readonly left: Source154;
readonly right: LeafPayload;
readonly tuple: readonly [Source154, LeafPayload, { wrapped: Source154 }];
};
}>;
type Materialized154 = Variant154<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized154: Materialized154;
const recursiveUtilityValue154: string =
materialized154.nested154.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant155<Source155> = UtilityPipeline<{
readonly item155: Source155;
readonly nested155: {
readonly left: Source155;
readonly right: LeafPayload;
readonly tuple: readonly [Source155, LeafPayload, { wrapped: Source155 }];
};
}>;
type Materialized155 = Variant155<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized155: Materialized155;
const recursiveUtilityValue155: string =
materialized155.nested155.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant156<Source156> = UtilityPipeline<{
readonly item156: Source156;
readonly nested156: {
readonly left: Source156;
readonly right: LeafPayload;
readonly tuple: readonly [Source156, LeafPayload, { wrapped: Source156 }];
};
}>;
type Materialized156 = Variant156<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized156: Materialized156;
const recursiveUtilityValue156: string =
materialized156.nested156.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant157<Source157> = UtilityPipeline<{
readonly item157: Source157;
readonly nested157: {
readonly left: Source157;
readonly right: LeafPayload;
readonly tuple: readonly [Source157, LeafPayload, { wrapped: Source157 }];
};
}>;
type Materialized157 = Variant157<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized157: Materialized157;
const recursiveUtilityValue157: string =
materialized157.nested157.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant158<Source158> = UtilityPipeline<{
readonly item158: Source158;
readonly nested158: {
readonly left: Source158;
readonly right: LeafPayload;
readonly tuple: readonly [Source158, LeafPayload, { wrapped: Source158 }];
};
}>;
type Materialized158 = Variant158<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized158: Materialized158;
const recursiveUtilityValue158: string =
materialized158.nested158.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant159<Source159> = UtilityPipeline<{
readonly item159: Source159;
readonly nested159: {
readonly left: Source159;
readonly right: LeafPayload;
readonly tuple: readonly [Source159, LeafPayload, { wrapped: Source159 }];
};
}>;
type Materialized159 = Variant159<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized159: Materialized159;
const recursiveUtilityValue159: string =
materialized159.nested159.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant160<Source160> = UtilityPipeline<{
readonly item160: Source160;
readonly nested160: {
readonly left: Source160;
readonly right: LeafPayload;
readonly tuple: readonly [Source160, LeafPayload, { wrapped: Source160 }];
};
}>;
type Materialized160 = Variant160<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized160: Materialized160;
const recursiveUtilityValue160: string =
materialized160.nested160.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant161<Source161> = UtilityPipeline<{
readonly item161: Source161;
readonly nested161: {
readonly left: Source161;
readonly right: LeafPayload;
readonly tuple: readonly [Source161, LeafPayload, { wrapped: Source161 }];
};
}>;
type Materialized161 = Variant161<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized161: Materialized161;
const recursiveUtilityValue161: string =
materialized161.nested161.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant162<Source162> = UtilityPipeline<{
readonly item162: Source162;
readonly nested162: {
readonly left: Source162;
readonly right: LeafPayload;
readonly tuple: readonly [Source162, LeafPayload, { wrapped: Source162 }];
};
}>;
type Materialized162 = Variant162<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized162: Materialized162;
const recursiveUtilityValue162: string =
materialized162.nested162.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant163<Source163> = UtilityPipeline<{
readonly item163: Source163;
readonly nested163: {
readonly left: Source163;
readonly right: LeafPayload;
readonly tuple: readonly [Source163, LeafPayload, { wrapped: Source163 }];
};
}>;
type Materialized163 = Variant163<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized163: Materialized163;
const recursiveUtilityValue163: string =
materialized163.nested163.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant164<Source164> = UtilityPipeline<{
readonly item164: Source164;
readonly nested164: {
readonly left: Source164;
readonly right: LeafPayload;
readonly tuple: readonly [Source164, LeafPayload, { wrapped: Source164 }];
};
}>;
type Materialized164 = Variant164<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized164: Materialized164;
const recursiveUtilityValue164: string =
materialized164.nested164.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant165<Source165> = UtilityPipeline<{
readonly item165: Source165;
readonly nested165: {
readonly left: Source165;
readonly right: LeafPayload;
readonly tuple: readonly [Source165, LeafPayload, { wrapped: Source165 }];
};
}>;
type Materialized165 = Variant165<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized165: Materialized165;
const recursiveUtilityValue165: string =
materialized165.nested165.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant166<Source166> = UtilityPipeline<{
readonly item166: Source166;
readonly nested166: {
readonly left: Source166;
readonly right: LeafPayload;
readonly tuple: readonly [Source166, LeafPayload, { wrapped: Source166 }];
};
}>;
type Materialized166 = Variant166<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized166: Materialized166;
const recursiveUtilityValue166: string =
materialized166.nested166.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant167<Source167> = UtilityPipeline<{
readonly item167: Source167;
readonly nested167: {
readonly left: Source167;
readonly right: LeafPayload;
readonly tuple: readonly [Source167, LeafPayload, { wrapped: Source167 }];
};
}>;
type Materialized167 = Variant167<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized167: Materialized167;
const recursiveUtilityValue167: string =
materialized167.nested167.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant168<Source168> = UtilityPipeline<{
readonly item168: Source168;
readonly nested168: {
readonly left: Source168;
readonly right: LeafPayload;
readonly tuple: readonly [Source168, LeafPayload, { wrapped: Source168 }];
};
}>;
type Materialized168 = Variant168<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized168: Materialized168;
const recursiveUtilityValue168: string =
materialized168.nested168.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant169<Source169> = UtilityPipeline<{
readonly item169: Source169;
readonly nested169: {
readonly left: Source169;
readonly right: LeafPayload;
readonly tuple: readonly [Source169, LeafPayload, { wrapped: Source169 }];
};
}>;
type Materialized169 = Variant169<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized169: Materialized169;
const recursiveUtilityValue169: string =
materialized169.nested169.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant170<Source170> = UtilityPipeline<{
readonly item170: Source170;
readonly nested170: {
readonly left: Source170;
readonly right: LeafPayload;
readonly tuple: readonly [Source170, LeafPayload, { wrapped: Source170 }];
};
}>;
type Materialized170 = Variant170<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized170: Materialized170;
const recursiveUtilityValue170: string =
materialized170.nested170.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant171<Source171> = UtilityPipeline<{
readonly item171: Source171;
readonly nested171: {
readonly left: Source171;
readonly right: LeafPayload;
readonly tuple: readonly [Source171, LeafPayload, { wrapped: Source171 }];
};
}>;
type Materialized171 = Variant171<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized171: Materialized171;
const recursiveUtilityValue171: string =
materialized171.nested171.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant172<Source172> = UtilityPipeline<{
readonly item172: Source172;
readonly nested172: {
readonly left: Source172;
readonly right: LeafPayload;
readonly tuple: readonly [Source172, LeafPayload, { wrapped: Source172 }];
};
}>;
type Materialized172 = Variant172<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized172: Materialized172;
const recursiveUtilityValue172: string =
materialized172.nested172.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant173<Source173> = UtilityPipeline<{
readonly item173: Source173;
readonly nested173: {
readonly left: Source173;
readonly right: LeafPayload;
readonly tuple: readonly [Source173, LeafPayload, { wrapped: Source173 }];
};
}>;
type Materialized173 = Variant173<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized173: Materialized173;
const recursiveUtilityValue173: string =
materialized173.nested173.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant174<Source174> = UtilityPipeline<{
readonly item174: Source174;
readonly nested174: {
readonly left: Source174;
readonly right: LeafPayload;
readonly tuple: readonly [Source174, LeafPayload, { wrapped: Source174 }];
};
}>;
type Materialized174 = Variant174<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized174: Materialized174;
const recursiveUtilityValue174: string =
materialized174.nested174.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant175<Source175> = UtilityPipeline<{
readonly item175: Source175;
readonly nested175: {
readonly left: Source175;
readonly right: LeafPayload;
readonly tuple: readonly [Source175, LeafPayload, { wrapped: Source175 }];
};
}>;
type Materialized175 = Variant175<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized175: Materialized175;
const recursiveUtilityValue175: string =
materialized175.nested175.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant176<Source176> = UtilityPipeline<{
readonly item176: Source176;
readonly nested176: {
readonly left: Source176;
readonly right: LeafPayload;
readonly tuple: readonly [Source176, LeafPayload, { wrapped: Source176 }];
};
}>;
type Materialized176 = Variant176<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized176: Materialized176;
const recursiveUtilityValue176: string =
materialized176.nested176.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant177<Source177> = UtilityPipeline<{
readonly item177: Source177;
readonly nested177: {
readonly left: Source177;
readonly right: LeafPayload;
readonly tuple: readonly [Source177, LeafPayload, { wrapped: Source177 }];
};
}>;
type Materialized177 = Variant177<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized177: Materialized177;
const recursiveUtilityValue177: string =
materialized177.nested177.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant178<Source178> = UtilityPipeline<{
readonly item178: Source178;
readonly nested178: {
readonly left: Source178;
readonly right: LeafPayload;
readonly tuple: readonly [Source178, LeafPayload, { wrapped: Source178 }];
};
}>;
type Materialized178 = Variant178<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized178: Materialized178;
const recursiveUtilityValue178: string =
materialized178.nested178.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant179<Source179> = UtilityPipeline<{
readonly item179: Source179;
readonly nested179: {
readonly left: Source179;
readonly right: LeafPayload;
readonly tuple: readonly [Source179, LeafPayload, { wrapped: Source179 }];
};
}>;
type Materialized179 = Variant179<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized179: Materialized179;
const recursiveUtilityValue179: string =
materialized179.nested179.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant180<Source180> = UtilityPipeline<{
readonly item180: Source180;
readonly nested180: {
readonly left: Source180;
readonly right: LeafPayload;
readonly tuple: readonly [Source180, LeafPayload, { wrapped: Source180 }];
};
}>;
type Materialized180 = Variant180<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized180: Materialized180;
const recursiveUtilityValue180: string =
materialized180.nested180.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant181<Source181> = UtilityPipeline<{
readonly item181: Source181;
readonly nested181: {
readonly left: Source181;
readonly right: LeafPayload;
readonly tuple: readonly [Source181, LeafPayload, { wrapped: Source181 }];
};
}>;
type Materialized181 = Variant181<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized181: Materialized181;
const recursiveUtilityValue181: string =
materialized181.nested181.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant182<Source182> = UtilityPipeline<{
readonly item182: Source182;
readonly nested182: {
readonly left: Source182;
readonly right: LeafPayload;
readonly tuple: readonly [Source182, LeafPayload, { wrapped: Source182 }];
};
}>;
type Materialized182 = Variant182<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized182: Materialized182;
const recursiveUtilityValue182: string =
materialized182.nested182.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant183<Source183> = UtilityPipeline<{
readonly item183: Source183;
readonly nested183: {
readonly left: Source183;
readonly right: LeafPayload;
readonly tuple: readonly [Source183, LeafPayload, { wrapped: Source183 }];
};
}>;
type Materialized183 = Variant183<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized183: Materialized183;
const recursiveUtilityValue183: string =
materialized183.nested183.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant184<Source184> = UtilityPipeline<{
readonly item184: Source184;
readonly nested184: {
readonly left: Source184;
readonly right: LeafPayload;
readonly tuple: readonly [Source184, LeafPayload, { wrapped: Source184 }];
};
}>;
type Materialized184 = Variant184<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized184: Materialized184;
const recursiveUtilityValue184: string =
materialized184.nested184.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant185<Source185> = UtilityPipeline<{
readonly item185: Source185;
readonly nested185: {
readonly left: Source185;
readonly right: LeafPayload;
readonly tuple: readonly [Source185, LeafPayload, { wrapped: Source185 }];
};
}>;
type Materialized185 = Variant185<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized185: Materialized185;
const recursiveUtilityValue185: string =
materialized185.nested185.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant186<Source186> = UtilityPipeline<{
readonly item186: Source186;
readonly nested186: {
readonly left: Source186;
readonly right: LeafPayload;
readonly tuple: readonly [Source186, LeafPayload, { wrapped: Source186 }];
};
}>;
type Materialized186 = Variant186<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized186: Materialized186;
const recursiveUtilityValue186: string =
materialized186.nested186.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant187<Source187> = UtilityPipeline<{
readonly item187: Source187;
readonly nested187: {
readonly left: Source187;
readonly right: LeafPayload;
readonly tuple: readonly [Source187, LeafPayload, { wrapped: Source187 }];
};
}>;
type Materialized187 = Variant187<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized187: Materialized187;
const recursiveUtilityValue187: string =
materialized187.nested187.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant188<Source188> = UtilityPipeline<{
readonly item188: Source188;
readonly nested188: {
readonly left: Source188;
readonly right: LeafPayload;
readonly tuple: readonly [Source188, LeafPayload, { wrapped: Source188 }];
};
}>;
type Materialized188 = Variant188<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized188: Materialized188;
const recursiveUtilityValue188: string =
materialized188.nested188.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant189<Source189> = UtilityPipeline<{
readonly item189: Source189;
readonly nested189: {
readonly left: Source189;
readonly right: LeafPayload;
readonly tuple: readonly [Source189, LeafPayload, { wrapped: Source189 }];
};
}>;
type Materialized189 = Variant189<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized189: Materialized189;
const recursiveUtilityValue189: string =
materialized189.nested189.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant190<Source190> = UtilityPipeline<{
readonly item190: Source190;
readonly nested190: {
readonly left: Source190;
readonly right: LeafPayload;
readonly tuple: readonly [Source190, LeafPayload, { wrapped: Source190 }];
};
}>;
type Materialized190 = Variant190<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized190: Materialized190;
const recursiveUtilityValue190: string =
materialized190.nested190.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant191<Source191> = UtilityPipeline<{
readonly item191: Source191;
readonly nested191: {
readonly left: Source191;
readonly right: LeafPayload;
readonly tuple: readonly [Source191, LeafPayload, { wrapped: Source191 }];
};
}>;
type Materialized191 = Variant191<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized191: Materialized191;
const recursiveUtilityValue191: string =
materialized191.nested191.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant192<Source192> = UtilityPipeline<{
readonly item192: Source192;
readonly nested192: {
readonly left: Source192;
readonly right: LeafPayload;
readonly tuple: readonly [Source192, LeafPayload, { wrapped: Source192 }];
};
}>;
type Materialized192 = Variant192<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized192: Materialized192;
const recursiveUtilityValue192: string =
materialized192.nested192.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant193<Source193> = UtilityPipeline<{
readonly item193: Source193;
readonly nested193: {
readonly left: Source193;
readonly right: LeafPayload;
readonly tuple: readonly [Source193, LeafPayload, { wrapped: Source193 }];
};
}>;
type Materialized193 = Variant193<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized193: Materialized193;
const recursiveUtilityValue193: string =
materialized193.nested193.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant194<Source194> = UtilityPipeline<{
readonly item194: Source194;
readonly nested194: {
readonly left: Source194;
readonly right: LeafPayload;
readonly tuple: readonly [Source194, LeafPayload, { wrapped: Source194 }];
};
}>;
type Materialized194 = Variant194<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized194: Materialized194;
const recursiveUtilityValue194: string =
materialized194.nested194.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant195<Source195> = UtilityPipeline<{
readonly item195: Source195;
readonly nested195: {
readonly left: Source195;
readonly right: LeafPayload;
readonly tuple: readonly [Source195, LeafPayload, { wrapped: Source195 }];
};
}>;
type Materialized195 = Variant195<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized195: Materialized195;
const recursiveUtilityValue195: string =
materialized195.nested195.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant196<Source196> = UtilityPipeline<{
readonly item196: Source196;
readonly nested196: {
readonly left: Source196;
readonly right: LeafPayload;
readonly tuple: readonly [Source196, LeafPayload, { wrapped: Source196 }];
};
}>;
type Materialized196 = Variant196<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized196: Materialized196;
const recursiveUtilityValue196: string =
materialized196.nested196.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant197<Source197> = UtilityPipeline<{
readonly item197: Source197;
readonly nested197: {
readonly left: Source197;
readonly right: LeafPayload;
readonly tuple: readonly [Source197, LeafPayload, { wrapped: Source197 }];
};
}>;
type Materialized197 = Variant197<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized197: Materialized197;
const recursiveUtilityValue197: string =
materialized197.nested197.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant198<Source198> = UtilityPipeline<{
readonly item198: Source198;
readonly nested198: {
readonly left: Source198;
readonly right: LeafPayload;
readonly tuple: readonly [Source198, LeafPayload, { wrapped: Source198 }];
};
}>;
type Materialized198 = Variant198<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized198: Materialized198;
const recursiveUtilityValue198: string =
materialized198.nested198.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant199<Source199> = UtilityPipeline<{
readonly item199: Source199;
readonly nested199: {
readonly left: Source199;
readonly right: LeafPayload;
readonly tuple: readonly [Source199, LeafPayload, { wrapped: Source199 }];
};
}>;
type Materialized199 = Variant199<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized199: Materialized199;
const recursiveUtilityValue199: string =
materialized199.nested199.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant200<Source200> = UtilityPipeline<{
readonly item200: Source200;
readonly nested200: {
readonly left: Source200;
readonly right: LeafPayload;
readonly tuple: readonly [Source200, LeafPayload, { wrapped: Source200 }];
};
}>;
type Materialized200 = Variant200<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized200: Materialized200;
const recursiveUtilityValue200: string =
materialized200.nested200.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant201<Source201> = UtilityPipeline<{
readonly item201: Source201;
readonly nested201: {
readonly left: Source201;
readonly right: LeafPayload;
readonly tuple: readonly [Source201, LeafPayload, { wrapped: Source201 }];
};
}>;
type Materialized201 = Variant201<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized201: Materialized201;
const recursiveUtilityValue201: string =
materialized201.nested201.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant202<Source202> = UtilityPipeline<{
readonly item202: Source202;
readonly nested202: {
readonly left: Source202;
readonly right: LeafPayload;
readonly tuple: readonly [Source202, LeafPayload, { wrapped: Source202 }];
};
}>;
type Materialized202 = Variant202<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized202: Materialized202;
const recursiveUtilityValue202: string =
materialized202.nested202.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant203<Source203> = UtilityPipeline<{
readonly item203: Source203;
readonly nested203: {
readonly left: Source203;
readonly right: LeafPayload;
readonly tuple: readonly [Source203, LeafPayload, { wrapped: Source203 }];
};
}>;
type Materialized203 = Variant203<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized203: Materialized203;
const recursiveUtilityValue203: string =
materialized203.nested203.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant204<Source204> = UtilityPipeline<{
readonly item204: Source204;
readonly nested204: {
readonly left: Source204;
readonly right: LeafPayload;
readonly tuple: readonly [Source204, LeafPayload, { wrapped: Source204 }];
};
}>;
type Materialized204 = Variant204<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized204: Materialized204;
const recursiveUtilityValue204: string =
materialized204.nested204.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant205<Source205> = UtilityPipeline<{
readonly item205: Source205;
readonly nested205: {
readonly left: Source205;
readonly right: LeafPayload;
readonly tuple: readonly [Source205, LeafPayload, { wrapped: Source205 }];
};
}>;
type Materialized205 = Variant205<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized205: Materialized205;
const recursiveUtilityValue205: string =
materialized205.nested205.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant206<Source206> = UtilityPipeline<{
readonly item206: Source206;
readonly nested206: {
readonly left: Source206;
readonly right: LeafPayload;
readonly tuple: readonly [Source206, LeafPayload, { wrapped: Source206 }];
};
}>;
type Materialized206 = Variant206<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized206: Materialized206;
const recursiveUtilityValue206: string =
materialized206.nested206.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant207<Source207> = UtilityPipeline<{
readonly item207: Source207;
readonly nested207: {
readonly left: Source207;
readonly right: LeafPayload;
readonly tuple: readonly [Source207, LeafPayload, { wrapped: Source207 }];
};
}>;
type Materialized207 = Variant207<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized207: Materialized207;
const recursiveUtilityValue207: string =
materialized207.nested207.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant208<Source208> = UtilityPipeline<{
readonly item208: Source208;
readonly nested208: {
readonly left: Source208;
readonly right: LeafPayload;
readonly tuple: readonly [Source208, LeafPayload, { wrapped: Source208 }];
};
}>;
type Materialized208 = Variant208<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized208: Materialized208;
const recursiveUtilityValue208: string =
materialized208.nested208.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant209<Source209> = UtilityPipeline<{
readonly item209: Source209;
readonly nested209: {
readonly left: Source209;
readonly right: LeafPayload;
readonly tuple: readonly [Source209, LeafPayload, { wrapped: Source209 }];
};
}>;
type Materialized209 = Variant209<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized209: Materialized209;
const recursiveUtilityValue209: string =
materialized209.nested209.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant210<Source210> = UtilityPipeline<{
readonly item210: Source210;
readonly nested210: {
readonly left: Source210;
readonly right: LeafPayload;
readonly tuple: readonly [Source210, LeafPayload, { wrapped: Source210 }];
};
}>;
type Materialized210 = Variant210<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized210: Materialized210;
const recursiveUtilityValue210: string =
materialized210.nested210.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant211<Source211> = UtilityPipeline<{
readonly item211: Source211;
readonly nested211: {
readonly left: Source211;
readonly right: LeafPayload;
readonly tuple: readonly [Source211, LeafPayload, { wrapped: Source211 }];
};
}>;
type Materialized211 = Variant211<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized211: Materialized211;
const recursiveUtilityValue211: string =
materialized211.nested211.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant212<Source212> = UtilityPipeline<{
readonly item212: Source212;
readonly nested212: {
readonly left: Source212;
readonly right: LeafPayload;
readonly tuple: readonly [Source212, LeafPayload, { wrapped: Source212 }];
};
}>;
type Materialized212 = Variant212<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized212: Materialized212;
const recursiveUtilityValue212: string =
materialized212.nested212.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant213<Source213> = UtilityPipeline<{
readonly item213: Source213;
readonly nested213: {
readonly left: Source213;
readonly right: LeafPayload;
readonly tuple: readonly [Source213, LeafPayload, { wrapped: Source213 }];
};
}>;
type Materialized213 = Variant213<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized213: Materialized213;
const recursiveUtilityValue213: string =
materialized213.nested213.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant214<Source214> = UtilityPipeline<{
readonly item214: Source214;
readonly nested214: {
readonly left: Source214;
readonly right: LeafPayload;
readonly tuple: readonly [Source214, LeafPayload, { wrapped: Source214 }];
};
}>;
type Materialized214 = Variant214<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized214: Materialized214;
const recursiveUtilityValue214: string =
materialized214.nested214.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant215<Source215> = UtilityPipeline<{
readonly item215: Source215;
readonly nested215: {
readonly left: Source215;
readonly right: LeafPayload;
readonly tuple: readonly [Source215, LeafPayload, { wrapped: Source215 }];
};
}>;
type Materialized215 = Variant215<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized215: Materialized215;
const recursiveUtilityValue215: string =
materialized215.nested215.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant216<Source216> = UtilityPipeline<{
readonly item216: Source216;
readonly nested216: {
readonly left: Source216;
readonly right: LeafPayload;
readonly tuple: readonly [Source216, LeafPayload, { wrapped: Source216 }];
};
}>;
type Materialized216 = Variant216<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized216: Materialized216;
const recursiveUtilityValue216: string =
materialized216.nested216.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant217<Source217> = UtilityPipeline<{
readonly item217: Source217;
readonly nested217: {
readonly left: Source217;
readonly right: LeafPayload;
readonly tuple: readonly [Source217, LeafPayload, { wrapped: Source217 }];
};
}>;
type Materialized217 = Variant217<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized217: Materialized217;
const recursiveUtilityValue217: string =
materialized217.nested217.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant218<Source218> = UtilityPipeline<{
readonly item218: Source218;
readonly nested218: {
readonly left: Source218;
readonly right: LeafPayload;
readonly tuple: readonly [Source218, LeafPayload, { wrapped: Source218 }];
};
}>;
type Materialized218 = Variant218<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized218: Materialized218;
const recursiveUtilityValue218: string =
materialized218.nested218.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant219<Source219> = UtilityPipeline<{
readonly item219: Source219;
readonly nested219: {
readonly left: Source219;
readonly right: LeafPayload;
readonly tuple: readonly [Source219, LeafPayload, { wrapped: Source219 }];
};
}>;
type Materialized219 = Variant219<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized219: Materialized219;
const recursiveUtilityValue219: string =
materialized219.nested219.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant220<Source220> = UtilityPipeline<{
readonly item220: Source220;
readonly nested220: {
readonly left: Source220;
readonly right: LeafPayload;
readonly tuple: readonly [Source220, LeafPayload, { wrapped: Source220 }];
};
}>;
type Materialized220 = Variant220<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized220: Materialized220;
const recursiveUtilityValue220: string =
materialized220.nested220.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant221<Source221> = UtilityPipeline<{
readonly item221: Source221;
readonly nested221: {
readonly left: Source221;
readonly right: LeafPayload;
readonly tuple: readonly [Source221, LeafPayload, { wrapped: Source221 }];
};
}>;
type Materialized221 = Variant221<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized221: Materialized221;
const recursiveUtilityValue221: string =
materialized221.nested221.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant222<Source222> = UtilityPipeline<{
readonly item222: Source222;
readonly nested222: {
readonly left: Source222;
readonly right: LeafPayload;
readonly tuple: readonly [Source222, LeafPayload, { wrapped: Source222 }];
};
}>;
type Materialized222 = Variant222<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized222: Materialized222;
const recursiveUtilityValue222: string =
materialized222.nested222.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant223<Source223> = UtilityPipeline<{
readonly item223: Source223;
readonly nested223: {
readonly left: Source223;
readonly right: LeafPayload;
readonly tuple: readonly [Source223, LeafPayload, { wrapped: Source223 }];
};
}>;
type Materialized223 = Variant223<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized223: Materialized223;
const recursiveUtilityValue223: string =
materialized223.nested223.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant224<Source224> = UtilityPipeline<{
readonly item224: Source224;
readonly nested224: {
readonly left: Source224;
readonly right: LeafPayload;
readonly tuple: readonly [Source224, LeafPayload, { wrapped: Source224 }];
};
}>;
type Materialized224 = Variant224<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized224: Materialized224;
const recursiveUtilityValue224: string =
materialized224.nested224.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant225<Source225> = UtilityPipeline<{
readonly item225: Source225;
readonly nested225: {
readonly left: Source225;
readonly right: LeafPayload;
readonly tuple: readonly [Source225, LeafPayload, { wrapped: Source225 }];
};
}>;
type Materialized225 = Variant225<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized225: Materialized225;
const recursiveUtilityValue225: string =
materialized225.nested225.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant226<Source226> = UtilityPipeline<{
readonly item226: Source226;
readonly nested226: {
readonly left: Source226;
readonly right: LeafPayload;
readonly tuple: readonly [Source226, LeafPayload, { wrapped: Source226 }];
};
}>;
type Materialized226 = Variant226<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized226: Materialized226;
const recursiveUtilityValue226: string =
materialized226.nested226.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant227<Source227> = UtilityPipeline<{
readonly item227: Source227;
readonly nested227: {
readonly left: Source227;
readonly right: LeafPayload;
readonly tuple: readonly [Source227, LeafPayload, { wrapped: Source227 }];
};
}>;
type Materialized227 = Variant227<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized227: Materialized227;
const recursiveUtilityValue227: string =
materialized227.nested227.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant228<Source228> = UtilityPipeline<{
readonly item228: Source228;
readonly nested228: {
readonly left: Source228;
readonly right: LeafPayload;
readonly tuple: readonly [Source228, LeafPayload, { wrapped: Source228 }];
};
}>;
type Materialized228 = Variant228<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized228: Materialized228;
const recursiveUtilityValue228: string =
materialized228.nested228.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant229<Source229> = UtilityPipeline<{
readonly item229: Source229;
readonly nested229: {
readonly left: Source229;
readonly right: LeafPayload;
readonly tuple: readonly [Source229, LeafPayload, { wrapped: Source229 }];
};
}>;
type Materialized229 = Variant229<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized229: Materialized229;
const recursiveUtilityValue229: string =
materialized229.nested229.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant230<Source230> = UtilityPipeline<{
readonly item230: Source230;
readonly nested230: {
readonly left: Source230;
readonly right: LeafPayload;
readonly tuple: readonly [Source230, LeafPayload, { wrapped: Source230 }];
};
}>;
type Materialized230 = Variant230<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized230: Materialized230;
const recursiveUtilityValue230: string =
materialized230.nested230.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant231<Source231> = UtilityPipeline<{
readonly item231: Source231;
readonly nested231: {
readonly left: Source231;
readonly right: LeafPayload;
readonly tuple: readonly [Source231, LeafPayload, { wrapped: Source231 }];
};
}>;
type Materialized231 = Variant231<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized231: Materialized231;
const recursiveUtilityValue231: string =
materialized231.nested231.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant232<Source232> = UtilityPipeline<{
readonly item232: Source232;
readonly nested232: {
readonly left: Source232;
readonly right: LeafPayload;
readonly tuple: readonly [Source232, LeafPayload, { wrapped: Source232 }];
};
}>;
type Materialized232 = Variant232<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized232: Materialized232;
const recursiveUtilityValue232: string =
materialized232.nested232.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant233<Source233> = UtilityPipeline<{
readonly item233: Source233;
readonly nested233: {
readonly left: Source233;
readonly right: LeafPayload;
readonly tuple: readonly [Source233, LeafPayload, { wrapped: Source233 }];
};
}>;
type Materialized233 = Variant233<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized233: Materialized233;
const recursiveUtilityValue233: string =
materialized233.nested233.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant234<Source234> = UtilityPipeline<{
readonly item234: Source234;
readonly nested234: {
readonly left: Source234;
readonly right: LeafPayload;
readonly tuple: readonly [Source234, LeafPayload, { wrapped: Source234 }];
};
}>;
type Materialized234 = Variant234<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized234: Materialized234;
const recursiveUtilityValue234: string =
materialized234.nested234.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant235<Source235> = UtilityPipeline<{
readonly item235: Source235;
readonly nested235: {
readonly left: Source235;
readonly right: LeafPayload;
readonly tuple: readonly [Source235, LeafPayload, { wrapped: Source235 }];
};
}>;
type Materialized235 = Variant235<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized235: Materialized235;
const recursiveUtilityValue235: string =
materialized235.nested235.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant236<Source236> = UtilityPipeline<{
readonly item236: Source236;
readonly nested236: {
readonly left: Source236;
readonly right: LeafPayload;
readonly tuple: readonly [Source236, LeafPayload, { wrapped: Source236 }];
};
}>;
type Materialized236 = Variant236<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized236: Materialized236;
const recursiveUtilityValue236: string =
materialized236.nested236.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant237<Source237> = UtilityPipeline<{
readonly item237: Source237;
readonly nested237: {
readonly left: Source237;
readonly right: LeafPayload;
readonly tuple: readonly [Source237, LeafPayload, { wrapped: Source237 }];
};
}>;
type Materialized237 = Variant237<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized237: Materialized237;
const recursiveUtilityValue237: string =
materialized237.nested237.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant238<Source238> = UtilityPipeline<{
readonly item238: Source238;
readonly nested238: {
readonly left: Source238;
readonly right: LeafPayload;
readonly tuple: readonly [Source238, LeafPayload, { wrapped: Source238 }];
};
}>;
type Materialized238 = Variant238<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized238: Materialized238;
const recursiveUtilityValue238: string =
materialized238.nested238.tuple[2].wrapped.next.next.value.flags.labels[0];
type Variant239<Source239> = UtilityPipeline<{
readonly item239: Source239;
readonly nested239: {
readonly left: Source239;
readonly right: LeafPayload;
readonly tuple: readonly [Source239, LeafPayload, { wrapped: Source239 }];
};
}>;
type Materialized239 = Variant239<{
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly next: {
readonly value: LeafPayload;
readonly done: true;
};
};
}>;
declare const materialized239: Materialized239;
const recursiveUtilityValue239: string =
materialized239.nested239.tuple[2].wrapped.next.next.value.flags.labels[0];