modcrawl 0.10.2 → 0.11.2

package/README.md

@@ -1,302 +1,164 @@
-# modcrawl
+<div align="center">
+
+<img src="./web/static/readme/banner.png" alt="Modcrawl banner" />
 
 [![Crates.io](https://img.shields.io/crates/v/modcrawl?style=flat-square)](https://crates.io/crates/modcrawl)
+[![docs.rs](https://img.shields.io/docsrs/modcrawl?style=flat-square)](https://docs.rs/modcrawl)
+[![npm](https://img.shields.io/npm/v/modcrawl?style=flat-square)](https://www.npmjs.com/package/modcrawl)
 [![CI](https://img.shields.io/github/actions/workflow/status/SirCesarium/modcrawl/ci.yml?branch=main&style=flat-square)](https://github.com/SirCesarium/modcrawl/actions)
-[![License](https://img.shields.io/github/license/SirCesarium/modcrawl?style=flat-square)]()
+[![License](https://img.shields.io/github/license/SirCesarium/modcrawl?style=flat-square)](https://github.com/SirCesarium/modcrawl/blob/main/LICENSE)
 
-Detect, inspect, and analyze Minecraft mods and plugins from JARs.
+</div>
 
-```bash
-modcrawl type MyMod.jar                           # → Fabric
-modcrawl metadata MyMod.jar                       # mod name, version, authors, license
-modcrawl metadata MyMod.jar --json                # same, as JSON
-modcrawl deps MyMod.jar                           # dependencies with version ranges
-modcrawl deps MyMod.jar --include-jar-in-jar       # include embedded JARs
-modcrawl classes MyMod.jar                        # list .class files
-modcrawl grep "func_" MyMod.jar                   # search constant pool
-modcrawl mixins MyMod.jar                         # extract @Mixin targets
-modcrawl dupes a.jar b.jar c.jar                  # find duplicate classes
-```
+Analyze **Minecraft mods and plugins** to find out which loader they belong to, which dependencies they have, and even **inspect their byte code** to find out **why your modpack is crashing**.
 
-```bash
-cat *.jar | modcrawl type                         # detect many at once
-modcrawl deps *.jar                               # per-file, continues on error
-modcrawl grep "net/minecraft/world" *.jar --quiet  # which mods reference a class
-modcrawl mixins *.jar --quiet                      # which jars have mixins
-modcrawl dupes *.jar --json                        # JSON of all class dupes
-```
+## What is `modcrawl`
 
-## How it works
+`modcrawl` is an all-in-one **Minecraft utility** as a **CLI**, a **Rust library**, and an **npm package** designed to **help modpackers** and **server admins** to inspect, organize, and debug modpacks without the headache.
 
-Inspects the ZIP entries inside a JAR without extracting. Picks the first matching sentinel file (Paper > Bukkit > NeoForge > Forge mods.toml > Forge mcmod.info > Fabric), then parses the corresponding metadata file and extracts dependency declarations.
+It helps you quickly answer the everyday questions that pop up while building or fixing a modpack:
 
-## Supported loaders
+- **Clean up mixed mod loaders:** Easily spot and remove leftover Fabric mods in a NeoForge modpack (like when **moving away from Sinytra Connector**).
+- **Separate Client, Server, and Both:** Quickly **identify client-only mods** mixed into a **server folder** so you can purge them before launching.
+- **Find the culprit behind cryptic crashes:** When a crash log gives you an obfuscated Java method call but doesn't mention which mod broke, trace references directly back to the offending JAR.
+- **Catch conflicts before they happen:** Identify duplicate classes or overlapping mixin targets across multiple mods that might collide on startup.
+- **Inspect metadata instantly:** Check mod loaders, dependencies, versions, and internal file lists without manually unzipping every JAR.
 
-| Loader | Sentinel file | Metadata format |
-|--------|---------------|-----------------|
-| Fabric | `fabric.mod.json` | JSON |
-| Forge (mods.toml) | `META-INF/mods.toml` | TOML |
-| NeoForge | `META-INF/neoforge.mods.toml` | TOML |
-| Forge (mcmod.info) | `mcmod.info` | JSON |
-| Bukkit / Spigot | `plugin.yml` | YAML |
-| Paper | `paper-plugin.yml` | YAML |
+### Example of `modcrawl`'s output
 
-Adding a new loader means one new module implementing `ModHandler` and a single `register()` call — no core changes.
+<div align="center">
 
-## Install
+![Modcrawl analyzing Create Mod metadata](./web/static/readme/create-metadata.png)
 
-```bash
-cargo install modcrawl
-```
+</div>
 
-Or download a prebuilt binary from [GitHub Releases](https://github.com/SirCesarium/modcrawl/releases) — the `modcrawl.h` header is shipped as a standalone asset (not inside archives).
 
-## Library
+## Quickstart
 
 ```bash
-cargo add modcrawl --no-default-features
-```
-
-```rust
-use modcrawl::core::identify::identify;
-use modcrawl::core::metadata::read_metadata;
-use modcrawl::core::dep::analyze;
-
-let mod_type = identify("MyMod.jar".as_ref())?;
+# Detect mod loader
+modcrawl type MyMod.jar
 
-let meta = read_metadata("MyMod.jar".as_ref())?;
-println!("{meta}");                                 // human-readable
-println!("{}", serde_json::to_string(&meta)?);       // JSON
+# Inspect metadata and dependencies
+modcrawl deps MyMod.jar
 
-let report = analyze("MyMod.jar".as_ref(), false)?;  // exclude jar-in-jar
-for dep in &report.dependencies {
-    println!("  {} {}", dep.kind.marker(), dep.name);
-}
-```
-
-Reader variants for in-memory buffers:
+# Find duplicate classes causing conflicts
+modcrawl dupes *.jar
 
-```rust
-use std::io::Cursor;
-use modcrawl::core::identify::identify_reader;
-use modcrawl::core::metadata::read_metadata_reader;
-use modcrawl::core::dep::analyze_reader;
-
-let data = std::fs::read("MyMod.jar")?;
-let mut cursor = Cursor::new(&data[..]);
-let mod_type = identify_reader(&mut cursor)?;
+# Search for obfuscated method references across all JARs
+modcrawl grep "net/minecraft/world" *.jar --quiet
 ```
 
-## Dependency analysis
-
-Dependencies are deduplicated by name. When the same dependency appears with different kinds (e.g. `depends` + `recommends`), the higher-priority kind wins:
-
-Required > LoadBefore > Optional > Recommended > Suggested
+## TL;DR - Shut up and let me download
 
-Jar-in-jar entries (`META-INF/jars/*.jar`) are always scanned internally. If a dependency matches a bundled JAR's filename, it's removed from the external dependency list. The `--include-jar-in-jar` flag controls whether the jar-in-jar section appears in the output.
+The binaries are uploaded into the [releases](https://github.com/SirCesarium/modcrawl/releases) section of the GitHub repository. You can download the latest version of `modcrawl` for your platform from there.
 
-## FFI / C bindings
+### Quick downloads
 
-Every core function is exposed as a C-compatible export:
+<div align="center">
 
-| Function | Returns |
-|----------|---------|
-| `modcrawl_identify(path)` | Type string |
-| `modcrawl_identify_bytes(data, len)` | Type string |
-| `modcrawl_metadata(path)` | Human-readable metadata |
-| `modcrawl_metadata_json(path)` | JSON metadata |
-| `modcrawl_metadata_bytes(data, len)` | Human-readable metadata |
-| `modcrawl_metadata_json_bytes(data, len)` | JSON metadata |
-| `modcrawl_deps(path, include_jij)` | Human-readable deps |
-| `modcrawl_deps_json(path, include_jij)` | JSON deps |
-| `modcrawl_deps_bytes(data, len, include_jij)` | Human-readable deps |
-| `modcrawl_deps_json_bytes(data, len, include_jij)` | JSON deps |
-| `modcrawl_classes_json(path)` | JSON list of .class files |
-| `modcrawl_grep_json(path, pattern)` | JSON grep matches |
-| `modcrawl_mixins_json(path)` | JSON list of mixin targets |
-| `modcrawl_dupes_json(paths)` | JSON list of duplicate classes |
-| `modcrawl_free_string(s)` | — (frees returned strings) |
+<a href="https://github.com/SirCesarium/modcrawl/releases/download/v0.11.2/modcrawl-0.11.2-x86_64.msi"><img src="./web/static/readme/windows.png" alt="Modcrawl Windows installer"></a>
+<a href="https://github.com/SirCesarium/modcrawl/releases/download/v0.11.2/modcrawl_0.11.2-1_amd64.deb"><img src="./web/static/readme/debian.png" alt="Modcrawl Debian package"></a>
+<a href="https://github.com/SirCesarium/modcrawl/releases/download/v0.11.2/modcrawl-0.11.2-1.x86_64.rpm"><img src="./web/static/readme/fedora.png" alt="Modcrawl Fedora package"></a>
+<a href="https://github.com/SirCesarium/modcrawl/releases/download/v0.11.2/modcrawl-macos-arm64"><img src="./web/static/readme/macos.png" alt="Modcrawl macOS binary"></a>
 
-The classes, grep, mixins and dupes exports require the `classfile` feature,
-which every published library is built with. `modcrawl_dupes_json` takes a
-null-terminated `char *const *paths` — the canonical call passes a
-`char *paths[]` array:
+</div>
 
-```c
-#include "modcrawl.h"
+The Windows, Debian, and Fedora buttons download installers; macOS downloads the standalone binary. If you have an uncommon architecture (like `Linux ARM64`) you can check the [releases](https://github.com/SirCesarium/modcrawl/releases) page.
 
-char *type = modcrawl_identify("/path/to/MyMod.jar");
-if (type) {
-    printf("Type: %s\n", type);
-    modcrawl_free_string(type);
-}
-
-// Metadata as JSON
-char *json = modcrawl_metadata_json("/path/to/MyMod.jar");
-if (json) {
-    printf("%s\n", json);
-    modcrawl_free_string(json);
-}
-
-// Duplicate classes across JARs
-char *paths[] = {"/path/to/a.jar", "/path/to/b.jar", NULL};
-char *dupes = modcrawl_dupes_json(paths);
-if (dupes) {
-    printf("%s\n", dupes);
-    modcrawl_free_string(dupes);
-}
-```
+Or even check the [Installation](#installation) section.
 
-### Contract
-
-- **Ownership**: every string-returning function hands you a null-terminated C
-  string that must be freed with `modcrawl_free_string` — never with `free()`,
-  the allocation belongs to Rust's allocator. Passing `NULL` to
-  `modcrawl_free_string` is a no-op.
-- **Errors**: `NULL` means an error occurred, and the reason is printed to
-  stderr. A zero-length buffer is also an error.
-- **Interior NULs**: mod metadata can legally contain a NUL character. These
-  are replaced with U+FFFD so a crafted JAR can never turn a successful parse
-  into an error return.
-- **Paths**: `modcrawl_dupes_json` requires valid UTF-8 paths; one that is not
-  is an error, not a silently skipped JAR.
-- **Thread safety**: every function may be called concurrently from any thread.
-- **Panics**: contained. A panic inside the parser is reported on stderr and
-  surfaces as `NULL` instead of aborting your process.
-
-### Using the header
-
-The `modcrawl.h` header ships as a release asset and inside every library
-archive. It compiles as both C and C++, and is generated by
-[cbindgen](https://github.com/mozilla/cbindgen) from `cbindgen.toml`:
-
-```bash
-cbindgen --config cbindgen.toml --crate modcrawl --output modcrawl.h
-```
-
-CI verifies on every push that the header compiles as C and C++ with
-`-Wall -Wextra -Werror`, that it matches the symbols each library actually
-exports, and that a C smoke test runs end to end (`tests/ffi/smoke.c`).
+## Supported loaders
 
-**The header describes a default-features build.** If you compile the crate
-yourself with `--no-default-features`, the `classfile` feature (and with it
-`modcrawl_classes_json`, `modcrawl_grep_json`, `modcrawl_mixins_json` and
-`modcrawl_dupes_json`) is compiled out — the library exports 11 symbols while
-the header declares 15. Every library we publish is built with the default
-features, so this only bites source builds; CI pins the contract so it cannot
-drift silently.
+These are the loaders that `modcrawl` currently supports.
 
-One packaging note: the musl libraries ship a **static library only**
-(`libmodcrawl.a`). Rust drops the cdylib on static-by-default targets and the
-musl toolchain used in CI cannot link a shared object. Every other ABI ships
-both a static and a shared library.
+*Feel free to contribute to the list while opening a **Pull request**!* ❤️
 
-## CLI reference
+| Loader | Status | Type |
+| --- | --- | --- |
+| NeoForge | ✅ | Mods |
+| Fabric | ✅ | Mods |
+| Forge | ✅ | Mods |
+| Forge (legacy `<1.12`) | ✅ | Mods |
+| Quilt | ✅ | Mods |
+| Bukkit | ✅ | Plugins |
+| Paper | Metadata, not dependencies | Plugins |
+| Bungee | Metadata, not dependencies | Plugins |
+| Velocity | Metadata, not dependencies | Plugins |
 
-| Command | Alias | What |
-|---------|-------|------|
-| `type` | `t`, `ty` | Detect mod/plugin type |
-| `metadata` | `meta`, `md` | Read mod metadata (human or `-j` JSON) |
-| `dep` | `d`, `deps`, `dependencies` | Analyze dependencies (`-j` JSON, `--include-jar-in-jar`/`--jij`) |
-| `classes` | `c`, `cls` | List `.class` files with Java version and access flags |
-| `grep` | `g`, `search` | Search constant pool strings across all `.class` files |
-| `mixins` | `m`, `mixin` | Extract `@Mixin` targets from class-level annotations |
-| `dupes` | `dp`, `duplicate` | Find duplicate `.class` entries across multiple JARs |
+## Installation
 
-### `type`
+First, **make sure** you have the **Rust Programming Language** installed on your machine, if not, [click here](https://rust-lang.org/).
 
-Reads from stdin when given no file arguments. Stdin can be raw ZIP bytes (detects EOCD boundaries for `cat *.jar`) or newline-separated file paths.
+### Install with cargo
 
-### `metadata`
+- Just run `cargo install modcrawl` and you're good to go!
 
-Takes one or more JAR paths. Multi-file output prefixes each result with the filename. `--json` / `-j` for compact JSON (one line per file).
+### Build from source
 
-### `dep` / `deps`
+- Clone the repository `git clone https://github.com/SirCesarium/modcrawl.git` and navigate to the `modcrawl` directory.
+- Install `modcrawl` with `cargo install --path .`.
 
-Takes one or more JAR paths. `--json` / `-j` for pretty-printed JSON. `--include-jar-in-jar` / `--jij` to show embedded JARs. Bundled dependencies are always filtered out of the external dependency list regardless of this flag.
+## Library usage
 
-### `classes` (requires `classfile` feature)
+### Rust
 
-Lists every `.class` file inside a JAR with its Java version and access flags.
+Add the crate with Cargo and use the exported detect, metadata, and dependency APIs:
 
+```bash
+cargo add modcrawl
 ```
-$ modcrawl classes MyMod.jar
-  mezz/jei/JustEnoughItems.class    Java 8   public
-  mezz/jei/color/ColorGetter.class  Java 8   public final
-```
-
-`--json` / `-j` for machine-readable output.
 
-### `grep` (requires `classfile` feature)
+```rust
+use std::path::Path;
 
-Searches the **constant pool** of every `.class` file inside a JAR — no decompilation needed. Finds class references, method calls, field accesses, annotations, and raw UTF-8 strings.
+use modcrawl::{analyze, identify, read_metadata};
 
-```
-$ modcrawl grep "func_186724_a" MyMod.jar
-  mezz/jei/color/ColorGetter.class:
-    Utf8: "(Lnet/minecraft/world/IBlockAccess;...)I"
-    MethodRef: "net/minecraft/client/renderer/color/BlockColors.func_186724_a:..."
-
-$ modcrawl grep "net/minecraft/world" *.jar --quiet
-  jei_1.12.2-4.16.1.1013.jar:
-    mezz/jei/color/ColorGetter.class
-    mezz/jei/plugins/vanilla/anvil/AnvilRecipeMaker.class
-```
+fn main() -> modcrawl::Result<()> {
+    let jar = Path::new("MyMod.jar");
 
-Useful for crash investigation: find which mod references an obfuscated function or class without opening a single JAR.
+    println!("{}", identify(jar)?);
+    println!("{}", read_metadata(jar)?);
+    print!("{}", analyze(jar, false)?);
 
-Flags: `--quiet` / `-q` (only show class file names), `--json` / `-j` (JSON output).
+    Ok(())
+}
+```
 
-### `mixins` (requires `classfile` feature)
+### npm
 
-Extracts `@Mixin` targets from SpongePowered mixin annotations at the class level. Parses `RuntimeVisibleAnnotations` / `RuntimeInvisibleAnnotations` attributes and resolves both `value` (Class ref) and `targets` (String ref) element pairs — no decompilation needed.
+The WASM package exposes the same core functionality to JavaScript and TypeScript:
 
-```
-$ modcrawl mixins MyMod.jar
-  some/mod/mixin/ExampleMixin.class ->
-    net/minecraft/world/entity/player/Player
-  another/mod/mixin/TitleScreenMixin.class ->
-    net/minecraft/client/gui/screens/TitleScreen
+```bash
+npm install modcrawl
 ```
 
-`--quiet` / `-q` (only show mixin class names), `--json` / `-j` (JSON output).
+```js
+import init, { identify, metadata_json } from "modcrawl";
 
-### `dupes` (requires `classfile` feature)
+await init();
 
-Finds `.class` files that appear in more than one JAR — useful for detecting classpath conflicts between mods. Uses zip entry listing only, no classfile parsing needed.
-
-By default, output is grouped by conflict pair (two JARs that share classes):
-
-```
-$ modcrawl dupes a.jar b.jar c.jar
-── Classpath Conflicts ──
-
-  a.jar
-  b.jar
-  ── 3 shared classes ──
-    com/example/SomeClass.class
-    com/example/OtherClass.class
-    com/example/ThirdClass.class
+const data = new Uint8Array(await (await fetch("/MyMod.jar")).arrayBuffer());
+console.log(identify(data));
+console.log(metadata_json(data));
 ```
 
-`--by-class` / `-b` groups by class instead (legacy format), showing how many JARs each class appears in:
+## Web
 
-```
-$ modcrawl dupes a.jar b.jar c.jar --by-class
-  com/example/SomeClass.class  (in 2 JARs)
-    a.jar
-    b.jar
-```
-
-`--count` / `-c` shows only a summary:
+There's a **WIP** web version of `modcrawl` that aims to provide all of the features of `modcrawl` in a more user-friendly way and will work completely offline (thanks to `WASM`!). It's still in development (currently there's not even a MVP), so expect some bugs and missing features. Stay tuned in [GitHub Discussions](https://github.com/SirCesarium/modcrawl/discussions) for any major updates :).
+  
+> [!NOTE]
+> There will be a structured documentation when the web version reaches a stable state.
+>
+> The documentation will show a deep overview of all of the commands and the *API Reference* of the **Rust Library** and the **NPM (TypeScript) Library**
 
-```
-$ modcrawl dupes *.jar --count
-Found 42 duplicate classes across 15 JAR files.
-```
+### Web setup
 
-`--json` / `-j` for machine-readable output. Combine with `--count` for a compact JSON summary.
+- Clone the repository `git clone https://github.com/SirCesarium/modcrawl.git` and navigate to the `modcrawl/web` directory.
+- Make sure you have **Bun Runtime** installed on your machine, if not, click [here](https://bun.sh/) to install it.
+- Run `bun install --frozen-lockfile` to install the dependencies.
+- Run `bun run dev` and navigate to `http://127.0.0.1:5173` in your browser.
 
 ## License
 
-MIT
+This project is licensed under the terms of the MIT license. See [LICENSE](./LICENSE) for details.

package/modcrawl.d.ts

@@ -8,7 +8,7 @@
  *
  * Returns a JS exception when the JAR is invalid.
  */
-export function classes_json(data: Uint8Array): string;
+export function classes_json(data: Uint8Array | number[]): string;
 
 /**
  * Analyze dependencies from a ZIP/JAR byte buffer, returning JSON.
@@ -20,7 +20,7 @@ export function classes_json(data: Uint8Array): string;
  *
  * Returns a JS exception when the JAR is invalid or cannot be parsed.
  */
-export function deps_json(data: Uint8Array, include_jij: boolean): string;
+export function deps_json(data: Uint8Array | number[], include_jij: boolean): string;
 
 /**
  * Find duplicate class entries across multiple ZIP/JAR byte buffers,
@@ -43,7 +43,7 @@ export function dupes_json(names: string[], jars: Array<any>): string;
  *
  * Returns a JS exception when the JAR is invalid.
  */
-export function grep_json(data: Uint8Array, pattern: string): string;
+export function grep_json(data: Uint8Array | number[], pattern: string): string;
 
 /**
  * Detect the mod/plugin type from a ZIP/JAR byte buffer.
@@ -52,7 +52,7 @@ export function grep_json(data: Uint8Array, pattern: string): string;
  *
  * Returns a JS exception when the data is not a valid ZIP archive.
  */
-export function identify(data: Uint8Array): string;
+export function identify(data: Uint8Array | number[]): string;
 
 /**
  * Read and parse metadata from a ZIP/JAR byte buffer, returning JSON.
@@ -62,7 +62,7 @@ export function identify(data: Uint8Array): string;
  * Returns a JS exception when the JAR is invalid or its metadata cannot
  * be parsed.
  */
-export function metadata_json(data: Uint8Array): string;
+export function metadata_json(data: Uint8Array | number[]): string;
 
 /**
  * Extract mixin targets from a ZIP/JAR byte buffer, returning JSON.
@@ -71,27 +71,12 @@ export function metadata_json(data: Uint8Array): string;
  *
  * Returns a JS exception when the JAR is invalid.
  */
-export function mixins_json(data: Uint8Array): string;
+export function mixins_json(data: Uint8Array | number[]): string;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
-    readonly modcrawl_classes_json: (a: number) => number;
-    readonly modcrawl_deps: (a: number, b: number) => number;
-    readonly modcrawl_deps_bytes: (a: number, b: number, c: number) => number;
-    readonly modcrawl_deps_json_bytes: (a: number, b: number, c: number) => number;
-    readonly modcrawl_dupes_json: (a: number) => number;
-    readonly modcrawl_free_string: (a: number) => void;
-    readonly modcrawl_grep_json: (a: number, b: number) => number;
-    readonly modcrawl_identify: (a: number) => number;
-    readonly modcrawl_identify_bytes: (a: number, b: number) => number;
-    readonly modcrawl_metadata_bytes: (a: number, b: number) => number;
-    readonly modcrawl_metadata_json_bytes: (a: number, b: number) => number;
-    readonly modcrawl_metadata: (a: number) => number;
-    readonly modcrawl_metadata_json: (a: number) => number;
-    readonly modcrawl_mixins_json: (a: number) => number;
-    readonly modcrawl_deps_json: (a: number, b: number) => number;
     readonly classes_json: (a: number, b: number) => [number, number, number, number];
     readonly deps_json: (a: number, b: number, c: number) => [number, number, number, number];
     readonly dupes_json: (a: number, b: number, c: any) => [number, number, number, number];
@@ -101,10 +86,11 @@ export interface InitOutput {
     readonly mixins_json: (a: number, b: number) => [number, number, number, number];
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __externref_table_dealloc: (a: number) => void;
-    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __externref_table_alloc: () => number;
+    readonly __externref_drop_slice: (a: number, b: number) => void;
     readonly __wbindgen_start: () => void;
 }
 

package/modcrawl.js

@@ -6,7 +6,7 @@
  * # Errors
  *
  * Returns a JS exception when the JAR is invalid.
- * @param {Uint8Array} data
+ * @param {Uint8Array | number[]} data
  * @returns {string}
  */
 export function classes_json(data) {
@@ -39,28 +39,29 @@ export function classes_json(data) {
  * # Errors
  *
  * Returns a JS exception when the JAR is invalid or cannot be parsed.
- * @param {Uint8Array} data
+ * @param {Uint8Array | number[]} data
  * @param {boolean} include_jij
  * @returns {string}
  */
 export function deps_json(data, include_jij) {
-    let deferred3_0;
-    let deferred3_1;
+    let deferred4_0;
+    let deferred4_1;
     try {
+        const val2 = +include_jij;
         const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.deps_json(ptr0, len0, include_jij);
-        var ptr2 = ret[0];
-        var len2 = ret[1];
+        const ret = wasm.deps_json(ptr0, len0, val2);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
         if (ret[3]) {
-            ptr2 = 0; len2 = 0;
+            ptr3 = 0; len3 = 0;
             throw takeFromExternrefTable0(ret[2]);
         }
-        deferred3_0 = ptr2;
-        deferred3_1 = len2;
-        return getStringFromWasm0(ptr2, len2);
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
     }
 }
 
@@ -106,7 +107,7 @@ export function dupes_json(names, jars) {
  * # Errors
  *
  * Returns a JS exception when the JAR is invalid.
- * @param {Uint8Array} data
+ * @param {Uint8Array | number[]} data
  * @param {string} pattern
  * @returns {string}
  */
@@ -114,10 +115,17 @@ export function grep_json(data, pattern) {
     let deferred4_0;
     let deferred4_1;
     try {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
+        let ptr0, len0, ptr1, len1;
+        try {
+            ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+            len0 = WASM_VECTOR_LEN;
+            ptr1 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            len1 = WASM_VECTOR_LEN;
+        } catch (e) {
+            if (ptr1) { wasm.__wbindgen_free(ptr1, len1 * 1, 1); }
+            if (ptr0) { wasm.__wbindgen_free(ptr0, len0 * 1, 1); }
+            throw e;
+        }
         const ret = wasm.grep_json(ptr0, len0, ptr1, len1);
         var ptr3 = ret[0];
         var len3 = ret[1];
@@ -139,7 +147,7 @@ export function grep_json(data, pattern) {
  * # Errors
  *
  * Returns a JS exception when the data is not a valid ZIP archive.
- * @param {Uint8Array} data
+ * @param {Uint8Array | number[]} data
  * @returns {string}
  */
 export function identify(data) {
@@ -170,7 +178,7 @@ export function identify(data) {
  *
  * Returns a JS exception when the JAR is invalid or its metadata cannot
  * be parsed.
- * @param {Uint8Array} data
+ * @param {Uint8Array | number[]} data
  * @returns {string}
  */
 export function metadata_json(data) {
@@ -200,7 +208,7 @@ export function metadata_json(data) {
  * # Errors
  *
  * Returns a JS exception when the JAR is invalid.
- * @param {Uint8Array} data
+ * @param {Uint8Array | number[]} data
  * @returns {string}
  */
 export function mixins_json(data) {
@@ -226,48 +234,47 @@ export function mixins_json(data) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
+        __wbg_Error_208446807d0d1e30: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_7ce8eee7fd327545: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             var len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+            getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32((arg0 >>> 0) + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+        __wbg___wbindgen_throw_4c88d8bf264fd984: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
+        __wbg_get_unchecked_e6325ad374eff861: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_length_7f3c00c40364105e: function(arg0) {
+        __wbg_length_186163212ffe79c3: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_d4bdea10311bd9cf: function(arg0) {
+        __wbg_length_b03a0fabb109b1e9: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_new_1dbf7428bba60a42: function(arg0) {
+        __wbg_new_13de428334042d26: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_13162965d1fe7aa3: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
         __wbindgen_init_externref_table: function() {
             const table = wasm.__wbindgen_externrefs;
-            const offset = table.grow(4);
             table.set(0, undefined);
-            table.set(offset + 0, undefined);
-            table.set(offset + 1, null);
-            table.set(offset + 2, true);
-            table.set(offset + 3, false);
+            table.set(1024, undefined);
+            table.set(1025, null);
+            table.set(1026, true);
+            table.set(1027, false);
         },
     };
     return {
@@ -296,7 +303,8 @@ function getDataViewMemory0() {
 }
 
 function getStringFromWasm0(ptr, len) {
-    return decodeText(ptr >>> 0, len);
+    ptr = ptr >>> 0;
+    return decodeText(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
 let cachedUint8ArrayMemory0 = null;
@@ -371,18 +379,18 @@ function takeFromExternrefTable0(idx) {
     return value;
 }
 
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
 cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
 let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
+function decodeText(bytes) {
+    numBytesDecoded += bytes.length;
     if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true });
         cachedTextDecoder.decode();
-        numBytesDecoded = len;
+        numBytesDecoded = bytes.length;
     }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+    return cachedTextDecoder.decode(bytes);
 }
 
 const cachedTextEncoder = new TextEncoder();
@@ -470,9 +478,17 @@ function initSync(module) {
     return __wbg_finalize_init(instance, module);
 }
 
+let __wbg_init_promise;
 async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
+    if (__wbg_init_promise === undefined) {
+        __wbg_init_promise = __wbg_init_once(module_or_path);
+        __wbg_init_promise.catch(() => { __wbg_init_promise = undefined; });
+    }
+    return __wbg_init_promise;
+}
 
+async function __wbg_init_once(module_or_path) {
 
     if (module_or_path !== undefined) {
         if (Object.getPrototypeOf(module_or_path) === Object.prototype) {

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "modcrawl",
   "type": "module",
+  "collaborators": [
+    "Cesarium <239650612+SirCesarium@users.noreply.github.com>"
+  ],
   "description": "Detect, inspect, and analyze Minecraft mods and plugins from JAR files",
-  "version": "0.10.2",
+  "version": "0.11.2",
   "license": "MIT",
   "repository": {
     "type": "git",