|  line  | 
 true  | 
 false  | 
 branch  | 
 
| 
35
 | 
 10  | 
 1  | 
 $INC{'Type/Registry.pm'} ? :  | 
 
| 
 | 
 1  | 
 0  | 
 unless ref $caller or $caller eq "-lexical" or $globals->{'lexical'}  | 
 
| 
42
 | 
 0  | 
 51  | 
 @_ == 1 ? :  | 
 
| 
45
 | 
 1  | 
 50  | 
 if exists $opts{'parent'}  | 
 
| 
48
 | 
 1  | 
 49  | 
 if exists $opts{'constraint'}  | 
 
| 
51
 | 
 1  | 
 48  | 
 if exists $opts{'inlined'}  | 
 
| 
52
 | 
 1  | 
 47  | 
 unless exists $opts{'values'}  | 
 
| 
57
 | 
 47  | 
 0  | 
 ref $opts{'values'} eq 'ARRAY' ? :  | 
 
| 
65
 | 
 47  | 
 0  | 
 if (defined $xs_encoding)  | 
 
| 
67
 | 
 47  | 
 0  | 
 if $xsub  | 
 
| 
70
 | 
 2  | 
 1  | 
 if (defined $opts{'coercion'} and not ref $opts{'coercion'} and 1 eq $opts{'coercion'})  | 
 
| 
79
 | 
 9  | 
 0  | 
 @_ ? :  | 
 
| 
94
 | 
 0  | 
 1  | 
 @_ == 1 ? :  | 
 
| 
102
 | 
 0  | 
 1  | 
 @_ == 1 ? :  | 
 
| 
127
 | 
 7  | 
 0  | 
 unless ($self->is_anon)  | 
 
| 
133
 | 
 6  | 
 1  | 
 if ($self->is_word_safe)  | 
 
| 
164
 | 
 0  | 
 359  | 
 if @$unique_values > 50  | 
 
| 
166
 | 
 22  | 
 0  | 
 eval {
	do {
	'Type::Tiny::XS'->VERSION('0.020');
1
}
} ? :  | 
 
| 
 | 
 22  | 
 337  | 
 unless defined $new_xs  | 
 
| 
168
 | 
 359  | 
 0  | 
 if ($new_xs) { }  | 
 
| 
176
 | 
 0  | 
 0  | 
 if grep /\W/, @$unique_values  | 
 
| 
189
 | 
 1  | 
 4  | 
 if $cached{$regexp}  | 
 
| 
190
 | 
 19  | 
 0  | 
 if defined $_  | 
 
| 
202
 | 
 0  | 
 0  | 
 if $cached{$regexp}  | 
 
| 
217
 | 
 2  | 
 1  | 
 @_ ? :  | 
 
| 
218
 | 
 1  | 
 2  | 
 unless (defined $flags and $flags =~ /^[i]*$/)  | 
 
| 
224
 | 
 1  | 
 1  | 
 $flags ? :  | 
 
| 
235
 | 
 312  | 
 0  | 
 if (my $xs_encoding = _xs_encoding($self->unique_values))  | 
 
| 
237
 | 
 257  | 
 55  | 
 if $xsub and not $Type::Tiny::AvoidCallbacks  | 
 
| 
241
 | 
 0  | 
 55  | 
 $_[0] eq '$_' ? :  | 
 
| 
246
 | 
 55  | 
 0  | 
 if $Type::Tiny::AvoidCallbacks  | 
 
| 
274
 | 
 0  | 
 1  | 
 unless defined $varname  | 
 
| 
276
 | 
 0  | 
 1  | 
 if $self->check($value)  | 
 
| 
279
 | 
 1  | 
 0  | 
 @$self < 13 ? :  | 
 
| 
 | 
 0  | 
 1  | 
 !defined($value) ? :  | 
 
| 
310
 | 
 1  | 
 6  | 
 if exists $hash{$value}  | 
 
| 
321
 | 
 6  | 
 3  | 
 exists $hash{$_[0]} ? :  | 
 
| 
332
 | 
 0  | 
 9  | 
 unless Types::Standard::is_Str($given)  | 
 
| 
334
 | 
 0  | 
 9  | 
 if $self->check($given)  | 
 
| 
336
 | 
 0  | 
 1  | 
 $] lt '5.016' ? :  | 
 
| 
346
 | 
 0  | 
 3  | 
 if exists $lookups{$key}  | 
 
| 
354
 | 
 2  | 
 7  | 
 if $self->{'_lookups'}{$cgiven}  | 
 
| 
359
 | 
 3  | 
 18  | 
 if ($cgiven eq &$canon($stem))  | 
 
| 
360
 | 
 1  | 
 2  | 
 if (defined $best and length $best >= length $possible)  | 
 
| 
367
 | 
 2  | 
 5  | 
 if defined $best  | 
 
| 
369
 | 
 4  | 
 1  | 
 if Types::Standard::is_Int($given)  | 
 
| 
421
 | 
 20  | 
 45  | 
 if $self->{''} and scalar keys %$self == 1  | 
 
| 
426
 | 
 57  | 
 2  | 
 if (ref $self->{$char}) { }  | 
 
| 
427
 | 
 37  | 
 20  | 
 if (defined(my $recurse = _regexp($self->{$char}))) { }  | 
 
| 
439
 | 
 14  | 
 3  | 
 @cc == 1 ? :  | 
 
| 
 | 
 17  | 
 28  | 
 if @cc  | 
 
| 
440
 | 
 38  | 
 7  | 
 @alt == 1 ? :  | 
 
| 
441
 | 
 2  | 
 0  | 
 $cconly ? :  | 
 
| 
 | 
 2  | 
 43  | 
 if $q  | 
 
| 
448
 | 
 0  | 
 8  | 
 unless @$vals  |