=pod

=encoding utf8

=head1 NAME

korapxml_offset_checker - Check offsets in KorAP-XML files

=head1 SYNOPSIS

  perl korapxml_offset_checker -i NKJP/NKJP/SuperExpress -a nkjp/morpho

=head1 INSTALLATION

Requires Mojolicious.

=head1 OPTIONS

=over 2

=item B<--input|-i>

Expects a path to the root of a KorAP-XML document
(the root being the text level, including the C<data.xml>),
e.g. C<NKJP/NKJP/SuperExpress>.

=item B<--annotation|-a>

Expects the annotation to check for failing offsets in the form of
C<foundry/layer>, e.g. C<nkjp/morpho>.

=item B<--fix|-f>

Binary flag to rewrite data.xml with fixed offsets.

=item B<--quiet|-q>

Binary flag to indicate to never ask, if fixing is really wanted.

=back

=head1 COPYRIGHT AND LICENSE

Copyright (C) 2022, L<IDS Mannheim|https://www.ids-mannheim.de/>

Author: Nils Diewald

This program is free software published under the
L<BSD-2 License|https://opensource.org/licenses/BSD-2-Clause>.

=cut

