infer

https://docs.rs/infer/latest/
Admin
infer is a Rust crate that identifies file and MIME types by analyzing magic number signatures in...
Tokens:41,287
Snippets:318
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Identify MSI Windows Installer Archive

Source: https://docs.rs/infer/latest/src/infer/matchers/archive.rs.html

Checks if the provided buffer starts with the signature for an MSI Windows Installer file.

```rust
/// Returns whether a buffer is a MSI Windows Installer archive.
#[must_use]
pub fn is_msi(buf: &[u8]) -> bool {
    buf.len() > 7
        && buf[0] == 0xD0
        && buf[1] == 0xCF
        && buf[2] == 0x11
        && buf[3] == 0xE0
        && buf[4] == 0xA1
        && buf[5] == 0xB1
        && buf[6] == 0x1A
        && buf[7] == 0xE1
}
```

--------------------------------

### Full implementation example for get_from_path

Source: https://docs.rs/infer/latest/infer/fn.get_from_path.html

A complete main function example showing how to handle successful detection, unknown types, and I/O errors.

```rust
4fn main() {
5    let mut args = args();
6    let Some(path) = args.nth(1) else {
7        eprintln!("Please specify the file path");
8        exit(1);
9    };
10
11    match infer::get_from_path(path) {
12        Ok(Some(info)) => {
13            println!("Through the arcane magic of this crate we determined the file type to be");
14            println!("mime type: {}", info.mime_type());
15            println!("extension: {}", info.extension());
16        }
17        Ok(None) => {
18            eprintln!("Unknown file type 😞");
19            eprintln!("If you think infer should be able to recognize this file type open an issue on GitHub!");
20            exit(1);
21        }
22        Err(e) => {
23            eprintln!("Looks like something went wrong 😔");
24            eprintln!("{e}");
25            exit(1);
26        }
27    }
28}
```

--------------------------------

### Example usage of a documented function

Source: https://docs.rs/infer/latest/scrape-examples-help.html

An example file demonstrating how to call a function from a crate, which Rustdoc will scrape for documentation.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### pub fn get(&self, buf: &[u8]) -> Option<Type>

Source: https://docs.rs/infer/latest/infer/struct.Infer.html

Returns the file type of the provided buffer.

```APIDOC
## pub fn get(&self, buf: &[u8]) -> Option<Type>

### Description
Returns the file type of the buffer.
```

--------------------------------

### Identify QCOW2 disk format

Source: https://docs.rs/infer/latest/src/infer/matchers/app.rs.html

Checks for the QCOW2 magic bytes at the start of a buffer.

```rust
pub fn is_qcow2(buf: &[u8]) -> bool {
    // https://github.com/qemu/qemu/blob/master/docs/interop/qcow2.txt
    buf.len() > 4 && buf[0] == b'Q' && buf[1] == b'F' && buf[2] == b'I' && buf[3] == 0xFB
}
```

--------------------------------

### pub fn get(buf: &[u8]) -> Option<Type>

Source: https://docs.rs/infer/latest/infer/fn.get.html

Returns the file type of the provided byte buffer.

```APIDOC
## pub fn get(buf: &[u8]) -> Option<Type>

### Description
Returns the file type of the buffer.

### Signature
`pub fn get(buf: &[u8]) -> Option<Type>`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to analyze.

### Returns
- **Option<Type>** - Returns the detected file type if identified, otherwise None.

### Example
```rust
let info = infer::Infer::new();
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
let kind = info.get(&buf).expect("file type is known");

assert_eq!(kind.mime_type(), "image/jpeg");
assert_eq!(kind.extension(), "jpg");
```
```

--------------------------------

### pub fn is_msi(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/archive/fn.is_msi.html

Determines if the provided byte buffer contains a Windows Installer (MSI) archive.

```APIDOC
## pub fn is_msi(buf: &[u8]) -> bool

### Description
Returns whether a buffer is a MSI Windows Installer archive.

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is an MSI archive, false otherwise.
```

--------------------------------

### Internal helper for case-insensitive prefix matching

Source: https://docs.rs/infer/latest/src/infer/matchers/text.rs.html

Utility to check if a buffer starts with a specific byte sequence, ignoring ASCII case.

```rust
fn starts_with_ignore_ascii_case(buf: &[u8], needle: &[u8]) -> bool {
    buf.len() >= needle.len() && buf[..needle.len()].eq_ignore_ascii_case(needle)
}
```

--------------------------------

### Identify PEM format

Source: https://docs.rs/infer/latest/src/infer/matchers/app.rs.html

Validates if a buffer starts with the standard PEM header signature.

```rust
pub fn is_pem(buf: &[u8]) -> bool {
    // https://en.wikipedia.org/wiki/List_of_file_signatures
    buf.len() > 11
        && buf[0] == b'-'
        && buf[1] == b'-'
        && buf[2] == b'-'
        && buf[3] == b'-'
        && buf[4] == b'-'
        && buf[5] == b'B'
        && buf[6] == b'E'
        && buf[7] == b'G'
        && buf[8] == b'I'
        && buf[9] == b'N'
        && buf[10] == b' '
}
```

--------------------------------

### Identify AutoCAD DWG format

Source: https://docs.rs/infer/latest/src/infer/matchers/image.rs.html

Checks if the buffer starts with a known AutoCAD DWG version signature.

```rust
pub fn is_dwg(buf: &[u8]) -> bool {
    if buf.len() < 6 {
        return false;
    }

    matches!(
        &buf[..6],
        b"MC0.0\0"
            | b"AC1.2\0"
            | b"AC1.3\0"
            | b"AC1.40"
            | b"AC1.50"
            | b"AC2.10"
            | b"AC2.21"
            | b"AC2.22"
            | b"AC1001"
            | b"AC1002"
            | b"AC1003"
            | b"AC1004"
            | b"AC1006"
            | b"AC1009"
            | b"AC1012"
            | b"AC1013"
            | b"AC1014"
            | b"AC1015"
            | b"AC1018"
            | b"AC1021"
            | b"AC1024"
            | b"AC1027"
            | b"AC1032"
            | b"AC1035"
    )
}
```

--------------------------------

### Detect shell scripts

Source: https://docs.rs/infer/latest/src/infer/matchers/text.rs.html

Checks if a buffer starts with the shebang sequence.

```rust
/// Returns whether a buffer is a shell script.
#[must_use]
pub fn is_shellscript(buf: &[u8]) -> bool {
    buf.len() > 2 && &buf[..2] == b"#!"
}
```

--------------------------------

### pub fn is_supported(extension: &str) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_supported.html

Checks whether the provided file extension is supported by the library.

```APIDOC
## Function: is_supported

### Description
Returns a boolean indicating whether the specified file extension is supported by the infer library.

### Signature
`pub fn is_supported(extension: &str) -> bool`

### Parameters
- **extension** (&str) - The file extension to check (e.g., "jpg").

### Returns
- **bool** - Returns true if the extension is supported, false otherwise.

### Example
```rust
assert!(infer::is_supported("jpg"));
```
```

--------------------------------

### Check extension support

Source: https://docs.rs/infer/latest/infer/fn.is_supported.html

Verifies if a specific file extension is supported by the library.

```rust
assert!(infer::is_supported("jpg"));
```

--------------------------------

### pub const fn new() -> Infer

Source: https://docs.rs/infer/latest/infer/struct.Infer.html

Initializes a new instance of the Infer struct.

```APIDOC
## pub const fn new() -> Infer

### Description
Initialize a new instance of the infer struct.
```

--------------------------------

### Check Matcher Type

Source: https://docs.rs/infer/latest/infer/struct.Type.html

Demonstrates how to retrieve the matcher type from a detected file type instance.

```rust
let info = infer::Infer::new();
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
let kind = info.get(&buf).expect("file type is known");

assert_eq!(kind.matcher_type(), infer::MatcherType::Image);
```

--------------------------------

### Infer::new

Source: https://docs.rs/infer/latest/src/infer/lib.rs.html

Initializes a new instance of the Infer struct.

```APIDOC
## pub const fn new()

### Description
Initialize a new instance of the infer struct.

### Signature
`pub const fn new() -> Infer`
```

--------------------------------

### pub fn is_wav(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/audio/fn.is_wav.html

Determines whether the provided byte buffer represents WAV audio data.

```APIDOC
## Function: is_wav

### Description
Returns a boolean indicating whether the provided buffer contains WAV data.

### Signature
`pub fn is_wav(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - A byte slice containing the data to be inspected.

### Returns
- **bool** - Returns `true` if the buffer is identified as WAV data, otherwise `false`.
```

--------------------------------

### pub fn is_pptx(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/doc/fn.is_pptx.html

Determines if the provided byte buffer represents a PPTX file.

```APIDOC
## Function: is_pptx

### Description
Returns whether a buffer is Microsoft PowerPoint Open XML Presentation (PPTX) data.

### Signature
`pub fn is_pptx(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as PPTX, otherwise false.
```

--------------------------------

### Get file type from buffer

Source: https://docs.rs/infer/latest/index.html

Uses a byte buffer to identify the file type, returning its MIME type, extension, and matcher type.

```rust
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
let kind = infer::get(&buf).expect("file type is known");

assert_eq!(kind.mime_type(), "image/jpeg");
assert_eq!(kind.extension(), "jpg");
assert_eq!(kind.matcher_type(), infer::MatcherType::Image);
```

--------------------------------

### Infer file type from path

Source: https://docs.rs/infer/latest/src/file/file.rs.html

Demonstrates reading a file path from command-line arguments and using infer::get_from_path to identify its type.

```rust
1use std::env::args;
2use std::process::exit;
3
4fn main() {
5    let mut args = args();
6    let Some(path) = args.nth(1) else {
7        eprintln!("Please specify the file path");
8        exit(1);
9    };
10
11    match infer::get_from_path(path) {
12        Ok(Some(info)) => {
13            println!("Through the arcane magic of this crate we determined the file type to be");
14            println!("mime type: {}", info.mime_type());
15            println!("extension: {}", info.extension());
16        }
17        Ok(None) => {
18            eprintln!("Unknown file type 😞");
19            eprintln!("If you think infer should be able to recognize this file type open an issue on GitHub!");
20            exit(1);
21        }
22        Err(e) => {
23            eprintln!("Looks like something went wrong 😔");
24            eprintln!("{e}");
25            exit(1);
26        }
27    }
28}
```

--------------------------------

### pub fn is_app(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_app.html

Determines whether a buffer is an application type.

```APIDOC
## Function: is_app

### Description
Determines whether a buffer is an application type.

### Signature
`pub fn is_app(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is an application type, false otherwise.

### Example
```rust
use std::fs;
assert!(infer::is_app(&fs::read("testdata/sample.wasm").unwrap()));
```
```

--------------------------------

### pub fn is_mp3(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/audio/fn.is_mp3.html

Determines whether the provided byte buffer represents MP3 data.

```APIDOC
## Function: is_mp3

### Description
Returns a boolean indicating whether the provided buffer contains MP3 data.

### Signature
`pub fn is_mp3(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for MP3 signatures.

### Returns
- **bool** - Returns true if the buffer is identified as MP3 data, false otherwise.
```

--------------------------------

### pub fn is_audio(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_audio.html

Determines whether a buffer is an audio type.

```APIDOC
## Function: is_audio

### Description
Determines whether a buffer is an audio type.

### Signature
`pub fn is_audio(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - A byte slice representing the file content to check.

### Returns
- **bool** - Returns true if the buffer is identified as an audio type, false otherwise.

### Example
```rust
// mp3
let v = [0xff, 0xfb, 0x90, 0x44, 0x00];
assert!(infer::is_audio(&v));
```
```

--------------------------------

### pub fn is_ape(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/audio/fn.is_ape.html

Determines whether the provided byte buffer represents APE (Monkey's Audio) data.

```APIDOC
## Function: is_ape

### Description
Returns a boolean indicating whether the provided buffer contains APE (Monkey's Audio) data.

### Signature
`pub fn is_ape(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for APE format signatures.

### Returns
- **bool** - Returns true if the buffer is identified as APE data, false otherwise.
```

--------------------------------

### pub fn is_docx(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/doc/fn.is_docx.html

Determines if the provided byte buffer represents a DOCX file.

```APIDOC
## Function: is_docx

### Description
Returns whether a buffer is Microsoft Word Open XML Format Document (DOCX) data.

### Signature
`pub fn is_docx(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is a DOCX file, false otherwise.
```

--------------------------------

### pub fn is_ico(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/image/fn.is_ico.html

Determines whether the provided byte buffer represents an ICO icon image.

```APIDOC
## is_ico

### Description
Returns whether a buffer is ICO icon image data.

### Signature
`pub fn is_ico(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for ICO image data.

### Returns
- **bool** - Returns true if the buffer is an ICO icon, false otherwise.
```

--------------------------------

### is_flac(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/audio/fn.is_flac.html

Determines whether the provided byte buffer represents FLAC audio data.

```APIDOC
## fn is_flac

### Description
Returns whether a buffer is FLAC data.

### Signature
`pub fn is_flac(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - A byte slice containing the data to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as FLAC data, false otherwise.
```

--------------------------------

### Detect ePub and mobi formats

Source: https://docs.rs/infer/latest/src/infer/matchers/book.rs.html

Functions to verify if a byte buffer corresponds to an ePub or mobi file based on magic bytes.

```rust
/// Returns whether a buffer is an ePub.
#[must_use]
pub fn is_epub(buf: &[u8]) -> bool {
    buf.len() > 57
        && buf[0] == 0x50
        && buf[1] == 0x4B
        && buf[2] == 0x3
        && buf[3] == 0x4
        && buf[30] == 0x6D
        && buf[31] == 0x69
        && buf[32] == 0x6D
        && buf[33] == 0x65
        && buf[34] == 0x74
        && buf[35] == 0x79
        && buf[36] == 0x70
        && buf[37] == 0x65
        && buf[38] == 0x61
        && buf[39] == 0x70
        && buf[40] == 0x70
        && buf[41] == 0x6C
        && buf[42] == 0x69
        && buf[43] == 0x63
        && buf[44] == 0x61
        && buf[45] == 0x74
        && buf[46] == 0x69
        && buf[47] == 0x6F
        && buf[48] == 0x6E
        && buf[49] == 0x2F
        && buf[50] == 0x65
        && buf[51] == 0x70
        && buf[52] == 0x75
        && buf[53] == 0x62
        && buf[54] == 0x2B
        && buf[55] == 0x7A
        && buf[56] == 0x69
        && buf[57] == 0x70
}

/// Returns whether a buffer is a mobi.
#[must_use]
pub fn is_mobi(buf: &[u8]) -> bool {
    buf.len() > 67
        // BOOK
        && buf[60] == 0x42
        && buf[61] == 0x4F
        && buf[62] == 0x4F
        && buf[63] == 0x4B
        // MOBI
        && buf[64] == 0x4D
        && buf[65] == 0x4F
        && buf[66] == 0x42
        && buf[67] == 0x49
}
```

--------------------------------

### pub fn is_ppt(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/doc/fn.is_ppt.html

Checks if the provided byte buffer represents a Microsoft PowerPoint 97-2003 Presentation (PPT) file.

```APIDOC
## Function: is_ppt

### Description
Returns a boolean indicating whether the provided byte buffer contains Microsoft PowerPoint 97-2003 Presentation (PPT) data.

### Signature
`pub fn is_ppt(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for PPT file signature.
```

--------------------------------

### is_flv(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/video/fn.is_flv.html

Determines whether the provided byte buffer represents FLV video data.

```APIDOC
## Function: is_flv

### Description
Checks if the provided byte buffer contains FLV video data.

### Signature
`pub fn is_flv(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is FLV video data, false otherwise.
```

--------------------------------

### pub fn is_ps(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/archive/fn.is_ps.html

Determines whether the provided byte buffer represents a PostScript file.

```APIDOC
## Function: is_ps

### Description
Returns whether a buffer is postscript.

### Signature
`pub fn is_ps(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as postscript, false otherwise.
```

--------------------------------

### pub fn is_midi(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/audio/fn.is_midi.html

Checks whether the provided byte buffer represents MIDI data.

```APIDOC
## pub fn is_midi(buf: &[u8]) -> bool

### Description
Returns a boolean indicating whether the provided buffer contains MIDI data.

### Signature
`pub fn is_midi(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect for MIDI data.

### Returns
- **bool** - Returns true if the buffer is identified as MIDI data, false otherwise.
```

--------------------------------

### pub fn is_webm(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/video/fn.is_webm.html

Determines whether the provided byte buffer represents WEBM video data.

```APIDOC
## Function: is_webm

### Description
Returns a boolean indicating whether the provided buffer contains WEBM video data.

### Signature
`pub fn is_webm(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - A byte slice containing the data to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as WEBM video data, otherwise false.
```

--------------------------------

### pub fn is_book(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_book.html

Determines whether a buffer is a book type.

```APIDOC
## is_book

### Description
Determines whether a buffer is a book type.

### Signature
`pub fn is_book(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - A byte slice representing the file content to check.

### Returns
- **bool** - Returns true if the buffer is identified as a book type, false otherwise.

### Example
```rust
use std::fs;
assert!(infer::is_book(&fs::read("testdata/sample.epub").unwrap()));
```
```

--------------------------------

### Identify file type from buffer

Source: https://docs.rs/infer/latest/infer/fn.get.html

Demonstrates using the Infer instance to retrieve file type information from a byte array.

```rust
let info = infer::Infer::new();
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
let kind = info.get(&buf).expect("file type is known");

assert_eq!(kind.mime_type(), "image/jpeg");
assert_eq!(kind.extension(), "jpg");
```

--------------------------------

### pub fn is_video(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_video.html

Determines whether a buffer is a video type.

```APIDOC
## is_video

### Description
Determines whether a buffer is a video type.

### Signature
`pub fn is_video(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is a video type, false otherwise.

### Example
```rust
use std::fs;
assert!(infer::is_video(&fs::read("testdata/sample.mov").unwrap()));
```
```

--------------------------------

### pub fn is_qcow2(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/app/fn.is_qcow2.html

Checks if the provided byte buffer contains a QCOW2 disk image signature.

```APIDOC
## Function: is_qcow2

### Description
Returns whether a buffer is a QCOW2 disk.

### Signature
`pub fn is_qcow2(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect for the QCOW2 signature.

### Returns
- **bool** - Returns true if the buffer is a QCOW2 disk, false otherwise.
```

--------------------------------

### is_avif(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/image/fn.is_avif.html

Determines whether the provided byte buffer represents an AVIF image.

```APIDOC
## Function: is_avif

### Description
Returns a boolean indicating whether the provided buffer contains AVIF image data.

### Signature
`pub fn is_avif(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - A byte slice containing the image data to inspect.

### Returns
- **bool** - Returns `true` if the buffer is identified as AVIF image data, otherwise `false`.
```

--------------------------------

### pub fn is_webp(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/image/fn.is_webp.html

Determines if the provided byte buffer represents a WEBP image.

```APIDOC
## Function: is_webp

### Description
Returns a boolean indicating whether the provided buffer contains WEBP image data.

### Signature
`pub fn is_webp(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for WEBP signature.

### Returns
- **bool** - Returns true if the buffer is WEBP image data, false otherwise.
```

--------------------------------

### Check for WebAssembly format

Source: https://docs.rs/infer/latest/infer/app/fn.is_wasm.html

Verifies if a file buffer is a WebAssembly module using the infer crate.

```rust
use std::fs;
assert!(infer::app::is_wasm(&fs::read("testdata/sample.wasm").unwrap()));
```

--------------------------------

### pub fn is_html(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/text/fn.is_html.html

Checks if the provided byte buffer represents HTML data according to the WHATWG specification.

```APIDOC
## Function: is_html

### Description
Returns a boolean indicating whether the provided byte buffer contains HTML data. This implementation conforms to the WHATWG specification.

### Signature
`pub fn is_html(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for HTML content.

### Returns
- **bool** - Returns true if the buffer is identified as HTML, otherwise false.
```

--------------------------------

### Check buffer extension with infer::is

Source: https://docs.rs/infer/latest/infer/fn.is.html

Verifies if the provided byte buffer matches the specified file extension string.

```rust
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
assert!(infer::is(&buf, "jpg"));
```

--------------------------------

### is_ogg(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/audio/fn.is_ogg.html

Determines whether the provided byte buffer represents OGG data.

```APIDOC
## Function: is_ogg

### Description
Returns a boolean indicating whether the provided buffer contains OGG data.

### Signature
`pub fn is_ogg(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for OGG format signatures.

### Returns
- **bool** - Returns true if the buffer is identified as OGG data, false otherwise.
```

--------------------------------

### pub fn is_psd(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/image/fn.is_psd.html

Determines if the provided byte buffer represents a Photoshop PSD image.

```APIDOC
## Function: is_psd

### Description
Returns whether a buffer is Photoshop PSD image data.

### Signature
`pub fn is_psd(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for PSD image data.

### Returns
- **bool** - Returns true if the buffer is a PSD image, false otherwise.
```

--------------------------------

### Check file type by path

Source: https://docs.rs/infer/latest/index.html

Reads a file from the specified path and returns its inferred type information.

```rust
let kind = infer::get_from_path("testdata/sample.jpg")
    .expect("file read successfully")
    .expect("file type is known");

assert_eq!(kind.mime_type(), "image/jpeg");
assert_eq!(kind.extension(), "jpg");
```

--------------------------------

### Unit tests for text matchers

Source: https://docs.rs/infer/latest/src/infer/matchers/text.rs.html

Test suite verifying whitespace trimming and content detection logic.

```rust
#[cfg(test)]
mod tests {
    use super::{is_html, is_shellscript, trim_start_whitespaces};

    #[test]
    fn trim_whitespaces() {
        let got = trim_start_whitespaces(&[0x09, 0x0A, 0x0C, 0x0D, 0x20, b'A', b'B', b'C']);
        assert_eq!(got, b"ABC");

        let got = trim_start_whitespaces(b"abc");
        assert_eq!(got, b"abc");

        let got = trim_start_whitespaces(&[]);
        assert_eq!(got, &[]);
    }

    #[test]
    fn html() {
        assert!(!is_html(b"<"));
        assert!(!is_html(b"<HTML"));
        assert!(is_html(b"<HTML "));
        assert!(is_html(b"   <BODY>"));
    }

    #[test]
    fn shellscript() {
        assert!(!is_shellscript(b"#!"));
    }
}
```

--------------------------------

### Test file identification

Source: https://docs.rs/infer/latest/src/infer/lib.rs.html

Unit tests demonstrating how to retrieve file information from a buffer.

```rust
let buf = [];
assert!(crate::get(&buf).is_none());
```

```rust
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
let kind = crate::get(&buf).expect("file type is known");
assert_eq!(kind.extension(), "jpg");
assert_eq!(kind.mime_type(), "image/jpeg");
```

```rust
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
let kind = crate::get(&buf).expect("file type is known");
assert_eq!(kind.matcher_type(), crate::MatcherType::Image);
```

--------------------------------

### infer::Infer::new()

Source: https://docs.rs/infer/latest/index.html

Creates a new Infer instance for managing custom file type matchers.

```APIDOC
## infer::Infer::new()

### Description
Initializes a new Infer struct that allows for the registration of custom matchers to identify specific file types.

### Methods
- **add(mime_type: &str, extension: &str, matcher: Matcher)** - Registers a custom matcher function for a specific MIME type and extension.
```

--------------------------------

### pub fn is_exe(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/app/fn.is_exe.html

Checks if the provided byte buffer contains the magic number for an EXE or DLL file.

```APIDOC
## is_exe

### Description
Returns whether a buffer is an EXE. Note that DLL and EXE files share the same magic number, so this function returns true for both.

### Signature
`pub fn is_exe(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - A byte slice containing the file content to inspect.

### Returns
- **bool** - Returns true if the buffer matches the EXE/DLL magic number, false otherwise.

### Example
```rust
use std::fs;
assert!(infer::app::is_exe(&fs::read("testdata/sample.exe").unwrap()));
```
```

--------------------------------

### pub fn is_image(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_image.html

Determines whether a buffer is an image type.

```APIDOC
## Function: is_image

### Description
Determines whether a buffer is an image type.

### Signature
`pub fn is_image(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as an image, false otherwise.

### Example
```rust
let v = [0xFF, 0xD8, 0xFF, 0xAA];
assert!(infer::is_image(&v));
```
```

--------------------------------

### pub fn is_llvm(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/app/fn.is_llvm.html

Checks if the provided byte buffer represents LLVM Bitcode.

```APIDOC
## is_llvm

### Description
Returns whether a buffer is LLVM Bitcode.

### Signature
`pub fn is_llvm(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is LLVM Bitcode, false otherwise.
```

--------------------------------

### pub fn is_mach(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/app/fn.is_mach.html

Determines if the provided byte buffer is a Mach-O binary.

```APIDOC
## Function: is_mach

### Description
Returns whether a buffer is a Mach-O binary.

### Signature
`pub fn is_mach(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is a Mach-O binary, false otherwise.
```

--------------------------------

### pub fn is_ora(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/image/fn.is_ora.html

Checks if the provided byte buffer represents an ORA image.

```APIDOC
## Function: is_ora

### Description
Returns whether a buffer is ORA image data.

### Signature
`pub fn is_ora(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is ORA image data, false otherwise.
```

--------------------------------

### Check for PPTX format

Source: https://docs.rs/infer/latest/infer/doc/fn.is_pptx.html

Determines if the provided byte buffer represents a PPTX file.

```rust
pub fn is_pptx(buf: &[u8]) -> bool
```

--------------------------------

### is_mime_supported(mime_type: &str) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_mime_supported.html

Checks whether a specific MIME type is supported by the infer library.

```APIDOC
## is_mime_supported

### Description
Returns a boolean indicating whether the provided MIME type string is supported by the library.

### Signature
`pub fn is_mime_supported(mime_type: &str) -> bool`

### Parameters
- **mime_type** (&str) - The MIME type string to check.

### Example
```rust
assert!(infer::is_mime_supported("image/jpeg"));
```
```

--------------------------------

### pub fn is_zip(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/archive/fn.is_zip.html

Determines if the provided byte buffer is a zip archive.

```APIDOC
## is_zip

### Description
Returns whether a buffer is a zip archive.

### Signature
`pub fn is_zip(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is a zip archive, false otherwise.
```

--------------------------------

### is_exe

Source: https://docs.rs/infer/latest/src/infer/matchers/app.rs.html

Checks if the provided buffer contains an EXE or DLL binary.

```APIDOC
## fn is_exe(buf: &[u8]) -> bool

### Description
Returns whether a buffer is an EXE. Since DLL and EXE share the same magic number, this function returns true for both.

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer matches the EXE/DLL magic number.
```

--------------------------------

### pub fn is_xml(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/text/fn.is_xml.html

Checks if the provided byte buffer represents XML data.

```APIDOC
## Function: is_xml

### Description
Returns a boolean indicating whether the provided buffer contains XML data. This implementation conforms to the WHATWG specification.

### Signature
`pub fn is_xml(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect for XML content.

### Returns
- **bool** - Returns true if the buffer is identified as XML, false otherwise.
```

--------------------------------

### pub fn is_epub(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/archive/fn.is_epub.html

Determines whether the provided byte buffer contains an ePub file.

```APIDOC
## pub fn is_epub(buf: &[u8]) -> bool

### Description
Returns whether a buffer is an ePub.

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is an ePub, false otherwise.
```

--------------------------------

### Check MIME type support

Source: https://docs.rs/infer/latest/infer/fn.is_mime_supported.html

Verifies if a specific MIME type string is supported by the library.

```rust
assert!(infer::is_mime_supported("image/jpeg"));
```

--------------------------------

### pub fn add(&mut self, mime_type: &'static str, extension: &'static str, m: Matcher)

Source: https://docs.rs/infer/latest/infer/struct.Infer.html

Adds a custom matcher to the Infer instance.

```APIDOC
## pub fn add(&mut self, mime_type: &'static str, extension: &'static str, m: Matcher)

### Description
Adds a custom matcher. Custom matchers are matched in order of addition and before the default set of matchers.
```

--------------------------------

### Byte Matching Utilities

Source: https://docs.rs/infer/latest/src/infer/matchers/mod.rs.html

Utility functions for comparing byte slices, including offset-based comparison and windowed matching.

```rust
1pub mod app;
2pub mod archive;
3pub mod audio;
4pub mod book;
5pub mod doc;
6pub mod font;
7pub mod image;
8pub mod odf;
9pub mod text;
10pub mod video;
11
12pub(crate) fn compare_bytes(slice: &[u8], sub_slice: &[u8], start_offset: usize) -> bool {
13    let sl = sub_slice.len();
14
15    if start_offset + sl > slice.len() {
16        return false;
17    }
18
19    for (i, v) in slice.iter().skip(start_offset).take(sl).enumerate() {
20        let v2 = sub_slice[i];
21
22        if *v != v2 {
23            return false;
24        }
25    }
26
27    true
28}
29
30pub(crate) fn match_bytes(slice: &[u8], sub_slice: &[u8]) -> bool {
31    slice
32        .windows(sub_slice.len())
33        .any(|window| window == sub_slice)
34}
```

--------------------------------

### pub fn is_avi(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/video/fn.is_avi.html

Checks if the provided byte buffer represents an AVI video file.

```APIDOC
## Function: is_avi

### Description
Returns whether a buffer is AVI video data.

### Signature
`pub fn is_avi(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - A byte slice containing the data to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as AVI video data, false otherwise.
```

--------------------------------

### pub fn is_coff_x64(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/app/fn.is_coff_x64.html

Determines if the provided byte buffer is a COFF file for x64 architecture.

```APIDOC
## Function: is_coff_x64

### Description
Returns whether a buffer is a Common Object File Format for x64 architecture.

### Signature
`pub fn is_coff_x64(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is a COFF x64 file, false otherwise.
```

--------------------------------

### infer::get(buf: &[u8])

Source: https://docs.rs/infer/latest/index.html

Returns the file type of the provided buffer.

```APIDOC
## infer::get(buf: &[u8])

### Description
Returns the file type of the buffer by checking its magic number signature.

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **Option<Type>** - Returns the inferred file type if known, otherwise None.
```

--------------------------------

### pub fn is_mime(buf: &[u8], mime_type: &str) -> bool

Source: https://docs.rs/infer/latest/infer/fn.is_mime.html

Determines whether a buffer is of a given mime type.

```APIDOC
## Function: is_mime

### Description
Determines whether a buffer is of a given mime type.

### Signature
`pub fn is_mime(buf: &[u8], mime_type: &str) -> bool`

### Parameters
- **buf** (&[u8]) - The byte buffer to inspect.
- **mime_type** (&str) - The MIME type string to check against.

### Returns
- **bool** - Returns true if the buffer matches the provided MIME type, false otherwise.

### Example
```rust
let buf = [0xFF, 0xD8, 0xFF, 0xAA];
assert!(infer::is_mime(&buf, "image/jpeg"));
```
```

--------------------------------

### is_epub function signature

Source: https://docs.rs/infer/latest/infer/archive/fn.is_epub.html

The function signature for checking if a buffer is an ePub.

```rust
pub fn is_epub(buf: &[u8]) -> bool
```

--------------------------------

### pub fn is_rtf(buf: &[u8]) -> bool

Source: https://docs.rs/infer/latest/infer/archive/fn.is_rtf.html

Determines whether the provided byte buffer represents an RTF file.

```APIDOC
## Function: is_rtf

### Description
Returns a boolean indicating whether the provided buffer is an RTF (Rich Text Format).

### Signature
`pub fn is_rtf(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - The byte buffer to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as RTF, false otherwise.
```

--------------------------------

### is_mov

Source: https://docs.rs/infer/latest/infer/video/fn.is_mov.html

Checks if the provided buffer represents a Quicktime MOV video file.

```APIDOC
## fn is_mov

### Description
Returns whether a buffer is Quicktime MOV video data.

### Signature
`pub fn is_mov(buf: &[u8]) -> bool`

### Parameters
- **buf** (&[u8]) - Required - A byte slice containing the data to inspect.

### Returns
- **bool** - Returns true if the buffer is identified as Quicktime MOV video data, otherwise false.
```
Tokens:
Raw