<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">package Test2::Util::Importer;
use strict; no strict 'refs';
use warnings; no warnings 'once';

our $VERSION = '0.000162';

my %SIG_TO_SLOT = (
    '&amp;' =&gt; 'CODE',
    '$' =&gt; 'SCALAR',
    '%' =&gt; 'HASH',
    '@' =&gt; 'ARRAY',
    '*' =&gt; 'GLOB',
);

our %IMPORTED;

# This will be used to check if an import arg is a version number
my %NUMERIC = map +($_ =&gt; 1), 0 .. 9;

sub IMPORTER_MENU() {
    return (
        export_ok   =&gt; [qw/optimal_import/],
        export_anon =&gt; {
            import =&gt; sub {
                my $from  = shift;
                my @caller = caller(0);

                _version_check($from, \@caller, shift @_) if @_ &amp;&amp; $NUMERIC{substr($_[0], 0, 1)};

                my $file = _mod_to_file($from);
                _load_file(\@caller, $file) unless $INC{$file};

                return if optimal_import($from, $caller[0], \@caller, @_);

                my $self = __PACKAGE__-&gt;new(
                    from   =&gt; $from,
                    caller =&gt; \@caller,
                );

                $self-&gt;do_import($caller[0], @_);
            },
        },
    );
}

###########################################################################
#
# These are class methods
# import and unimport are what you would expect.
# import_into and unimport_from are the indirect forms you can use in other
# package import() methods.
#
# These all attempt to do a fast optimal-import if possible, then fallback to
# the full-featured import that constructs an object when needed.
#

sub import {
    my $class = shift;

    my @caller = caller(0);

    _version_check($class, \@caller, shift @_) if @_ &amp;&amp; $NUMERIC{substr($_[0], 0, 1)};

    return unless @_;

    my ($from, @args) = @_;

    my $file = _mod_to_file($from);
    _load_file(\@caller, $file) unless $INC{$file};

    return if optimal_import($from, $caller[0], \@caller, @args);

    my $self = $class-&gt;new(
        from   =&gt; $from,
        caller =&gt; \@caller,
    );

    $self-&gt;do_import($caller[0], @args);
}

sub unimport {
    my $class = shift;
    my @caller = caller(0);

    my $self = $class-&gt;new(
        from   =&gt; $caller[0],
        caller =&gt; \@caller,
    );

    $self-&gt;do_unimport(@_);
}

sub import_into {
    my $class = shift;
    my ($from, $into, @args) = @_;

    my @caller;

    if (ref($into)) {
        @caller = @$into;
        $into = $caller[0];
    }
    elsif ($into =~ m/^\d+$/) {
        @caller = caller($into + 1);
        $into = $caller[0];
    }
    else {
        @caller = caller(0);
    }

    my $file = _mod_to_file($from);
    _load_file(\@caller, $file) unless $INC{$file};

    return if optimal_import($from, $into, \@caller, @args);

    my $self = $class-&gt;new(
        from   =&gt; $from,
        caller =&gt; \@caller,
    );

    $self-&gt;do_import($into, @args);
}

sub unimport_from {
    my $class = shift;
    my ($from, @args) = @_;

    my @caller;
    if ($from =~ m/^\d+$/) {
        @caller = caller($from + 1);
        $from = $caller[0];
    }
    else {
        @caller = caller(0);
    }

    my $self = $class-&gt;new(
        from   =&gt; $from,
        caller =&gt; \@caller,
    );

    $self-&gt;do_unimport(@args);
}

###########################################################################
#
# Constructors
#

sub new {
    my $class = shift;
    my %params = @_;

    my $caller = $params{caller} || [caller()];

    die "You must specify a package to import from at $caller-&gt;[1] line $caller-&gt;[2].\n"
        unless $params{from};

    return bless {
        from   =&gt; $params{from},
        caller =&gt; $params{caller},    # Do not use our caller.
    }, $class;
}

###########################################################################
#
# Shortcuts for getting symbols without any namespace modifications
#

sub get {
    my $proto = shift;
    my @caller = caller(1);

    my $self = ref($proto) ? $proto : $proto-&gt;new(
        from   =&gt; shift(@_),
        caller =&gt; \@caller,
    );

    my %result;
    $self-&gt;do_import($caller[0], @_, sub { $result{$_[0]} = $_[1] });
    return \%result;
}

sub get_list {
    my $proto = shift;
    my @caller = caller(1);

    my $self = ref($proto) ? $proto : $proto-&gt;new(
        from   =&gt; shift(@_),
        caller =&gt; \@caller,
    );

    my @result;
    $self-&gt;do_import($caller[0], @_, sub { push @result =&gt; $_[1] });
    return @result;
}

sub get_one {
    my $proto = shift;
    my @caller = caller(1);

    my $self = ref($proto) ? $proto : $proto-&gt;new(
        from   =&gt; shift(@_),
        caller =&gt; \@caller,
    );

    my $result;
    $self-&gt;do_import($caller[0], @_, sub { $result = $_[1] });
    return $result;
}

###########################################################################
#
# Object methods
#

sub do_import {
    my $self = shift;

    my ($into, $versions, $exclude, $import, $set) = $self-&gt;parse_args(@_);

    # Exporter supported multiple version numbers being listed...
    _version_check($self-&gt;from, $self-&gt;get_caller, @$versions) if @$versions;

    return unless @$import;

    $self-&gt;_handle_fail($into, $import) if $self-&gt;menu($into)-&gt;{fail};
    $self-&gt;_set_symbols($into, $exclude, $import, $set);
}

sub do_unimport {
    my $self = shift;

    my $from = $self-&gt;from;
    my $imported = $IMPORTED{$from} or $self-&gt;croak("'$from' does not have any imports to remove");

    my %allowed = map { $_ =&gt; 1 } @$imported;

    my @args = @_ ? @_ : @$imported;

    my $stash = \%{"$from\::"};

    for my $name (@args) {
        $name =~ s/^&amp;//;

        $self-&gt;croak("Sub '$name' was not imported using " . ref($self)) unless $allowed{$name};

        my $glob = delete $stash-&gt;{$name};
        local *GLOBCLONE = *$glob;

        for my $type (qw/SCALAR HASH ARRAY FORMAT IO/) {
            next unless defined(*{$glob}{$type});
            *{"$from\::$name"} = *{$glob}{$type}
        }
    }
}

sub from { $_[0]-&gt;{from} }

sub from_file {
    my $self = shift;

    $self-&gt;{from_file} ||= _mod_to_file($self-&gt;{from});

    return $self-&gt;{from_file};
}

sub load_from {
    my $self = shift;
    my $from_file = $self-&gt;from_file;
    my $this_file = __FILE__;

    return if $INC{$from_file};

    my $caller = $self-&gt;get_caller;

    _load_file($caller, $from_file);
}

sub get_caller {
    my $self = shift;
    return $self-&gt;{caller} if $self-&gt;{caller};

    my $level = 1;
    while(my @caller = caller($level++)) {
        return \@caller if @caller &amp;&amp; !$caller[0]-&gt;isa(__PACKAGE__);
        last unless @caller;
    }

    # Fallback
    return [caller(0)];
}

sub croak {
    my $self = shift;
    my ($msg) = @_;
    my $caller = $self-&gt;get_caller;
    my $file = $caller-&gt;[1] || 'unknown file';
    my $line = $caller-&gt;[2] || 'unknown line';
    die "$msg at $file line $line.\n";
}

sub carp {
    my $self = shift;
    my ($msg) = @_;
    my $caller = $self-&gt;get_caller;
    my $file = $caller-&gt;[1] || 'unknown file';
    my $line = $caller-&gt;[2] || 'unknown line';
    warn "$msg at $file line $line.\n";
}

sub menu {
    my $self = shift;
    my ($into) = @_;

    $self-&gt;croak("menu() requires the name of the destination package")
        unless $into;

    my $for = $self-&gt;{menu_for};
    delete $self-&gt;{menu} if $for &amp;&amp; $for ne $into;
    return $self-&gt;{menu} || $self-&gt;reload_menu($into);
}

sub reload_menu {
    my $self = shift;
    my ($into) = @_;

    $self-&gt;croak("reload_menu() requires the name of the destination package")
        unless $into;

    my $from = $self-&gt;from;

    if (my $menu_sub = *{"$from\::IMPORTER_MENU"}{CODE}) {
        # Hook, other exporter modules can define this method to be compatible with
        # Importer.pm

        my %got = $from-&gt;$menu_sub($into, $self-&gt;get_caller);

        $got{export}       ||= [];
        $got{export_ok}    ||= [];
        $got{export_tags}  ||= {};
        $got{export_fail}  ||= [];
        $got{export_anon}  ||= {};
        $got{export_magic} ||= {};

        $self-&gt;croak("'$from' provides both 'generate' and 'export_gen' in its IMPORTER_MENU (They are exclusive, module must pick 1)")
            if $got{export_gen} &amp;&amp; $got{generate};

        $got{export_gen} ||= {};

        $self-&gt;{menu} = $self-&gt;_build_menu($into =&gt; \%got, 1);
    }
    else {
        my %got;
        $got{export}        = \@{"$from\::EXPORT"};
        $got{export_ok}     = \@{"$from\::EXPORT_OK"};
        $got{export_tags}   = \%{"$from\::EXPORT_TAGS"};
        $got{export_fail}   = \@{"$from\::EXPORT_FAIL"};
        $got{export_gen}    = \%{"$from\::EXPORT_GEN"};
        $got{export_anon}   = \%{"$from\::EXPORT_ANON"};
        $got{export_magic}  = \%{"$from\::EXPORT_MAGIC"};

        $self-&gt;{menu} = $self-&gt;_build_menu($into =&gt; \%got, 0);
    }

    $self-&gt;{menu_for} = $into;

    return $self-&gt;{menu};
}

sub _build_menu {
    my $self = shift;
    my ($into, $got, $new_style) = @_;

    my $from = $self-&gt;from;

    my $export       = $got-&gt;{export}       || [];
    my $export_ok    = $got-&gt;{export_ok}    || [];
    my $export_tags  = $got-&gt;{export_tags}  || {};
    my $export_fail  = $got-&gt;{export_fail}  || [];
    my $export_anon  = $got-&gt;{export_anon}  || {};
    my $export_gen   = $got-&gt;{export_gen}   || {};
    my $export_magic = $got-&gt;{export_magic} || {};

    my $generate = $got-&gt;{generate};

    $generate ||= sub {
        my $symbol = shift;
        my ($sig, $name) = ($symbol =~ m/^(\W?)(.*)$/);
        $sig ||= '&amp;';

        my $do = $export_gen-&gt;{"${sig}${name}"};
        $do ||= $export_gen-&gt;{$name} if !$sig || $sig eq '&amp;';

        return undef unless $do;

        $from-&gt;$do($into, $symbol);
    } if $export_gen &amp;&amp; keys %$export_gen;

    my $lookup  = {};
    my $exports = {};
    for my $sym (@$export, @$export_ok, keys %$export_gen, keys %$export_anon) {
        my ($sig, $name) = ($sym =~ m/^(\W?)(.*)$/);
        $sig ||= '&amp;';

        $lookup-&gt;{"${sig}${name}"} = 1;
        $lookup-&gt;{$name} = 1 if $sig eq '&amp;';

        next if $export_gen-&gt;{"${sig}${name}"};
        next if $sig eq '&amp;' &amp;&amp; $export_gen-&gt;{$name};
        next if $got-&gt;{generate} &amp;&amp; $generate-&gt;("${sig}${name}");

        my $fqn = "$from\::$name";
        # We cannot use *{$fqn}{TYPE} here, it breaks for autoloaded subs, this
        # does not:
        $exports-&gt;{"${sig}${name}"} = $export_anon-&gt;{$sym} || (
            $sig eq '&amp;' ? \&amp;{$fqn} :
            $sig eq '$' ? \${$fqn} :
            $sig eq '@' ? \@{$fqn} :
            $sig eq '%' ? \%{$fqn} :
            $sig eq '*' ? \*{$fqn} :
            # Sometimes people (CGI::Carp) put invalid names (^name=) into
            # @EXPORT. We simply go to 'next' in these cases. These modules
            # have hooks to prevent anyone actually trying to import these.
            next
        );
    }

    my $f_import = $new_style || $from-&gt;can('import');
    $self-&gt;croak("'$from' does not provide any exports")
        unless $new_style
            || keys %$exports
            || $from-&gt;isa('Exporter')
            || ($INC{'Exporter.pm'} &amp;&amp; $f_import &amp;&amp; $f_import == \&amp;Exporter::import);

    # Do not cleanup or normalize the list added to the DEFAULT tag, legacy....
    my $tags = {
        %$export_tags,
        'DEFAULT' =&gt; [ @$export ],
    };

    # Add 'ALL' tag unless already specified. We want to normalize it.
    $tags-&gt;{ALL} ||= [ sort grep {m/^[\&amp;\$\@\%\*]/} keys %$lookup ];

    my $fail = @$export_fail ? {
        map {
            my ($sig, $name) = (m/^(\W?)(.*)$/);
            $sig ||= '&amp;';
            ("${sig}${name}" =&gt; 1, $sig eq '&amp;' ? ($name =&gt; 1) : ())
        } @$export_fail
    } : undef;

    my $menu = {
        lookup   =&gt; $lookup,
        exports  =&gt; $exports,
        tags     =&gt; $tags,
        fail     =&gt; $fail,
        generate =&gt; $generate,
        magic    =&gt; $export_magic,
    };

    return $menu;
}

sub parse_args {
    my $self = shift;
    my ($into, @args) = @_;

    my $menu = $self-&gt;menu($into);

    my @out = $self-&gt;_parse_args($into, $menu, \@args);
    pop @out;
    return @out;
}

sub _parse_args {
    my $self = shift;
    my ($into, $menu, $args, $is_tag) = @_;

    my $from = $self-&gt;from;
    my $main_menu = $self-&gt;menu($into);
    $menu ||= $main_menu;

    # First we strip out versions numbers and setters, this simplifies the logic late.
    my @sets;
    my @versions;
    my @leftover;
    for my $arg (@$args) {
        no warnings 'void';

        # Code refs are custom setters
        # If the first character is an ASCII numeric then it is a version number
        push @sets     =&gt; $arg and next if ref($arg) eq 'CODE';
        push @versions =&gt; $arg xor next if $NUMERIC{substr($arg, 0, 1)};
        push @leftover =&gt; $arg;
    }

    $self-&gt;carp("Multiple setters specified, only 1 will be used") if @sets &gt; 1;
    my $set = pop @sets;

    $args = \@leftover;
    @$args = (':DEFAULT') unless $is_tag || @$args || @versions;

    my %exclude;
    my @import;

    while(my $full_arg = shift @$args) {
        my $arg = $full_arg;
        my $lead = substr($arg, 0, 1);

        my ($spec, $exc);
        if ($lead eq '!') {
            $exc = $lead;

            if ($arg eq '!') {
                # If the current arg is just '!' then we are negating the next item.
                $arg = shift @$args;
            }
            else {
                # Strip off the '!'
                substr($arg, 0, 1, '');
            }

            # Exporter.pm legacy behavior
            # negated first item implies starting with default set:
            unshift @$args =&gt; ':DEFAULT' unless @import || keys %exclude || @versions;

            # Now we have a new lead character
            $lead = substr($arg, 0, 1);
        }
        else {
            # If the item is followed by a reference then they are asking us to
            # do something special...
            $spec = ref($args-&gt;[0]) eq 'HASH' ? shift @$args : {};
        }

        if($lead eq ':') {
            substr($arg, 0, 1, '');
            my $tag = $menu-&gt;{tags}-&gt;{$arg} or $self-&gt;croak("$from does not export the :$arg tag");

            my (undef, $cvers, $cexc, $cimp, $cset, $newmenu) = $self-&gt;_parse_args($into, $menu, $tag, $arg);

            $self-&gt;croak("Exporter specified version numbers (" . join(', ', @$cvers) . ") in the :$arg tag!")
                if @$cvers;

            $self-&gt;croak("Exporter specified a custom symbol setter in the :$arg tag!")
                if $cset;

            # Merge excludes
            %exclude = (%exclude, %$cexc);

            if ($exc) {
                $exclude{$_} = 1 for grep {!ref($_) &amp;&amp; substr($_, 0, 1) ne '+'} map {$_-&gt;[0]} @$cimp;
            }
            elsif ($spec &amp;&amp; keys %$spec) {
                $self-&gt;croak("Cannot use '-as' to rename multiple symbols included by: $full_arg")
                    if $spec-&gt;{'-as'} &amp;&amp; @$cimp &gt; 1;

                for my $set (@$cimp) {
                    my ($sym, $cspec) = @$set;

                    # Start with a blind squash, spec from tag overrides the ones inside.
                    my $nspec = {%$cspec, %$spec};

                    $nspec-&gt;{'-prefix'}  = "$spec-&gt;{'-prefix'}$cspec-&gt;{'-prefix'}"   if $spec-&gt;{'-prefix'}  &amp;&amp; $cspec-&gt;{'-prefix'};
                    $nspec-&gt;{'-postfix'} = "$cspec-&gt;{'-postfix'}$spec-&gt;{'-postfix'}" if $spec-&gt;{'-postfix'} &amp;&amp; $cspec-&gt;{'-postfix'};

                    push @import =&gt; [$sym, $nspec];
                }
            }
            else {
                push @import =&gt; @$cimp;
            }

            # New menu
            $menu = $newmenu;

            next;
        }

        # Process the item to figure out what symbols are being touched, if it
        # is a tag or regex than it can be multiple.
        my @list;
        if(ref($arg) eq 'Regexp') {
            @list = sort grep /$arg/, keys %{$menu-&gt;{lookup}};
        }
        elsif($lead eq '/' &amp;&amp; $arg =~ m{^/(.*)/$}) {
            my $pattern = $1;
            @list = sort grep /$1/, keys %{$menu-&gt;{lookup}};
        }
        else {
            @list = ($arg);
        }

        # Normalize list, always have a sigil
        @list = map {m/^\W/ ? $_ : "\&amp;$_" } @list;

        if ($exc) {
            $exclude{$_} = 1 for @list;
        }
        else {
            $self-&gt;croak("Cannot use '-as' to rename multiple symbols included by: $full_arg")
                if $spec-&gt;{'-as'} &amp;&amp; @list &gt; 1;

            push @import =&gt; [$_, $spec] for @list;
        }
    }

    return ($into, \@versions, \%exclude, \@import, $set, $menu);
}

sub _handle_fail {
    my $self = shift;
    my ($into, $import) = @_;

    my $from = $self-&gt;from;
    my $menu = $self-&gt;menu($into);

    # Historically Exporter would strip the '&amp;' off of sub names passed into export_fail.
    my @fail = map {my $x = $_-&gt;[0]; $x =~ s/^&amp;//; $x} grep $menu-&gt;{fail}-&gt;{$_-&gt;[0]}, @$import or return;

    my @real_fail = $from-&gt;can('export_fail') ? $from-&gt;export_fail(@fail) : @fail;

    if (@real_fail) {
        $self-&gt;carp(qq["$_" is not implemented by the $from module on this architecture])
            for @real_fail;

        $self-&gt;croak("Can't continue after import errors");
    }

    $self-&gt;reload_menu($menu);
    return;
}

sub _set_symbols {
    my $self = shift;
    my ($into, $exclude, $import, $custom_set) = @_;

    my $from   = $self-&gt;from;
    my $menu   = $self-&gt;menu($into);
    my $caller = $self-&gt;get_caller();

    my $set_symbol = $custom_set || eval &lt;&lt;"    EOT" || die $@;
# Inherit the callers warning settings. If they have warnings and we
# redefine their subs they will hear about it. If they do not have warnings
# on they will not.
BEGIN { \${^WARNING_BITS} = \$caller-&gt;[9] if defined \$caller-&gt;[9] }
#line $caller-&gt;[2] "$caller-&gt;[1]"
sub { *{"$into\\::\$_[0]"} = \$_[1] }
    EOT

    for my $set (@$import) {
        my ($symbol, $spec) = @$set;

        my ($sig, $name) = ($symbol =~ m/^(\W)(.*)$/) or die "Invalid symbol: $symbol";

        # Find the thing we are actually shoving in a new namespace
        my $ref = $menu-&gt;{exports}-&gt;{$symbol};
        $ref ||= $menu-&gt;{generate}-&gt;($symbol) if $menu-&gt;{generate};

        # Exporter.pm supported listing items in @EXPORT that are not actually
        # available for export. So if it is listed (lookup) but nothing is
        # there (!$ref) we simply skip it.
        $self-&gt;croak("$from does not export $symbol") unless $ref || $menu-&gt;{lookup}-&gt;{"${sig}${name}"};
        next unless $ref;

        my $type = ref($ref);
        $type = 'SCALAR' if $type eq 'REF';
        $self-&gt;croak("Symbol '$sig$name' requested, but reference (" . ref($ref) . ") does not match sigil ($sig)")
            if $ref &amp;&amp; $type ne $SIG_TO_SLOT{$sig};

        # If they directly renamed it then we assume they want it under the new
        # name, otherwise excludes get kicked. It is useful to be able to
        # exclude an item in a tag/match where the group has a prefix/postfix.
        next if $exclude-&gt;{"${sig}${name}"} &amp;&amp; !$spec-&gt;{'-as'};

        my $new_name = join '' =&gt; ($spec-&gt;{'-prefix'} || '', $spec-&gt;{'-as'} || $name, $spec-&gt;{'-postfix'} || '');

        # Set the symbol (finally!)
        $set_symbol-&gt;($new_name, $ref, sig =&gt; $sig, symbol =&gt; $symbol, into =&gt; $into, from =&gt; $from, spec =&gt; $spec);

        # The remaining things get skipped with a custom setter
        next if $custom_set;

        # Record the import so that we can 'unimport'
        push @{$IMPORTED{$into}} =&gt; $new_name if $sig eq '&amp;';

        # Apply magic
        my $magic = $menu-&gt;{magic}-&gt;{$symbol};
        $magic  ||= $menu-&gt;{magic}-&gt;{$name} if $sig eq '&amp;';
        $from-&gt;$magic(into =&gt; $into, orig_name =&gt; $name, new_name =&gt; $new_name, ref =&gt; $ref)
            if $magic;
    }
}

###########################################################################
#
# The rest of these are utility functions, not methods!
#

sub _version_check {
    my ($mod, $caller, @versions) = @_;

    eval &lt;&lt;"    EOT" or die $@;
#line $caller-&gt;[2] "$caller-&gt;[1]"
\$mod-&gt;VERSION(\$_) for \@versions;
1;
    EOT
}

sub _mod_to_file {
    my $file = shift;
    $file =~ s{::}{/}g;
    $file .= '.pm';
    return $file;
}

sub _load_file {
    my ($caller, $file) = @_;

    eval &lt;&lt;"    EOT" || die $@;
#line $caller-&gt;[2] "$caller-&gt;[1]"
require \$file;
    EOT
}


my %HEAVY_VARS = (
    IMPORTER_MENU =&gt; 'CODE',     # Origin package has a custom menu
    EXPORT_FAIL   =&gt; 'ARRAY',    # Origin package has a failure handler
    EXPORT_GEN    =&gt; 'HASH',     # Origin package has generators
    EXPORT_ANON   =&gt; 'HASH',     # Origin package has anonymous exports
    EXPORT_MAGIC  =&gt; 'HASH',     # Origin package has magic to apply post-export
);

sub optimal_import {
    my ($from, $into, $caller, @args) = @_;

    defined(*{"$from\::$_"}{$HEAVY_VARS{$_}}) and return 0 for keys %HEAVY_VARS;

    # Default to @EXPORT
    @args = @{"$from\::EXPORT"} unless @args;

    # Subs will be listed without sigil in %allowed, all others keep sigil
    my %allowed = map +(substr($_, 0, 1) eq '&amp;' ? substr($_, 1) : $_ =&gt; 1),
        @{"$from\::EXPORT"}, @{"$from\::EXPORT_OK"};

    # First check if it is allowed, stripping '&amp;' if necessary, which will also
    # let scalars in, we will deal with those shortly.
    # If not allowed return 0 (need to do a heavy import)
    # if it is allowed then see if it has a CODE slot, if so use it, otherwise
    # we have a symbol that needs heavy due to non-sub, autoload, etc.
    # This will not allow $foo to import foo() since '$from' still contains the
    # sigil making it an invalid symbol name in our globref below.
    my %final = map +(
        (!ref($_) &amp;&amp; ($allowed{$_} || (substr($_, 0, 1, "") eq '&amp;' &amp;&amp; $allowed{$_})))
            ? ($_ =&gt; *{"$from\::$_"}{CODE} || return 0)
            : return 0
    ), @args;

    eval &lt;&lt;"    EOT" || die $@;
# If the caller has redefine warnings enabled then we want to warn them if
# their import redefines things.
BEGIN { \${^WARNING_BITS} = \$caller-&gt;[9] if defined \$caller-&gt;[9] };
#line $caller-&gt;[2] "$caller-&gt;[1]"
(*{"$into\\::\$_"} = \$final{\$_}, push \@{\$Test2::Util::Importer::IMPORTED{\$into}} =&gt; \$_) for keys %final;
1;
    EOT
}

1;

__END__

=pod

=encoding UTF-8

=head1 NAME

Test2::Util::Importer - Inline copy of L&lt;Importer&gt;.

=head1 DESCRIPTION

See L&lt;Importer&gt;.

=head1 MAINTAINERS

=over 4

=item Chad Granum E&lt;lt&gt;exodist@cpan.orgE&lt;gt&gt;

=back

=head1 AUTHORS

=over 4

=item Chad Granum E&lt;lt&gt;exodist@cpan.orgE&lt;gt&gt;

=back

=head1 COPYRIGHT

Copyright 2023 Chad Granum E&lt;lt&gt;exodist7@gmail.comE&lt;gt&gt;.

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

See L&lt;http://dev.perl.org/licenses/&gt;

=cut
</pre></body></html>