slidge-whatsapp 0.2.2__cp311-cp311-manylinux_2_36_aarch64.whl → 0.2.7__cp311-cp311-manylinux_2_36_aarch64.whl

slidge_whatsapp/vendor/github.com/h2non/filetype/matchers/archive.go

@@ -0,0 +1,211 @@
+package matchers
+
+import "encoding/binary"
+
+const (
+	ZstdMagicSkippableStart = 0x184D2A50
+	ZstdMagicSkippableMask  = 0xFFFFFFF0
+)
+
+var (
+	TypeEpub   = newType("epub", "application/epub+zip")
+	TypeZip    = newType("zip", "application/zip")
+	TypeTar    = newType("tar", "application/x-tar")
+	TypeRar    = newType("rar", "application/vnd.rar")
+	TypeGz     = newType("gz", "application/gzip")
+	TypeBz2    = newType("bz2", "application/x-bzip2")
+	Type7z     = newType("7z", "application/x-7z-compressed")
+	TypeXz     = newType("xz", "application/x-xz")
+	TypeZstd   = newType("zst", "application/zstd")
+	TypePdf    = newType("pdf", "application/pdf")
+	TypeExe    = newType("exe", "application/vnd.microsoft.portable-executable")
+	TypeSwf    = newType("swf", "application/x-shockwave-flash")
+	TypeRtf    = newType("rtf", "application/rtf")
+	TypeEot    = newType("eot", "application/octet-stream")
+	TypePs     = newType("ps", "application/postscript")
+	TypeSqlite = newType("sqlite", "application/vnd.sqlite3")
+	TypeNes    = newType("nes", "application/x-nintendo-nes-rom")
+	TypeCrx    = newType("crx", "application/x-google-chrome-extension")
+	TypeCab    = newType("cab", "application/vnd.ms-cab-compressed")
+	TypeDeb    = newType("deb", "application/vnd.debian.binary-package")
+	TypeAr     = newType("ar", "application/x-unix-archive")
+	TypeZ      = newType("Z", "application/x-compress")
+	TypeLz     = newType("lz", "application/x-lzip")
+	TypeRpm    = newType("rpm", "application/x-rpm")
+	TypeElf    = newType("elf", "application/x-executable")
+	TypeDcm    = newType("dcm", "application/dicom")
+	TypeIso    = newType("iso", "application/x-iso9660-image")
+	TypeMachO  = newType("macho", "application/x-mach-binary") // Mach-O binaries have no common extension.
+)
+
+var Archive = Map{
+	TypeEpub:   bytePrefixMatcher(epubMagic),
+	TypeZip:    Zip,
+	TypeTar:    Tar,
+	TypeRar:    Rar,
+	TypeGz:     bytePrefixMatcher(gzMagic),
+	TypeBz2:    bytePrefixMatcher(bz2Magic),
+	Type7z:     bytePrefixMatcher(sevenzMagic),
+	TypeXz:     bytePrefixMatcher(xzMagic),
+	TypeZstd:   Zst,
+	TypePdf:    bytePrefixMatcher(pdfMagic),
+	TypeExe:    bytePrefixMatcher(exeMagic),
+	TypeSwf:    Swf,
+	TypeRtf:    bytePrefixMatcher(rtfMagic),
+	TypeEot:    Eot,
+	TypePs:     bytePrefixMatcher(psMagic),
+	TypeSqlite: bytePrefixMatcher(sqliteMagic),
+	TypeNes:    bytePrefixMatcher(nesMagic),
+	TypeCrx:    bytePrefixMatcher(crxMagic),
+	TypeCab:    Cab,
+	TypeDeb:    bytePrefixMatcher(debMagic),
+	TypeAr:     bytePrefixMatcher(arMagic),
+	TypeZ:      Z,
+	TypeLz:     bytePrefixMatcher(lzMagic),
+	TypeRpm:    Rpm,
+	TypeElf:    Elf,
+	TypeDcm:    Dcm,
+	TypeIso:    Iso,
+	TypeMachO:  MachO,
+}
+
+var (
+	epubMagic = []byte{
+		0x50, 0x4B, 0x03, 0x04, 0x6D, 0x69, 0x6D, 0x65,
+		0x74, 0x79, 0x70, 0x65, 0x61, 0x70, 0x70, 0x6C,
+		0x69, 0x63, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x2F,
+		0x65, 0x70, 0x75, 0x62, 0x2B, 0x7A, 0x69, 0x70,
+	}
+	gzMagic     = []byte{0x1F, 0x8B, 0x08}
+	bz2Magic    = []byte{0x42, 0x5A, 0x68}
+	sevenzMagic = []byte{0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C}
+	pdfMagic    = []byte{0x25, 0x50, 0x44, 0x46}
+	exeMagic    = []byte{0x4D, 0x5A}
+	rtfMagic    = []byte{0x7B, 0x5C, 0x72, 0x74, 0x66}
+	nesMagic    = []byte{0x4E, 0x45, 0x53, 0x1A}
+	crxMagic    = []byte{0x43, 0x72, 0x32, 0x34}
+	psMagic     = []byte{0x25, 0x21}
+	xzMagic     = []byte{0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00}
+	sqliteMagic = []byte{0x53, 0x51, 0x4C, 0x69}
+	debMagic    = []byte{
+		0x21, 0x3C, 0x61, 0x72, 0x63, 0x68, 0x3E, 0x0A,
+		0x64, 0x65, 0x62, 0x69, 0x61, 0x6E, 0x2D, 0x62,
+		0x69, 0x6E, 0x61, 0x72, 0x79,
+	}
+	arMagic   = []byte{0x21, 0x3C, 0x61, 0x72, 0x63, 0x68, 0x3E}
+	zstdMagic = []byte{0x28, 0xB5, 0x2F, 0xFD}
+	lzMagic   = []byte{0x4C, 0x5A, 0x49, 0x50}
+)
+
+func bytePrefixMatcher(magicPattern []byte) Matcher {
+	return func(data []byte) bool {
+		return compareBytes(data, magicPattern, 0)
+	}
+}
+
+func Zip(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x50 && buf[1] == 0x4B &&
+		(buf[2] == 0x3 || buf[2] == 0x5 || buf[2] == 0x7) &&
+		(buf[3] == 0x4 || buf[3] == 0x6 || buf[3] == 0x8)
+}
+
+func Tar(buf []byte) bool {
+	return len(buf) > 261 &&
+		buf[257] == 0x75 && buf[258] == 0x73 &&
+		buf[259] == 0x74 && buf[260] == 0x61 &&
+		buf[261] == 0x72
+}
+
+func Rar(buf []byte) bool {
+	return len(buf) > 6 &&
+		buf[0] == 0x52 && buf[1] == 0x61 && buf[2] == 0x72 &&
+		buf[3] == 0x21 && buf[4] == 0x1A && buf[5] == 0x7 &&
+		(buf[6] == 0x0 || buf[6] == 0x1)
+}
+
+func Swf(buf []byte) bool {
+	return len(buf) > 2 &&
+		(buf[0] == 0x43 || buf[0] == 0x46) &&
+		buf[1] == 0x57 && buf[2] == 0x53
+}
+
+func Cab(buf []byte) bool {
+	return len(buf) > 3 &&
+		((buf[0] == 0x4D && buf[1] == 0x53 && buf[2] == 0x43 && buf[3] == 0x46) ||
+			(buf[0] == 0x49 && buf[1] == 0x53 && buf[2] == 0x63 && buf[3] == 0x28))
+}
+
+func Eot(buf []byte) bool {
+	return len(buf) > 35 &&
+		buf[34] == 0x4C && buf[35] == 0x50 &&
+		((buf[8] == 0x02 && buf[9] == 0x00 &&
+			buf[10] == 0x01) || (buf[8] == 0x01 &&
+			buf[9] == 0x00 && buf[10] == 0x00) ||
+			(buf[8] == 0x02 && buf[9] == 0x00 &&
+				buf[10] == 0x02))
+}
+
+func Z(buf []byte) bool {
+	return len(buf) > 1 &&
+		((buf[0] == 0x1F && buf[1] == 0xA0) ||
+			(buf[0] == 0x1F && buf[1] == 0x9D))
+}
+
+func Rpm(buf []byte) bool {
+	return len(buf) > 96 &&
+		buf[0] == 0xED && buf[1] == 0xAB &&
+		buf[2] == 0xEE && buf[3] == 0xDB
+}
+
+func Elf(buf []byte) bool {
+	return len(buf) > 52 &&
+		buf[0] == 0x7F && buf[1] == 0x45 &&
+		buf[2] == 0x4C && buf[3] == 0x46
+}
+
+func Dcm(buf []byte) bool {
+	return len(buf) > 131 &&
+		buf[128] == 0x44 && buf[129] == 0x49 &&
+		buf[130] == 0x43 && buf[131] == 0x4D
+}
+
+func Iso(buf []byte) bool {
+	return len(buf) > 32773 &&
+		buf[32769] == 0x43 && buf[32770] == 0x44 &&
+		buf[32771] == 0x30 && buf[32772] == 0x30 &&
+		buf[32773] == 0x31
+}
+
+func MachO(buf []byte) bool {
+	return len(buf) > 3 && ((buf[0] == 0xFE && buf[1] == 0xED && buf[2] == 0xFA && buf[3] == 0xCF) ||
+		(buf[0] == 0xFE && buf[1] == 0xED && buf[2] == 0xFA && buf[3] == 0xCE) ||
+		(buf[0] == 0xBE && buf[1] == 0xBA && buf[2] == 0xFE && buf[3] == 0xCA) ||
+		// Big endian versions below here...
+		(buf[0] == 0xCF && buf[1] == 0xFA && buf[2] == 0xED && buf[3] == 0xFE) ||
+		(buf[0] == 0xCE && buf[1] == 0xFA && buf[2] == 0xED && buf[3] == 0xFE) ||
+		(buf[0] == 0xCA && buf[1] == 0xFE && buf[2] == 0xBA && buf[3] == 0xBE))
+}
+
+// Zstandard compressed data is made of one or more frames.
+// There are two frame formats defined by Zstandard: Zstandard frames and Skippable frames.
+// See more details from https://tools.ietf.org/id/draft-kucherawy-dispatch-zstd-00.html#rfc.section.2
+func Zst(buf []byte) bool {
+  if compareBytes(buf, zstdMagic, 0) {
+    return true
+  } else {
+		// skippable frames
+    if len(buf) < 8 {
+      return false
+    }
+    if binary.LittleEndian.Uint32(buf[:4]) & ZstdMagicSkippableMask == ZstdMagicSkippableStart {
+      userDataLength := binary.LittleEndian.Uint32(buf[4:8])
+      if len(buf) < 8 + int(userDataLength) {
+        return false
+      }
+      nextFrame := buf[8+userDataLength:]
+      return Zst(nextFrame)
+    }
+    return false
+  }
+}

slidge_whatsapp/vendor/github.com/h2non/filetype/matchers/audio.go

@@ -0,0 +1,85 @@
+package matchers
+
+var (
+	TypeMidi = newType("mid", "audio/midi")
+	TypeMp3  = newType("mp3", "audio/mpeg")
+	TypeM4a  = newType("m4a", "audio/m4a")
+	TypeOgg  = newType("ogg", "audio/ogg")
+	TypeFlac = newType("flac", "audio/x-flac")
+	TypeWav  = newType("wav", "audio/x-wav")
+	TypeAmr  = newType("amr", "audio/amr")
+	TypeAac  = newType("aac", "audio/aac")
+	TypeAiff = newType("aiff", "audio/x-aiff")
+)
+
+var Audio = Map{
+	TypeMidi: Midi,
+	TypeMp3:  Mp3,
+	TypeM4a:  M4a,
+	TypeOgg:  Ogg,
+	TypeFlac: Flac,
+	TypeWav:  Wav,
+	TypeAmr:  Amr,
+	TypeAac:  Aac,
+	TypeAiff: Aiff,
+}
+
+func Midi(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x4D && buf[1] == 0x54 &&
+		buf[2] == 0x68 && buf[3] == 0x64
+}
+
+func Mp3(buf []byte) bool {
+	return len(buf) > 2 &&
+		((buf[0] == 0x49 && buf[1] == 0x44 && buf[2] == 0x33) ||
+			(buf[0] == 0xFF && buf[1] == 0xfb))
+}
+
+func M4a(buf []byte) bool {
+	return len(buf) > 10 &&
+		((buf[4] == 0x66 && buf[5] == 0x74 && buf[6] == 0x79 &&
+			buf[7] == 0x70 && buf[8] == 0x4D && buf[9] == 0x34 && buf[10] == 0x41) ||
+			(buf[0] == 0x4D && buf[1] == 0x34 && buf[2] == 0x41 && buf[3] == 0x20))
+}
+
+func Ogg(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x4F && buf[1] == 0x67 &&
+		buf[2] == 0x67 && buf[3] == 0x53
+}
+
+func Flac(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x66 && buf[1] == 0x4C &&
+		buf[2] == 0x61 && buf[3] == 0x43
+}
+
+func Wav(buf []byte) bool {
+	return len(buf) > 11 &&
+		buf[0] == 0x52 && buf[1] == 0x49 &&
+		buf[2] == 0x46 && buf[3] == 0x46 &&
+		buf[8] == 0x57 && buf[9] == 0x41 &&
+		buf[10] == 0x56 && buf[11] == 0x45
+}
+
+func Amr(buf []byte) bool {
+	return len(buf) > 11 &&
+		buf[0] == 0x23 && buf[1] == 0x21 &&
+		buf[2] == 0x41 && buf[3] == 0x4D &&
+		buf[4] == 0x52 && buf[5] == 0x0A
+}
+
+func Aac(buf []byte) bool {
+	return len(buf) > 1 &&
+		((buf[0] == 0xFF && buf[1] == 0xF1) ||
+			(buf[0] == 0xFF && buf[1] == 0xF9))
+}
+
+func Aiff(buf []byte) bool {
+	return len(buf) > 11 &&
+		buf[0] == 0x46 && buf[1] == 0x4F &&
+		buf[2] == 0x52 && buf[3] == 0x4D &&
+		buf[8] == 0x41 && buf[9] == 0x49 &&
+		buf[10] == 0x46 && buf[11] == 0x46
+}

slidge_whatsapp/vendor/github.com/h2non/filetype/matchers/document.go

@@ -0,0 +1,197 @@
+package matchers
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+var (
+	TypeDoc  = newType("doc", "application/msword")
+	TypeDocx = newType("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
+	TypeXls  = newType("xls", "application/vnd.ms-excel")
+	TypeXlsx = newType("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+	TypePpt  = newType("ppt", "application/vnd.ms-powerpoint")
+	TypePptx = newType("pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation")
+)
+
+var Document = Map{
+	TypeDoc:  Doc,
+	TypeDocx: Docx,
+	TypeXls:  Xls,
+	TypeXlsx: Xlsx,
+	TypePpt:  Ppt,
+	TypePptx: Pptx,
+}
+
+type docType int
+
+const (
+	TYPE_DOC docType = iota
+	TYPE_DOCX
+	TYPE_XLS
+	TYPE_XLSX
+	TYPE_PPT
+	TYPE_PPTX
+	TYPE_OOXML
+)
+
+//reference: https://bz.apache.org/ooo/show_bug.cgi?id=111457
+func Doc(buf []byte) bool {
+	if len(buf) > 513 {
+		return buf[0] == 0xD0 && buf[1] == 0xCF &&
+			buf[2] == 0x11 && buf[3] == 0xE0 &&
+			buf[512] == 0xEC && buf[513] == 0xA5
+	} else {
+		return len(buf) > 3 &&
+			buf[0] == 0xD0 && buf[1] == 0xCF &&
+			buf[2] == 0x11 && buf[3] == 0xE0
+	}
+}
+
+func Docx(buf []byte) bool {
+	typ, ok := msooxml(buf)
+	return ok && typ == TYPE_DOCX
+}
+
+func Xls(buf []byte) bool {
+	if len(buf) > 513 {
+		return buf[0] == 0xD0 && buf[1] == 0xCF &&
+			buf[2] == 0x11 && buf[3] == 0xE0 &&
+			buf[512] == 0x09 && buf[513] == 0x08
+	} else {
+		return len(buf) > 3 &&
+			buf[0] == 0xD0 && buf[1] == 0xCF &&
+			buf[2] == 0x11 && buf[3] == 0xE0
+	}
+}
+
+func Xlsx(buf []byte) bool {
+	typ, ok := msooxml(buf)
+	return ok && typ == TYPE_XLSX
+}
+
+func Ppt(buf []byte) bool {
+	if len(buf) > 513 {
+		return buf[0] == 0xD0 && buf[1] == 0xCF &&
+			buf[2] == 0x11 && buf[3] == 0xE0 &&
+			buf[512] == 0xA0 && buf[513] == 0x46
+	} else {
+		return len(buf) > 3 &&
+			buf[0] == 0xD0 && buf[1] == 0xCF &&
+			buf[2] == 0x11 && buf[3] == 0xE0
+	}
+}
+
+func Pptx(buf []byte) bool {
+	typ, ok := msooxml(buf)
+	return ok && typ == TYPE_PPTX
+}
+
+func msooxml(buf []byte) (typ docType, found bool) {
+	signature := []byte{'P', 'K', 0x03, 0x04}
+
+	// start by checking for ZIP local file header signature
+	if ok := compareBytes(buf, signature, 0); !ok {
+		return
+	}
+
+	// make sure the first file is correct
+	if v, ok := checkMSOoml(buf, 0x1E); ok {
+		return v, ok
+	}
+
+	if !compareBytes(buf, []byte("[Content_Types].xml"), 0x1E) &&
+		!compareBytes(buf, []byte("_rels/.rels"), 0x1E) &&
+		!compareBytes(buf, []byte("docProps"), 0x1E) {
+		return
+	}
+
+	// skip to the second local file header
+	// since some documents include a 520-byte extra field following the file
+	// header, we need to scan for the next header
+	startOffset := int(binary.LittleEndian.Uint32(buf[18:22]) + 49)
+	idx := search(buf, startOffset, 6000)
+	if idx == -1 {
+		return
+	}
+
+	// now skip to the *third* local file header; again, we need to scan due to a
+	// 520-byte extra field following the file header
+	startOffset += idx + 4 + 26
+	idx = search(buf, startOffset, 6000)
+	if idx == -1 {
+		return
+	}
+
+	// and check the subdirectory name to determine which type of OOXML
+	// file we have.  Correct the mimetype with the registered ones:
+	// http://technet.microsoft.com/en-us/library/cc179224.aspx
+	startOffset += idx + 4 + 26
+	if typ, ok := checkMSOoml(buf, startOffset); ok {
+		return typ, ok
+	}
+
+	// OpenOffice/Libreoffice orders ZIP entry differently, so check the 4th file
+	startOffset += 26
+	idx = search(buf, startOffset, 6000)
+	if idx == -1 {
+		return TYPE_OOXML, true
+	}
+
+	startOffset += idx + 4 + 26
+	if typ, ok := checkMSOoml(buf, startOffset); ok {
+		return typ, ok
+	} else {
+		return TYPE_OOXML, true
+	}
+}
+
+func compareBytes(slice, subSlice []byte, startOffset int) bool {
+	sl := len(subSlice)
+
+	if startOffset+sl > len(slice) {
+		return false
+	}
+
+	s := slice[startOffset : startOffset+sl]
+	for i := range s {
+		if subSlice[i] != s[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+func checkMSOoml(buf []byte, offset int) (typ docType, ok bool) {
+	ok = true
+
+	switch {
+	case compareBytes(buf, []byte("word/"), offset):
+		typ = TYPE_DOCX
+	case compareBytes(buf, []byte("ppt/"), offset):
+		typ = TYPE_PPTX
+	case compareBytes(buf, []byte("xl/"), offset):
+		typ = TYPE_XLSX
+	default:
+		ok = false
+	}
+
+	return
+}
+
+func search(buf []byte, start, rangeNum int) int {
+	length := len(buf)
+	end := start + rangeNum
+	signature := []byte{'P', 'K', 0x03, 0x04}
+
+	if end > length {
+		end = length
+	}
+
+	if start >= end {
+		return -1
+	}
+
+	return bytes.Index(buf[start:end], signature)
+}

slidge_whatsapp/vendor/github.com/h2non/filetype/matchers/font.go

@@ -0,0 +1,45 @@
+package matchers
+
+var (
+	TypeWoff  = newType("woff", "application/font-woff")
+	TypeWoff2 = newType("woff2", "application/font-woff")
+	TypeTtf   = newType("ttf", "application/font-sfnt")
+	TypeOtf   = newType("otf", "application/font-sfnt")
+)
+
+var Font = Map{
+	TypeWoff:  Woff,
+	TypeWoff2: Woff2,
+	TypeTtf:   Ttf,
+	TypeOtf:   Otf,
+}
+
+func Woff(buf []byte) bool {
+	return len(buf) > 7 &&
+		buf[0] == 0x77 && buf[1] == 0x4F &&
+		buf[2] == 0x46 && buf[3] == 0x46 &&
+		buf[4] == 0x00 && buf[5] == 0x01 &&
+		buf[6] == 0x00 && buf[7] == 0x00
+}
+
+func Woff2(buf []byte) bool {
+	return len(buf) > 7 &&
+		buf[0] == 0x77 && buf[1] == 0x4F &&
+		buf[2] == 0x46 && buf[3] == 0x32 &&
+		buf[4] == 0x00 && buf[5] == 0x01 &&
+		buf[6] == 0x00 && buf[7] == 0x00
+}
+
+func Ttf(buf []byte) bool {
+	return len(buf) > 4 &&
+		buf[0] == 0x00 && buf[1] == 0x01 &&
+		buf[2] == 0x00 && buf[3] == 0x00 &&
+		buf[4] == 0x00
+}
+
+func Otf(buf []byte) bool {
+	return len(buf) > 4 &&
+		buf[0] == 0x4F && buf[1] == 0x54 &&
+		buf[2] == 0x54 && buf[3] == 0x4F &&
+		buf[4] == 0x00
+}

slidge_whatsapp/vendor/github.com/h2non/filetype/matchers/image.go

@@ -0,0 +1,143 @@
+package matchers
+
+import "github.com/h2non/filetype/matchers/isobmff"
+
+var (
+	TypeJpeg     = newType("jpg", "image/jpeg")
+	TypeJpeg2000 = newType("jp2", "image/jp2")
+	TypePng      = newType("png", "image/png")
+	TypeGif      = newType("gif", "image/gif")
+	TypeWebp     = newType("webp", "image/webp")
+	TypeCR2      = newType("cr2", "image/x-canon-cr2")
+	TypeTiff     = newType("tif", "image/tiff")
+	TypeBmp      = newType("bmp", "image/bmp")
+	TypeJxr      = newType("jxr", "image/vnd.ms-photo")
+	TypePsd      = newType("psd", "image/vnd.adobe.photoshop")
+	TypeIco      = newType("ico", "image/vnd.microsoft.icon")
+	TypeHeif     = newType("heif", "image/heif")
+	TypeDwg      = newType("dwg", "image/vnd.dwg")
+)
+
+var Image = Map{
+	TypeJpeg:     Jpeg,
+	TypeJpeg2000: Jpeg2000,
+	TypePng:      Png,
+	TypeGif:      Gif,
+	TypeWebp:     Webp,
+	TypeCR2:      CR2,
+	TypeTiff:     Tiff,
+	TypeBmp:      Bmp,
+	TypeJxr:      Jxr,
+	TypePsd:      Psd,
+	TypeIco:      Ico,
+	TypeHeif:     Heif,
+	TypeDwg:      Dwg,
+}
+
+func Jpeg(buf []byte) bool {
+	return len(buf) > 2 &&
+		buf[0] == 0xFF &&
+		buf[1] == 0xD8 &&
+		buf[2] == 0xFF
+}
+
+func Jpeg2000(buf []byte) bool {
+	return len(buf) > 12 &&
+		buf[0] == 0x0 &&
+		buf[1] == 0x0 &&
+		buf[2] == 0x0 &&
+		buf[3] == 0xC &&
+		buf[4] == 0x6A &&
+		buf[5] == 0x50 &&
+		buf[6] == 0x20 &&
+		buf[7] == 0x20 &&
+		buf[8] == 0xD &&
+		buf[9] == 0xA &&
+		buf[10] == 0x87 &&
+		buf[11] == 0xA &&
+		buf[12] == 0x0
+}
+
+func Png(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x89 && buf[1] == 0x50 &&
+		buf[2] == 0x4E && buf[3] == 0x47
+}
+
+func Gif(buf []byte) bool {
+	return len(buf) > 2 &&
+		buf[0] == 0x47 && buf[1] == 0x49 && buf[2] == 0x46
+}
+
+func Webp(buf []byte) bool {
+	return len(buf) > 11 &&
+		buf[8] == 0x57 && buf[9] == 0x45 &&
+		buf[10] == 0x42 && buf[11] == 0x50
+}
+
+func CR2(buf []byte) bool {
+	return len(buf) > 10 &&
+		((buf[0] == 0x49 && buf[1] == 0x49 && buf[2] == 0x2A && buf[3] == 0x0) || // Little Endian
+			(buf[0] == 0x4D && buf[1] == 0x4D && buf[2] == 0x0 && buf[3] == 0x2A)) && // Big Endian
+		buf[8] == 0x43 && buf[9] == 0x52 && // CR2 magic word
+		buf[10] == 0x02 // CR2 major version
+}
+
+func Tiff(buf []byte) bool {
+	return len(buf) > 10 &&
+		((buf[0] == 0x49 && buf[1] == 0x49 && buf[2] == 0x2A && buf[3] == 0x0) || // Little Endian
+			(buf[0] == 0x4D && buf[1] == 0x4D && buf[2] == 0x0 && buf[3] == 0x2A)) && // Big Endian
+		!CR2(buf) // To avoid conflicts differentiate Tiff from CR2
+}
+
+func Bmp(buf []byte) bool {
+	return len(buf) > 1 &&
+		buf[0] == 0x42 &&
+		buf[1] == 0x4D
+}
+
+func Jxr(buf []byte) bool {
+	return len(buf) > 2 &&
+		buf[0] == 0x49 &&
+		buf[1] == 0x49 &&
+		buf[2] == 0xBC
+}
+
+func Psd(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x38 && buf[1] == 0x42 &&
+		buf[2] == 0x50 && buf[3] == 0x53
+}
+
+func Ico(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x00 && buf[1] == 0x00 &&
+		buf[2] == 0x01 && buf[3] == 0x00
+}
+
+func Heif(buf []byte) bool {
+	if !isobmff.IsISOBMFF(buf) {
+		return false
+	}
+
+	majorBrand, _, compatibleBrands := isobmff.GetFtyp(buf)
+	if majorBrand == "heic" {
+		return true
+	}
+
+	if majorBrand == "mif1" || majorBrand == "msf1" {
+		for _, compatibleBrand := range compatibleBrands {
+			if compatibleBrand == "heic" {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func Dwg(buf []byte) bool {
+	return len(buf) > 3 &&
+		buf[0] == 0x41 && buf[1] == 0x43 &&
+		buf[2] == 0x31 && buf[3] == 0x30
+}