Recursive utility aliases N=120
Recursive utility alias applications that stress generic instantiation, substitution, and cache reuse.
tsz is 2.0x faster 2924 lines 80 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];