marcel 1.2.0 → 2.0.0

data/lib/marcel/magic/zip.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Marcel
+  class Magic
+    # Procedural refinement of ZIP-based container types.
+    #
+    # The declarative magic tables scan a bounded prefix of the file (matchers are capped at
+    # 64KB offsets when the tables are generated), so ZIP containers whose distinguishing
+    # members are catalogued later in the archive — such as OOXML documents with
+    # [Content_Types].xml stored past the 64KB mark — fall back to their generic container
+    # type. This module instead parses the ZIP central directory, a bounded read from the end
+    # of the file, to recover the specific document type, including macro-enabled variants,
+    # which no prefix bytes can distinguish.
+    module Zip
+      EOCD_SIGNATURE = "PK\x05\x06".b
+      ZIP64_EOCD_SIGNATURE = "PK\x06\x06".b
+      ZIP64_EOCD_LOCATOR_SIGNATURE = "PK\x06\x07".b
+      CENTRAL_DIRECTORY_SIGNATURE = "PK\x01\x02".b
+
+      EOCD_SIZE = 22
+      ZIP64_EOCD_SIZE = 56
+      ZIP64_EOCD_LOCATOR_SIZE = 20
+      MAX_COMMENT_SIZE = 0xFFFF
+
+      # The end-of-central-directory record sits at most a maximal comment from the end of
+      # the file, possibly preceded by a Zip64 locator.
+      MAX_EOCD_SEARCH = EOCD_SIZE + MAX_COMMENT_SIZE + ZIP64_EOCD_LOCATOR_SIZE
+
+      # A malformed trailer full of EOCD signature bytes could otherwise force a quadratic
+      # backward scan; real archives find the record on the first candidate.
+      MAX_EOCD_CANDIDATES = 64
+
+      CENTRAL_DIRECTORY_HEADER_SIZE = 46
+      MAX_CENTRAL_DIRECTORY_READ = 1 << 20
+      MAX_ENTRIES = 8192
+
+      # Container types a central directory listing can make more specific.
+      REFINABLE_TYPES = [
+        "application/zip",
+        "application/x-tika-ooxml",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+      ].freeze
+
+      # Standardised OPC part names identifying each OOXML document family:
+      # main part, macro part, and the types each implies.
+      DOCUMENT_FAMILIES = [
+        [ "word/document.xml", "word/vbaProject.bin",
+          "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+          "application/vnd.ms-word.document.macroenabled.12" ],
+        [ "xl/workbook.xml", "xl/vbaProject.bin",
+          "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+          "application/vnd.ms-excel.sheet.macroenabled.12" ],
+        [ "ppt/presentation.xml", "ppt/vbaProject.bin",
+          "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+          "application/vnd.ms-powerpoint.presentation.macroenabled.12" ]
+      ].freeze
+
+      DISCRIMINATING_PARTS = DOCUMENT_FAMILIES.flat_map { |main, macro, *| [main, macro] }.freeze
+
+      class << self
+        # Returns a more specific type than +base_type+ if the IO's ZIP central directory
+        # identifies one, or +base_type+ unchanged. Unseekable IOs, partial reads and
+        # malformed archives refine nothing: the base type stands.
+        def refine(io, base_type)
+          return base_type unless REFINABLE_TYPES.include?(base_type)
+
+          io = StringIO.new(io.to_s) unless io.respond_to?(:read)
+          return base_type unless io.respond_to?(:seek) && io.respond_to?(:size)
+
+          parts = begin
+            discriminating_parts(io)
+          rescue StandardError
+            nil
+          ensure
+            begin
+              io.rewind
+            rescue StandardError
+              nil
+            end
+          end
+
+          parts ? classify(parts, base_type) : base_type
+        end
+
+        private
+
+          def classify(parts, base_type)
+            DOCUMENT_FAMILIES.each do |main_part, macro_part, type, macro_type|
+              return parts.include?(macro_part) ? macro_type : type if parts.include?(main_part)
+            end
+            base_type
+          end
+
+          # Reads the archive's central directory and returns the OOXML part names it
+          # catalogues, or nil if no well-formed central directory is found.
+          def discriminating_parts(io)
+            size = io.size
+            return nil unless size.is_a?(Integer) && size >= EOCD_SIZE
+
+            tail_size = [size, MAX_EOCD_SEARCH].min
+            io.seek(size - tail_size)
+            tail = io.read(tail_size)
+            return nil unless tail && tail.bytesize == tail_size
+            tail = tail.dup.force_encoding(Encoding::BINARY)
+
+            eocd_pos = locate_eocd(tail)
+            return nil unless eocd_pos
+
+            entries, directory_size, directory_offset = parse_eocd(io, tail, eocd_pos)
+            return nil unless entries && directory_offset + directory_size <= size
+
+            read_parts(io, entries, directory_size, directory_offset)
+          end
+
+          # Scans backward through the file's tail for the end-of-central-directory record,
+          # validating each candidate signature against its comment length.
+          def locate_eocd(tail)
+            pos = tail.bytesize - EOCD_SIZE
+            MAX_EOCD_CANDIDATES.times do
+              return nil unless pos && pos >= 0 && (pos = tail.rindex(EOCD_SIGNATURE, pos))
+              comment_size = tail[pos + 20, 2].unpack1("v")
+              return pos if pos + EOCD_SIZE + comment_size == tail.bytesize
+              pos -= 1
+            end
+            nil
+          end
+
+          # Returns [entry count, central directory size, central directory offset], following
+          # the Zip64 records when the classic fields overflow. Multi-disk archives and
+          # malformed records return nil.
+          def parse_eocd(io, tail, eocd_pos)
+            disk, directory_disk, entries, directory_size, directory_offset =
+              tail[eocd_pos + 4, 16].unpack("vvx2vVV")
+            return nil unless disk == 0 && directory_disk == 0
+
+            if entries == 0xFFFF || directory_size == 0xFFFFFFFF || directory_offset == 0xFFFFFFFF
+              parse_zip64_eocd(io, tail, eocd_pos)
+            else
+              [entries, directory_size, directory_offset]
+            end
+          end
+
+          def parse_zip64_eocd(io, tail, eocd_pos)
+            locator_pos = eocd_pos - ZIP64_EOCD_LOCATOR_SIZE
+            return nil if locator_pos < 0 || tail[locator_pos, 4] != ZIP64_EOCD_LOCATOR_SIGNATURE
+
+            locator_disk, zip64_eocd_offset, total_disks = tail[locator_pos + 4, 16].unpack("VQ<V")
+            return nil unless locator_disk == 0 && total_disks == 1
+
+            io.seek(zip64_eocd_offset)
+            record = io.read(ZIP64_EOCD_SIZE)
+            return nil unless record && record.bytesize == ZIP64_EOCD_SIZE
+            record = record.dup.force_encoding(Encoding::BINARY)
+            return nil unless record[0, 4] == ZIP64_EOCD_SIGNATURE
+
+            disk, directory_disk, _, entries, directory_size, directory_offset =
+              record[16, 40].unpack("VVQ<Q<Q<Q<")
+            return nil unless disk == 0 && directory_disk == 0
+
+            [entries, directory_size, directory_offset]
+          end
+
+          # Walks central directory entries, collecting the OOXML part names that
+          # discriminate between document families. Reads and entry counts are bounded;
+          # the walk stops early once a family and its macro part are both seen.
+          def read_parts(io, entries, directory_size, directory_offset)
+            io.seek(directory_offset)
+            directory = io.read([directory_size, MAX_CENTRAL_DIRECTORY_READ].min)
+            return nil unless directory
+            directory = directory.dup.force_encoding(Encoding::BINARY)
+
+            parts = []
+            pos = 0
+            [entries, MAX_ENTRIES].min.times do
+              break unless pos + CENTRAL_DIRECTORY_HEADER_SIZE <= directory.bytesize &&
+                directory[pos, 4] == CENTRAL_DIRECTORY_SIGNATURE
+
+              name_size, extra_size, comment_size = directory[pos + 28, 6].unpack("vvv")
+              name = directory[pos + CENTRAL_DIRECTORY_HEADER_SIZE, name_size]
+              break unless name && name.bytesize == name_size
+
+              parts << name if DISCRIMINATING_PARTS.include?(name)
+              break if complete?(parts)
+
+              pos += CENTRAL_DIRECTORY_HEADER_SIZE + name_size + extra_size + comment_size
+            end
+            parts
+          end
+
+          # A main part plus its macro part is as specific as classification gets.
+          def complete?(parts)
+            DOCUMENT_FAMILIES.any? do |main_part, macro_part, *|
+              parts.include?(main_part) && parts.include?(macro_part)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/marcel/magic.rb

@@ -25,25 +25,79 @@ module Marcel
     # Option keys:
     # * <i>:extensions</i>: String list or single string of file extensions
     # * <i>:parents</i>: String list or single string of parent mime types
+    # * <i>:aliases</i>: String list or single string of aliased mime types
     # * <i>:magic</i>: Mime magic specification
     # * <i>:comment</i>: Comment string
     def self.add(type, options)
+      # Validate the complete registration before mutating any table, so a rejected
+      # registration leaves every registry untouched.
+      #
+      # Alias keys are never registered types and alias values never alias keys, so
+      # resolution is single-hop by construction: aliasing a registered type is rejected
+      # here, and canonicalize (the sanctioned path) re-points existing aliases itself.
+      aliases = [options[:aliases]].flatten.compact.map(&:downcase) - [type.downcase]
+      aliases.each do |aliased|
+        if TYPE_EXTS.key?(aliased) || TYPE_PARENTS.key?(aliased) || MAGIC.any? { |t, _| t == aliased }
+          raise ArgumentError, "#{aliased} is a registered type; use canonicalize to alias it to #{type}"
+        end
+      end
+
       extensions = [options[:extensions]].flatten.compact
       TYPE_EXTS[type] = extensions
+      extensions.each {|ext| EXTENSIONS[ext] = type }
+
+      TYPE_ALIASES.delete(type)
+      aliases.each {|aliased| TYPE_ALIASES[aliased] = type }
+
       parents = [options[:parents]].flatten.compact
       TYPE_PARENTS[type] = parents unless parents.empty?
-      extensions.each {|ext| EXTENSIONS[ext] = type }
+
       MAGIC.unshift [type, options[:magic]] if options[:magic]
     end
 
-    # Removes a mime type from the dictionary.  You might want to do this if
+    # Renames a canonical type: the +instead_of+ type's extensions, magic matchers, parents,
+    # and aliases are re-registered under +type+, and the old name becomes an alias of the
+    # new. Useful when a historical or de facto type is preferable to the canonical type
+    # shipped in the generated tables, without giving up its matchers.
+    def self.canonicalize(type, instead_of:)
+      raise ArgumentError, "#{instead_of} is an alias, not canonical" if TYPE_ALIASES[instead_of]
+
+      # Displace whatever the new canonical type was registered as before.
+      remove(type)
+
+      # Re-register the old canonical type's dictionary under the new name.
+      EXTENSIONS.select { |_, existing| existing == instead_of }.each_key do |ext|
+        EXTENSIONS[ext] = type
+      end
+
+      if extensions = TYPE_EXTS.delete(instead_of)
+        TYPE_EXTS[type] = extensions
+      end
+
+      TYPE_ALIASES.select { |_, canonical| canonical == instead_of }.each_key do |aliased|
+        TYPE_ALIASES[aliased] = type
+      end
+
+      if parents = TYPE_PARENTS.delete(instead_of)
+        TYPE_PARENTS[type] = parents
+      end
+
+      MAGIC.each { |pair| pair[0] = type if pair[0] == instead_of }
+
+      # Alias the old canonical type to the new.
+      TYPE_ALIASES[instead_of] = type
+    end
+
+    # Removes a mime type from the dictionary. You might want to do this if
     # you're seeing impossible conflicts (for instance, application/x-gmc-link).
-    # * <i>type</i>: The mime type to remove.  All associated extensions and magic are removed too.
+    # * <i>type</i>: The mime type to remove. All associated extensions, magic,
+    #   and aliases are removed too.
     def self.remove(type)
       EXTENSIONS.delete_if {|ext, t| t == type }
       MAGIC.delete_if {|t, m| t == type }
       TYPE_EXTS.delete(type)
       TYPE_PARENTS.delete(type)
+      TYPE_ALIASES.delete_if {|aliased, canonical| aliased == type || canonical == type }
     end
 
     # Returns true if type is a text format
@@ -64,14 +118,31 @@ module Marcel
       TYPE_EXTS[type] || []
     end
 
+    # Resolve an aliased type to its canonical type; canonical types return themselves
+    def canonical
+      if canonical_type = TYPE_ALIASES[type]
+        self.class.new(canonical_type)
+      else
+        self
+      end
+    end
+
     # Get mime comment
     def comment
       nil # deprecated
     end
 
+    # Lookup canonical mime type by mime type string, resolving aliases
+    def self.by_type(type)
+      new(canonical(type)) if type
+    end
+
     # Lookup mime type by file extension
     def self.by_extension(ext)
-      ext = ext.to_s.downcase
+      ext = ext.to_s
+      return unless ext.valid_encoding?
+
+      ext = ext.downcase
       mime = ext[0..0] == '.' ? EXTENSIONS[ext[1..-1]] : EXTENSIONS[ext]
       mime && new(mime)
     end
@@ -79,6 +150,8 @@ module Marcel
     # Lookup mime type by filename
     def self.by_path(path)
       by_extension(File.extname(path))
+    rescue ArgumentError, EncodingError
+      nil
     end
 
     # Lookup mime type by magic content analysis.
@@ -111,46 +184,151 @@ module Marcel
     alias == eql?
 
     def self.child?(child, parent)
-      child == parent || TYPE_PARENTS[child]&.any? {|p| child?(p, parent) }
+      parent = canonical(parent)
+      pending = [child]
+      visited = {}
+
+      until pending.empty?
+        type = canonical(pending.pop)
+        return true if type == parent
+        next if visited[type]
+
+        visited[type] = true
+        pending.concat(TYPE_PARENTS[type] || [])
+      end
+
+      false
+    end
+
+    # Resolve an aliased type string to its canonical type string
+    def self.canonical(type)
+      if type
+        # Allocation-free for already-lowercase input: child? resolves every node it visits.
+        type = type.downcase if /[A-Z]/.match?(type)
+        TYPE_ALIASES[type] || type
+      end
     end
 
     def self.magic_match(io, method)
+      if defined?(Pathname) && io.is_a?(Pathname)
+        return io.open("rb") { |file| magic_match(file, method) }
+      end
+
       return magic_match(StringIO.new(io.to_s), method) unless io.respond_to?(:read)
 
       buffer = "".b
-      MAGIC.send(method) { |type, matches| magic_match_io(io, matches, buffer) }
+      read_mode = read_mode(io)
+      io.rewind
+      body_failed = true
+      begin
+        result = MAGIC.send(method) { |type, matches| magic_match_io(io, matches, buffer, read_mode) }
+        body_failed = false
+        result
+      ensure
+        begin
+          io.rewind
+        rescue Exception # Preserve an exception already raised while reading or matching.
+          raise unless body_failed
+        end
+      end
     end
 
-    def self.magic_match_io(io, matches, buffer)
+    def self.magic_match_io(io, matches, buffer, mode = read_mode(io))
       matches.any? do |offset, value, children|
-        match =
-          if value
-            if value.is_a?(Regexp)
-              match_regex(io, offset, value, buffer)
-            elsif Range === offset
-              io.read(offset.begin, buffer)
-              x = io.read(offset.end - offset.begin + value.bytesize, buffer)
-              x && x.include?(value)
-            else
-              io.read(offset, buffer)
-              io.read(value.bytesize, buffer) == value
+        match = if value
+          is_range = Range === offset
+          is_regexp = Regexp === value
+          sample_size = is_regexp ? 256 : value.bytesize
+
+          x = if is_range
+            if io_seek(io, offset.begin, buffer, mode)
+              io_read(io, offset.end - offset.begin + sample_size, buffer, mode)
             end
+          else
+            if io_seek(io, offset, buffer, mode)
+              io_read(io, sample_size, buffer, mode)
+            end
+          end
+          x.force_encoding(Encoding::BINARY) if x
+
+          if is_regexp
+            x&.match?(value)
+          elsif is_range
+            x&.include?(value)
+          else
+            x == value
           end
+        end
 
         io.rewind
-        match && (!children || magic_match_io(io, children, buffer))
+        match && (!children || magic_match_io(io, children, buffer, mode))
       end
     end
 
-    def self.match_regex(io, offset, regexp, buffer)
-      start = offset.is_a?(Range) ? offset.begin : offset
-      io.read(start, buffer) if start > 0
-      data = io.read(256, buffer)
-      return false unless data
+    def self.io_seek(io, offset, buffer, mode)
+      return true if offset == 0
+
+      if offset < 0
+        return false unless io.respond_to?(:size)
 
-      data.match?(regexp)
+        offset = io.size + offset
+        return false if offset < 0
+      end
+
+      if io.respond_to?(:seek)
+        io.seek(offset, IO::SEEK_SET)
+      else
+        # Some IOs don't support `seek`. e.g. Rack::RewindableInput
+        skipped = io_read(io, offset, buffer, mode)
+        return false unless skipped && skipped.bytesize == offset
+      end
+
+      true
+    end
+
+    def self.io_read(io, length, buffer, mode)
+      return io.read(length, buffer) if mode == :native
+
+      buffer.clear
+
+      read_with_buffer = mode == :buffer
+      chunk = read_with_buffer ? io.read(length, buffer) : io.read(length)
+      return if chunk && chunk.bytesize > length
+      buffer.replace(chunk) if chunk && !chunk.equal?(buffer)
+
+      return if chunk.nil? || buffer.empty?
+      return buffer if buffer.bytesize == length
+
+      continuation_buffer = "".b if read_with_buffer
+      while buffer.bytesize < length
+        remaining = length - buffer.bytesize
+        chunk = if read_with_buffer
+          io.read(remaining, continuation_buffer.clear)
+        else
+          io.read(remaining)
+        end
+        return if chunk && chunk.bytesize > remaining
+        break if chunk.nil? || chunk.empty?
+
+        buffer << chunk
+      end
+
+      buffer unless buffer.empty?
     end
 
-    private_class_method :magic_match, :magic_match_io, :match_regex
+    def self.read_mode(io)
+      return :native if io.is_a?(IO) || io.is_a?(StringIO)
+
+      parameters = io.method(:read).parameters
+      supports_buffer = parameters.any? { |kind,| kind == :rest } ||
+        parameters.count { |kind,| kind == :req || kind == :opt } >= 2
+      supports_buffer ? :buffer : :single
+    end
+
+    private_class_method :magic_match, :magic_match_io, :io_seek, :io_read, :read_mode
   end
 end
+
+require "marcel/magic/definitions"
+require "marcel/magic/xml"
+require "marcel/magic/zip"

data/lib/marcel/mime_type/definitions.rb

@@ -2,29 +2,6 @@
 
 Marcel::MimeType.extend "text/plain", extensions: %w( txt asc )
 
-Marcel::Magic.remove("text/html")
-Marcel::MimeType.extend "text/html", 
-  extensions: %w( html htm ),
-  magic: [
-    [0, "<!DOCTYPE html"],
-    [0, "<!DOCTYPE HTML"], 
-    [0, "<!doctype html"],
-    [0, "<!doctype HTML"],
-    [0, "<html"],
-    [0, "<HTML"],
-    [0, " <!DOCTYPE html"],
-    [0, "\n<!DOCTYPE html"],
-    [0, "\r<!DOCTYPE html"], 
-    [0, "\r\n<!DOCTYPE html"],
-    [0, "\t<!DOCTYPE html"],
-    [0, " <html"],
-    [0, "\n<html"],
-    [0, "\r<html"],
-    [0, "\r\n<html"],
-    [0, "\t<html"]
-  ]
-
-Marcel::MimeType.extend "application/illustrator", parents: "application/pdf"
 Marcel::MimeType.extend "image/vnd.adobe.photoshop", magic: [[0, "8BPS"]], extensions: %w( psd psb )
 
 Marcel::MimeType.extend "application/vnd.ms-excel", parents: "application/x-ole-storage"
@@ -33,47 +10,61 @@ Marcel::MimeType.extend "application/vnd.ms-powerpoint", parents: "application/x
 Marcel::MimeType.extend "application/vnd.openxmlformats-officedocument.wordprocessingml.document", parents: "application/zip"
 Marcel::MimeType.extend "application/vnd.openxmlformats-officedocument.wordprocessingml.template", parents: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
 Marcel::MimeType.extend "application/vnd.ms-word.document.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-Marcel::MimeType.extend "application/vnd.ms-word.template.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+Marcel::MimeType.extend "application/vnd.ms-word.template.macroenabled.12", parents: %w( application/vnd.openxmlformats-officedocument.wordprocessingml.document application/vnd.ms-word.document.macroenabled.12 )
 
 Marcel::MimeType.extend "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", parents: "application/zip"
 Marcel::MimeType.extend "application/vnd.openxmlformats-officedocument.spreadsheetml.template", parents: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 Marcel::MimeType.extend "application/vnd.ms-excel.sheet.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-Marcel::MimeType.extend "application/vnd.ms-excel.template.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-Marcel::MimeType.extend "application/vnd.ms-excel.addin.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+Marcel::MimeType.extend "application/vnd.ms-excel.template.macroenabled.12", parents: %w( application/vnd.openxmlformats-officedocument.spreadsheetml.sheet application/vnd.ms-excel.sheet.macroenabled.12 )
+Marcel::MimeType.extend "application/vnd.ms-excel.addin.macroenabled.12", parents: %w( application/vnd.openxmlformats-officedocument.spreadsheetml.sheet application/vnd.ms-excel.sheet.macroenabled.12 )
 Marcel::MimeType.extend "application/vnd.ms-excel.sheet.binary.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 
 Marcel::MimeType.extend "application/vnd.openxmlformats-officedocument.presentationml.presentation", parents: "application/zip"
 Marcel::MimeType.extend "application/vnd.openxmlformats-officedocument.presentationml.template", parents: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 Marcel::MimeType.extend "application/vnd.openxmlformats-officedocument.presentationml.slideshow", parents: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-Marcel::MimeType.extend "application/vnd.ms-powerpoint.addin.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+Marcel::MimeType.extend "application/vnd.ms-powerpoint.addin.macroenabled.12", parents: %w( application/vnd.openxmlformats-officedocument.presentationml.presentation application/vnd.ms-powerpoint.presentation.macroenabled.12 )
 Marcel::MimeType.extend "application/vnd.ms-powerpoint.presentation.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-Marcel::MimeType.extend "application/vnd.ms-powerpoint.template.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-Marcel::MimeType.extend "application/vnd.ms-powerpoint.slideshow.macroenabled.12", parents: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+Marcel::MimeType.extend "application/vnd.ms-powerpoint.template.macroenabled.12", parents: %w( application/vnd.openxmlformats-officedocument.presentationml.presentation application/vnd.ms-powerpoint.presentation.macroenabled.12 )
+Marcel::MimeType.extend "application/vnd.ms-powerpoint.slideshow.macroenabled.12", parents: %w( application/vnd.openxmlformats-officedocument.presentationml.presentation application/vnd.ms-powerpoint.presentation.macroenabled.12 )
 
-Marcel::MimeType.extend "application/vnd.apple.pages", extensions: %w( pages ), parents: "application/zip"
-Marcel::MimeType.extend "application/vnd.apple.numbers", extensions: %w( numbers ), parents: "application/zip"
-Marcel::MimeType.extend "application/vnd.apple.keynote", extensions: %w( key ), parents: "application/zip"
+Marcel::MimeType.extend "application/vnd.apple.pages", parents: "application/zip"
+Marcel::MimeType.extend "application/vnd.apple.numbers", parents: "application/zip"
+Marcel::MimeType.extend "application/vnd.apple.keynote", parents: "application/zip"
 
-Marcel::MimeType.extend "audio/aac", extensions: %w( aac ), parents: "audio/x-aac"
 Marcel::MimeType.extend("audio/ogg", extensions: %w( opus ), magic: [[0, 'OggS', [[28, 'OpusHead']]]])
 Marcel::MimeType.extend("audio/ogg", extensions: %w( ogg oga ), magic: [[0, 'OggS', [[29, 'vorbis']]]])
 
+# Prefer the types browsers actually use over Tika's historical canonical types,
+# keeping their file extensions and magic byte matchers.
+Marcel::MimeType.canonicalize "audio/aac", instead_of: "audio/x-aac"
+Marcel::MimeType.canonicalize "audio/flac", instead_of: "audio/x-flac"
+Marcel::MimeType.canonicalize "audio/x-wav", instead_of: "audio/vnd.wave"
+
+# Prefer IANA-registered types where Tika canonicalizes on a deprecated or private-tree name.
+Marcel::MimeType.canonicalize "application/yaml", instead_of: "text/x-yaml" # RFC 9512
+Marcel::MimeType.canonicalize "application/vnd.debian.binary-package", instead_of: "application/x-debian-package"
+Marcel::MimeType.canonicalize "application/xliff+xml", instead_of: "application/x-xliff+xml"
+
 Marcel::MimeType.extend "image/vnd.dwg", magic: [[0, "AC10"]]
 Marcel::MimeType.extend "application/pkcs8", magic: [[0, '-----BEGIN PRIVATE KEY-----']], extensions: %w( p8 )
 
+# Tika aliases this to application/x-x509-cert; the generated tables deliberately skip that
+# alias so Marcel can reuse the name for PEM-format certificates via a ;format=pem subtype.
 Marcel::MimeType.extend "application/x-x509-ca-cert", magic: [[0, '-----BEGIN CERTIFICATE-----']], extensions: %w( pem ), parents: "application/x-x509-cert;format=pem"
 
-Marcel::MimeType.extend "image/avif", magic: [[4, "ftypavif"]], extensions: %w( avif )
-Marcel::MimeType.extend "image/heif", magic: [[4, "ftypmif1"]], extensions: %w( heif )
-Marcel::MimeType.extend "image/heic", magic: [[4, "ftypheic"]], extensions: %w( heic )
+# Re-registering these matchers promotes them ahead of video/quicktime's broad ftyp match.
+Marcel::MimeType.extend "image/avif", magic: [[4, "ftypavif"]]
+Marcel::MimeType.extend "image/avif", magic: [[4, "ftypavis"]]
+Marcel::MimeType.extend "image/heif", magic: [[4, "ftypmif1"]]
+Marcel::MimeType.extend "image/heic", magic: [[4, "ftypheic"]]
 
 Marcel::MimeType.extend "image/x-raw-sony", magic: [[0, "II*\000", [[0..4096, 'SONY']]], [0, "MM\000*", [[0..4096, 'SONY']]]], extensions: %w( arw ), parents: "image/tiff"
-Marcel::MimeType.extend "image/x-raw-canon",  extensions: %w( cr2 crw ), parents: "image/tiff"
+# CRW only: .cr2 belongs to image/x-canon-cr2, which Tika matches by magic (TIFF header
+# plus CR marker at offset 8) and already subclasses image/tiff.
+Marcel::MimeType.extend "image/x-raw-canon", parents: "image/tiff"
 
 Marcel::MimeType.extend "video/mp4", magic: [[4, "ftypisom"], [4, "ftypM4V "]], extensions: %w( mp4 m4v )
 
-Marcel::MimeType.extend "audio/flac", magic: [[0, 'fLaC']], extensions: %w( flac ), parents: "audio/x-flac"
-Marcel::MimeType.extend "audio/x-wav", magic: [[0, 'RIFF', [[8, 'WAVE']]]], extensions: %w( wav ), parents: "audio/vnd.wav"
 Marcel::MimeType.extend "audio/mpc", magic: [[0, "MPCKSH"]], extensions: %w( mpc )
 
 Marcel::MimeType.extend "font/ttf", magic: [[0, "\x00\x01\x00\x00"]], extensions: %w( ttf ttc )
@@ -92,4 +83,4 @@ Marcel::MimeType.extend(
   parents: "application/x-msaccess"
 )
 
-Marcel::MimeType.extend "text/markdown", extensions: %w(md mdtext markdown mkd), parents: "text/x-web-markdown"
+Marcel::MimeType.extend "text/markdown", parents: "text/x-web-markdown"