stash-clipboard (0.5.0-1)

Published 2026-08-22 11:39:59 +02:00 by BaumSplitter41 in BaumSplitter41/deb-packages

Setup this registry from the command line:

sudo curl  -o /etc/apt/keyrings/forgejo-BaumSplitter41.asc
echo "deb [signed-by=/etc/apt/keyrings/forgejo-BaumSplitter41.asc]  $distribution $component" | sudo tee -a /etc/apt/sources.list.d/forgejo.list
sudo apt update

Choose $distribution and $component from the list below.

To install the package, run the following command:

sudo apt install stash-clipboard=0.5.0-1

For more information on the Debian registry, see the documentation.

Distributions	bookworm, jammy, noble, trixie
Components	main
Architectures	amd64

Wayland clipboard "manager" with fast persistent history and multi-media support  . <h1 id="header" align="center"> <pre>Stash</pre> </h1> . <div align="center"> <a alt="CI Status" href="https://github.com/NotAShelf/stash/actions"> <img src="https://github.com/NotAShelf/stash/actions/workflows/ci.yml/badge.svg" alt="CI Status" /> </a> <a alt="Dependencies" href="https://deps.rs/repo/github/notashelf/stash"> <img src="https://deps.rs/repo/github/notashelf/stash/status.svg" alt="Dependency Status" /> </a> <a alt="CodeQL Scan" href="https://github.com/NotAShelf/stash/actions/workflows/github-code-scanning/codeql"> <img src="https://github.com/NotAShelf/stash/actions/workflows/github-code-scanning/codeql/badge.svg" alt="CodeQL Scan" /> </a> </div> . <div align="center"> Lightweight & feature-rich Wayland clipboard "manager" with fast persistent history, robust multi-media support, encryption and more. Stash stores and previews clipboard entries (text, images) on the clipboard with a neat TUI and advanced scripting capabilities for your integration needs. </div> . <div align="center"> <br/> <a href="#features">Features</a><br/> <a href="#installation">Installation</a> | <a href="#usage">Usage</a> | <a href="#usage">Motivation</a></br> <a href="#tips--tricks">Tips and Tricks</a> <br/> </div> . ## Features . Stash is simple in design, and lightweight during operation but it remains a feature-rich clipboard management utility with _many_ features such as but necessarily limited to: . - Automatic MIME detection for stored entries - Fast persistent storage using SQLite - List, search, decode, delete, and wipe clipboard history with ease - Backwards compatible with Cliphist TSV format - Import clipboard history from TSV (e.g., from `cliphist list`) - Image preview (shows dimensions and format) - Text previews with customizable width - De-duplication, whitespace prevention and entry limit control - Automatic clipboard monitoring with [`stash watch`](#watch-clipboard-for-changes-and-store-automatically) - Configurable auto-expiry of old entries in watch mode as a safety buffer - Drop-in replacement for `wl-clipboard` tools (`wl-copy` and `wl-paste`) - Sensitive clipboard filtering via regex (see below) - Sensitive clipboard filtering by application (see below) - Password manager hint filtering (`x-kde-passwordManagerHint`) - Optional at-rest encryption for database entries using age . on top of the existing features of Cliphist, which are as follows: . - Write clipboard changes to a history file. - Recall history with dmenu, rofi, wofi (or whatever other picker you like). - Both text and images are supported. - Clipboard is preserved byte-for-byte. - Leading/trailing whitespace, no whitespace, or newlines are preserved. - Won’t break fancy editor selections like Vim wordwise, linewise, or block mode. . Most of Stash's usage is documented in the [usage section](#usage) for more details. Refer to the [Tips & Tricks section](#tips--tricks) for more "advanced" features, or conveniences provided by Stash. . ## Installation . ### With Nix . Nix is the _recommended_ method for downloading (and developing!) Stash. As of 26.11 , Stash is available as `pkgs.stash-clipboard` in Nixpkgs. You may use the NixOS module: . ```nix { services.stash-clipboard.enable = true; } ``` . Alternatively, you may install it using Nix flakes using `nix profile add` if on non-nixos or add Stash as a flake input if you are on NixOS. . ```nix { # Add Stash to your inputs like so inputs.stash.url = "github:NotAShelf/stash"; . outputs = { /* ... */ }; } ``` . Then you can get the package from your flake input, and add it to your packages to make `stash` available in your system. . ```nix {inputs, pkgs, ...}: let stashPkg = inputs.stash.packages.${pkgs.stdenv.hostPlatform}.stash; in { services.stash-clipboard = { enable = true; package = stashPkg; }; } ``` . If you want to give Stash a try before you switch to it, you may also run it one time with `nix run`. . ```sh # Run directly from the git repository; will be garbage collected $ nix run github:NotAShelf/stash -- watch && # start the watch daemon in the background . # Then once you copy something, retrieve it from the CLI: $ nix run github:NotAShelf/stash -- list --format tsv # emit --format for a TUI ``` . ### Without Nix . [GitHub Releases]: https://github.com/notashelf/stash/releases . You can also install Stash on any of your systems _without_ using Nix. New releases are made when a version gets tagged, and are available under [GitHub Releases]. To install Stash on your system without Nix, either: . - Download a tagged release from [GitHub Releases] for your platform and place the binary in your `$PATH`. Instructions may differ based on your distribution, but generally you want to download the built binary from releases and put it somewhere like `/usr/bin` or `~/.local/bin` depending on your distribution. - Build and install from source with Cargo: . ```bash # Install Stash from crates.io using the latest published version $ cargo install stash-clipboard --locked ``` . Additionally, you may get Stash from source via `cargo install` using `cargo install --git https://github.com/notashelf/stash --locked` or you may check out to the repository, and use Cargo to build it. You'll need Rust 1.95.0 or above. Most distributions should package this version already. You may, of course, prefer to package the built releases if you'd like. . ## Usage . > [!IMPORTANT] > It is not a priority to provide 1:1 backwards compatibility with Cliphist. > While the interface is generally similar, Stash chooses to build upon > Cliphist's design and extend existing design choices. See > [Migrating from Cliphist](#migrating-from-cliphist) for more details. Refer to > help text if confused. . The command interface of Stash is _only slightly_ different from Cliphist. In most cases, you may simply replace `cliphist` with `stash` and your commands, aliases or scripts will continue to work as intended. . Some of the commands allow further fine-graining with flags such as `--type` or `--format` to allow specific input and output specifiers. See `--help` for individual subcommands if in doubt. .  . ```console $ stash help Wayland clipboard manager . Usage: stash [OPTIONS] [COMMAND] . Commands: store Store clipboard contents list List clipboard history decode Decode and output clipboard entry by id delete Delete clipboard entry by id (if numeric), or entries matching a query (if not). Numeric arguments are treated as ids. Use --type to specify explicitly db Database management operations import Import clipboard data from stdin (default: TSV format) watch Start a process to watch clipboard for changes and store automatically help Print this message or the help of the given subcommand(s) . Options: --max-items <MAX_ITEMS> Maximum number of clipboard entries to keep [default: 18446744073709551615] --max-dedupe-search <MAX_DEDUPE_SEARCH> Number of recent entries to check for duplicates when storing new clipboard data [default: 20] --min-size <MIN_SIZE> Minimum size (in bytes) for clipboard entries. Entries smaller than this will not be stored [env: STASH_MIN_SIZE=] --max-size <MAX_SIZE> Maximum size (in bytes) for clipboard entries. Entries larger than this will not be stored. Defaults to 5MB [env: STASH_MAX_SIZE=] [default: 5000000] --preview-width <PREVIEW_WIDTH> Maximum width (in characters) for clipboard entry previews in list output [default: 100] --db-path <DB_PATH> Path to the `SQLite` clipboard database file [env: STASH_DB_PATH=] --excluded-apps <EXCLUDED_APPS> Application names to exclude from clipboard history [env: STASH_EXCLUDED_APPS=] --ask Ask for confirmation before destructive operations -v, --verbose... Increase logging verbosity -q, --quiet... Decrease logging verbosity -h, --help Print help -V, --version Print version ``` .  . ### Store an entry . ```bash # Copy something to your clipboard from the terminal $ echo "some clipboard text" | stash store ``` . ### List entries . ```bash # List all entries in the database in a TUI (interactive terminals) or in TSV # format in non-interactive environments, e.g., your Bash scripts. $ stash list ``` . Stash list will list all entries in an interactive TUI that allows navigation and copying/deleting entries. This behaviour is EXCLUSIVE TO TTYs and Stash will display entries in Cliphist-compatible TSV format in Bash scripts. You may also enforce the output format with `stash list --format <tsv | json>`. . You may also view your clipboard _with the addition of expired entries_, i.e., entries that have reached their TTL and are marked as expired, using the `--expired` flag as `stash list --expired`. Expired entries are not cleaned up when using this flag, allowing you to inspect them before running cleanup. . ### Decode an entry by ID . ```bash # Decode an entry with its given ID $ stash decode <input ID> ``` . > [!TIP] > Decoding from dmenu-compatible tools: > > ```bash > # Display decoded entries in your own picker > $ stash list | tofi | stash decode > ``` . ### Delete entries matching a query . ```bash # Delete an entry by ID or exact query match $ stash delete --type [id | query] <text or ID> ``` . By default stash will try to guess the type of an entry, but this may not be desirable for all users. If you wish to be explicit, pass `--type` to `stash delete`. . ### Delete multiple entries by ID (from a file or stdin) . ```bash # Delete all IDs from a given file $ stash delete --type id < ids.txt ``` . ### Database management . Stash provides a `db` subcommand for database maintenance operations: . ```bash # Common database maintenance commands $ stash db wipe [--expired] [--ask] $ stash db vacuum $ stash db stats ``` . - `stash db wipe`: Remove all entries from the database. Use `--expired` to only wipe expired entries instead of all entries. Use `--ask` or global `--ask` when you want an interactive confirmation prompt. - `stash db vacuum`: Optimize the database using SQLite's VACUUM command, reclaiming space and improving performance. - `stash db stats`: Display database statistics including total/active/expired entry counts, encrypted/undecryptable entry counts, storage size, and page information. . ### Watch clipboard for changes and store automatically . ```bash # Start a Wayland clipboard watcher to forward Wayland clipboard entries # to the database. $ stash watch ``` . This runs a daemon that monitors the clipboard and stores new entries automatically. This is designed as an alternative to shelling out to `wl-paste --watch` inside a Systemd service or XDG autostart. You may find a premade Systemd service in `contrib/`. Packagers are encouraged to vendor the service unless adding their own. . #### Automatic Clipboard Clearing on Expiration . When `stash watch` is running and a clipboard entry expires, Stash will detect if the current clipboard still contains that expired content and automatically clear it. This prevents stale data from remaining in your clipboard after an entry has expired from history. . > [!NOTE] > This behavior only applies when the watch daemon is actively running. Manual > expiration or deletion of entries will not clear the clipboard. . #### MIME Type Preference for Watch . `stash watch` supports a `--mime-type` (short `-t`) option that lets you prioritise which MIME type the daemon should request from the clipboard when multiple representations are available. . - `any` (default): Request any available representation (current behaviour). - `text`: Prefer text representations (e.g. `text/plain`, `text/html`). - `image`: Prefer image representations (e.g. `image/png`, `image/jpeg`) so that image copies from browsers or file managers are stored as images rather than HTML fragments. . Example: prefer images when running the watch daemon . ```bash # You may override Stash's built-in priority and MIME type detection with # `--mime-type` to `stash watch`. $ stash watch --mime-type image ``` . This is useful when copying images from browsers or file managers where the clipboard may offer both HTML and image representations; selecting `image` will ask the compositor for image data first. Most users will be fine using the default value (`any`) but in the case your browser (or other applications!) regularly misrepresent data, you might wish to prioritize a different type. . #### Clipboard Persistence . By default, when you copy something and close the source application, Wayland clears the clipboard. Stash can optionally keep the clipboard contents available after the source closes using the `--persist` flag. . ```bash # Persist the clipboard data after the source app is closed. $ stash watch --persist ``` . When enabled, Stash will fork a background process to serve the clipboard contents, keeping them available even after the original application exits. . > [!NOTE] > This feature is **opt-in** and disabled by default, as it may not be desirable > for all users and can leave clipboard data in memory longer than expected. You > must start the `stash watch` daemon with `--persist` for clipboard > persistence. . ### Options . Some commands take additional flags to modify Stash's behavior. See each commands `--help` text for more details. The following are generally standard: . - `--db-path <path>`: Custom database path - `--max-items <N>`: Maximum number of entries to keep (oldest trimmed) - `--max-dedupe-search <N>`: Deduplication window size - `--preview-width <N>`: Text preview max width for `list` - `--version`: Print the current version and exit . ### Sensitive Clipboard Filtering . Stash can be configured to avoid storing clipboard entries that match a sensitive pattern, using a regular expression. This is useful for preventing accidental storage of secrets, passwords, or other sensitive data. You don't want sensitive data ending up in your persistent clipboard, right? . The filter can be configured in several ways, as part of three separate features. . #### Clipboard Filtering by Entry Regex . This can be configured in several ways. The simplest is the **environment variable** `STASH_SENSITIVE_REGEX` set to a valid regex pattern; if the clipboard text matches, it will not be stored. Useful for trivial secrets such as GitHub tokens or secrets that follow a rule. You would typically set this in your `~/.bashrc` or similar, but in some cases this might be a security flaw. . The less-insecure alternatives are: . - `STASH_SENSITIVE_REGEX_FILE`: read the regex from a file path. Useful with NixOS secrets managers like agenix or sops-nix. . ```bash export STASH_SENSITIVE_REGEX_FILE=/run/secrets/stash/clipboard_filter ``` . - `STASH_SENSITIVE_REGEX_COMMAND`: execute a shell command whose stdout is the regex pattern. Works well with password managers. . ```bash export STASH_SENSITIVE_REGEX_COMMAND="pass show stash/clipboard-filter" ``` . The safest option is **Systemd LoadCredential**. If Stash is running as a Systemd service, you can provide a regex pattern using a credential file. For example, add to your `stash.service`: . ```dosini LoadCredential=clipboard_filter:/etc/stash/clipboard_filter ``` . The file `/etc/stash/clipboard_filter` should contain your regex pattern (no quotes). This is done automatically in the [vendored Systemd service](./contrib/stash.service). Remember to set the appropriate file permissions if using this option. . The service will check the credential file first, then the command, then the file path, then the environment variable. If a clipboard entry matches the regex, it will be skipped and a warning will be logged. . > [!TIP] > **Example regex to block common password patterns**: > > `(password|secret|api[_-]?key|token)[=: ]+[^\s]+` > > For security reasons, you are recommended to use the regex only for generic > tokens that follow a specific rule, for example a generic prefix or suffix. . #### Clipboard Filtering by Application Class . Stash allows blocking an entry from the persistent history if it has been copied from certain applications. This depends on the `use-toplevel` feature flag and uses the the `wlr-foreign-toplevel-management-v1` protocol for precise focus detection. While this feature flag is enabled (the default) you may use `--excluded-apps` in, e.g., `stash watch` or set the `STASH_EXCLUDED_APPS` environment variable to block entries from persisting in the database if they are coming from your password manager for example. The entry is still copied to the clipboard, but it will never be put inside the database. . This is a focused-window alternative to using the regex method above, since you likely do not want to catch your passwords with a regex. Pass your password manager's **window class** to `--excluded-apps` and entries copied while that window is focused will be skipped. . > [!TIP] > **Example startup command for Stash daemon**: > > ```bash > # Exclude entries from applications matching this application **class**. > $ stash --excluded-apps Bitwarden watch > ``` . #### Clipboard Filtering by Password Manager Hint . Stash automatically skips entries whose clipboard offer includes the `x-kde-passwordManagerHint` MIME type. This is the convention used by KeePassXC and compatible password managers to signal that clipboard content is sensitive and should not be persisted. . No configuration is required. If the hint is present in the clipboard offer, the entry is dropped before storage. The entry is still available in your clipboard; it is only excluded from the persistent database. . > [!NOTE] > This filter only applies via the watch daemon (`stash watch`), where MIME type > metadata is available from the Wayland clipboard protocol. Manual > `stash store` invocations do not have this context and are not filtered. . ### Database Encryption . Stash supports encrypting clipboard entries at rest using the [age](https://age-encryption.org/) encryption format. . Encryption is **opt-in** and only activates when a passphrase is configured. When one is configured, all new entries are encrypted before storage and decrypted transparently on retrieval. Entries stored without encryption remain as plaintext. Only new entries written after configuring encryption are encrypted. . > [!WARNING] > Removing the passphrase after encrypted entries have been stored leaves those > entries permanently unreadable. There is no migration path short of wiping the > database. `stash db stats` reports affected entries as Undecryptable. > > Full-text search (`stash delete --type query`, TUI search) operates on raw > database contents. Encrypted entries will not match any search query. . #### Configuration . Provide a passphrase in one of these ways (checked in order): . 1. **Systemd LoadCredential** (safest): add to `stash.service`: . ```dosini LoadCredential=stash_encryption_passphrase:/etc/stash/encryption_passphrase ``` . 2. **Command**, stdout of a shell command: . ```bash export STASH_ENCRYPTION_PASSPHRASE_COMMAND="pass show stash/encryption-key" ``` . 3. **File**, path to a file containing the passphrase: . ```bash export STASH_ENCRYPTION_PASSPHRASE_FILE=/run/secrets/stash/encryption_passphrase ``` . 4. **Environment variable** (least secure): . ```bash export STASH_ENCRYPTION_PASSPHRASE="your-secure-passphrase" ``` . > [!TIP] > Back up your passphrase. Encrypted entries cannot be recovered without it. . ## Motivation . I've been a long-time user of Cliphist. You can probably tell by the number of times it has been mentioned in the README, if not for the attributions section, that Stash is _clearly_ inspired and adapted from it. It's actually a great clipboard manager if your needs are simple, but mine aren't. I need an **all-in-one** solution, that I can freely hack on, with simple solutions to complex problems that I've had with managing my clipboard. I wanted it to be scriptable _and_ interactive, I wanted it to be performant, I wanted it to be... . You get the point. Perhaps you also share similar needs, or just like Rust software in general on your desktop. In either case, Stash hopes to serve as an excellent clipboard manager for your needs, with _excellent_ performance. . ## Tips & Tricks . ### Migrating from Cliphist . Stash was designed to be a drop-in replacement for Cliphist, with only minor improvements. If you are migrating from Cliphist, here are a few things you should know. . - Most Cliphist commands have direct equivalents in Stash. For example, `cliphist store` -> `stash store`, `cliphist list` -> `stash list`, etc. - Cliphist uses `delete-query`; in Stash, you must use `stash delete --type query "your query"`. - Both Cliphist and Stash support deleting by ID, including from stdin or a file. - Stash respects the `STASH_CLIPBOARD_STATE` environment variable for sensitive/clear entries, just like Cliphist. The `STASH_` prefix is added for granularity, you must update your scripts. - You can export your Cliphist history to TSV and import it into Stash (see below). - Stash supports text and image previews, including dimensions and format. - Stash adds a `watch` command to automatically store clipboard changes. This is an alternative to `wl-paste --watch cliphist list`. You can avoid shelling out and depending on `wl-paste` as Stash implements it through `wl-clipboard-rs` crate and provides its own `wl-copy` and `wl-paste` binaries. . ### TSV Export and Import . Both Stash and Cliphist support TSV format for clipboard history. You can export from Cliphist and import into Stash, or use Stash to export TSV for interoperability. . **Export TSV from Cliphist:** . ```bash # Export Cliphist's database $ cliphist list --db ~/.cache/cliphist/db > cliphist.tsv ``` . **Import TSV into Stash:** . ```bash # Read and import the TSV file produced by Cliphist $ stash import < cliphist.tsv ``` . **Export TSV from Stash:** . ```bash # Export Stash's clipboard database as a TSV $ stash list > stash.tsv ``` . **Import TSV into Cliphist:** . ```bash # Import Stash's clipboard data into Cliphist $ cliphist --import < stash.tsv ``` . ### More Tricks . Here are some other tips for Stash that are worth documenting. If you have figured out something new, e.g. a neat shell trick, feel free to add it here! . 1. You may use `stash list` to view your clipboard history in an interactive TUI. This is obvious if you have ever ran the command, but here are some things that you might not have known. - `stash list` displays the TUI _only_ if the user is in an interactive TTY. If it is invoked in, e.g., a Bash script, `stash list` **will output TSV**. - You can change the format with `--format` to e.g. JSON but you can also force a TSV format inside an interactive session with `--format tsv`. - `stash list` displays the mime type for newly recorded entries, but it will not be able to display them for entries imported by Cliphist since Cliphist never made a record of this data. 2. You can pipe `cliphist list --db ~/.cache/cliphist/db` to `stash import --type tsv` to mimic importing from STDIN. . ```bash # Best-effort importing from `cliphist list` $ cliphist list --db ~/.cache/cliphist/db | stash import ``` . 3. Stash provides common-compatible `wl-copy` and `wl-paste` implementations backed by `wl-clipboard-rs`. The Nix package links `stash` as `stash-copy`, `stash-paste`, `wl-copy`, and `wl-paste` in `$out/bin`. Other package managers may need to add equivalent links; when building from source, link `target/release/stash` manually. . ### Entry Expiration . Stash supports time-to-live (TTL) for clipboard entries. When an entry's expiration time is reached, it is marked as expired rather than immediately deleted. This allows for inspection of expired entries and automatic clipboard cleanup. . #### How Expiration Works . When `stash watch` is running with `--expire-after`, it monitors the clipboard and processes expired entries periodically. Upon expiration: . 1. The entry's `is_expired` flag is set to `1` in the database 2. If the current clipboard content matches the expired entry, Stash clears the clipboard to prevent pasting stale data 3. Expired entries are excluded from normal list operations unless `--expired` is specified . > [!NOTE] > By default, entries do not expire. Use `stash watch --expire-after DURATION` > to enable expiration (e.g., `--expire-after 24h` for 24-hour TTL). . #### Viewing Expired Entries . Use `stash list --expired` to include expired entries in the output. This is useful for: . - Inspecting what has expired from your clipboard history - Verifying that sensitive data has been properly expired - Debugging expiration behavior . ```bash # View all entries including expired ones $ stash list --expired . # View expired entries in JSON format $ stash list --expired --format json ``` . #### Cleaning Up Expired Entries . The watch daemon automatically cleans up expired entries when it processes them. For manual cleanup, use: . ```bash # Remove all expired entries from the database $ stash db wipe --expired ``` . > [!NOTE] > If you have a large number of expired entries, consider running > `stash db vacuum` afterward to reclaim disk space. . #### Automatic Clipboard Clearing . When `stash watch` is running and an entry expires, Stash checks if the current clipboard still contains that expired content. If it matches, Stash clears the clipboard automatically. This prevents accidentally pasting outdated content. . > [!TIP] > This behavior only applies when the watch daemon is actively running. Manual > expiration or deletion of entries will not clear the clipboard. . #### Database Maintenance . Stash uses SQLite for persistent storage. Over time, deleted entries and fragmentation can affect performance. Use the `stash db` command to maintain your database: . Stash opens SQLite in WAL mode with `synchronous=NORMAL`, which is a balanced default for desktop clipboard history: writes stay fast while avoiding the data-loss profile of an in-memory journal. . - **Check statistics**: `stash db stats` shows entry counts and storage usage. Use this to monitor growth and decide when to clean up. - **Remove expired entries**: `stash db wipe --expired` removes entries that have reached their TTL. The daemon normally handles this, but this is useful for manual cleanup. - **Optimize storage**: `stash db vacuum` runs SQLite's VACUUM command to reclaim space and defragment the database. This is safe to run periodically. . It is recommended to run `stash db vacuum` occasionally (e.g., monthly) to keep the database compact, especially after deleting many entries. You can, of course, wipe the database entirely if it has grown too large. . ## Attributions . My thanks go first to [@YaLTeR](https://github.com/YaLTeR/) for the [wl-clipboard-rs](https://github.com/YaLTeR/wl-clipboard-rs) crate. Stash is powered by [several crates](./Cargo.toml), but none of them were as detrimental in Stash's design process. . Secondly, but by no means less importantly, I would like to thank [cliphist](https://github.com/sentriz/cliphist) for the excellent reference it has provided to me as a "solid clipboard manager." The interface of Stash is inspired by Cliphist, and it has served me very well for a very long time. . Additional and definitely heartfelt thanks to my testers, who have tested earlier versions of Stash, helped with packaging and provided feedback. Thank you :) . ## License .  . This project is made available under Mozilla Public License (MPL) version 2.0. See [LICENSE](LICENSE) for more details on the exact conditions. An online copy is provided [here](https://www.mozilla.org/en-US/MPL/2.0/). .

libc6 (>= 2.39)

Details

Debian

BaumSplitter41/deb-packages

2026-08-22 11:39:59 +02:00

NotAShelf

Project website

7.4 MiB

Assets (4)

stash-clipboard_0.5.0-1_amd64.deb 1.9 MiB