exiftool_vendored 9.45.0 → 9.46.0

data/bin/Image-ExifTool-9.45/lib/Image/ExifTool/RSRC.pm

@@ -1,241 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         RSRC.pm
-#
-# Description:  Read Mac OS Resource information
-#
-# Revisions:    2010/03/17 - P. Harvey Created
-#
-# References:   1) http://developer.apple.com/legacy/mac/library/documentation/mac/MoreToolbox/MoreToolbox-99.html
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::RSRC;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.08';
-
-# Information decoded from Mac OS resources
-%Image::ExifTool::RSRC::Main = (
-    GROUPS => { 2 => 'Document' },
-    NOTES => q{
-        Tags extracted from Mac OS resource files and DFONT files.  These tags may
-        also be extracted from the resource fork of any file in OS X, either by
-        adding "/..namedfork/rsrc" to the filename to process the resource fork
-        alone, or by using the ExtractEmbedded (-ee) option to process the resource
-        fork as a sub-document of the main file.  When writing, ExifTool preserves
-        the Mac OS resource fork by default, but it may deleted with C<-rsrc:all=>
-        on the command line.
-    },
-    '8BIM' => {
-        Name => 'PhotoshopInfo',
-        SubDirectory => { TagTable => 'Image::ExifTool::Photoshop::Main' },
-    },
-    'sfnt' => {
-        Name => 'Font',
-        SubDirectory => { TagTable => 'Image::ExifTool::Font::Name' },
-    },
-    # my samples of postscript-type DFONT files have a POST resource
-    # with ID 0x1f5 and the same format as a PostScript file
-    'POST_0x01f5' => {
-        Name => 'PostscriptFont',
-        SubDirectory => { TagTable => 'Image::ExifTool::PostScript::Main' },
-    },
-    'usro_0x0000' => 'OpenWithApplication',
-    'vers_0x0001' => 'ApplicationVersion',
-    'STR _0xbff3' => 'ApplicationMissingMsg',
-    'STR _0xbff4' => 'CreatorApplication',
-    # the following written by Photoshop
-    # (ref http://www.adobe.ca/devnet/photoshop/psir/ps_image_resources.pdf)
-    'STR#_0x0080' => 'Keywords',
-    'TEXT_0x0080' => 'Description',
-    # don't extract PICT's because the clip region isn't set properly
-    # in the PICT resource for some reason.  Also, a dummy 512-byte
-    # header would have to be added to create a valid PICT file.
-    # 'PICT' => { Name => 'PreviewPICT', Binary => 1 },
-);
-
-#------------------------------------------------------------------------------
-# Read information from a Mac resource file (ref 1)
-# Inputs: 0) ExifTool ref, 1) dirInfo ref
-# Returns: 1 on success, 0 if this wasn't a valid resource file
-sub ProcessRSRC($$)
-{
-    my ($et, $dirInfo) = @_;
-    my $raf = $$dirInfo{RAF};
-    my ($hdr, $map, $buff, $i, $j);
-
-    # attempt to validate the format as thoroughly as practical
-    return 0 unless $raf->Read($hdr, 30) == 30;
-    my ($datOff, $mapOff, $datLen, $mapLen) = unpack('N*', $hdr);
-    return 0 unless $raf->Seek(0, 2);
-    my $fLen = $raf->Tell();
-    return 0 if $datOff < 0x10 or $datOff + $datLen > $fLen;
-    return 0 if $mapOff < 0x10 or $mapOff + $mapLen > $fLen or $mapLen < 30;
-    return 0 if $datOff < $mapOff and $datOff + $datLen > $mapOff;
-    return 0 if $mapOff < $datOff and $mapOff + $mapLen > $datOff;
-
-    # read the resource map
-    $raf->Seek($mapOff, 0) and $raf->Read($map, $mapLen) == $mapLen or return 0;
-    SetByteOrder('MM');
-    my $typeOff = Get16u(\$map, 24);
-    my $nameOff = Get16u(\$map, 26);
-    my $numTypes = Get16u(\$map, 28);
-
-    # validate offsets in the resource map
-    return 0 if $typeOff < 28 or $nameOff < 30;
-
-    $et->SetFileType('RSRC') unless $$et{IN_RESOURCE};
-    my $verbose = $et->Options('Verbose');
-    my $tagTablePtr = GetTagTable('Image::ExifTool::RSRC::Main');
-    $et->VerboseDir('RSRC', $numTypes+1);
-
-    # parse resource type list
-    for ($i=0; $i<=$numTypes; ++$i) {
-        my $off = $typeOff + 2 + 8 * $i;    # offset of entry in type list
-        last if $off + 8 > $mapLen;
-        my $resType = substr($map,$off,4);  # resource type
-        my $resNum = Get16u(\$map,$off+4);  # number of resources - 1
-        my $refOff = Get16u(\$map,$off+6) + $typeOff; # offset to first resource reference
-        # loop through all resources
-        for ($j=0; $j<=$resNum; ++$j) {
-            my $roff = $refOff + 12 * $j;
-            last if $roff + 12 > $mapLen;
-            # read only the 24-bit resource data offset
-            my $id = Get16u(\$map,$roff);
-            my $resOff = (Get32u(\$map,$roff+4) & 0x00ffffff) + $datOff;
-            my $resNameOff = Get16u(\$map,$roff+2) + $nameOff + $mapOff;
-            my ($tag, $val, $valLen);
-            my $tagInfo = $$tagTablePtr{$resType};
-            if ($tagInfo) {
-                $tag = $resType;
-            } else {
-                $tag = sprintf('%s_0x%.4x', $resType, $id);
-                $tagInfo = $$tagTablePtr{$tag};
-            }
-            # read the resource data if necessary
-            if ($tagInfo or $verbose) {
-                unless ($raf->Seek($resOff, 0) and $raf->Read($buff, 4) == 4 and
-                        ($valLen = unpack('N', $buff)) < 100000000 and # arbitrary size limit (100MB)
-                        $raf->Read($val, $valLen) == $valLen)
-                {
-                    $et->Warn("Error reading $resType resource");
-                    next;
-                }
-            }
-            if ($verbose) {
-                my ($resName, $nameLen);
-                $resName = '' unless $raf->Seek($resNameOff, 0) and $raf->Read($buff, 1) and
-                    ($nameLen = ord $buff) != 0 and $raf->Read($resName, $nameLen) == $nameLen;
-                $et->VPrint(0,sprintf("%s resource ID 0x%.4x (offset 0x%.4x, $valLen bytes, name='%s'):\n",
-                    $resType, $id, $resOff, $resName));
-                $et->VerboseDump(\$val);
-            }
-            next unless $tagInfo;
-            if ($resType eq 'vers') {
-                # parse the 'vers' resource to get the long version string
-                next unless $valLen > 8;
-                # long version string is after short version
-                my $p = 7 + Get8u(\$val, 6);
-                next if $p >= $valLen;
-                my $vlen = Get8u(\$val, $p++);
-                next if $p + $vlen > $valLen;
-                my $tagTablePtr = GetTagTable('Image::ExifTool::RSRC::Main');
-                $val = $et->Decode(substr($val, $p, $vlen), 'MacRoman');
-            } elsif ($resType eq 'sfnt') {
-                # parse the OTF font block
-                $raf->Seek($resOff + 4, 0) or next;
-                $$dirInfo{Base} = $resOff + 4;
-                require Image::ExifTool::Font;
-                unless (Image::ExifTool::Font::ProcessOTF($et, $dirInfo)) {
-                    $et->Warn('Unrecognized sfnt resource format');
-                }
-                # assume this is a DFONT file unless processing the rsrc fork
-                $et->OverrideFileType('DFONT') unless $$et{DOC_NUM};
-                next;
-            } elsif ($resType eq '8BIM') {
-                my $ttPtr = GetTagTable('Image::ExifTool::Photoshop::Main');
-                $et->HandleTag($ttPtr, $id, $val,
-                    DataPt  => \$val,
-                    DataPos => $resOff + 4,
-                    Size    => $valLen,
-                    Start   => 0,
-                    Parent  => 'RSRC',
-                );
-                next;
-            } elsif ($resType eq 'STR ' and $valLen > 1) {
-                # extract Pascal string
-                my $len = ord $val;
-                next unless $valLen >= $len + 1;
-                $val = substr($val, 1, $len);
-            } elsif ($resType eq 'usro' and $valLen > 4) {
-                my $len = unpack('N', $val);
-                next unless $valLen >= $len + 4;
-                ($val = substr($val, 4, $len)) =~ s/\0.*//g; # truncate at null
-            } elsif ($resType eq 'STR#' and $valLen > 2) {
-                # extract list of strings (ref http://simtech.sourceforge.net/tech/strings.html)
-                my $num = unpack('n', $val);
-                next if $num & 0xf000; # (ignore special-format STR# resources)
-                my ($i, @vals);
-                my $pos = 2;
-                for ($i=0; $i<$num; ++$i) {
-                    last if $pos >= $valLen;
-                    my $len = ord substr($val, $pos++, 1);
-                    last if $pos + $len > $valLen;
-                    push @vals, substr($val, $pos, $len);
-                    $pos += $len;
-                }
-                $val = \@vals;
-            } elsif ($resType eq 'POST') {
-                # assume this is a DFONT file unless processing the rsrc fork
-                $et->OverrideFileType('DFONT') unless $$et{DOC_NUM};
-                $val = substr $val, 2;
-            } elsif ($resType ne 'TEXT') {
-                next;
-            }
-            $et->HandleTag($tagTablePtr, $tag, $val);
-        }
-    }
-    return 1;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::RSRC - Read Mac OS Resource information
-
-=head1 SYNOPSIS
-
-This module is used by Image::ExifTool
-
-=head1 DESCRIPTION
-
-This module contains routines required by Image::ExifTool to read Mac OS
-resource files.
-
-=head1 AUTHOR
-
-Copyright 2003-2013, Phil Harvey (phil at owl.phy.queensu.ca)
-
-This library is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-
-=head1 REFERENCES
-
-=over 4
-
-=item L<http://developer.apple.com/legacy/mac/library/documentation/mac/MoreToolbox/MoreToolbox-99.html>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/RSRC Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-

data/bin/Image-ExifTool-9.45/lib/Image/ExifTool/RTF.pm

@@ -1,383 +0,0 @@
-#------------------------------------------------------------------------------
-# File:         RTF.pm
-#
-# Description:  Read Rich Text Format meta information
-#
-# Revisions:    2010/06/17 - P. Harvey Created
-#
-# References:   1) http://download.microsoft.com/download/2/f/5/2f599e18-07ee-4ec5-a1e7-f4e6a9423592/Word2007RTFSpec9.doc
-#               2) http://search.cpan.org/dist/RTF-Writer/lib/RTF/Cookbook.pod
-#------------------------------------------------------------------------------
-
-package Image::ExifTool::RTF;
-
-use strict;
-use vars qw($VERSION);
-use Image::ExifTool qw(:DataAccess :Utils);
-
-$VERSION = '1.02';
-
-sub ProcessUserProps($$$);
-
-# supported RTF character entities
-my %rtfEntity = (
-    par       => 0x0a,
-    tab       => 0x09,
-    endash    => 0x2013,
-    emdash    => 0x2014,
-    lquote    => 0x2018,
-    rquote    => 0x2019,
-    ldblquote => 0x201c,
-    rdblquote => 0x201d,
-    bullet    => 0x2022,
-);
-
-# RTF tags (ref 1)
-%Image::ExifTool::RTF::Main = (
-    GROUPS => { 2 => 'Document' },
-    NOTES => q{
-        This table lists standard tags of the RTF information group, but ExifTool
-        will also extract any non-standard tags found in this group.  As well,
-        ExifTool will extract any custom properties that are found.  See
-        L<http://www.microsoft.com/en-ca/download/details.aspx?id=10725> for the
-        specification.
-    },
-    title    => { },
-    subject  => { },
-    author   => { Groups => { 2 => 'Author' } },
-    manager  => { },
-    company  => { },
-    copyright=> { Groups => { 2 => 'Author' } }, # (written by Apple TextEdit)
-    operator => { Name => 'LastModifiedBy' },
-    category => { },
-    keywords => { },
-    comment  => { },
-    doccomm  => { Name => 'Comments' },
-    hlinkbase=> { Name => 'HyperlinkBase' },
-    creatim  => {
-        Name => 'CreateDate',
-        Format => 'date',
-        Groups => { 2 => 'Time' },
-        PrintConv => '$self->ConvertDateTime($val)',
-    },
-    revtim   => {
-        Name => 'ModifyDate',
-        Format => 'date',
-        Groups => { 2 => 'Time' },
-        PrintConv => '$self->ConvertDateTime($val)',
-    },
-    printim  => {
-        Name => 'LastPrinted',
-        Format => 'date',
-        Groups => { 2 => 'Time' },
-        PrintConv => '$self->ConvertDateTime($val)',
-    },
-    buptim   => {
-        Name => 'BackupTime',
-        Format => 'date',
-        Groups => { 2 => 'Time' },
-        PrintConv => '$self->ConvertDateTime($val)',
-    },
-    edmins   => {
-        Name => 'TotalEditTime', # in minutes
-        PrintConv => 'ConvertTimeSpan($val, 60)',
-    },
-    nofpages => { Name => 'Pages' },
-    nofwords => { Name => 'Words' },
-    nofchars => { Name => 'Characters' },
-    nofcharsws=>{
-        Name => 'CharactersWithSpaces',
-        Notes => q{
-            according to the 2007 Microsoft RTF specification this is clearly the number
-            of characters NOT including spaces, but Microsoft Word writes this as the
-            number WITH spaces, so ExifTool names this tag according to the de facto
-            standard
-        },
-    },
-    id       => { Name => 'InternalIDNumber' },
-    version  => { Name => 'RevisionNumber' },
-    vern     => { Name => 'InternalVersionNumber' },
-);
-
-# lookup for user-defined properties
-# (none are pre-defined and this table doesn't appear in the docs)
-%Image::ExifTool::RTF::UserProps = (
-    GROUPS => { 2 => 'Document' },
-);
-
-#------------------------------------------------------------------------------
-# Read to nested closing curly bracket "}"
-# Inputs: 0) data ref, 1) optional RAF ref to read more data if available
-# Returns: text inside brackets, or undef on error
-# Notes: On entry the current position in the data must be set to immediately
-#        after the command that opens the bracket.  On return the current
-#        position is immediately following the closing brace if the return
-#        value is defined.
-sub ReadToNested($;$)
-{
-    my ($dataPt, $raf) = @_;
-    my $pos = pos $$dataPt;
-    my $level = 1;
-    for (;;) {
-        # look for the next bracket
-        unless ($$dataPt =~ /(\\*)([{}])/g) {
-            # must read some more data
-            my $p = length $$dataPt;
-            my $buff;
-            last unless $raf and $raf->Read($buff, 65536);
-            $$dataPt .= $buff;
-            # rewind position to include any leading backslashes
-            --$p while $p and substr($$dataPt, $p - 1, 1) eq '\\';
-            pos($$dataPt) = $p; # set position to continue search
-            next;
-        }
-        # bracket is escaped if preceded by an odd number of backslashes
-        next if $1 and length($1) & 0x01;
-        $2 eq '{' and ++$level, next;
-        next unless --$level <= 0;
-        return substr($$dataPt, $pos, pos($$dataPt) - $pos - 1);
-    }
-    return undef;
-}
-
-#------------------------------------------------------------------------------
-# Unescape RTF escape sequences
-# Inputs: 0) ExifTool ref, 1) RTF text, 2) RTF character set (for hex characters)
-# Returns: Unescaped text (in current ExifTool Charset)
-sub UnescapeRTF($$$)
-{
-    my ($et, $val, $charset) = @_;
-
-    # return now unless we have a control sequence
-    unless ($val =~ /\\/) {
-        $val =~ tr/\n\r//d; # ignore CR's and LF's
-        return $val;
-    }
-    # CR/LF is signficant if it terminates a control sequence (so change these to a space)
-    $val =~ s/(^|[^\\])((?:\\\\)*)(\\[a-zA-Z]+(?:-?\d+)?)[\n\r]/$1$2$3 /g;
-    # protect the newline control sequence by converting to a \par command
-    $val =~ s/(^|[^\\])((?:\\\\)*)(\\[\n\r])/$1$2\\par /g;
-    # all other CR/LF's are ignored (so delete them)
-    $val =~ tr/\n\r//d;
-
-    my $rtnVal = '';
-    my $len = length $val;
-    my $skip = 1;   # default Unicode skip count
-    my $p0 = 0;
-
-    for (;;) {
-        # find next backslash
-        my $p1 = ($val =~ /\\/g) ? pos($val) : $len + 1;
-        # add text up to start of this control sequence (or up to end)
-        my $n = $p1 - $p0 - 1;
-        $rtnVal .= substr($val, $p0, $n) if $n > 0;
-        # all done if at the end or if control sequence is empty
-        last if $p1 >= $len;
-        # look for an ASCII-letter control word or Unicode control
-        if ($val =~ /\G([a-zA-Z]+)(-?\d+)? ?/g) {
-            # interpret command if recognized
-            if ($1 eq 'uc') {       # \ucN
-                $skip = $2;
-            } elsif ($1 eq 'u') {   # \uN
-                require Image::ExifTool::Charset;
-                $rtnVal .= Image::ExifTool::Charset::Recompose($et, [$2]);
-                if ($skip) {
-                    # must skip the specified number of characters
-                    # (not simple because RTF control words count as a single character)
-                    last unless $val =~ /\G([^\\]|\\([a-zA-Z]+)(-?\d+)? ?|\\'.{2}|\\.){$skip}/g;
-                }
-            } elsif ($rtfEntity{$1}) {
-                require Image::ExifTool::Charset;
-                $rtnVal .= Image::ExifTool::Charset::Recompose($et, [$rtfEntity{$1}]);
-            } # (else ignore the command)
-        } else {
-            my $ch = substr($val, $p1, 1);
-            if ($ch eq "'") {
-                # hex character code
-                last if $p1 + 3 > $len;
-                my $hex = substr($val, $p1 + 1, 2);
-                if ($hex =~ /^[0-9a-fA-F]{2}$/) {
-                    require Image::ExifTool::Charset;
-                    $rtnVal .= $et->Decode(chr(hex($hex)), $charset);
-                }
-                pos($val) = $p1 + 3;    # skip to after the hex code
-            } else {
-                # assume a standard control symbol (\, {, }, etc)
-                # (note, this may not be valid for some uncommon
-                #  control symbols like \~ for non-breaking space)
-                $rtnVal .= $ch;
-                pos($val) = $p1 + 1;    # skip to after this character
-            }
-        }
-        $p0 = pos($val);
-    }
-    return $rtnVal;
-}
-
-#------------------------------------------------------------------------------
-# Read information in a RTF document
-# Inputs: 0) ExifTool ref, 1) dirInfo ref
-# Returns: 1 on success, 0 if this wasn't a valid RTF file
-sub ProcessRTF($$)
-{
-    my ($et, $dirInfo) = @_;
-    my $raf = $$dirInfo{RAF};
-    my ($buff, $buf2, $cs);
-    
-    return 0 unless $raf->Read($buff, 64) and $raf->Seek(0,0);
-    return 0 unless $buff =~ /^[\n\r]*\{[\n\r]*\\rtf[^a-zA-Z]/;
-    $et->SetFileType();
-#
-# determine the RTF character set
-#
-    if ($buff=~ /\\ansicpg(\d*)/) { 
-        $cs = "cp$1";
-    } elsif ($buff=~ /\\(ansi|mac|pc|pca)[^a-zA-Z]/) {
-        my %trans = (
-            ansi => 'Latin',
-            mac  => 'MacRoman',
-            pc   => 'cp437',
-            pca  => 'cp850',
-        );
-        $cs = $trans{$1};
-    } else {
-        $et->Warn('Unspecified RTF encoding. Will assume Latin');
-        $cs = 'Latin';
-    }
-    my $charset = $Image::ExifTool::charsetName{lc $cs};
-    unless ($charset) {
-        $et->Warn("Unsupported RTF encoding $cs. Will assume Latin.");
-        $charset = 'Latin';
-    }
-    my $tagTablePtr = GetTagTable('Image::ExifTool::RTF::Main');
-    undef $buff;
-#
-# scan for \info group
-#
-    for (;;) {
-        $raf->Read($buf2, 65536) or last;
-        if (defined $buff) {
-            # read more but leave some overlap for the match
-            $buff = substr($buff, -16) . $buf2;
-        } else {
-            $buff = $buf2;
-        }
-        next unless $buff =~ /[^\\]\{[\n\r]*\\info([^a-zA-Z])/g;
-        # anything but a space is included in the contents
-        pos($buff) = pos($buff) - 1 if $1 ne ' ';
-        my $info = ReadToNested(\$buff, $raf);
-        unless (defined $info) {
-            $et->Warn('Unterminated information group');
-            last;
-        }
-        # process info commands (ie. "\author", "\*\copyright");
-        while ($info =~ /\{[\n\r]*(\\\*[\n\r]*)?\\([a-zA-Z]+)([^a-zA-Z])/g) {
-            pos($info) = pos($info) - 1 if $3 ne ' ';
-            my $tag = $2;
-            my $val = ReadToNested(\$info);
-            last unless defined $val;
-            my $tagInfo = $$tagTablePtr{$tag};
-            if ($tagInfo and $$tagInfo{Format} and $$tagInfo{Format} eq 'date') {
-                # parse RTF date commands
-                my %idx = (yr=>0,mo=>1,dy=>2,hr=>3,min=>4,sec=>5);
-                my @t = (0) x 6;
-                while ($val =~ /\\([a-z]+)(\d+)/g) {
-                    next unless defined $idx{$1};
-                    $t[$idx{$1}] = $2;
-                }
-                $val = sprintf("%.4d:%.2d:%.2d %.2d:%.2d:%.2d", @t);
-            } else {
-                # unescape RTF string value
-                $val = UnescapeRTF($et, $val, $charset);
-            }
-            # create tagInfo for unknown tags
-            if (not $tagInfo) {
-                AddTagToTable($tagTablePtr, $tag, { Name => ucfirst($tag) });
-            }
-            $et->HandleTag($tagTablePtr, $tag, $val);
-        }
-    }
-    return 1 unless defined $buff;
-#
-# scan for \userprops (but don't read more from file to find the start of this command)
-#
-    pos($buff) = 0;
-    while ($buff =~ /[^\\]\{[\n\r]*\\\*[\n\r]*\\userprops([^a-zA-Z])/g) {
-        # Note: The RTF spec places brackets around each propinfo structure,
-        # but Microsoft Word doesn't write it this way, so tolerate either.
-        pos($buff) = pos($buff) - 1 if $1 ne ' ';
-        my $props = ReadToNested(\$buff, $raf);
-        $tagTablePtr = Image::ExifTool::GetTagTable('Image::ExifTool::RTF::UserProps');
-        unless (defined $props) {
-            $et->Warn('Unterminated user properties');
-            last;
-        }
-        # process user properties
-        my $tag;
-        while ($props =~ /\{[\n\r]*(\\\*[\n\r]*)?\\([a-zA-Z]+)([^a-zA-Z])/g) {
-            pos($props) = pos($props) - 1 if $3 ne ' ';
-            my $t = $2;
-            my $val = ReadToNested(\$props);
-            last unless defined $val;
-            $val = UnescapeRTF($et, $val, $charset);
-            if ($t eq 'propname') {
-                $tag = $val;
-                next;
-            } elsif ($t ne 'staticval' or not defined $tag) {
-                next;   # ignore \linkval and \proptype for now
-            }
-            $tag =~ s/\s(.)/\U$1/g;     # capitalize all words in tag name
-            $tag =~ tr/-_a-zA-Z0-9//dc; # remove illegal characters
-            next unless $tag;
-            # create tagInfo for unknown tags
-            unless ($$tagTablePtr{$tag}) {
-                AddTagToTable($tagTablePtr, $tag, { Name => $tag });
-            }
-            $et->HandleTag($tagTablePtr, $tag, $val);
-        }
-        last;   # (didn't really want to loop)
-    }
-    return 1;
-}
-
-1;  # end
-
-__END__
-
-=head1 NAME
-
-Image::ExifTool::RTF - Read Rich Text Format meta information
-
-=head1 SYNOPSIS
-
-This module is used by Image::ExifTool
-
-=head1 DESCRIPTION
-
-This module contains definitions required by Image::ExifTool to read meta
-information from RTF (Rich Text Format) documents.
-
-=head1 AUTHOR
-
-Copyright 2003-2013, Phil Harvey (phil at owl.phy.queensu.ca)
-
-This library is free software; you can redistribute it and/or modify it
-under the same terms as Perl itself.
-
-=head1 REFERENCES
-
-=over 4
-
-=item L<http://download.microsoft.com/download/2/f/5/2f599e18-07ee-4ec5-a1e7-f4e6a9423592/Word2007RTFSpec9.doc>
-
-=item L<http://search.cpan.org/dist/RTF-Writer/lib/RTF/Cookbook.pod>
-
-=back
-
-=head1 SEE ALSO
-
-L<Image::ExifTool::TagNames/RTF Tags>,
-L<Image::ExifTool(3pm)|Image::ExifTool>
-
-=cut
-