commit ea385b5366bb95ecea597734feac3f1e2d365fe0
Author: ZDDC <caseywitt@proton.me>
Date:   Mon Apr 27 11:05:47 2026 -0500

    Initial commit
    
    ZDDC — Zero Day Document Control. A file-naming convention plus five
    single-file HTML tools (archive, transmittal, classifier, mdedit,
    landing) and an optional Go HTTP server (zddc-server) with ACL and a
    virtual archive index. Self-contained, offline-capable, dependency-free.
    
    See README.md for an overview, AGENTS.md and ARCHITECTURE.md for the
    build/release/architecture detail, bootstrap/README.md for the
    two-level deployment install pattern, and zddc/README.md for the
    HTTP server.

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..cfe51ec
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,29 @@
+tossme/
+examples/
+.env
+.vscode
+
+# Session planning (never public)
+PLAN.md
+
+# Node dependencies
+node_modules/
+
+# Test report and results
+playwright-report/
+test-results/
+
+# Build artifacts
+# NOTE: dist/ is listed here but each tool's dist/*.html is force-tracked in git
+# (added with `git add -f tool/dist/tool.html`). This is intentional — built artifacts
+# are committed alongside source so users can download them directly from the repo.
+# New tool dist files must be force-added: git add -f tool/dist/tool.html
+dist/
+
+# IDE and project files
+.opencode/
+opencode.json
+package-lock.json
+zddc-knowledge*.json
+zddc-knowledge*.md
+zddc-knowledge*.html
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..6a5df51
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,264 @@
+# AGENTS.md — ZDDC
+
+## Commands
+
+```bash
+# Build all tools (writes to dist/ only)
+sh build.sh
+
+# Build single tool
+sh tool/build.sh              # archive | transmittal | classifier | mdedit | landing
+
+# Cut a stable release (auto-increments patch version, tags, writes to website/releases/)
+sh tool/build.sh --release
+sh tool/build.sh --release 1.2.0      # explicit version
+
+# Cut an alpha/beta channel build (mutable, no git tag)
+sh tool/build.sh --release alpha
+sh tool/build.sh --release beta
+
+# Release all tools at once
+sh build.sh --release [version|alpha|beta]
+
+# Test all tools
+npm test
+
+# Test single tool
+npx playwright test tool        # archive | transmittal | classifier | mdedit
+
+# Dev server (cache-busting HTTP, on port 8000)
+./dev-server start
+./dev-server stop
+```
+
+No lint, typecheck, or format commands exist — the project is plain sh + vanilla JS.
+
+## Architecture
+
+Five independent single-file HTML tools (`archive`, `transmittal`, `classifier`, `mdedit`, `landing`). Each compiles to one self-contained `.html` in `dist/` with all CSS and JS inlined — the first four name their output `dist/tool.html`; `landing` writes `dist/index.html` (it's served at `/` by `zddc-server`). Tools share a small set of canonical helpers in `shared/` (filename parsing, ZDDC filter UI, theme, help) — see "Shared modules" below.
+
+```
+tool/
+  css/           source stylesheets (concatenated in order)
+  js/            vanilla JS IIFEs (concatenated in order)
+  template.html  placeholder markers: {{CSS_PLACEHOLDER}}, {{JS_PLACEHOLDER}}, {{BUILD_LABEL}}
+  build.sh       assembles dist/tool.html
+  dist/tool.html generated output — committed with `git add -f`
+
+shared/
+  base.css        CSS tokens and primitives included first by every tool's CSS build
+  zddc.js         canonical filename/folder/revision parsers, formatters, status validation
+  zddc-filter.js  shared ZDDC project/status filter UI module
+  theme.js        light/dark theme switcher
+  help.js         shared help dialog module
+  build-lib.sh    POSIX sh helpers (ensure_exists, concat_files, build_timestamp)
+                  sourced by every tool's build.sh via: . "$root_dir/../shared/build-lib.sh"
+
+website/
+  index.html                       current stable landing (root URL)
+  releases/
+    <tool>_v<X>.<Y>.<Z>.html       immutable stable release archives
+    <tool>_latest.html  -> ...     symlink to current stable (highest semver)
+    <tool>_alpha.html              mutable; overwritten by --release alpha
+    <tool>_beta.html               mutable; overwritten by --release beta
+  install.zip                      drop-in self-contained install (5 stable HTMLs + _template/ stubs)
+  track-latest.zip                 level-2 stubs that track the current-stable channel
+  track-alpha.zip                  level-2 stubs that track the alpha channel
+  track-beta.zip                   level-2 stubs that track the beta channel
+
+bootstrap/
+  level1.html.tmpl   per-project bootstrap template (relative ../<tool>.html)
+  level2.html.tmpl   level-2 channel-tracking bootstrap template
+  README.md          install / channel / pin docs
+```
+
+**Critical:** `dist/` files are gitignored but force-committed (`git add -f`). Never edit them directly.
+
+## Shared CSS (`shared/base.css`)
+
+Included as the **first** positional arg to every tool's `concat_files` CSS call. Provides:
+- `:root` CSS custom properties — `--primary`, `--bg`, `--text`, `--border`, `--font`, etc.
+- Brand color: `--primary: #2a5a8a` (matches zddc.varasys.io)
+- Button primitive: `.btn`, `.btn-primary`, `.btn-secondary`, `.btn-sm`, `.btn-lg`, `.btn-link`
+- `.app-header` + `.app-header__title` chrome rules
+- `.build-timestamp`, `.hidden`, `.truncate`, webkit scrollbars
+
+**Do not** define these in any tool's own CSS — they come from shared.
+
+**Toast CSS** lives in `classifier/css/base.css` only (classifier is the only tool that uses toasts).
+
+## Transmittal CSS quirks
+
+- `transmittal/css/base.css` overrides `html { font-size: 16px }` inside `@media screen` — this must stay. `shared/base.css` sets `14px`; transmittal's floating labels are rem-based and were designed for 16px.
+- The floating label position is defined in `transmittal/css/forms.css`, not Tailwind classes. If adding new Tailwind classes to `template.html`, add them to `transmittal/css/utilities.css` too — there is no Tailwind build step.
+
+## Build system rules
+
+- Every `build.sh` sources `shared/build-lib.sh` first (provides `ensure_exists`, `concat_files`, `build_timestamp`). Set `root_dir` before sourcing.
+- Build scripts use **POSIX sh** (`#!/bin/sh` with `set -eu`), not bash.
+- `concat_files` accepts **positional args only** (not array names).
+- `awk` processes `template.html`, replacing `{{PLACEHOLDER}}` markers and stripping CDN `<script>`/`<link>` tags (pattern: `https?://`)
+- `{{BUILD_LABEL}}` is substituted in all five tools via `gsub` in awk (use `gsub`, not `print` — the placeholder is inline in an HTML line). Value is `Built: <timestamp> BETA` for dev builds, `v<version>` for stable releases, and `<channel> · <date> · <sha>` for alpha/beta channel builds; computed before the awk step. The shared `is_red` flag controls whether the label is wrapped in a red+bold `<span>` (true for dev/alpha/beta, false for stable).
+- Cleans up temp files via `trap cleanup EXIT`
+
+**`</` escaping is mandatory.** Any JS containing `</tag>` inside string or template literals will break inline `<script>` embedding. Run:
+```bash
+sed 's#</#<\\/#g' "$input_js" > "$safe_js"
+```
+Required for any new tool with vendor JS or JS containing HTML template literals.
+
+## JS module pattern
+
+All JS is vanilla, no bundlers. Files are IIFEs, registered on `window.app.modules`. Load order = declaration order in `build.sh`. `window.app` is the only global.
+
+```javascript
+(function() {
+    window.app.modules.mymodule = { ... };
+})();
+```
+
+**Exception:** archive uses plain globals (`APP_STATE`, top-level functions) — not the IIFE/modules pattern.
+
+## ZDDC filename parsers
+
+All parsing/formatting goes through `shared/zddc.js`, exposed as `window.zddc`. Tools call it directly — no per-tool wrappers.
+
+`window.zddc` exports:
+- `parseFilename(name)` → `{ trackingNumber, revision, status, title, extension, valid } | null` (extension WITHOUT leading dot)
+- `parseFolder(name)` → `{ date, trackingNumber, status, title, valid } | null`
+- `parseRevision(rev)` → `{ base, modifier, modifierType, modifierNumber, isDraft, modifierIsDraft, full }`
+- `compareRevisions(a, b)` → number (canonical sort order)
+- `formatFilename(parts)` / `formatFolder(parts)` — round-trips parsed output
+- `isValidStatus(code)` — accepts known status codes plus `---`
+
+All file objects across tools use `file.trackingNumber` (string) and `file.extension` (string, **no leading dot**, e.g. `'pdf'` not `'.pdf'`). When concatenating into a filename, write `name + '.' + ext`.
+
+Coverage lives in `tests/zddc.spec.js` (47 cases). Add new edge cases there, not in tool tests.
+
+## Testing quirks
+
+- Playwright + Chromium only (File System Access API requirement)
+- Tests open `dist/tool.html` via `file://` protocol — **always build before testing**
+- File System Access API is mocked via `page.addInitScript()` using `tests/fixtures/mock-fs-api.js`
+- Use `waitUntil: 'load'` or `'domcontentloaded'` not `'networkidle'` — bundled scripts keep the network "active"
+- Archive's `#noDirectoryMessage` empty-state overlay is `position: absolute; top: 50px` — it must clear the header or it will block button clicks in tests
+
+## ZDDC filename convention
+
+Format: `trackingNumber_revision (status) - title.extension`
+
+- `trackingNumber`: no spaces or underscores (e.g. `123456-EL-SPC-2623`)
+- `revision`: `A`, `B`, `0`; draft prefix `~`; modifiers `+C1`, `+B1`, `+N1`, `+Q1`
+- `status`: `IFA IFB IFC IFD IFI IFP IFR IFU REC RSA RSB RSC RSD RSI` or `---`
+- Folder names prefix with date: `2025-10-31_trackingNumber (status) - title`
+
+## Git workflow
+
+- Feature-branch workflow; squash-merge feature branches to `main`
+- Conventional commits: `feat(archive): ...`, `fix(transmittal): ...`
+- Release tags: `archive-v1.0.0` (per-tool semver)
+- Commit dist files: `git add -f tool/dist/tool.html`
+
+### Releasing — channels and layout
+
+Three channels:
+
+- **Stable**: versioned, immutable. `sh tool/build.sh --release [version]` writes `website/releases/<tool>_v<version>.html`, refreshes the `<tool>_latest.html` symlink, and tags `<tool>-v<version>`. Skips automatically if source has not changed since the latest tag. Pass an explicit version to override auto-increment.
+- **Beta**: mutable. `sh tool/build.sh --release beta` overwrites `website/releases/<tool>_beta.html` in place. No tag. The on-page label is `beta · <date> · <sha>` so the source is recoverable from git via the SHA.
+- **Alpha**: mutable, analogous. `sh tool/build.sh --release alpha`.
+
+Stable releases do **not** automatically clobber `<tool>_alpha.html` / `<tool>_beta.html` — those keep whatever was last built into them. To freshen alpha to current stable, `git checkout v<X>.<Y>.<Z> && sh tool/build.sh --release alpha`.
+
+After cutting a stable release, run `git push --tags` to publish the tag.
+
+The "skip if no source change since last tag" guard for stable releases compares **HEAD** to the latest tag — uncommitted working-tree changes are invisible. If you edit a tool and want a stable release to actually fire, commit the change first; otherwise the build prints `no source changes since <tool>-vX.Y.Z — skipping` and exits 0. Alpha and beta channel builds always rebuild (no skip check).
+
+Agents must **never** write to `website/releases/` or `website/index.html` directly — always go through `--release`.
+
+`landing/build.sh --release <version>` additionally writes `website/index.html` (the root URL of zddc.varasys.io).
+
+### Bootstrap zips
+
+`build.sh` regenerates three downloadable zips into `website/` on every invocation:
+
+- `install.zip` — 5 current-stable HTMLs at root + `_template/` directory containing 4 level-1 bootstrap stubs (per-project use). Skipped if any tool has no stable release yet.
+- `track-{alpha,beta,latest}.zip` — 5 level-2 stubs each, hardcoded to fetch the named channel from `zddc.varasys.io/releases/`. Drop one over a deployment root to switch the whole site to that channel.
+
+See `bootstrap/README.md` for the install / pin / audit story.
+
+### Worktrees
+
+Use `git worktree` to run multiple agents on separate branches simultaneously without filesystem collisions.
+
+- Worktrees live at `~/src/zddc-<branch-name>` (sibling of the main clone)
+- Before starting work on a feature branch, check `git worktree list`; if no worktree exists, create one: `git worktree add ~/src/zddc-<branch-name> -b <branch-name>`
+- All edits, builds (`sh build.sh`), and tests (`npm test`) run from within the worktree directory — build scripts use relative paths so this works correctly
+- The `dist/` force-commit rule (`git add -f`) applies per-worktree
+- After the branch is merged, clean up: `git worktree remove ~/src/zddc-<branch-name>` then delete the branch
+- Never run `git checkout` or `git switch` inside a worktree that another agent may be using
+
+## Transmittal-specific
+
+- Two-phase hydration: `populateStatic()` before publish, `hydrate()` on load of published file
+- Reactive state via Proxy — `app.state.mode = 'view'` auto-notifies subscribers
+- Runtime CDN loads (jszip, docx-preview, xlsx) are allowed only for the optional DOCX/XLSX preview; core features work offline
+- Published payload stored in `<script id="transmittal-data" type="application/json">`
+
+## mdedit-specific
+
+- `css/tailwind-utils.css` is a pre-generated static subset (~80 classes). Add new Tailwind classes here; do not re-run Tailwind.
+- Toast UI Editor v3.2.2 is bundled in `vendor/`; `template.html` loads it from CDN for dev convenience
+- `</` escaping is essential: `sed 's#</#<\\/#g'` runs on both app JS and vendor JS at build time
+
+## Training-data
+
+The `training-data/` directory scripts and README are committed. The data itself is excluded via `training-data/.gitignore`:
+
+- `raw/` — raw interaction logs (never committed)
+- `processed/`, `validation/`, `adapters/`, `snapshots/` — generated data (never committed)
+
+## zddc-server
+
+Go HTTP server sub-project living at `zddc/`. Replaces `caddy file-server --browse` for ZDDC archives.
+
+### Build
+
+```sh
+# Build the container image (from the zddc/ directory)
+podman build -t zddc-server zddc/
+
+# Or inside the zddc/ directory:
+podman build -t zddc-server .
+```
+
+### Run (development)
+
+```sh
+ZDDC_DATA_DIR=/path/to/your/archive podman-compose -f zddc/podman-compose.yaml up --build
+```
+
+### Key environment variables
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `ZDDC_ROOT` | *(required)* | Path to served file tree |
+| `ZDDC_ADDR` | `:8443` | Bind address |
+| `ZDDC_EMAIL_HEADER` | `X-Email` | Header set by upstream proxy with user email |
+| `ZDDC_INDEX_PATH` | `.archive` | Virtual archive index URL segment |
+| `ZDDC_LOG_LEVEL` | `info` | Logging verbosity |
+| `ZDDC_CORS_ORIGIN` | `https://zddc.varasys.io` | Comma-separated CORS allowlist; empty value disables CORS. Default lets tools served from zddc.varasys.io call back into a customer-deployed server. |
+
+### Release tagging
+
+```sh
+git tag zddc-server-v1.0.0
+git push --tags
+```
+
+### Notes
+
+- No external test framework yet — Go unit tests run with `go test ./...` inside `zddc/` (requires Go 1.24+)
+- The container image does NOT require Go on the host — the Containerfile uses a multi-stage build
+- Portfolio files (`*.portfolio`) in the served tree appear as virtual group directories
+- The `.archive` virtual path resolves ZDDC tracking numbers to their earliest-received revision
+- ACL is enforced via cascading `.zddc` YAML files; authentication is delegated to the upstream proxy via the `X-Email` header
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
new file mode 100644
index 0000000..36e4088
--- /dev/null
+++ b/ARCHITECTURE.md
@@ -0,0 +1,476 @@
+# ZDDC Architecture
+
+This document is the single authoritative reference for how ZDDC tools are designed and built. It covers the shared single-file HTML application pattern, the build system, tool-specific architectural decisions, and contribution guidelines.
+
+---
+
+## Why Single-File HTML Applications
+
+Every ZDDC tool compiles to a single self-contained `.html` file — no servers, no installers, no subscriptions.
+
+| Principle | Rationale |
+|-----------|-----------|
+| **Reliability** | Opens in any modern Chromium-based browser without network access or external services |
+| **Portability** | Can be emailed, archived, or deployed to air-gapped environments with no tooling |
+| **Auditability** | Source, embedded data, and output travel together, satisfying ZDDC traceability requirements |
+| **Longevity** | Static assets remain functional long after build environments have changed |
+| **Simplicity** | A single `.html` file eliminates deployment steps and brittle dependency chains |
+
+---
+
+## Repository Structure
+
+Every HTML tool follows the same directory layout:
+
+```
+tool/
+  README.md        # Feature scope, UI design, domain rules, help content
+  css/             # Logically separated stylesheets (one responsibility per file)
+  js/              # Vanilla ES modules (one responsibility per file)
+  template.html    # Shell markup with {{PLACEHOLDER}} markers for development
+  build.sh         # Inlines css/ and js/ into dist/tool.html
+  dist/
+    tool.html      # Generated output — never edit this manually
+```
+
+Website files (what `zddc.varasys.io` serves) are organized by channel:
+
+```
+website/
+  index.html                    # current stable landing tool (root URL)
+  releases/
+    <tool>_v<X>.<Y>.<Z>.html    # immutable stable release archives
+    <tool>_latest.html  -> ...  # symlink to the highest-versioned stable
+    <tool>_alpha.html           # mutable: overwritten on every --release alpha
+    <tool>_beta.html            # mutable: overwritten on every --release beta
+  install.zip                   # current-stable HTMLs + project bootstrap stubs
+  track-{alpha,beta,latest}.zip # level-2 channel-tracking stubs
+```
+
+There is no `website/dev/`. To preview a build locally, open `dist/tool.html` directly via the dev server. To publish on `zddc.varasys.io`, cut a release.
+
+Vendor dependencies (bundled third-party libraries) live in `tool/vendor/` if present. The build script is responsible for inlining them into the output.
+
+---
+
+## Documentation ownership
+
+Each topic has exactly one authoritative home; everything else links to it.
+
+| Topic | Single home | Linked from |
+|---|---|---|
+| What ZDDC is + tool channel links + install bundles | `website/index.html` (hand-edited intro for `zddc.varasys.io/`) | repo `README.md`, `bootstrap/README.md` |
+| File-naming convention spec (status codes, modifiers, folder format) | `website/reference.html` | repo `README.md`, in-tool help text |
+| Customer-deployment install (install.zip, level-1/2 stubs, `?v=`, audit) | `bootstrap/README.md` | website intro, `zddc/README.md` |
+| zddc-server config, ACL, `.archive`, deployment | `zddc/README.md` | `AGENTS.md`, `bootstrap/README.md` |
+| Build / release / channel commands | `AGENTS.md` | repo `README.md` ("see AGENTS.md") |
+| Architecture & internal patterns | `ARCHITECTURE.md` (this file) | `AGENTS.md` |
+| Per-tool internal design quirks | `<tool>/README.md` | (linked from website intro tool cards) |
+
+`website/index.html` is **hand-edited static content** (analogous to `reference.html`), not the landing-tool output. The landing tool ships only via `website/releases/landing_v<X>.html` and `install.zip` — `install.zip` copies `landing_latest.html` to `<deployment-root>/index.html` for customer sites where the project picker UI is actually useful (it queries `zddc-server` for the project list). The public website at `zddc.varasys.io/` has nothing to pick, so its root URL is the introduction page.
+
+When updating documentation, prefer linking over duplicating. If you find yourself rewriting the file-naming convention in a tool's README, link to `reference.html` instead.
+
+---
+
+## Build System
+
+### How It Works
+
+Each tool's `build.sh`:
+
+1. Reads CSS files in declaration order, concatenates them
+2. Reads JS files in declaration order, concatenates them
+3. Processes `template.html` with `awk`, replacing `{{PLACEHOLDER}}` markers with the concatenated content and stripping CDN `<script>`/`<link>` tags
+4. Writes the result to `dist/tool.html`
+5. If `--release <channel-or-version>` was passed, calls `promote_release` to write the appropriate file under `website/releases/`
+
+The top-level `build.sh` at the repository root calls all five tool build scripts in sequence and then regenerates the bootstrap zips (`install.zip`, `track-{alpha,beta,latest}.zip`) so they always match what's in `releases/`.
+
+### Channels
+
+Three release channels:
+
+- **Stable** — versioned, immutable. `--release [version]` writes `website/releases/<tool>_v<version>.html`, refreshes the `<tool>_latest.html` symlink, and tags `<tool>-v<version>` in git. Skips automatically when there is no source change since the last tag.
+- **Beta** — mutable. `--release beta` overwrites `website/releases/<tool>_beta.html` in place. No git tag; the on-page label is `beta · <date> · <sha>` so the source is recoverable from git history via the SHA.
+- **Alpha** — mutable, analogous to beta.
+
+Stable releases do not automatically clobber `<tool>_alpha.html` / `<tool>_beta.html` — those keep whatever was last built into them. To freshen alpha to current stable, `git checkout v<X>.<Y>.<Z> && sh tool/build.sh --release alpha`.
+
+The on-page `{{BUILD_LABEL}}` is rendered red+bold for dev/alpha/beta builds (`is_red=1`) and black for stable releases. The label format is:
+
+| Build         | Label                                       |
+|---------------|---------------------------------------------|
+| dev           | `Built: 2026-04-27 14:00:00 BETA`           |
+| alpha         | `alpha · 2026-04-27 · abc1234`              |
+| beta          | `beta · 2026-04-27 · abc1234`               |
+| stable        | `v0.0.5`                                    |
+
+### Two-level bootstrap
+
+Customer deployments under `zddc-server` use a two-level bootstrap pattern that keeps tool installation decoupled from publishing. See `bootstrap/README.md` for the full story; in short:
+
+- **Level 1**: per-project stub at `<project>/<tool>.html` that fetches `../<tool>.html` (always same-origin). One file per project per tool, never edited after install.
+- **Level 2** (optional): site admin replaces `<deployment-root>/<tool>.html` with a stub fetching `https://zddc.varasys.io/releases/<tool>_<channel>.html` — switches the whole site to a channel. Without it, `<deployment-root>/<tool>.html` is just the actual built tool HTML (self-contained install).
+
+`document.write()` chains across both levels; origin stays at the deployment domain throughout. CORS only matters at level 2 (cross-origin to `zddc.varasys.io`); level 1 is same-origin.
+
+The stubs are generated from `bootstrap/level{1,2}.html.tmpl` by the root `build.sh` and packaged into `install.zip` and `track-<channel>.zip`.
+
+### Build Script Requirements
+
+Every `build.sh` must:
+
+- Begin with `#!/bin/sh` and `set -eu` (POSIX sh, not bash)
+- Source `shared/build-lib.sh` first (provides `ensure_exists`, `concat_files`, `build_timestamp`, `compute_build_label`, `promote_release`)
+- Fail immediately on missing source files (`ensure_exists` pattern)
+- Clean up temp files on exit (use `trap cleanup EXIT`)
+- Accept `--release [<version>|alpha|beta]` — explicit version or channel name; otherwise produce a dev build
+
+### HTML Embedding Safety
+
+When inlining JavaScript into a `<script>` block, the HTML parser scans for the exact string `</script>` to terminate the block — backslash escaping (`<\/script>`) does **not** prevent termination. Any JS source file or vendor library that contains `</tag>` sequences inside string literals or template literals will break the inline `<script>` block.
+
+The rule is:
+
+> **All `</` sequences in inlined JavaScript must be escaped as `<\/` using `sed`.**
+
+Both the app JS concatenation step and any vendor JS bundling step must run through:
+
+```bash
+sed 's#</#<\\/#g' "$input_js" > "$safe_js"
+```
+
+Then use `</script>` (not `<\/script>`) to close the `<script>` block, since the content no longer contains any `</` sequences that the parser could misread.
+
+This is already enforced for mdedit's vendor bundling. It is the contributor's responsibility to ensure new tools follow this pattern.
+
+### Vendor Dependencies
+
+Some tools bundle third-party libraries. These live in `tool/vendor/` and are committed to the repository. The build script inlines them into `dist/tool.html`.
+
+**Current vendor files:**
+
+| Tool | Library | File | Notes |
+|------|---------|------|-------|
+| mdedit | Toast UI Editor v3.2.2 | `vendor/toastui-editor-all.min.js` | Markdown editor with live preview |
+| mdedit | Toast UI Editor CSS | `vendor/toastui-editor.min.css` | Editor stylesheet |
+| transmittal | jszip, docx-preview, xlsx | CDN at runtime | Optional preview features; tool works without them |
+
+**Runtime CDN loading exception**: The transmittal tool loads jszip, docx-preview, and xlsx from CDN at runtime via `loadLibrary()` forDOCX/XLSX preview functionality. These are **optional enhancements**—core transmittal functionality (JSON payload communication) works without them. This exception is documented here because:
+
+1. The core transmittal features (creating, signing, verifying SHA-256 digests) do not depend on these libraries
+2. Preview functionality gracefully degrades if libraries fail to load
+3. Bundling would significantly increase file size for rarely-used features
+
+**Rule**: Runtime CDN loading is allowed only when:
+- Features are strictly optional (graceful degradation)
+- Core functionality works without the external library
+- Library is clearly documented as non-essential
+
+`template.html` for tools with vendor deps loads those deps from CDN for convenient local development. The build script replaces CDN tags with the bundled vendor files in the output.
+
+### Development vs Production
+
+| Context | Tailwind / Vendor | How to run |
+|---------|-------------------|-----------|
+| Development | CDN (live, from `template.html`) | Open `template.html` directly in Chromium |
+| Production | Bundled / Static CSS | Run `bash tool/build.sh`, open `dist/tool.html` |
+
+For mdedit specifically: `template.html` loads Toast UI from CDN and uses Tailwind Play CDN. The build replaces Toast UI with the bundled vendor file and replaces the Tailwind CDN script with the static `css/tailwind-utils.css` subset.
+
+---
+
+## JavaScript Architecture
+
+### Vanilla JS Only
+
+All tools use plain JavaScript — no TypeScript, no frameworks, no bundlers. Dependencies are managed manually via vendor files.
+
+### Module Pattern
+
+Each JS file wraps its code in an IIFE or module-scope block and registers its API on `window.app.modules`:
+
+```javascript
+// js/mymodule.js
+(function() {
+    function doSomething() { ... }
+
+    window.app.modules.mymodule = { doSomething };
+})();
+```
+
+Two top-level globals:
+
+- `window.app` — per-tool app state, modules, and debug surface (every tool)
+- `window.zddc` — shared filename/folder/revision parsers from `shared/zddc.js` (every tool)
+
+No other globals. Never expose implementation internals beyond what's needed for testing.
+
+### Module Load Order
+
+JS files are concatenated in the order declared in `build.sh`. Each file can assume earlier files' modules are available on `window.app`. Circular dependencies are not permitted — modules must be layered.
+
+Typical ordering:
+
+```
+app.js          ← Declares window.app and top-level state
+utils.js        ← Stateless helpers (no dependencies)
+store.js        ← State management (depends on app.js)
+[domain].js     ← Feature modules (depend on store/utils)
+main.js         ← Initialization (depends on all modules)
+```
+
+### State Management
+
+Tools manage state in one of two patterns:
+
+**1. Direct state on `window.app`** (archive, classifier, mdedit)
+
+```javascript
+window.app = { files: [], selectedFolders: new Set(), modules: {}, ... };
+```
+
+State is read directly; mutations trigger explicit re-render calls. Classifier additionally layers a small pub-sub on top via `store.js` (`store.on('files', render)`).
+
+**2. Proxy-based reactive state** (transmittal)
+
+```javascript
+const state = createReactiveState({ mode: 'edit', published: false });
+state.subscribe((prop, newVal) => { /* auto-update UI */ });
+state.mode = 'view'; // Proxy notifies all subscribers automatically
+```
+
+Use reactive state when the same property drives multiple independent UI elements. Use direct state when the data flow is simple and unidirectional.
+
+---
+
+## Tool-Specific Architecture
+
+### Archive Browser
+
+**Pattern:** Direct mutation of `window.app.{directories, files, filteredFiles, selectedFiles, ...}`, helper modules namespaced under `window.app.modules.{events, table, urlState, source, ...}`. Supports two source modes (`window.app.sourceMode`): `'local'` (File System Access API) and `'http'` (zddc-server JSON browse).
+
+**Two-level directory structure required:**
+
+```
+root-directory/
+  transmittal-folder/         ← "grouping folder" — must be a subdirectory
+    123456-EL-SPC-0001_A (IFC) - Spec.pdf
+    ...
+```
+
+Files at the root level are ignored. The grouping folder list and transmittal folder list are populated from the first two levels of the selected directory. Files are only counted in `filteredFiles` after ZDDC filename parsing succeeds.
+
+**Key DOM IDs:** `#addDirectoryBtn`, `#noDirectoryMessage`, `.main-container`, `#filesTableBody`, `#fileCount`, `#selectedCount`, `#selectAllGroupingCheckbox`.
+
+---
+
+### Document Classifier
+
+**Pattern:** Event-driven store (`store.js`) with `notify()` / `on()` pub-sub, spreadsheet rendering on `'files'` events.
+
+**File object shape** (as produced by `scanner.js`):
+
+```javascript
+{
+    trackingNumber: '123456-EL-SPC-2623',
+    title: 'Specification',
+    revision: 'A',
+    status: 'IFC',
+    extension: 'pdf',                 // no leading dot
+    originalFilename: '...',          // filename without extension
+    name: '...',                      // full filename with extension
+    path: 'folder/filename.pdf',
+    size: 45000,
+    isDirectory: false,
+    manualFilename: null              // set if user overrides computed name
+}
+```
+
+**`computeNewFilename(file)`** (in `utils.js`) returns `file.originalFilename + '.' + file.extension` if any required field is missing.
+
+**Main app panel** (`#mainApp`) stays hidden (class `hidden`) until a real directory is opened via `showDirectoryPicker`. State can be injected via `store.setFolderTree()` + `store.setSelectedFolders()` for testing without triggering the picker.
+
+---
+
+### Markdown Editor (mdedit)
+
+**Pattern:** Global functions (`window.updateToc`), editor instances managed per file-path in a `Map`, File System Access API for direct file read/write.
+
+**Dependencies:** Toast UI Editor v3.2.2 (bundled), Tailwind utility subset (static CSS).
+
+**Toast UI availability check:**
+
+```javascript
+if (typeof toastui === 'undefined') {
+    // Graceful degradation — show error message
+}
+const editor = new toastui.Editor({ el: container, ... });
+```
+
+**Key DOM IDs:** `#app`, `#select-directory`, `#welcome-screen`, `#file-tree`, `#content-container`.
+
+**File tree:** Populated after `showDirectoryPicker()` resolves. File items are rendered as DOM children of `#file-tree`. Clicking a file opens it in the editor panel.
+
+---
+
+### Transmittal Creator
+
+**Pattern:** Proxy-based reactive state, two-phase hydration, ECDSA digital signatures, SHA-256 file integrity.
+
+**Two-phase hydration:**
+
+1. **`populateStatic()`** — called before publishing. Fills all form fields and the file table into the HTML so the output is readable without JavaScript (progressive enhancement for SharePoint, email clients, etc.).
+2. **`hydrate()`** — called on page load of a published transmittal. Hides the "Not Validated" static warning, runs signature verification, and enables interactive features.
+
+**Progressive enhancement matrix:**
+
+| Feature | No JavaScript | With JavaScript |
+|---------|--------------|-----------------|
+| Content display | ✅ Full | ✅ Full |
+| File table | ✅ Shown | ✅ Shown |
+| Digest / signatures | ✅ Listed | ✅ Listed + cryptographically verified |
+| Validation status | ⚠️ "Not Validated" badge | ✅ "Verified" / ❌ "Invalid" |
+| Editing | ❌ Disabled | ✅ Enabled (if draft) |
+| Column filtering | ❌ No | ✅ Yes |
+
+**Data store:** A `<script id="transmittal-data" type="application/json">` element embedded in the published HTML holds the full transmittal payload. On load, `data.js` reads and parses it; all UI state derives from this JSON.
+
+**Reactive state:**
+
+```javascript
+// app.state is a Proxy — assignments auto-notify subscribers
+app.state.mode = 'view';  // Triggers UI updates automatically
+```
+
+Subscribe for cross-cutting concerns:
+```javascript
+app.state.subscribe((property, newValue) => {
+    if (property === 'mode') updateModeToggleLabel(newValue);
+});
+```
+
+**Security model:** ECDSA P-256 signing of the SHA-256 digest. Signatures are stored in the JSON payload. Any number of signers can co-sign. Verification runs client-side in the browser's Web Crypto API — no server required.
+
+**Key module globals:** `window.transmittalApp` exposes `app.data`, `app.state`, and `app.modules` for debugging and testing.
+
+---
+
+## CSS Architecture
+
+All tools use vanilla CSS. No frameworks at build time (mdedit's Tailwind utilities are pre-generated static CSS).
+
+**Common conventions:**
+
+- CSS variables for theme colors and spacing in `base.css`
+- Component-scoped class names (no global utilities except where Tailwind provides them)
+- `.hidden` class uses `display: none !important` for JavaScript show/hide
+- Print styles in a separate `print.css`
+
+**mdedit Tailwind subset:**
+
+`css/tailwind-utils.css` contains only the ~80 Tailwind v3 utility classes actually used in `template.html`. If a new utility class is needed in the template, add it here. Classes follow Tailwind v3 naming and values exactly.
+
+---
+
+## Testing
+
+Tests use Playwright with Chromium only (File System Access API requires it).
+
+### Running Tests
+
+```bash
+npm test                    # all tools
+npx playwright test archive # single tool
+npx playwright test --debug # debug mode
+```
+
+### Test Structure
+
+Each tool has a spec file in `tests/`:
+
+```
+tests/
+  archive.spec.js      ← 2 tests: load + directory scan
+  classifier.spec.js   ← 2 tests: load + store injection
+  mdedit.spec.js       ← 2 tests: load + file tree render
+  transmittal.spec.js  ← 2 tests: paste round-trip + filesystem round-trip
+  fixtures/
+    mock-fs-api.js     ← Reusable File System Access API mock
+    transmittal-data.js
+    zddc-filenames.js
+```
+
+### Mock File System API
+
+`MOCK_FS_INIT_SCRIPT` (from `tests/fixtures/mock-fs-api.js`) overrides `showDirectoryPicker`, `showOpenFilePicker`, and `showSaveFilePicker`. Inject it via `page.addInitScript` before navigating.
+
+```javascript
+// Flat directory
+window.__setMockDirectory('name', [{ name: 'file.pdf', content: '...', size: 100 }]);
+
+// Nested directory tree
+window.__setMockDirectoryTree('name', {
+    'subfolder': { 'file.pdf': 'content' },
+    'root-file.md': 'content',
+});
+```
+
+### Writing Tests
+
+Follow the pattern in `tests/transmittal.spec.js`:
+
+- Use ESM `import` syntax
+- Inject `MOCK_FS_INIT_SCRIPT` in `test.beforeEach` for any test that navigates to a tool page
+- Use `waitUntil: 'domcontentloaded'` or `'load'` (not `'networkidle'` — the bundled scripts may keep the network active)
+- Prefer `page.waitForFunction` over `page.waitForSelector` for app-state readiness
+- Assert through the store/module API for tests that don't need visible DOM
+
+---
+
+## Code Standards
+
+| Rule | Rationale |
+|------|-----------|
+| No `</script>` or any `</tag>` in JS string literals | Breaks inline HTML embedding — escape with `'<' + '/tag>'` or use `<\/` in `sed` at build time |
+| No external dependencies at runtime | Self-contained output requirement |
+| No TypeScript, no bundlers | Keeps the build system auditable and simple |
+| Only `window.app` and `window.zddc` are global | Keeps the global namespace clean; expose only what's needed for debugging |
+| Defensive input validation | File System API handles and user-pasted data are untrusted |
+| Update README.md when features ship | Documentation parity is a delivery requirement, not optional |
+
+---
+
+## Git Workflow
+
+**Branching:** short-lived feature branches (`feature/<name>`, `bugfix/<name>`, `hotfix/<name>`), squash-merged to `main` and immediately deleted. Quick fixes (typos, one-liners) go direct to `main`.
+
+**Commit messages:** Conventional Commits — `<type>(<scope>): <description>`. Types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `chore`. See `AGENTS.md` for the full table and examples.
+
+**Releases:** Tag the commit after confirming `dist/` is current. Format: `{project}-v{version}` (e.g. `archive-v1.0.0`). Semantic versioning applies. There is no CI/CD — the built `.html` file is already committed to the repo.
+
+```bash
+bash tool/build.sh                  # rebuild dist/
+git add -f tool/dist/tool.html      # stage if needed
+git commit -m "chore(tool): rebuild for vX.Y.Z"
+git tag tool-vX.Y.Z
+git push origin main --tags
+
+git tag -l "archive-v*"             # list releases
+git push origin :refs/tags/tag-name # delete a remote tag
+```
+
+---
+
+## Adding a New Tool
+
+1. Create `tool/` with the standard directory layout
+2. Write `template.html` with `{{CSS_PLACEHOLDER}}` and `{{JS_PLACEHOLDER}}` markers
+3. Write `tool/build.sh` following the pattern of an existing tool
+4. Add `bash "$SCRIPT_DIR/tool/build.sh"` to the root `build.sh`
+5. Add a test project entry to `playwright.config.js`
+6. Create a stub `tests/tool.spec.js`
+7. Force-add the dist output: `git add -f tool/dist/tool.html`
+
+If the tool requires vendor dependencies, download them to `tool/vendor/`, add them to `.gitignore` exclusions if appropriate, and update `build.sh` to inline them (with the `</` escaping step).
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000..87a9b29
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,47 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Authoritative docs — read these first
+
+This repo already has two thorough agent-facing references. **Always consult them before working** — they cover details intentionally omitted here:
+
+- **`AGENTS.md`** — commands, build-system rules, per-tool parser quirks, testing gotchas, git/worktree workflow, release process, zddc-server notes
+- **`ARCHITECTURE.md`** — single-file HTML pattern rationale, JS module/state patterns, per-tool architecture, security model
+
+If something in this CLAUDE.md conflicts with those, those win — and please update them rather than letting drift accumulate.
+
+## Repo shape
+
+This is a **monorepo of independent tools**, not one application:
+
+- `archive/`, `transmittal/`, `classifier/`, `mdedit/`, `landing/` — five self-contained HTML tools, each compiled to a single inlined HTML file in its own `dist/`. Naming: the first four output `dist/tool.html`; **`landing/` outputs `dist/index.html`** (it's the project picker served at the root of `zddc-server`).
+- `zddc/` — Go HTTP server (separate sub-project, podman/podman-compose; Go 1.24+). Serves `ZDDC_ROOT/index.html` at `GET /` as the landing page; `Accept: application/json` on `/` returns the ACL-filtered project list.
+- `shared/` — `base.css` plus shared JS modules (`zddc.js`, `hash.js`, `zddc-filter.js`, `theme.js`, `help.js`) included by every tool's build, and `build-lib.sh` (POSIX sh helpers sourced by every tool's `build.sh`)
+- `website/` — published artifacts: `index.html` (root URL), `releases/<tool>_v<X.Y.Z>.html` (immutable stable archives), `releases/<tool>_latest.html` (symlink to current stable), `releases/<tool>_{alpha,beta}.html` (mutable channel files), plus bootstrap zips (`install.zip`, `track-{alpha,beta,latest}.zip`). `--release` is the only path to publishing — there is no `website/dev/`.
+- `tests/` — Playwright specs (Chromium only, requires File System Access API). `tests/schema.spec.js` validates `transmittal.schema.json` against canonical fixtures via `ajv` (only dev dep besides Playwright)
+
+## Most-used commands
+
+```bash
+sh build.sh                                 # build all five HTML tools (dist/ only)
+sh tool/build.sh                            # build one (archive|transmittal|classifier|mdedit|landing)
+sh tool/build.sh --release [version]        # cut stable; tag, write website/releases/<tool>_v<ver>.html, refresh _latest symlink
+sh tool/build.sh --release alpha|beta       # cut channel build; overwrites website/releases/<tool>_<channel>.html (mutable, no tag)
+npm test                                    # all Playwright specs (build first!)
+npx playwright test <tool>                  # one spec
+./dev-server start  # ./dev-server stop     # cache-busting HTTP on :8000
+```
+
+No lint/typecheck/format commands exist — vanilla JS + POSIX sh by design.
+
+## Things that bite if you forget
+
+- **`dist/` is gitignored but force-committed** (`git add -f tool/dist/tool.html`). Never hand-edit a `dist/` file.
+- **Never write to `website/index.html` or `website/releases/*` directly** — promote via `sh tool/build.sh --release [version|alpha|beta]`. Stable releases write `website/releases/<tool>_v<ver>.html` (immutable) and refresh `<tool>_latest.html`; alpha/beta overwrite `<tool>_<channel>.html` in place.
+- **Always build before running tests** — Playwright opens `dist/tool.html` via `file://`.
+- **`</` in JS string/template literals breaks inline `<script>`** embedding. `shared/build-lib.sh` provides `escape_js_close_tags`; every tool's `build.sh` runs JS through it before inlining.
+- **All ZDDC parsing/formatting/hashing goes through `window.zddc`** (from `shared/zddc.js` + `shared/hash.js` + `shared/zddc-filter.js`). API: `parseFilename`, `parseFolder`, `parseRevision`, `formatFilename`, `formatFolder`, `compareRevisions`, `isValidStatus`, `splitExtension`, `joinExtension`, `crypto.{sha256Hex, sha256String, sha256File, bytesToHex}`, `filter.{parse, matches}`. File objects across tools use `trackingNumber` (string) and `extension` (string, **no leading dot** — use `zddc.joinExtension(name, ext)` to build a filename). Add edge cases to `tests/zddc.spec.js`, not per-tool tests.
+- **Two globals only**: `window.app` (per-tool app state + modules) and `window.zddc` (shared library). No others — anything that crosses tool boundaries goes through one of these.
+- **Worktrees live at `~/src/zddc-<branch>`.** Check `git worktree list` before starting a feature branch; never `git checkout`/`switch` inside a worktree another agent might be using.
+- **Build scripts are POSIX `sh` with `set -eu`**, not bash. `concat_files` takes positional args only.
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..0ad25db
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f06595e
--- /dev/null
+++ b/README.md
@@ -0,0 +1,55 @@
+# Zero Day Document Control (ZDDC)
+
+**The Universal Distributed Filing Cabinet**
+
+ZDDC is an information management convention plus a small set of single-file HTML tools. Every deliverable's filename encodes its tracking number, revision, status, and title; every transmittal folder is date-prefixed and self-describing. A plain shared folder becomes a fully searchable, auditable archive — no server, no database, no software required to read it.
+
+The name "Zero Day Document Control" comes from the convention itself — adopt it on day zero of a project, with no setup time. The tools are *optional* interfaces around the structure; the structure works without them.
+
+> **For end users**: <https://zddc.varasys.io/> introduces the project, links to all tool channels (stable / beta / alpha), and offers `install.zip` for self-hosted deployments.
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| **[Archive Browser](https://zddc.varasys.io/releases/archive_latest.html)** | Browse, search, and filter a project archive folder. Group by transmittal, export selections as ZIP. |
+| **[Transmittal Creator](https://zddc.varasys.io/releases/transmittal_latest.html)** | Self-contained HTML transmittal records with SHA-256 checksums and optional digital signatures. |
+| **[Document Classifier](https://zddc.varasys.io/releases/classifier_latest.html)** | Spreadsheet-like bulk-renamer that copy/pastes with Excel and writes back to disk. |
+| **[Markdown Editor](https://zddc.varasys.io/releases/mdedit_latest.html)** | Browser-based markdown editor with YAML front matter, TOC, and direct local file access. |
+
+Each tool is published in three channels (stable, beta, alpha) at `https://zddc.varasys.io/releases/<tool>_<channel>.html`. Append `?v=alpha` (or `?v=0.0.4`, etc.) to any URL to switch versions for one request. See [`bootstrap/README.md`](bootstrap/README.md) for the install / pin / audit story.
+
+## File-naming convention
+
+The full specification — filename format, tracking numbers, revision rules, status codes, folder naming, and the transmittal workflow — lives at <https://zddc.varasys.io/reference.html>.
+
+Quick example: `123456-EL-SPC-2623_A (IFR) - Specification For Switchgear.pdf`
+
+## Build & develop
+
+```bash
+git clone https://codeberg.org/VARASYS/ZDDC.git && cd ZDDC
+
+sh build.sh                              # build all tools (writes to dist/ only)
+sh archive/build.sh                      # build one tool
+
+sh archive/build.sh --release            # cut stable; auto-bumps patch from last tag
+sh archive/build.sh --release 0.1.0      # explicit version
+sh archive/build.sh --release alpha      # cut alpha (mutable channel, no tag)
+sh archive/build.sh --release beta       # cut beta
+
+npm install && npx playwright install chromium && npm test    # tests
+./dev-server start                       # cache-busting HTTP on :8000
+```
+
+Authoritative build/release docs are in [`AGENTS.md`](AGENTS.md). Architecture notes (single-file rationale, JS module pattern, security model) are in [`ARCHITECTURE.md`](ARCHITECTURE.md). zddc-server (optional Go HTTP server with ACL and a virtual archive index) is in [`zddc/README.md`](zddc/README.md).
+
+## Contributing
+
+ZDDC is an open source project hosted on Codeberg at <https://codeberg.org/VARASYS/ZDDC>. Bug reports, feature requests, and pull requests welcome.
+
+ZDDC is designed for zero configuration to start and minimal configuration overall — feature proposals are filtered through that lens.
+
+## License
+
+[GNU Affero General Public License v3.0](https://www.gnu.org/licenses/agpl-3.0.en.html). Free to use, modify, and distribute, including commercially, under the terms of the license. Provided "as is" without warranty.
diff --git a/archive/README.md b/archive/README.md
new file mode 100644
index 0000000..571d838
--- /dev/null
+++ b/archive/README.md
@@ -0,0 +1,277 @@
+# Archive Browser
+
+[← Back to ZDDC](../README.md)
+
+Your digital filing cabinet - a complete document management system in a single HTML file. No installation, no updates, no cloud required. Just open it and start organizing.
+
+**[🔗 Open Archive Browser](dist/archive.html)** - Click to use online, or right-click → "Save Link As" to keep your own copy forever.
+
+## What Makes This Special?
+
+This is a "record player with the record" - the entire application travels with the file. Save it to a USB drive, email it to a colleague, or archive it with your project files. It will work exactly the same way in 20 years as it does today. No dependencies, no obsolescence.
+
+## Quick Start
+
+1. **Click "Select Directory"** - Choose your project folder
+2. **All folders auto-expand** - See everything at once
+3. **Type to filter** - Use the search boxes to find files instantly
+4. **Click to sort** - Any column header sorts your data
+5. **Download selected** - Check boxes and download as ZIP
+
+## Overview
+
+The archive browser presents a two-pane interface:
+- **Navigation Pane** (left): Your folder hierarchy with smart filtering
+- **Content Area** (right): All your files in a searchable, sortable table
+
+## User Interface Layout
+
+### Navigation Pane
+The navigation pane displays a hierarchical folder structure with:
+
+1. **Grouping Folders** (top level)
+   - Folders that don't match transmittal naming convention
+   - Used for organizational hierarchy (e.g., permissions, departments)
+   - Has its own autofilter input
+   - Supports multi-select (Shift+Click, Ctrl+Click)
+   - **Right-click context menu** for recursive select/deselect of folder trees
+   - **Collapsible section** with toggle button to hide/show when not needed
+   - **Resizable height** - drag the divider to adjust space allocation
+   - Default: 250px height, can be collapsed to header-only
+   - Folders named "incoming" (case-insensitive) are excluded from default selection
+
+2. **Transmittal Folders** (displayed in a flat sorted list in a separate section below the grouping folders)
+   - Follow naming convention: `YYYY-MM-DD_TRACKINGNUMBER (STATUS) - TITLE`
+   - Example: `2025-09-15_A101-203 (IFC) - Site Plan`
+   - Has its own autofilter input
+   - Supports multi-select
+   - Only folders within selected grouping folders are visible
+   - **Grouped by date** with collapsible date headers showing folder count
+   - **Expand/collapse all** toggle button in section header
+   - Date removed from individual folder display (shown in group header instead)
+   - All transmittal folders selected by default (except those under "incoming")
+
+### Content Area
+Displays files from all selected transmittal folders in a unified table.
+
+**Table Columns**:
+1. **Tracking Number** - Extracted from filename
+2. **Title** - Extracted from filename
+3. **Revisions** - Shows all available revisions/documents for a tracking number
+   - Each revision shows: revision identifier, status, and file links
+   - Multiple files per revision supported (e.g., PDF, DWG)
+   - Checkboxes for selecting individual files
+
+The Revisions column must provide an efficient way to both display all revisions and modifiers compactly while allowing for efficient selection of specific revisions.
+
+
+## Core Features
+
+### 🔍 Smart Search & Filter
+- **Find anything instantly** - Type in any filter box to narrow results
+- **Power search** - Use `+must have` or `-exclude` for precise filtering
+- **Excel-like sorting** - Click any column header to sort your data
+
+### 📁 Organize Your Files
+- **Drag & drop** - Drop files onto folders to create organized transmittals
+- **Smart naming** - Automatically extracts document info from ZDDC filenames
+- **Version tracking** - See all revisions of a document in one place
+- **Batch operations** - Select multiple files for download or export
+
+### 🔒 Data Integrity
+- **SHA-256 checksums** - Verify files haven't changed
+- **Hash caching** - Fast rescanning of large archives
+- **Export to ZIP/CSV** - Take your data with you
+
+Files are sorted by tracking number first, then by revision in proper order (~A, A, B, C+C1, C, 1, 2, 3, etc.)
+
+## Technical Architecture
+
+### Frontend Stack
+- **Vanilla JavaScript**: No framework dependencies
+- **Inline CSS**: Self-contained styling
+- **File System Access API**: Local directory access
+- **Web Crypto API**: SHA-256 file hashing
+
+### Build System
+- Modular architecture with separate CSS and JavaScript files
+- Build script concatenates and inlines all assets
+- Produces single self-contained HTML file
+- No external dependencies in final output
+
+Uses the same build.sh structure as the transmittal project (requires Git Bash on Windows).
+
+
+## Additional Features
+
+### File Operations
+- **Download Selected**: Creates ZIP file of checked files
+- **Export CSV**: Exports only visible/filtered files with metadata
+- **Drag & Drop**: Drop files onto table rows to copy metadata
+- **File Renaming**: Modal for fixing non-conforming filenames
+
+### Context Menu Operations (Right-click on Grouping Folders)
+- **Select This & Subfolders**: Recursively select folder and all descendants
+- **Deselect This & Subfolders**: Recursively deselect folder and all descendants
+- **Select All Visible**: Select all currently visible grouping folders
+- **Deselect All**: Clear all grouping folder selections
+
+Users can drag and drop files onto a grouping folder. The system creates a transmittal folder with the correct naming convention and displays a dialog where users can:
+  - Confirm/edit the transmittal folder name
+  - Review and correct file names to ensure ZDDC compliance
+  - See preview of final file organization before committing
+
+### Data Management
+- **SHA-256 Hashing**: Integrity verification for all files
+- **Hash Cache**: `.hashes.json` file to avoid re-hashing unchanged files
+- **Refresh**: Re-scan directories for changes
+
+Implements hash caching by creating a `.hashes.json` file in each scanned directory (when writable) to store file hashes and modification times, significantly improving performance on subsequent scans.
+
+## Implementation Details
+
+### Resizable Interface
+- **Column Resizing**: Draggable column borders with persistent widths
+- **Navigation Pane Width**: Drag horizontal divider between nav pane and content area
+- **Section Heights**: Drag vertical divider between grouping and transmittal sections
+- Visual feedback (blue highlight) when hovering or actively resizing
+- Minimum/maximum sizes enforced to prevent unusable layouts
+
+### Performance Optimizations
+- Standard scrolling with sticky headers (no virtual scrolling needed)
+- Debounced search inputs
+- Progressive file scanning
+- Cached file metadata
+
+The table uses standard scrolling with sticky headers for navigation. No pagination or virtual scrolling is needed.
+
+### Folder Hierarchy Logic
+1. **Grouping Folders**: Any folder not matching transmittal convention
+2. **Transmittal Folders**: Match `YYYY-MM-DD_TRACKINGNUMBER (STATUS) - TITLE`
+3. **Selection Cascade** (strict enforcement): 
+   - If grouping folders exist, at least one must be selected to see transmittal folders
+   - Selecting grouping folder shows only its transmittal folders
+   - At least one transmittal folder must be selected to see files
+   - Selecting transmittal folders shows only their files
+   - Multiple selections combine results
+   - **Default Selection**: All folders selected except "incoming" and its subfolders
+
+### File Grouping Logic
+Files with the same tracking number are grouped together, showing:
+- Base revisions (A, B, C, 1, 2, 3)
+- Revision modifiers (+C1, +B1, +N1)
+- Draft indicators (~A, ~B)
+- Multiple file types per revision
+
+
+## Filtering
+
+Each column has a text filter input. The syntax supports simple boolean logic per field:
+- Required token: `+token` must be present in that field.
+- Prohibited token: `-token` must not be present.
+- Parentheses group sub‑expressions: `(+revA plan)`.
+- Terms (without +/−) are OR’ed within the same field: `as-built asbuilt`.
+- Wildcard support: `+token*` (starts with), `*token` (ends with), `token` (contains)
+Examples:
+
+- Only PDFs: in EXT filter, type `+pdf`.
+- Exclude superseded: in Status, type `-superseded`.
+- Revisions A or B, but not Draft: in Revision, type `revA revB -draft`.
+- Title contains both "floor" and "plan": Title `+floor +plan`.
+
+## UI/UX Considerations
+
+### Visual Design
+- Clean, professional interface
+- Hover states for interactive elements
+- Clear visual hierarchy
+- Consistent spacing and alignment
+- Status color coding (optional)
+
+Status codes are prominently displayed alongside revisions without color coding. The status is always shown as part of the revision information for clarity.
+
+### Accessibility
+- Keyboard navigation support (Ctrl+Click, Shift+Click, Ctrl+A)
+- Right-click context menus for advanced operations
+- ARIA labels for screen readers
+- High contrast mode support
+- Resizable text and interface elements
+- Collapsible sections to reduce visual clutter
+
+### Error Handling
+- Graceful handling of permission errors
+- Clear error messages
+- Recovery options
+- Console logging for debugging
+
+
+## Browser Compatibility
+
+- **Required**: Chromium-based browsers (Chrome, Edge, Brave) for File System Access API
+- **Fallback**: Display message for unsupported browsers
+- **Print Styles**: Optimized for US Letter (8.5×11")
+- **Responsive Design**: Works on desktop and tablet screens
+
+## Windows Path Length Limitations
+
+The application includes safeguards for Windows' 260-character path limit:
+
+- **Path Length Monitoring**: Warns when paths exceed 240 characters
+- **Depth Limits**: Stops scanning directories deeper than 10 levels
+- **Path Truncation**: Long paths are truncated in the UI while maintaining full paths internally
+- **Graceful Failure**: Files with paths too long are skipped with console warnings
+- **Display Optimization**: Shows `...` with shortened paths for better readability
+
+To enable long path support in Windows 10 (1607+):
+1. Run `gpedit.msc` as Administrator
+2. Navigate to: Computer Configuration → Administrative Templates → System → Filesystem
+3. Enable "Enable Win32 long paths"
+4. Restart your computer
+
+## Security Considerations
+
+- No data leaves the browser
+- All processing happens locally
+- Directory permissions requested per-session
+- No tracking or analytics
+
+## File Preview
+
+Clicking on a file link opens it in a new browser tab if the browser can display it (PDFs, images, text files), otherwise triggers a download.
+
+## Deliverables
+
+1. **Single HTML file** (`archive.html`) containing all functionality
+2. **Modular source code** organized as:
+    - `js/` - JavaScript modules
+    - `css/` - CSS modules
+    - `template.html` - HTML template
+    - `build.sh` - Build script
+3. **Documentation** embedded in the final HTML file
+
+## CSS/JS Architecture
+
+### CSS Files (loaded in dependency order)
+
+| File | Size | Purpose |
+|------|------|---------|
+| `css/base.css` | 1.5KB | Core styles, layout reset, typography, theme variables |
+| `css/components.css` | 10KB | Button styles, inputs, modal dialogs, menu systems |
+| `css/layout.css` | 3.7KB | Page structure, header/footer, container width |
+| `css/table.css` | 3.4KB | Table styling, cell padding, border styles, sorting headers |
+| `css/print.css` | 2.2KB | Print-specific styles, hide interactive elements |
+
+### JavaScript Modules (loaded in dependency order)
+
+| File | Size | Purpose |
+|------|------|---------|
+| `js/parser.js` | 7.4KB | ZDDC filename parsing, revision extraction, status validation |
+| `js/hash.js` | 5.9KB | SHA-256 hashing for file integrity verification |
+| `js/drag-drop.js` | 9.1KB | File system access API integration, drag-and-drop handling |
+| `js/directory.js` | 11.9KB | Directory scanning, folder tree rendering, path handling |
+| `js/filtering.js` | 8.8KB | Boolean filter logic, column filtering, show/hide rows |
+| `js/table.js` | 26KB | Table rendering, row management, selection handling |
+| `js/export.js` | 8.2KB | JSON export, file download with ZDDC naming |
+| `js/events.js` | 18.9KB | Event bus, state change notifications, UI coordination |
+| `js/app.js` | 19.6KB | Main entry point, initialization, state management |
+
diff --git a/archive/build.sh b/archive/build.sh
new file mode 100644
index 0000000..264dd1a
--- /dev/null
+++ b/archive/build.sh
@@ -0,0 +1,88 @@
+#!/bin/sh
+set -eu
+
+root_dir=$(cd "$(dirname "$0")" && pwd)
+. "$root_dir/../shared/build-lib.sh"
+
+src_html="$root_dir/template.html"
+output_dir="$root_dir/dist"
+output_html="$output_dir/archive.html"
+
+mkdir -p "$output_dir"
+ensure_exists "$src_html"
+
+css_temp=$(mktemp)
+js_raw=$(mktemp)
+js_temp=$(mktemp)
+cleanup() { rm -f "$css_temp" "$js_raw" "$js_temp"; }
+trap cleanup EXIT
+
+# CSS files to concatenate in order
+concat_files \
+  "../shared/base.css" \
+  "css/base.css" \
+  "css/layout.css" \
+  "css/components.css" \
+  "css/table.css" \
+  "css/print.css" \
+  > "$css_temp"
+
+# JavaScript files to concatenate in order
+concat_files \
+  "../shared/zddc.js" \
+  "../shared/hash.js" \
+  "../shared/theme.js" \
+  "js/init.js" \
+  "js/parser.js" \
+  "js/source.js" \
+  "js/hash.js" \
+  "js/drag-drop.js" \
+  "js/directory.js" \
+  "../shared/zddc-filter.js" \
+  "js/filtering.js" \
+  "js/table.js" \
+  "js/export.js" \
+  "js/presets.js" \
+  "js/url-state.js" \
+  "js/events.js" \
+  "js/app.js" \
+  "../shared/help.js" \
+  > "$js_raw"
+
+# Escape '</' in inlined JS so the HTML parser cannot mistake string contents
+# for a closing </script> tag. Required for any tool with template literals.
+escape_js_close_tags "$js_raw" "$js_temp"
+
+compute_build_label "archive" "${1:-}" "${2:-}"
+
+# Process template: inject CSS/JS, substitute build label, strip CDN refs.
+awk -v css_file="$css_temp" -v js_file="$js_temp" -v build_label="$build_label" -v is_red="$is_red" '
+  /\{\{CSS_PLACEHOLDER\}\}/ {
+    while ((getline line < css_file) > 0) print line
+    close(css_file)
+    next
+  }
+  /\{\{JS_PLACEHOLDER\}\}/ {
+    while ((getline line < js_file) > 0) print line
+    close(js_file)
+    next
+  }
+  /\{\{BUILD_LABEL\}\}/ {
+    if (is_red == "1") {
+      gsub(/\{\{BUILD_LABEL\}\}/, "<span style=\"color:red;font-weight:bold\">" build_label "</span>")
+    } else {
+      gsub(/\{\{BUILD_LABEL\}\}/, build_label)
+    }
+    print
+    next
+  }
+  /<script src="https?:\/\// { next }
+  /<link rel="stylesheet" href="https?:\/\// { next }
+  { print }
+' "$src_html" > "$output_html"
+
+echo "Wrote $output_html"
+
+if [ "$is_release" = "1" ]; then
+    promote_release "archive"
+fi
diff --git a/archive/css/base.css b/archive/css/base.css
new file mode 100644
index 0000000..3cf2c4d
--- /dev/null
+++ b/archive/css/base.css
@@ -0,0 +1,32 @@
+/* Archive-specific base overrides
+   Reset, tokens, and font are provided by shared/base.css */
+
+#appContainer {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    overflow: hidden;
+}
+
+.note {
+    font-size: 0.9em;
+    color: var(--text-muted);
+    font-style: italic;
+}
+
+/* Scan spinner */
+.scan-spinner {
+    display: inline-block;
+    width: 0.85em;
+    height: 0.85em;
+    border: 2px solid var(--border);
+    border-top-color: var(--primary);
+    border-radius: 50%;
+    animation: spin 0.7s linear infinite;
+    vertical-align: middle;
+    margin-left: 0.4rem;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
diff --git a/archive/css/components.css b/archive/css/components.css
new file mode 100644
index 0000000..8a5f08d
--- /dev/null
+++ b/archive/css/components.css
@@ -0,0 +1,899 @@
+/* Archive component styles — tokens from shared/base.css */
+
+/* Select All checkbox label */
+.select-all-label {
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    font-size: 0.8rem;
+    color: var(--text-muted);
+    cursor: pointer;
+    white-space: nowrap;
+}
+
+.select-all-label input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+/* One-line bar variant — sits below the section header */
+.select-all-bar {
+    padding: 0.2rem 0;
+    margin-bottom: 0.35rem;
+}
+
+/* Filter + Select All inline row */
+.filter-select-row {
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    margin-bottom: 0.35rem;
+}
+
+.filter-select-row .filter-input {
+    flex: 1;
+    margin-bottom: 0;
+}
+
+/* Inline variant: label to the right of the filter, text above checkbox */
+.select-all-inline {
+    flex-shrink: 0;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.1rem;
+    font-size: 0.7rem;
+    line-height: 1.1;
+    color: var(--text-muted);
+    cursor: pointer;
+    white-space: nowrap;
+    text-align: center;
+}
+
+.select-all-inline input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+/* Form Inputs */
+.filter-input,
+.form-input {
+    width: 100%;
+    padding: 0.5rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    font-size: 0.9rem;
+    font-family: var(--font);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.2s;
+}
+
+.filter-input:focus,
+.form-input:focus {
+    outline: none;
+    border-color: var(--primary);
+}
+
+.filter-input.filter-active {
+    background: rgba(234, 179, 8, 0.18);
+    border-color: rgba(234, 179, 8, 0.7);
+}
+
+/* Form Groups */
+.form-group {
+    margin-bottom: 1rem;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 0.25rem;
+    font-weight: 500;
+}
+
+.form-help {
+    display: block;
+    margin-top: 0.25rem;
+    font-size: 0.85rem;
+    color: var(--text-muted);
+}
+
+/* Checkboxes */
+input[type="checkbox"] {
+    margin-right: 0.5rem;
+    cursor: pointer;
+}
+
+/* Folder Tree Chevrons */
+.folder-chevron {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1rem;
+    height: 1rem;
+    font-size: 0.6rem;
+    color: var(--text-muted);
+    cursor: pointer;
+    transition: transform 0.15s ease;
+    flex-shrink: 0;
+    margin-right: 0.25rem;
+}
+
+.folder-chevron:not(.collapsed) {
+    transform: rotate(90deg);
+}
+
+.folder-chevron:hover {
+    color: var(--primary);
+}
+
+.folder-chevron-placeholder {
+    width: 1rem;
+    flex-shrink: 0;
+    margin-right: 0.25rem;
+}
+
+/* Folder Items */
+.folder-item {
+    display: flex;
+    align-items: center;
+    padding: 0.25rem 0.5rem;
+    cursor: pointer;
+    user-select: none;
+    border-radius: 3px;
+    border-left: 3px solid transparent;
+}
+
+.folder-item:hover {
+    background: var(--bg-hover);
+}
+
+.folder-item.selected {
+    background: var(--bg-selected);
+    color: inherit;
+    border-left: 3px solid var(--primary);
+    padding-left: calc(0.5rem - 3px);
+}
+
+.folder-item.selected:hover {
+    background: var(--bg-hover);
+}
+
+.folder-item-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    user-select: text;
+    cursor: text;
+}
+
+/* Transmittal folder formatting */
+.transmittal-folder-content {
+    flex: 1;
+    overflow: hidden;
+    user-select: text;
+    cursor: text;
+}
+
+[data-folder-type="transmittal"] {
+    padding-top: 0.5rem;
+    padding-bottom: 0.5rem;
+}
+
+.transmittal-first-line {
+    font-size: 0.9em;
+    font-weight: 500;
+    color: var(--text);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.transmittal-second-line {
+    font-size: 0.85em;
+    color: var(--text-muted);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* Empty filter message in folder lists */
+.folder-list-empty {
+    padding: 0.75rem 0.5rem;
+    color: var(--text-muted);
+    font-size: 0.85rem;
+    font-style: italic;
+    text-align: center;
+}
+
+/* Focus styles for keyboard navigation */
+.folder-list:focus {
+    outline: 2px solid var(--primary);
+    outline-offset: -2px;
+}
+
+.folder-list:focus .folder-item:focus {
+    outline: 1px dotted var(--primary);
+    outline-offset: -1px;
+}
+
+/* ── Folder type toggle bar ─────────────────────────────────────────────── */
+.folder-type-bar {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.3rem;
+    padding: 0.3rem 0 0.4rem;
+    flex-shrink: 0;
+}
+
+.folder-type-toggle {
+    padding: 0.2rem 0.6rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: 999px;
+    background: var(--bg);
+    color: var(--text-muted);
+    cursor: pointer;
+    transition: background 0.15s, color 0.15s, border-color 0.15s;
+    line-height: 1.4;
+    white-space: nowrap;
+}
+
+.folder-type-toggle:hover {
+    background: var(--bg-hover);
+    color: var(--text);
+    border-color: var(--border-dark);
+}
+
+.folder-type-toggle.active {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.folder-type-toggle.active:hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+}
+
+/* Date Group Headers */
+.date-group-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    cursor: pointer;
+    user-select: none;
+    font-weight: 600;
+    color: var(--text);
+    position: sticky;
+    top: 0;
+    z-index: 1;
+}
+
+.date-group-header:hover {
+    background: var(--bg-hover);
+}
+
+.date-group-toggle {
+    font-size: 0.8em;
+    width: 1rem;
+    text-align: center;
+}
+
+.date-group-date {
+    flex: 1;
+}
+
+.date-group-count {
+    font-size: 0.85em;
+    color: var(--text-muted);
+    font-weight: normal;
+}
+
+/* Nav section header with button */
+.nav-section-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: var(--bg-secondary);
+    margin: -1rem -1rem 0.75rem -1rem;
+    padding: 0.4rem 1rem;
+    border-bottom: 1px solid var(--border);
+}
+
+.nav-section-header h3 {
+    margin-bottom: 0;
+}
+
+.btn-icon {
+    background: none;
+    border: none;
+    padding: 0.25rem;
+    cursor: pointer;
+    color: var(--text-muted);
+    font-size: 1rem;
+    line-height: 1;
+    border-radius: 3px;
+    transition: background 0.2s;
+}
+
+.btn-icon:hover {
+    background: var(--bg-hover);
+    color: var(--text);
+}
+
+/* Modals */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    z-index: 1000;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.modal-backdrop {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+}
+
+.modal-content {
+    position: relative;
+    background: var(--bg);
+    border-radius: 8px;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+    max-width: 90vw;
+    max-height: 90vh;
+    display: flex;
+    flex-direction: column;
+}
+
+.modal-large {
+    width: 80vw;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--border);
+}
+
+.modal-header h2 {
+    margin: 0;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    font-size: 1.5rem;
+    color: var(--text-muted);
+    padding: 0;
+    width: 2rem;
+    height: 2rem;
+    cursor: pointer;
+}
+
+.modal-close:hover {
+    color: var(--text);
+}
+
+.modal-body {
+    padding: 1.5rem;
+    overflow-y: auto;
+    flex: 1;
+}
+
+.modal-footer {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.5rem;
+    padding: 1rem 1.5rem;
+    border-top: 1px solid var(--border);
+}
+
+/* Preview Table */
+.preview-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-top: 0.5rem;
+}
+
+.preview-table th,
+.preview-table td {
+    text-align: left;
+    padding: 0.5rem;
+    border-bottom: 1px solid var(--border);
+}
+
+.preview-table th {
+    font-weight: 600;
+    background: var(--bg-secondary);
+}
+
+/* Drag & Drop */
+.drag-over {
+    background: var(--bg-selected) !important;
+    border-color: var(--primary) !important;
+}
+
+/* Loading Spinner */
+.spinner {
+    display: inline-block;
+    width: 1rem;
+    height: 1rem;
+    border: 2px solid var(--border);
+    border-top: 2px solid var(--primary);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    0%   { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Revision Title Styling */
+.titles-container {
+    display: flex;
+    flex-direction: column;
+}
+
+.revision-title-base,
+.revision-title-modifier {
+    margin-bottom: 0.5rem;
+}
+
+.revision-title-base:last-child,
+.revision-title-modifier:last-child {
+    margin-bottom: 0;
+}
+
+.revision-title-base {
+    color: var(--text);
+}
+
+.revision-title-modifier {
+    color: var(--text-muted);
+}
+
+/* Modifier Filter Dropdown */
+.modifier-filter-container {
+    position: relative;
+    display: inline-block;
+}
+
+.modifier-filter-btn {
+    min-width: 100px;
+}
+
+.modifier-filter-dropdown {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    z-index: 1000;
+    min-width: 180px;
+    background: var(--bg);
+    border: 1px solid var(--border-dark);
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    margin-top: 4px;
+}
+
+.modifier-filter-header {
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--border);
+    background: var(--bg-secondary);
+}
+
+.modifier-filter-header label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-weight: 500;
+    cursor: pointer;
+}
+
+.modifier-filter-list {
+    max-height: 250px;
+    overflow-y: auto;
+    padding: 0.25rem 0;
+}
+
+.modifier-filter-item {
+    padding: 0.4rem 0.75rem;
+}
+
+.modifier-filter-item label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+    font-size: 0.9rem;
+}
+
+.modifier-filter-item:hover {
+    background: var(--bg-hover);
+}
+
+.modifier-base {
+    font-weight: 500;
+    color: var(--text);
+}
+
+.modifier-type {
+    color: var(--text-muted);
+}
+
+/* Active toggle button state */
+.btn-active {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-active:hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+}
+
+/* Path Error Row Warning */
+.file-row-path-error {
+    background: rgba(217, 119, 6, 0.08) !important;
+}
+
+.file-row-path-error:hover {
+    background: rgba(217, 119, 6, 0.15) !important;
+}
+
+.path-error-indicator {
+    color: var(--warning);
+    cursor: help;
+    margin-right: 0.25rem;
+}
+
+.file-link-disabled {
+    color: var(--text-muted);
+    text-decoration: none;
+    cursor: not-allowed;
+}
+
+.file-link-disabled:hover {
+    text-decoration: none;
+    color: var(--text-muted);
+}
+
+/* PDF Preview Toggle */
+.preview-toggle-label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.9rem;
+    color: var(--text);
+    cursor: pointer;
+    padding: 0.4rem 0.85rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    transition: background 0.15s;
+}
+
+.preview-toggle-label:hover {
+    background: var(--bg-secondary);
+}
+
+.preview-toggle-label input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+.preview-toggle-label input[type="checkbox"]:checked + span {
+    color: var(--primary);
+    font-weight: 500;
+}
+
+/* ── Download progress indicator ────────────────────────────────────────── */
+.progress-indicator {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+    z-index: 1000;
+    min-width: 300px;
+}
+
+.progress-indicator__message {
+    margin-bottom: 10px;
+}
+
+.progress-indicator__track {
+    background: var(--bg-secondary);
+    height: 20px;
+    border-radius: 10px;
+    overflow: hidden;
+}
+
+.progress-indicator__fill {
+    background: var(--primary);
+    height: 100%;
+    transition: width 0.3s;
+}
+
+.progress-indicator__label {
+    text-align: center;
+    margin-top: 5px;
+    font-size: 0.9em;
+    color: var(--text-muted);
+}
+
+/* ── Welcome screen list ─────────────────────────────────────────────────── */
+.welcome-list {
+    text-align: left;
+    margin: 0.5rem auto;
+    max-width: 400px;
+}
+
+/* ── Windows path tip (inside welcome screen) ────────────────────────────── */
+.windows-tip {
+    text-align: left;
+    margin: 1rem auto;
+    max-width: 500px;
+    font-size: 0.9rem;
+}
+
+.windows-tip summary {
+    cursor: pointer;
+    color: var(--text-muted);
+}
+
+.windows-tip__body {
+    margin-top: 0.5rem;
+    padding: 0.75rem;
+    background: var(--bg);
+    border: 1px solid var(--warning);
+    border-radius: var(--radius);
+}
+
+.windows-tip__body > p:first-child {
+    margin: 0 0 0.5rem 0;
+}
+
+.windows-tip__body ol {
+    margin: 0.5rem 0;
+    padding-left: 1.5rem;
+}
+
+.windows-tip__code {
+    display: block;
+    margin: 0.25rem 0;
+    padding: 0.25rem 0.5rem;
+    background: var(--bg-secondary);
+    border-radius: var(--radius);
+    font-family: var(--font-mono);
+    font-size: 0.85em;
+}
+
+.windows-tip__note {
+    margin: 0.5rem 0 0 0;
+    font-size: 0.85rem;
+    color: var(--text-muted);
+}
+
+/* Outstanding virtual transmittal — pinned at top of transmittal list */
+.outstanding-transmittal {
+    border-top: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 0.25rem;
+}
+
+.outstanding-label {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+.outstanding-transmittal.selected .outstanding-label {
+    color: var(--text);
+}
+
+/* Reset Filters Button */
+.btn-icon-only {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 2rem;
+    height: 2rem;
+    font-size: 1.1rem;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    cursor: pointer;
+    transition: background 0.2s, border-color 0.2s, color 0.2s;
+}
+
+.btn-icon-only:hover {
+    background: var(--bg-hover);
+    border-color: var(--primary);
+}
+
+.btn-icon-only:active {
+    background: var(--primary);
+    border-color: var(--primary);
+    color: var(--text-light);
+}
+
+/* Toolbar separator */
+.toolbar-separator {
+    width: 1px;
+    height: 1.5rem;
+    background: var(--border);
+    margin: 0 0.25rem;
+    align-self: center;
+    flex-shrink: 0;
+}
+
+/* ── Preset dropdown ─────────────────────────────────────────────────────── */
+.preset-section {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+}
+
+.preset-dropdown {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    z-index: 1000;
+    min-width: 350px;
+    max-height: 400px;
+    background: var(--bg);
+    border: 1px solid var(--border-dark);
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+}
+
+.preset-section-label {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--text-muted);
+    padding: 0.5rem 0.75rem 0.25rem;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.preset-list {
+    padding: 0.25rem 0;
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.preset-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.4rem 0.75rem;
+    cursor: pointer;
+    user-select: none;
+}
+
+.preset-item:hover {
+    background: var(--bg-hover);
+}
+
+.preset-item .preset-delete {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1rem;
+    padding: 0.25rem 0.5rem;
+    cursor: pointer;
+    border-radius: 3px;
+    line-height: 1;
+}
+
+.preset-item .preset-delete:hover {
+    background: rgba(255, 0, 0, 0.1);
+    color: var(--error);
+}
+
+.preset-no-presets {
+    padding: 0.75rem 0.75rem;
+    color: var(--text-muted);
+    font-size: 0.85rem;
+    font-style: italic;
+    text-align: center;
+}
+
+.preset-divider {
+    height: 1px;
+    background: var(--border);
+    margin: 0.5rem 0;
+}
+
+.preset-projects-list {
+    padding: 0.25rem 0;
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.preset-project-item {
+    padding: 0.25rem 0.75rem;
+}
+
+.preset-project-label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+    font-size: 0.9rem;
+    user-select: none;
+}
+
+.preset-project-label input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+.preset-footer-actions {
+    padding: 0.5rem 0.75rem;
+    border-top: 1px solid var(--border);
+    background: var(--bg-secondary);
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+}
+
+.preset-footer-naming {
+    padding: 0.5rem 0.75rem;
+    border-top: 1px solid var(--border);
+    background: var(--bg-secondary);
+    display: flex;
+    gap: 0.5rem;
+}
+
+.preset-name-input {
+    flex: 1;
+    padding: 0.4rem 0.6rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    font-size: 0.9rem;
+    font-family: var(--font);
+    background: var(--bg);
+    color: var(--text);
+}
+
+.preset-name-input:focus {
+    outline: none;
+    border-color: var(--primary);
+}
+
+.preset-section-top,
+.preset-section-bottom {
+    padding: 0.25rem 0;
+}
+
+.preset-section-bottom {
+    flex: 1;
+    overflow-y: auto;
+}
+
+
diff --git a/archive/css/layout.css b/archive/css/layout.css
new file mode 100644
index 0000000..3ed4949
--- /dev/null
+++ b/archive/css/layout.css
@@ -0,0 +1,279 @@
+/* Archive layout — tokens from shared/base.css */
+
+/* Header — shared/base.css provides base .app-header; add archive-specific overrides */
+.app-header {
+    padding: 0.5rem 1rem;
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.header-right {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+}
+
+.preview-toggle-label {
+    display: flex;
+    align-items: center;
+    gap: 0.35rem;
+    font-size: 0.875rem;
+    cursor: pointer;
+    white-space: nowrap;
+}
+
+/* Main Container */
+.main-container {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+}
+
+/* Navigation Pane */
+.nav-pane {
+    width: 300px;
+    min-width: 200px;
+    background: var(--bg);
+    border-right: 1px solid var(--border);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    height: 100%;
+    position: relative;
+}
+
+.nav-section {
+    display: flex;
+    flex-direction: column;
+    padding: 1rem;
+    border-bottom: 1px solid var(--border);
+    overflow: hidden;
+    position: relative;
+}
+
+/* Grouping section - larger default size */
+.nav-section:first-child {
+    flex: 0 0 auto;
+    height: 250px;
+    min-height: 50px;
+}
+
+/* Grouping section when collapsed */
+.nav-section:first-child.collapsed {
+    height: auto;
+    flex: 0 0 auto;
+}
+
+/* Transmittal section takes remaining space */
+.nav-section:last-child {
+    flex: 1;
+    min-height: 150px;
+    border-bottom: none;
+}
+
+/* Nav section content wrapper */
+.nav-section-content {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    overflow: hidden;
+    min-height: 0;
+}
+
+/* Hide content when collapsed */
+.nav-section.collapsed .nav-section-content {
+    display: none;
+}
+
+/* Resize handles — persistent 1px divider; grab cursor on hover */
+.resize-handle-horizontal {
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 5px;
+    cursor: ew-resize;
+    z-index: 10;
+    /* Persistent 1px right-edge indicator */
+    border-right: 1px solid var(--border-dark);
+}
+
+.resize-handle-horizontal:hover,
+.resize-handle-horizontal.resizing {
+    background: rgba(42, 90, 138, 0.25);
+    cursor: col-resize;
+}
+
+.resize-handle-vertical {
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: -3px;
+    height: 6px;
+    cursor: ns-resize;
+    z-index: 10;
+    /* Persistent 1px bottom-edge indicator */
+    border-bottom: 1px solid var(--border-dark);
+}
+
+.resize-handle-vertical:hover,
+.resize-handle-vertical.resizing {
+    background: rgba(42, 90, 138, 0.25);
+    cursor: row-resize;
+}
+
+.nav-section h3 {
+    font-size: 1em;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    margin-bottom: 0.5rem;
+    flex-shrink: 0;
+}
+
+.nav-section h3 {
+    font-size: 1em;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    margin-bottom: 0;
+    flex-shrink: 0;
+}
+
+.folder-list {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+    margin-top: 0.5rem;
+    min-height: 0;
+}
+
+/* Content Area */
+.content-area {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background: var(--bg-secondary);
+    overflow: hidden;
+}
+
+.content-header {
+    display: flex;
+    justify-content: flex-start;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.75rem 1rem;
+    background: var(--bg);
+    border-bottom: 1px solid var(--border);
+}
+
+.content-header .content-actions {
+    margin-left: auto;
+}
+
+.content-actions {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+}
+
+/* Table Container */
+.table-container {
+    flex: 1;
+    overflow: auto;
+    background: var(--bg);
+    margin: 1rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+}
+
+/* Status Bar */
+.status-bar {
+    display: flex;
+    justify-content: flex-start;
+    align-items: center;
+    padding: 0.35rem 1rem;
+    background: var(--bg);
+    border-top: 1px solid var(--border);
+    font-size: 0.85em;
+    color: var(--text-muted);
+    gap: 1rem;
+}
+
+/* Empty State — positioned below the app header */
+.empty-state {
+    position: absolute;
+    top: 50px; /* clear the header */
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--bg);
+    z-index: 10;
+}
+
+.empty-state-content {
+    text-align: center;
+    max-width: 500px;
+    padding: 2rem;
+}
+
+/* Project warning banner */
+.project-warning-banner {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 16px;
+    background: #fff3cd;
+    border-bottom: 1px solid #ffc107;
+    color: #664d03;
+    font-size: 0.875rem;
+    gap: 12px;
+}
+.project-warning-banner.hidden { display: none; }
+.project-warning-dismiss {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #664d03;
+    font-size: 1rem;
+    padding: 0 4px;
+    flex-shrink: 0;
+}
+
+.empty-state-content h2 {
+    color: var(--text);
+    margin-bottom: 1rem;
+}
+
+.empty-state-content p {
+    margin-bottom: 1rem;
+    color: var(--text-muted);
+}
+
+/* Project access warning banner */
+.project-warning-banner {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 16px;
+    background: #fff3cd;
+    border-bottom: 1px solid #ffc107;
+    color: #664d03;
+    font-size: 0.875rem;
+    gap: 12px;
+}
+.project-warning-banner.hidden { display: none; }
+.project-warning-dismiss {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #664d03;
+    font-size: 1rem;
+    padding: 0 4px;
+    flex-shrink: 0;
+}
diff --git a/archive/css/print.css b/archive/css/print.css
new file mode 100644
index 0000000..4f26951
--- /dev/null
+++ b/archive/css/print.css
@@ -0,0 +1,121 @@
+/* Print styles */
+
+@media print {
+    /* Hide UI elements */
+    .app-header,
+    .nav-pane,
+    .content-header,
+    .status-bar,
+    .modal,
+    .btn,
+    .filter-input,
+    .global-search,
+    .column-filter,
+    input[type="checkbox"],
+    .resize-handle,
+    .sort-indicator {
+        display: none !important;
+    }
+
+    /* Reset layout */
+    body {
+        font-size: 10pt;
+        line-height: 1.4;
+    }
+
+    #appContainer {
+        height: auto;
+    }
+
+    .main-container {
+        display: block;
+    }
+
+    .content-area {
+        background: white;
+    }
+
+    .table-container {
+        margin: 0;
+        border: none;
+        overflow: visible;
+    }
+
+    /* Table adjustments */
+    .files-table {
+        font-size: 9pt;
+        border: 1px solid #000;
+    }
+
+    .files-table thead {
+        position: static;
+    }
+
+    .files-table th {
+        background: #f0f0f0;
+        border: 1px solid #000;
+        padding: 4pt 6pt;
+        font-weight: bold;
+    }
+
+    .files-table td {
+        border: 1px solid #000;
+        padding: 3pt 6pt;
+    }
+
+    .files-table tbody tr:hover {
+        background: transparent;
+    }
+
+    /* Show only text content for revisions */
+    .revision-item {
+        display: inline;
+        margin-right: 0.5em;
+    }
+
+    .file-link {
+        color: black;
+        text-decoration: none;
+    }
+
+    .file-link::after {
+        content: " (" attr(href) ")";
+        font-size: 8pt;
+        color: #666;
+    }
+
+    /* Page breaks */
+    .files-table {
+        page-break-inside: auto;
+    }
+
+    .files-table tr {
+        page-break-inside: avoid;
+        page-break-after: auto;
+    }
+
+    /* Header on each page */
+    @page {
+        size: letter portrait;
+        margin: 0.5in;
+    }
+
+    /* Add document title */
+    body::before {
+        content: "Archive Browser Report";
+        display: block;
+        font-size: 16pt;
+        font-weight: bold;
+        margin-bottom: 12pt;
+    }
+
+    /* Add timestamp */
+    body::after {
+        content: "Generated: " attr(data-print-date);
+        display: block;
+        margin-top: 12pt;
+        font-size: 9pt;
+        color: #666;
+        text-align: right;
+    }
+}
diff --git a/archive/css/table.css b/archive/css/table.css
new file mode 100644
index 0000000..f03dadf
--- /dev/null
+++ b/archive/css/table.css
@@ -0,0 +1,231 @@
+/* Table styles */
+
+.files-table {
+    width: 100%;
+    border-collapse: collapse;
+    background: var(--bg);
+}
+
+/* Table Header */
+.files-table thead {
+    position: sticky;
+    top: 0;
+    background: var(--bg);
+    z-index: 10;
+}
+
+.files-table th {
+    position: relative;
+    text-align: left;
+    font-weight: 600;
+    background: var(--bg-secondary);
+    border-bottom: 2px solid var(--border);
+    user-select: none;
+}
+
+.th-content {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    cursor: default;
+}
+
+.sortable .th-content {
+    cursor: pointer;
+}
+
+.sortable .th-content:hover {
+    background: var(--bg-hover);
+}
+
+/* Sort Indicators */
+.sort-indicator {
+    display: inline-block;
+    width: 0.75rem;
+    height: 1rem;
+    margin-left: 0.5rem;
+    position: relative;
+}
+
+.sort-indicator::before,
+.sort-indicator::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    width: 0;
+    height: 0;
+    border-style: solid;
+}
+
+.sort-indicator::before {
+    top: 0;
+    border-width: 0 0.375rem 0.375rem 0.375rem;
+    border-color: transparent transparent var(--border-dark) transparent;
+}
+
+.sort-indicator::after {
+    bottom: 0;
+    border-width: 0.375rem 0.375rem 0 0.375rem;
+    border-color: var(--border-dark) transparent transparent transparent;
+}
+
+th[data-sort="asc"] .sort-indicator::before {
+    border-bottom-color: var(--text);
+}
+
+th[data-sort="desc"] .sort-indicator::after {
+    border-top-color: var(--text);
+}
+
+/* Resize Handle */
+.resize-handle {
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 4px;
+    cursor: col-resize;
+    background: transparent;
+}
+
+.resize-handle:hover {
+    background: var(--primary);
+}
+
+/* Table Body */
+.files-table tbody tr {
+    transition: background-color 0.1s;
+}
+
+.files-table tbody tr.group-last {
+    border-bottom: 1px solid var(--border);
+}
+
+.files-table tbody tr:hover {
+    background: var(--bg-hover);
+}
+
+.files-table td {
+    padding: 0.25rem 1rem;
+    vertical-align: top;
+}
+
+/* Tracking Number Column */
+td[data-field="trackingNumber"],
+th[data-sort="trackingNumber"] {
+    white-space: nowrap;
+}
+
+td[data-field="trackingNumber"] {
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.9em;
+}
+
+/* Revisions Column */
+.revision-group {
+    margin-bottom: 0.5rem;
+}
+
+.revision-group:last-child {
+    margin-bottom: 0;
+}
+
+.revision-item {
+    display: flex;
+    align-items: center;
+    margin-bottom: 0.25rem;
+}
+
+.revision-item:last-child {
+    margin-bottom: 0;
+}
+
+.revision-info {
+    display: inline-flex;
+    align-items: center;
+    margin-right: 0.5rem;
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.9em;
+}
+
+.revision-id {
+    font-weight: 600;
+    margin-right: 0.25rem;
+}
+
+.revision-status {
+    color: var(--text-muted);
+    font-size: 0.85em;
+}
+
+.revision-file {
+    display: inline-flex;
+    align-items: center;
+    margin-left: 0.25rem;
+}
+
+.file-link,
+.file-link-disabled {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: flex-start;
+    margin-right: 0.25rem;
+    line-height: 1.1;
+}
+
+.file-link {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+.file-link:hover {
+    text-decoration: underline;
+}
+
+
+.file-ext {
+    color: var(--text-muted);
+    font-size: 0.85em;
+    text-transform: uppercase;
+}
+
+/* Empty Table State */
+.empty-table {
+    text-align: center;
+    padding: 3rem;
+    color: var(--text-muted);
+}
+
+/* Column Widths */
+.files-table th:nth-child(1),
+.files-table td:nth-child(1) {
+    width: 240px;
+    min-width: 220px;
+}
+
+.files-table th:nth-child(2),
+.files-table td:nth-child(2) {
+    width: 40%;
+    min-width: 200px;
+}
+
+.files-table th:nth-child(3),
+.files-table td:nth-child(3) {
+    width: auto;
+    min-width: 300px;
+}
+
+/* File size — half the height of the extension badge, left-aligned below it */
+.file-size {
+    color: var(--text-muted);
+    font-size: 0.5em;
+    line-height: 1;
+    margin-top: 0.15em;
+}
+
+/* Active column filter highlight */
+.column-filter.filter-active {
+    background: rgba(234, 179, 8, 0.18);
+    border-color: rgba(234, 179, 8, 0.7);
+}
diff --git a/archive/js/app.js b/archive/js/app.js
new file mode 100644
index 0000000..1a2bd4b
--- /dev/null
+++ b/archive/js/app.js
@@ -0,0 +1,888 @@
+(function() {
+    'use strict';
+    // window.app is initialized in init.js. Reference shape (read-only docs):
+    //   directories[], groupingFolders[], transmittalFolders[], files[],
+    //   filteredFiles[], selectedFiles:Set, sourceMode ('local'|'http'),
+    //   isScanning, scanProgress,
+    //   columnFilters {trackingNumber,title,revisions}, columnFilterASTs {...},
+    //   groupingFilter, transmittalFilter,
+    //   enabledFolderTypes:Set('issued','received'),
+    //   sortField ('trackingNumber'), sortDirection ('asc'|'desc'),
+    //   selectedGroupingFolders:Set, selectedTransmittalFolders:Set,
+    //   collapsedDateGroups:Set, collapsedGroupingFolders:Set,
+    //   selectAllGroupingFolders:bool, selectAllTransmittals:bool,
+    //   availableModifiers:Set, selectedModifiers:Set, showSelectedOnly:bool
+
+    // Parse search terms from filter string
+    function parseSearchTerms(filter) {
+        if (!filter || !filter.trim()) return [];
+        return filter.trim().toLowerCase().split(/\s+/);
+    }
+
+    // Check if text matches all search terms (AND logic)
+    function matchesSearchTerms(text, terms) {
+        if (!terms || terms.length === 0) return true;
+        return terms.every(term => text.includes(term));
+    }
+
+    // Initialize application
+    function initApp() {
+        // Detect source mode from protocol
+        window.app.sourceMode = (location.protocol === 'file:') ? 'local' : 'http';
+    
+        if (window.app.sourceMode === 'local') {
+            // Check File System Access API support (local mode only)
+            if (!('showDirectoryPicker' in window)) {
+                showUnsupportedBrowserMessage();
+                return;
+            }
+        }
+    
+        // Set up event listeners
+        window.app.modules.events.setupEventListeners();
+    
+        // Set up file link handlers (event delegation)
+        window.app.modules.table.setupFileLinkHandlers();
+    
+        // Apply source-mode-specific UI adjustments
+        applySourceModeUI();
+    
+        // Restore filter/sort state from URL query string
+        window.app.modules.urlState.restore();
+    
+        // Initialize UI
+        updateUI();
+    
+        // Show initial sort indicator
+        window.app.modules.table.updateSortIndicators();
+    
+        if (window.app.sourceMode === 'http') {
+            // Auto-connect to the server in HTTP mode
+            autoConnectHttpSource();
+        } else {
+            // Show empty state if no directories (local mode)
+            if (window.app.directories.length === 0) {
+                showEmptyState();
+            }
+        }
+    }
+
+    // Apply UI differences based on source mode
+    function applySourceModeUI() {
+        // "Add Local Directory" button is always visible in both modes —
+        // in HTTP mode the user can augment the online archive with local directories.
+    }
+
+    // Auto-connect to the HTTP server
+    // Derives the base URL from the current page's location
+    async function autoConnectHttpSource() {
+        var href = window.location.href;
+        // Strip query string and fragment
+        href = href.split('?')[0].split('#')[0];
+        // Strip the filename to get the directory
+        var lastSlash = href.lastIndexOf('/');
+        var baseUrl = (lastSlash >= 0) ? href.substring(0, lastSlash + 1) : href + '/';
+
+        // Check for projects that are in the URL filter but not accessible on the server
+        if (window.app.projectFilter && window.app.projectFilter.size > 0) {
+            try {
+                var resp = await fetch(baseUrl, { headers: { 'Accept': 'application/json' } });
+                if (resp.ok) {
+                    var serverProjects = await resp.json();
+                    var accessibleNames = new Set(serverProjects.map(function(p) { return p.name; }));
+                    var missing = Array.from(window.app.projectFilter).filter(function(p) {
+                        return !accessibleNames.has(p);
+                    });
+                    if (missing.length > 0) {
+                        showProjectWarning(missing);
+                    }
+                }
+            } catch (e) {
+                // Silently ignore — server may not support the project list API
+            }
+        }
+
+        await addHttpSource(baseUrl);
+    }
+
+    // Add an HTTP source root (analogous to addDirectory() for local mode)
+    async function addHttpSource(baseUrl) {
+        // Derive a display name from the URL path
+        var urlPath = baseUrl.replace(/\/$/, '');
+        var rootName = urlPath.substring(urlPath.lastIndexOf('/') + 1) || urlPath;
+    
+        // Check if already added
+        var exists = window.app.directories.some(function(d) { return d.url === baseUrl; });
+        if (exists) return;
+    
+        window.app.directories.push({
+            handle: null,
+            name: rootName,
+            path: rootName,
+            url: baseUrl
+        });
+    
+        if (window.app.directories.length === 1) {
+            hideEmptyState();
+        }
+    
+        await scanHttpSource(baseUrl, rootName);
+        updateUI();
+    }
+
+    // Scan an HTTP source root
+    async function scanHttpSource(baseUrl, rootName) {
+        window.app.isScanning = true;
+        window.app.scanProgress = 'Connecting to server...';
+        updateStatusBar();
+    
+        var source = window.app.modules.source.createSource('http', { baseUrl: baseUrl });
+    
+        var fileCount = 0;
+        var callbacks = {
+            onGroupingFolder: function(folder) {
+                window.app.groupingFolders.push(folder);
+            },
+            onTransmittalFolder: function(folder) {
+                window.app.transmittalFolders.push(folder);
+            },
+            onFile: function(file) {
+                window.app.files.push(file);
+                fileCount++;
+                // Throttled progress update — don't update DOM on every file
+                if (fileCount % 10 === 0) {
+                    window.app.scanProgress = 'Scanning\u2026 ' + fileCount + ' files found';
+                    updateStatusBar();
+                }
+            },
+            onProgress: function() { /* no-op: parallel scan — spinner is enough */ }
+        };
+    
+        try {
+            await source.scan(baseUrl, callbacks);
+        
+            // Auto-select top-level party folders (shallowest depth)
+            var groupingDepths = window.app.groupingFolders.map(function(f) { return f.path.split('/').length; });
+            var minGroupingDepth = groupingDepths.length > 0 ? Math.min.apply(null, groupingDepths) : 1;
+            window.app.groupingFolders.forEach(function(folder) {
+                if (folder.path.split('/').length === minGroupingDepth) {
+                    window.app.selectedGroupingFolders.add(folder.path);
+                }
+            });
+        
+            window.app.transmittalFolders.forEach(function(folder) {
+                if (!isUnderHiddenFolderType(folder.path)) {
+                    window.app.selectedTransmittalFolders.add(folder.path);
+                }
+            });
+        
+            ensureOutstandingTransmittal();
+            // Auto-select Outstanding if selectAllTransmittals is active
+            if (window.app.selectAllTransmittals) {
+                window.app.selectedTransmittalFolders.add('__outstanding__');
+            }
+        
+            collectModifiers();
+            updateUI();
+            window.app.modules.filtering.applyFilters();
+            if (window.app.modules.presets) {
+                window.app.modules.presets.init();
+            }
+        } catch (err) {
+            console.error('Error scanning HTTP source:', err);
+            showHttpErrorState(err.message);
+        } finally {
+            window.app.isScanning = false;
+            window.app.scanProgress = '';
+            updateStatusBar();
+        }
+    }
+
+    // Ensure the Outstanding virtual transmittal exists if there are any outstanding files.
+    // Called after each scan completes. Idempotent — safe to call multiple times.
+    function ensureOutstandingTransmittal() {
+        const hasOutstanding = window.app.files.some(f => f.folderPath === '__outstanding__');
+        const alreadyExists = window.app.transmittalFolders.some(f => f.path === '__outstanding__');
+        if (hasOutstanding && !alreadyExists) {
+            window.app.transmittalFolders.push({
+                name: 'Outstanding',
+                path: '__outstanding__',
+                displayPath: 'Outstanding',
+                handle: null,
+                url: null,
+                isVirtual: true
+            });
+        }
+    }
+
+    // Show error state when HTTP server is unreachable
+    function showHttpErrorState(message) {
+        var el = document.getElementById('noDirectoryMessage');
+        if (!el) return;
+        var content = el.querySelector('.empty-state-content');
+        if (content) {
+            content.innerHTML =
+                '<h2>Could not connect to server</h2>' +
+                '<p>The archive browser could not retrieve the directory listing from the server.</p>' +
+                '<p><strong>Error:</strong> ' + escapeHtml(message || 'Unknown error') + '</p>' +
+                '<p>Ensure the server is running, CORS is not blocking the request, and Caddy\'s file browsing is enabled.</p>';
+        }
+        el.classList.remove('hidden');
+    }
+
+    // Show a warning banner listing projects in the URL filter that the user cannot access
+    function showProjectWarning(missingProjects) {
+        var el = document.getElementById('projectWarningBanner');
+        if (!el || missingProjects.length === 0) return;
+        var list = missingProjects.map(function(p) { return escapeHtml(p); }).join(', ');
+        el.querySelector('.project-warning-text').innerHTML =
+            'This link includes projects you don\'t have access to: <strong>' + list + '</strong>';
+        el.classList.remove('hidden');
+    }
+
+    function dismissProjectWarning() {
+        var el = document.getElementById('projectWarningBanner');
+        if (el) el.classList.add('hidden');
+    }
+
+    // Show unsupported browser message
+    function showUnsupportedBrowserMessage() {
+        const app = document.getElementById('app');
+        app.innerHTML = `
+            <div class="empty-state">
+                <div class="empty-state-content">
+                    <h2>Browser Not Supported</h2>
+                    <p>This application requires a Chromium-based browser (Chrome, Edge, Brave) with File System Access API support.</p>
+                    <p>Please use one of these browsers to access the Archive Browser.</p>
+                </div>
+            </div>
+        `;
+    }
+
+    // Show empty state
+    function showEmptyState() {
+        document.getElementById('noDirectoryMessage').classList.remove('hidden');
+        document.querySelector('.main-container').style.display = 'none';
+        // Keep header visible
+        document.querySelector('.app-header').style.display = '';
+        var refreshBtn = document.getElementById('refreshHeaderBtn');
+        if (refreshBtn) { refreshBtn.classList.add('hidden'); }
+    }
+
+    // Hide empty state
+    function hideEmptyState() {
+        document.getElementById('noDirectoryMessage').classList.add('hidden');
+        document.querySelector('.main-container').style.display = '';
+        var refreshBtn = document.getElementById('refreshHeaderBtn');
+        if (refreshBtn) { refreshBtn.classList.remove('hidden'); }
+    }
+
+    // Update UI based on current state
+    function updateUI() {
+        renderFolderTypeBar();
+        renderFolderLists();
+        window.app.modules.table.updateFileTable();
+        updateStatusBar();
+    }
+
+    // Render folder lists (rebuilds DOM)
+    function renderFolderLists() {
+        renderGroupingFolders();
+        renderTransmittalFolders();
+    }
+
+    // Check if a folder path is under a hidden folder type
+    // Returns true if any path segment is a known folder type that is NOT currently enabled
+    function isUnderHiddenFolderType(path) {
+        const parts = path.toLowerCase().split('/');
+        return parts.some(part =>
+            window.app.FOLDER_TYPE_NAMES.includes(part) && !window.app.enabledFolderTypes.has(part)
+        );
+    }
+
+    // Get filtered grouping folders (single source of truth for filtering logic)
+    function getFilteredGroupingFolders() {
+        const filter = window.app.groupingFilter;
+    
+        return window.app.groupingFolders.filter(folder => {
+            if (isUnderHiddenFolderType(folder.path)) {
+                return false;
+            }
+        
+            if (!filter) return true;
+        
+            const terms = parseSearchTerms(filter);
+            return matchesSearchTerms(folder.name.toLowerCase(), terms);
+        });
+    }
+
+    // Render grouping folders as a flat list of party names (depth 1 only)
+    function renderGroupingFolders() {
+        const container = document.getElementById('groupingFoldersList');
+
+        // Get filtered grouping folders (uses shared filtering logic)
+        const filteredFolders = getFilteredGroupingFolders();
+
+        // Only show top-level party folders (the shallowest depth among all grouping folders)
+        const allDepths = window.app.groupingFolders.map(f => f.path.split('/').length);
+        const minDepth = allDepths.length > 0 ? Math.min(...allDepths) : 1;
+        const partyFolders = filteredFolders.filter(f => f.path.split('/').length === minDepth);
+
+        // Sort alphabetically
+        partyFolders.sort((a, b) => a.path.localeCompare(b.path));
+
+        // Build set of paths for quick lookup
+        const partyPaths = new Set(partyFolders.map(f => f.path));
+
+        // If "Select All" mode is active, auto-select all visible party folders
+        if (window.app.selectAllGroupingFolders) {
+            window.app.selectedGroupingFolders.clear();
+            partyFolders.forEach(f => window.app.selectedGroupingFolders.add(f.path));
+        } else {
+            // Remove selections for folders that are no longer visible
+            for (const selectedPath of window.app.selectedGroupingFolders) {
+                if (!partyPaths.has(selectedPath)) {
+                    window.app.selectedGroupingFolders.delete(selectedPath);
+                }
+            }
+        }
+
+        // Sync checkbox state
+        const checkbox = document.getElementById('selectAllGroupingCheckbox');
+        if (checkbox) checkbox.checked = window.app.selectAllGroupingFolders;
+
+        if (partyFolders.length === 0 && window.app.groupingFilter) {
+            container.innerHTML = '<div class="folder-list-empty">No parties match your filter</div>';
+            updateFolderSelectionState('groupingFoldersList');
+            return;
+        }
+
+        container.innerHTML = partyFolders.map(folder => `
+            <div class="folder-item ${window.app.selectedGroupingFolders.has(folder.path) ? 'selected' : ''}"
+                 data-path="${escapeHtml(folder.path)}"
+                 data-folder-type="grouping">
+                <span class="folder-item-name" title="${escapeHtml(folder.path)}">${escapeHtml(folder.name)}</span>
+            </div>
+        `).join('');
+
+        updateFolderSelectionState('groupingFoldersList');
+    }
+
+    // Render the global folder type toggle bar
+    function renderFolderTypeBar() {
+        const bar = document.getElementById('folderTypeBar');
+        if (!bar) return;
+
+        const FOLDER_TYPE_LABELS = { mdl: 'MDL', incoming: 'Incoming', issued: 'Issued', received: 'Received' };
+        bar.innerHTML = window.app.FOLDER_TYPE_NAMES.map(type => {
+            const active = window.app.enabledFolderTypes.has(type);
+            const label = FOLDER_TYPE_LABELS[type] || (type.charAt(0).toUpperCase() + type.slice(1));
+            return `<button class="folder-type-toggle ${active ? 'active' : ''}"
+                            data-type="${type}"
+                            title="Toggle ${label} folders">${label}</button>`;
+        }).join('');
+    }
+
+    // Toggle a folder type on/off globally
+    function toggleFolderType(type) {
+        if (window.app.enabledFolderTypes.has(type)) {
+            window.app.enabledFolderTypes.delete(type);
+        } else {
+            window.app.enabledFolderTypes.add(type);
+        }
+        renderFolderTypeBar();
+        renderGroupingFolders();
+        renderTransmittalFolders();
+        window.app.modules.filtering.applyFilters();
+        window.app.modules.urlState.push();
+    }
+
+    // Returns true if an outstanding file's actualPath is under a selected grouping folder
+    // that is itself visible (not hidden by folder type toggles).
+    function outstandingFileIsVisible(file) {
+        const selectedGrouping = window.app.selectedGroupingFolders;
+        if (selectedGrouping.size === 0) return false;
+        // The actualPath must not be under a hidden folder type
+        if (isUnderHiddenFolderType(file.actualPath)) return false;
+        // The actualPath must be at or under one of the selected grouping folder paths
+        return Array.from(selectedGrouping).some(function(gPath) {
+            return file.actualPath === gPath || file.actualPath.startsWith(gPath + '/');
+        });
+    }
+
+    // Returns true if any outstanding (non-transmittal) files exist under the currently
+    // selected and visible grouping folders.
+    function hasVisibleOutstandingFiles() {
+        return window.app.files.some(function(f) {
+            if (f.folderPath !== '__outstanding__') return false;
+            return outstandingFileIsVisible(f);
+        });
+    }
+
+    // Returns true if a transmittal folder is under a selected party and an enabled folder type.
+    // Handles both HTTP paths (party at depth 0) and local paths (party at depth 1+ due to root dir prefix).
+    function transmittalIsUnderVisibleParty(folder) {
+        const parts = folder.path.split('/');
+
+        // Find which segment is the party (the one that matches a selected grouping folder path prefix).
+        // The party path is the selected grouping folder path, so check prefix matches.
+        for (const partyPath of window.app.selectedGroupingFolders) {
+            const partyParts = partyPath.split('/');
+            const partyDepth = partyParts.length; // e.g. 1 for HTTP ("ACME"), 2 for local ("RootDir/ACME")
+
+            // Check that folder path starts with partyPath
+            if (!folder.path.startsWith(partyPath + '/') && folder.path !== partyPath) continue;
+
+            // The segment immediately after partyPath is either a folder type or the transmittal itself
+            const remainder = folder.path.substring(partyPath.length + 1); // e.g. "Issued/2025-01-01_..." or "2025-01-01_..."
+            const remainderParts = remainder.split('/');
+
+            if (remainderParts.length >= 2) {
+                // There's a folder type segment before the transmittal
+                const folderType = remainderParts[0].toLowerCase();
+                if (window.app.FOLDER_TYPE_NAMES.includes(folderType)) {
+                    // Must be an enabled type
+                    return window.app.enabledFolderTypes.has(folderType);
+                }
+                // Unknown folder type — treat as visible
+                return true;
+            }
+
+            // Transmittal is directly under the party (no folder type level) — always show
+            return true;
+        }
+
+        // Party not selected
+        return false;
+    }
+
+    // Render transmittal folders (rebuilds DOM)
+    function renderTransmittalFolders() {
+        const container = document.getElementById('transmittalFoldersList');
+        const filter = window.app.transmittalFilter;
+    
+        // Filter transmittal folders based on grouping selection and name filter
+        const filteredFolders = window.app.transmittalFolders.filter(folder => {
+            // Outstanding virtual transmittal: include if there are visible outstanding files
+            if (folder.path === '__outstanding__') {
+                if (!hasVisibleOutstandingFiles()) return false;
+                // Apply name filter to "Outstanding" label too
+                if (filter && filter.trim()) {
+                    const terms = parseSearchTerms(filter.trim());
+                    if (!matchesSearchTerms('outstanding', terms)) return false;
+                }
+                return true;
+            }
+        
+            // Check name filter
+            let matchesFilter = true;
+            if (filter && filter.trim()) {
+                const terms = parseSearchTerms(filter.trim());
+                const folderText = folder.name.toLowerCase();
+                matchesFilter = matchesSearchTerms(folderText, terms);
+            }
+        
+            // If no grouping folders exist at all, show all transmittal folders (flat structure)
+            if (window.app.groupingFolders.length === 0) {
+                return matchesFilter;
+            }
+        
+            // If grouping folders exist but none are selected, show nothing
+            if (window.app.selectedGroupingFolders.size === 0) {
+                return false;
+            }
+        
+            // Check party + folder type visibility
+            return matchesFilter && transmittalIsUnderVisibleParty(folder);
+        });
+    
+        // Sort regular transmittal folders by date (newest first); Outstanding handled separately
+        const regularFolders = filteredFolders.filter(f => f.path !== '__outstanding__');
+        regularFolders.sort((a, b) => b.name.localeCompare(a.name));
+    
+        const showOutstanding = filteredFolders.some(f => f.path === '__outstanding__');
+    
+        // Build set of visible folder paths (for Select All and deselection logic)
+        const filteredPaths = new Set(filteredFolders.map(f => f.path));
+    
+        // If "Select All" mode is active, auto-select all visible transmittal folders
+        if (window.app.selectAllTransmittals) {
+            window.app.selectedTransmittalFolders.clear();
+            filteredFolders.forEach(f => window.app.selectedTransmittalFolders.add(f.path));
+        } else {
+            // Remove selections for folders that are now filtered out
+            for (const selectedPath of window.app.selectedTransmittalFolders) {
+                if (!filteredPaths.has(selectedPath)) {
+                    window.app.selectedTransmittalFolders.delete(selectedPath);
+                }
+            }
+        }
+    
+        // Sync checkbox state
+        const checkbox = document.getElementById('selectAllTransmittalsCheckbox');
+        if (checkbox) checkbox.checked = window.app.selectAllTransmittals;
+    
+        // Group regular folders by date
+        const foldersByDate = new Map();
+        regularFolders.forEach(folder => {
+            const match = folder.name.match(/^(\d{4}-\d{2}-\d{2})/);
+            const date = match ? match[1] : 'Unknown';
+            if (!foldersByDate.has(date)) {
+                foldersByDate.set(date, []);
+            }
+            foldersByDate.get(date).push(folder);
+        });
+    
+        // Build HTML
+        let html = '';
+    
+        // Outstanding virtual transmittal — pinned at top
+        if (showOutstanding) {
+            const isSelected = window.app.selectedTransmittalFolders.has('__outstanding__');
+            html += `
+                <div class="folder-item outstanding-transmittal ${isSelected ? 'selected' : ''}"
+                     data-path="__outstanding__"
+                     data-folder-type="transmittal"
+                     title="Files in non-transmittal folders under selected grouping folders">
+                    <div class="transmittal-folder-content">
+                        <div class="transmittal-first-line outstanding-label">⋯ Outstanding</div>
+                    </div>
+                </div>
+            `;
+        }
+    
+        // Regular date-grouped folders
+        for (const [date, folders] of foldersByDate) {
+            const isCollapsed = window.app.collapsedDateGroups.has(date);
+            const folderCount = folders.length;
+        
+            html += `
+                <div class="date-group-header" data-date="${escapeHtml(date)}">
+                    <span class="date-group-toggle">${isCollapsed ? '▶' : '▼'}</span>
+                    <span class="date-group-date">${escapeHtml(date)}</span>
+                    <span class="date-group-count">(${folderCount})</span>
+                </div>
+            `;
+        
+            if (!isCollapsed) {
+                for (const folder of folders) {
+                    const match = folder.name.match(/^\d{4}-\d{2}-\d{2}_([^_\s]+)\s*\(([^)]+)\)\s*-\s*(.+)$/);
+                    let firstLine = folder.name;
+                    let secondLine = '';
+                
+                    if (match) {
+                        const [, tracking, status, title] = match;
+                        firstLine = `${tracking} • ${status}`;
+                        secondLine = title;
+                    }
+                
+                    html += `
+                        <div class="folder-item ${window.app.selectedTransmittalFolders.has(folder.path) ? 'selected' : ''}"
+                             data-path="${escapeHtml(folder.path)}"
+                             data-folder-type="transmittal"
+                             title="${escapeHtml(folder.path)}">
+                            <div class="transmittal-folder-content">
+                                <div class="transmittal-first-line">${escapeHtml(firstLine)}</div>
+                                ${secondLine ? `<div class="transmittal-second-line">${escapeHtml(secondLine)}</div>` : ''}
+                            </div>
+                        </div>
+                    `;
+                }
+            }
+        }
+    
+        if (filteredFolders.length === 0 && window.app.transmittalFilter) {
+            container.innerHTML = '<div class="folder-list-empty">No folders match your filter</div>';
+            updateFolderSelectionState('transmittalFoldersList');
+            window.app.modules.events.updateToggleAllIcon();
+            return;
+        }
+
+        container.innerHTML = html;
+    
+        // Ensure selection state is visually reflected after DOM rebuild
+        updateFolderSelectionState('transmittalFoldersList');
+    
+        // Update the toggle all icon to reflect current state
+        window.app.modules.events.updateToggleAllIcon();
+    }
+
+
+    // Update status bar
+    function updateStatusBar() {
+        const fileCountEl = document.getElementById('fileCount');
+        const selectedCountEl = document.getElementById('selectedCount');
+
+        // Before any directory is loaded, show a hint instead of "0 files"
+        if (window.app.directories.length === 0 && !window.app.isScanning) {
+            fileCountEl.textContent = 'Select a directory to begin';
+            selectedCountEl.textContent = '';
+            document.getElementById('scanStatus').textContent = '';
+            var spinner2 = document.getElementById('scanSpinner');
+            if (spinner2) spinner2.classList.add('hidden');
+            document.getElementById('downloadSelectedBtn').disabled = true;
+            document.getElementById('exportCsvBtn').disabled = true;
+            return;
+        }
+
+        // Count unique tracking numbers
+        const trackingNumbers = new Set(window.app.filteredFiles.map(f => f.trackingNumber));
+        const trackingCount = trackingNumbers.size;
+        const fileCount = window.app.filteredFiles.length;
+    
+        // Count files with path errors
+        const pathErrorCount = window.app.filteredFiles.filter(f => f.hasPathError).length;
+    
+        // Format: "X tracking numbers, Y files" + optional path error warning
+        let countText = `${trackingCount} tracking number${trackingCount !== 1 ? 's' : ''}, ${fileCount} file${fileCount !== 1 ? 's' : ''}`;
+        if (pathErrorCount > 0) {
+            countText += ` (⚠️ ${pathErrorCount} inaccessible)`;
+        }
+    
+        fileCountEl.textContent = countText;
+        selectedCountEl.textContent = `${window.app.selectedFiles.size} selected`;
+        document.getElementById('scanStatus').textContent = window.app.scanProgress;
+        var spinner = document.getElementById('scanSpinner');
+        if (spinner) { spinner.classList.toggle('hidden', !window.app.isScanning); }
+
+        // Disable action buttons when nothing is selected
+        const noneSelected = window.app.selectedFiles.size === 0;
+        document.getElementById('downloadSelectedBtn').disabled = noneSelected;
+        document.getElementById('exportCsvBtn').disabled = noneSelected;
+    }
+
+    // Escape HTML for safe insertion
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    /**
+     * Update folder selection visual state without rebuilding DOM
+     * This is more efficient than re-rendering when only selection changes
+     * @param {string} containerId - 'groupingFoldersList' or 'transmittalFoldersList'
+     */
+    function updateFolderSelectionState(containerId) {
+        const container = document.getElementById(containerId);
+        if (!container) {
+            console.warn(`Container not found: ${containerId}`);
+            return;
+        }
+    
+        const selectedSet = containerId === 'groupingFoldersList' ? 
+            window.app.selectedGroupingFolders : 
+            window.app.selectedTransmittalFolders;
+    
+        // Update selected class on existing elements
+        container.querySelectorAll('.folder-item').forEach(item => {
+            const path = item.getAttribute('data-path');
+            if (path) {
+                item.classList.toggle('selected', selectedSet.has(path));
+            }
+        });
+    }
+
+    // Extract modifier type from revision string (e.g., "2+B1" -> "+B", "2" -> "base")
+    function getModifierType(revision) {
+        if (!revision) return 'base';
+        const match = revision.match(/\+([A-Za-z])/);
+        return match ? '+' + match[1].toUpperCase() : 'base';
+    }
+
+    // Collect all unique modifiers from files
+    function collectModifiers() {
+        window.app.availableModifiers.clear();
+    
+        window.app.files.forEach(file => {
+            const modType = getModifierType(file.revision);
+            window.app.availableModifiers.add(modType);
+        });
+    
+        // Select all by default
+        window.app.selectedModifiers = new Set(window.app.availableModifiers);
+    
+        // Update the dropdown UI
+        renderModifierDropdown();
+    }
+
+    // Render the modifier dropdown options
+    function renderModifierDropdown() {
+        const list = document.getElementById('modifierFilterList');
+        if (!list) return;
+    
+        // Sort modifiers: "base" first, then alphabetically
+        const sorted = Array.from(window.app.availableModifiers).sort((a, b) => {
+            if (a === 'base') return -1;
+            if (b === 'base') return 1;
+            return a.localeCompare(b);
+        });
+    
+        let html = '';
+        sorted.forEach(mod => {
+            const checked = window.app.selectedModifiers.has(mod) ? 'checked' : '';
+            const label = mod === 'base' ? 'Base (no modifier)' : mod;
+            const labelClass = mod === 'base' ? 'modifier-base' : 'modifier-type';
+            html += `
+                <div class="modifier-filter-item">
+                    <label>
+                        <input type="checkbox" 
+                               data-modifier="${mod}" 
+                               ${checked}
+                               onchange="toggleModifierFilter('${mod}')">
+                        <span class="${labelClass}">${label}</span>
+                    </label>
+                </div>
+            `;
+        });
+    
+        list.innerHTML = html;
+        updateModifierSelectAll();
+        updateModifierButtonLabel();
+    }
+
+    // Toggle a specific modifier filter
+    function toggleModifierFilter(mod) {
+        if (window.app.selectedModifiers.has(mod)) {
+            window.app.selectedModifiers.delete(mod);
+        } else {
+            window.app.selectedModifiers.add(mod);
+        }
+        updateModifierSelectAll();
+        updateModifierButtonLabel();
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Toggle all modifiers
+    function toggleAllModifiers(selectAll) {
+        if (selectAll) {
+            window.app.selectedModifiers = new Set(window.app.availableModifiers);
+        } else {
+            window.app.selectedModifiers.clear();
+        }
+        renderModifierDropdown();
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Update the "Select All" checkbox state
+    function updateModifierSelectAll() {
+        const selectAllCheckbox = document.getElementById('modifierSelectAll');
+        if (selectAllCheckbox) {
+            selectAllCheckbox.checked = window.app.selectedModifiers.size === window.app.availableModifiers.size;
+            selectAllCheckbox.indeterminate = window.app.selectedModifiers.size > 0 && 
+                                              window.app.selectedModifiers.size < window.app.availableModifiers.size;
+        }
+    }
+
+    // Update button label to show filter status
+    function updateModifierButtonLabel() {
+        const btn = document.getElementById('modifierFilterBtn');
+        if (!btn) return;
+    
+        const total = window.app.availableModifiers.size;
+        const selected = window.app.selectedModifiers.size;
+    
+        if (selected === total) {
+            btn.textContent = 'Modifiers ▼';
+        } else if (selected === 0) {
+            btn.textContent = 'Modifiers (none) ▼';
+        } else {
+            btn.textContent = `Modifiers (${selected}/${total}) ▼`;
+        }
+    }
+
+    // Toggle modifier dropdown visibility
+    function toggleModifierDropdown() {
+        const dropdown = document.getElementById('modifierFilterDropdown');
+        dropdown.classList.toggle('hidden');
+    }
+
+    // Update the Folders icon button state based on active visibility toggles
+    function updateFolderVisibilityBtnLabel() {
+        // replaced by renderFolderTypeBar()
+    }
+
+    // Check if a file passes the modifier filter
+    function filePassesModifierFilter(file) {
+        const modType = getModifierType(file.revision);
+        return window.app.selectedModifiers.has(modType);
+    }
+
+    // Toggle filter to show only selected files
+    function toggleFilterSelected() {
+        window.app.showSelectedOnly = !window.app.showSelectedOnly;
+    
+        // Update button visual state and label
+        const btn = document.getElementById('filterSelectedBtn');
+        if (window.app.showSelectedOnly) {
+            btn.classList.add('btn-active');
+            btn.textContent = 'Show All';
+        } else {
+            btn.classList.remove('btn-active');
+            btn.textContent = 'Filter Selected';
+        }
+    
+        window.app.modules.filtering.applyFilters();
+    }
+    // Register with module system
+    window.app.modules.app = {
+        updateUI,
+        updateStatusBar,
+        escapeHtml,
+        updateFolderSelectionState,
+        getModifierType,
+        collectModifiers,
+        renderModifierDropdown,
+        toggleModifierFilter,
+        toggleAllModifiers,
+        updateModifierSelectAll,
+        updateModifierButtonLabel,
+        toggleModifierDropdown,
+        updateFolderVisibilityBtnLabel,
+        filePassesModifierFilter,
+        toggleFilterSelected,
+        isUnderHiddenFolderType,
+        ensureOutstandingTransmittal,
+        showHttpErrorState,
+        showUnsupportedBrowserMessage,
+        showProjectWarning,
+        dismissProjectWarning,
+        showEmptyState,
+        hideEmptyState,
+        addHttpSource,
+        scanHttpSource,
+        renderGroupingFolders,
+        renderTransmittalFolders,
+        renderFolderTypeBar,
+        toggleFolderType,
+        outstandingFileIsVisible,
+        hasVisibleOutstandingFiles,
+        transmittalIsUnderVisibleParty,
+        renderFolderLists,
+        getFilteredGroupingFolders,
+        showProjectWarning,
+        dismissProjectWarning,
+    };
+
+    // Expose key functions on window for inline HTML handlers
+    window.initApp = initApp;
+    window.toggleFileSelection = function(id) { window.app.modules.table.toggleFileSelection(id); };
+    window.sortTable = function(f) { window.app.modules.table.sortTable(f); };
+    window.confirmTransmittal = function() { window.app.modules.dragDrop.confirmTransmittal(); };
+    window.toggleModifierFilter = toggleModifierFilter;
+    window.toggleFilterSelected = toggleFilterSelected;
+    window.toggleFolderType = toggleFolderType;
+    window.toggleGroupingFolder = function(p, r) { window.app.modules.events.toggleGroupingFolder(p, r); };
+    window.toggleDateGroup = function(d) { window.app.modules.events.toggleDateGroup(d); };
+    window.toggleAllDateGroups = function() { window.app.modules.events.toggleAllDateGroups(); };
+    window.selectAllVisibleFolders = function(t) { window.app.modules.events.selectAllVisibleFolders(t); };
+    window.removeDirectory = function(n) { window.app.modules.directory.removeDirectory(n); };
+    window.dismissProjectWarning = dismissProjectWarning;
+    window.verifyFileIntegrity = function(id) { window.app.modules.hash.verifyFileIntegrity(id); };
+    window.showProjectWarning = showProjectWarning;
+    window.dismissProjectWarning = dismissProjectWarning;
+
+    // Initialize on DOM ready
+    document.addEventListener('DOMContentLoaded', initApp);
+
+})();
diff --git a/archive/js/directory.js b/archive/js/directory.js
new file mode 100644
index 0000000..580dbd8
--- /dev/null
+++ b/archive/js/directory.js
@@ -0,0 +1,188 @@
+(function() {
+    'use strict';
+    // Directory selection and scanning functionality
+
+    // Add directory
+    async function addDirectory() {
+        try {
+            const dirHandle = await window.showDirectoryPicker();
+        
+            // Check if already added
+            const exists = window.app.directories.some(d => d.name === dirHandle.name);
+            if (exists) {
+                alert('This directory has already been added.');
+                return;
+            }
+        
+            // Add to directories
+            window.app.directories.push({
+                handle: dirHandle,
+                name: dirHandle.name,
+                path: dirHandle.name // Root path
+            });
+        
+            // Hide empty state if this is the first directory
+            if (window.app.directories.length === 1) {
+                window.app.modules.app.hideEmptyState();
+            }
+        
+            // Scan the new directory
+            await scanDirectory(dirHandle, dirHandle.name);
+        
+            window.app.modules.app.updateUI();
+        } catch (err) {
+            if (err.name !== 'AbortError') {
+                console.error('Error selecting directory:', err);
+                alert('Error selecting directory: ' + err.message);
+            }
+        }
+    }
+
+    // Scan directory recursively (local mode — delegates to local source in source.js)
+    async function scanDirectory(dirHandle, path) {
+        window.app.isScanning = true;
+        window.app.scanProgress = 'Scanning ' + path + '...';
+        window.app.modules.app.updateStatusBar();
+    
+        const source = window.app.modules.source.createSource('local', {});
+    
+        const callbacks = {
+            onGroupingFolder: function(folder) {
+                window.app.groupingFolders.push(folder);
+            },
+            onTransmittalFolder: function(folder) {
+                window.app.transmittalFolders.push(folder);
+            },
+            onFile: function(file) {
+                window.app.files.push(file);
+            },
+            onProgress: function(message) {
+                window.app.scanProgress = message;
+                window.app.modules.app.updateStatusBar();
+            }
+        };
+    
+        try {
+            await source.scan(dirHandle, callbacks);
+        
+            // Only auto-select top-level party folders (shallowest depth)
+            const groupingDepths = window.app.groupingFolders.map(f => f.path.split('/').length);
+            const minGroupingDepth = groupingDepths.length > 0 ? Math.min(...groupingDepths) : 1;
+            window.app.groupingFolders.forEach(folder => {
+                if (folder.path.split('/').length === minGroupingDepth) {
+                    window.app.selectedGroupingFolders.add(folder.path);
+                }
+            });
+        
+            window.app.transmittalFolders.forEach(folder => {
+                if (!window.app.modules.app.isUnderHiddenFolderType(folder.path)) {
+                    window.app.selectedTransmittalFolders.add(folder.path);
+                }
+            });
+        
+            window.app.modules.app.ensureOutstandingTransmittal();
+            // Auto-select Outstanding if selectAllTransmittals is active
+            if (window.app.selectAllTransmittals) {
+                window.app.selectedTransmittalFolders.add('__outstanding__');
+            }
+
+            window.app.modules.app.collectModifiers();
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters();
+            if (window.app.modules.presets) {
+                window.app.modules.presets.init();
+            }
+        } catch (err) {
+            console.error('Error scanning directory:', err);
+            alert('Error scanning directory: ' + err.message);
+        } finally {
+            window.app.isScanning = false;
+            window.app.scanProgress = '';
+            window.app.modules.app.updateStatusBar();
+        }
+    }
+
+    // Refresh all directories
+    async function refreshDirectories() {
+        // Clear existing data
+        window.app.groupingFolders = [];
+        window.app.transmittalFolders = [];
+        window.app.files = [];
+        window.app.filteredFiles = [];
+    
+        if (window.app.sourceMode === 'http') {
+            // Re-scan all HTTP sources
+            const dirs = window.app.directories.slice();
+            window.app.directories = [];
+            for (const dir of dirs) {
+                await window.app.modules.app.addHttpSource(dir.url);
+            }
+        } else {
+            // Re-scan all local directories
+            for (const dir of window.app.directories) {
+                await scanDirectory(dir.handle, dir.name);
+            }
+        }
+    
+        window.app.modules.app.updateUI();
+    }
+
+    // Remove directory
+    function removeDirectory(dirName) {
+        const index = window.app.directories.findIndex(d => d.name === dirName);
+        if (index !== -1) {
+            window.app.directories.splice(index, 1);
+        
+            // Remove associated folders and files
+            window.app.groupingFolders = window.app.groupingFolders.filter(f => 
+                !f.path.startsWith(dirName)
+            );
+            window.app.transmittalFolders = window.app.transmittalFolders.filter(f => 
+                !f.path.startsWith(dirName)
+            );
+            window.app.files = window.app.files.filter(f => 
+                !f.path.startsWith(dirName)
+            );
+        
+            // Clean up the Outstanding virtual transmittal if no outstanding files remain
+            const hasAnyOutstanding = window.app.files.some(f => f.folderPath === '__outstanding__');
+            if (!hasAnyOutstanding) {
+                window.app.transmittalFolders = window.app.transmittalFolders.filter(f => f.path !== '__outstanding__');
+                window.app.selectedTransmittalFolders.delete('__outstanding__');
+            }
+        
+            // Show empty state if no directories left
+            if (window.app.directories.length === 0) {
+                window.app.modules.app.showEmptyState();
+            }
+        
+            window.app.modules.app.updateUI();
+        }
+    }
+
+    // Request permission for directory
+    async function requestPermission(dirHandle) {
+        const options = { mode: 'read' };
+    
+        // Check current permission state
+        if ((await dirHandle.queryPermission(options)) === 'granted') {
+            return true;
+        }
+    
+        // Request permission
+        if ((await dirHandle.requestPermission(options)) === 'granted') {
+            return true;
+        }
+    
+        return false;
+    }
+
+    window.app.modules.directory = {
+        addDirectory,
+        scanDirectory,
+        refreshDirectories,
+        removeDirectory,
+        requestPermission
+    };
+
+})();
diff --git a/archive/js/drag-drop.js b/archive/js/drag-drop.js
new file mode 100644
index 0000000..9869a3f
--- /dev/null
+++ b/archive/js/drag-drop.js
@@ -0,0 +1,280 @@
+(function() {
+    'use strict';
+    // Drag and drop functionality
+
+    let draggedFiles = [];
+    let targetGroupingFolder = null;
+
+    // Setup drag and drop
+    function setupDragAndDrop() {
+        // Prevent default drag behaviors
+        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+            document.addEventListener(eventName, preventDefaults, false);
+        });
+    
+        // Highlight drop zones
+        ['dragenter', 'dragover'].forEach(eventName => {
+            document.addEventListener(eventName, highlight, false);
+        });
+    
+        ['dragleave', 'drop'].forEach(eventName => {
+            document.addEventListener(eventName, unhighlight, false);
+        });
+    
+        // Handle drops on grouping folders (for creating transmittals)
+        document.getElementById('groupingFoldersList').addEventListener('drop', handleDrop, false);
+    
+        // Handle drops on the main app area (for adding directories)
+        document.getElementById('app').addEventListener('drop', handleAppDrop, false);
+    }
+
+    // Prevent default behaviors
+    function preventDefaults(e) {
+        e.preventDefault();
+        e.stopPropagation();
+    }
+
+    // Highlight drop zone
+    function highlight(e) {
+        const folderItem = e.target.closest('.folder-item');
+        if (folderItem && folderItem.parentElement.id === 'groupingFoldersList') {
+            folderItem.classList.add('drag-over');
+        }
+    }
+
+    // Remove highlight
+    function unhighlight(e) {
+        document.querySelectorAll('.drag-over').forEach(item => {
+            item.classList.remove('drag-over');
+        });
+    }
+
+    // Handle directory drop on main app area (for adding directories)
+    async function handleAppDrop(e) {
+        // Check if this is a drop on a grouping folder (handled separately)
+        const folderItem = e.target.closest('.folder-item');
+        if (folderItem && folderItem.parentElement.id === 'groupingFoldersList') {
+            return; // Let handleDrop handle this
+        }
+    
+        // Check if dataTransfer has directory items
+        const items = e.dataTransfer.items;
+        if (!items || items.length === 0) return;
+    
+        // Process each dropped item
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+        
+            // Check if it's a directory using the File System Access API
+            if (item.kind === 'file') {
+                const entry = await item.getAsFileSystemHandle();
+            
+                if (entry && entry.kind === 'directory') {
+                    // Check if already added
+                    const exists = window.app.directories.some(d => d.name === entry.name);
+                    if (exists) {
+
+                        continue;
+                    }
+                
+                    // Add to directories
+                    window.app.directories.push({
+                        handle: entry,
+                        name: entry.name,
+                        path: entry.name
+                    });
+                
+                    // Hide empty state if this is the first directory
+                    if (window.app.directories.length === 1) {
+                        window.app.modules.app.hideEmptyState();
+                    }
+                
+                    // Scan the new directory
+                    await window.app.modules.directory.scanDirectory(entry, entry.name);
+                }
+            }
+        }
+    
+        // Update UI after processing all dropped directories
+        if (window.app.directories.length > 0) {
+            window.app.modules.app.updateUI();
+        }
+    }
+
+    // Handle file drop on grouping folder (for creating transmittals)
+    async function handleDrop(e) {
+        const folderItem = e.target.closest('.folder-item');
+        if (!folderItem) return;
+    
+        const files = Array.from(e.dataTransfer.files);
+        if (files.length === 0) return;
+    
+        // Find the grouping folder
+        const folderPath = folderItem.getAttribute('data-path');
+        const groupingFolder = window.app.groupingFolders.find(f => f.path === folderPath);
+        if (!groupingFolder) return;
+    
+        targetGroupingFolder = groupingFolder;
+        draggedFiles = files;
+    
+        // Show transmittal creation dialog
+        showTransmittalDialog();
+    }
+
+    // Show transmittal creation dialog
+    function showTransmittalDialog() {
+        const modal = document.getElementById('dropModal');
+    
+        // Generate default transmittal name
+        const today = new Date();
+        const dateStr = today.toISOString().split('T')[0]; // YYYY-MM-DD
+    
+        // Try to extract tracking number from first file
+        let trackingNumber = 'TRACKING';
+        let title = 'Transmittal';
+    
+        if (draggedFiles.length > 0) {
+            const firstFile = draggedFiles[0];
+            const parsed = zddc.parseFilename(firstFile.name) || {};
+            if (parsed.trackingNumber) {
+                trackingNumber = parsed.trackingNumber;
+            }
+            if (parsed.title) {
+                title = parsed.title;
+            }
+        }
+    
+        const defaultName = `${dateStr}_${trackingNumber} (IFI) - ${title}`;
+        document.getElementById('transmittalName').value = defaultName;
+    
+        // Show file preview
+        updateFilePreview();
+    
+        modal.classList.remove('hidden');
+    }
+
+    // Update file preview in dialog
+    function updateFilePreview() {
+        const tbody = document.getElementById('filesPreviewBody');
+    
+        const rows = draggedFiles.map(file => {
+            const parsed = zddc.parseFilename(file.name) || {};
+        
+            // Generate ZDDC-compliant name
+            let newName = file.name;
+            if (parsed.trackingNumber) {
+                newName = `${parsed.trackingNumber}_${parsed.revision || 'A'} (${parsed.status || 'IFI'}) - ${parsed.title}.${parsed.extension}`;
+            }
+        
+            const isValid = !!parsed.trackingNumber;
+        
+            return `
+                <tr>
+                    <td>${window.app.modules.app.escapeHtml(file.name)}</td>
+                    <td>
+                        <input type="text" 
+                               class="form-input" 
+                               value="${window.app.modules.app.escapeHtml(newName)}"
+                               data-original="${window.app.modules.app.escapeHtml(file.name)}"
+                               style="width: 100%;">
+                    </td>
+                    <td style="color: ${isValid ? 'green' : 'red'};">
+                        ${isValid ? '✓ Valid' : '✗ Invalid'}
+                    </td>
+                </tr>
+            `;
+        }).join('');
+    
+        tbody.innerHTML = rows;
+    }
+
+    // Confirm transmittal creation
+    async function confirmTransmittal() {
+        const transmittalName = document.getElementById('transmittalName').value.trim();
+    
+        // Validate transmittal folder name
+        if (!window.app.modules.parser.isTransmittalFolder(transmittalName)) {
+            alert('Invalid transmittal folder name. Must follow format: YYYY-MM-DD_TRACKINGNUMBER (STATUS) - TITLE');
+            return;
+        }
+    
+        try {
+            // Create transmittal folder
+            const transmittalHandle = await targetGroupingFolder.handle.getDirectoryHandle(transmittalName, { create: true });
+        
+            // Get file mappings from preview
+            const fileMappings = [];
+            const inputs = document.querySelectorAll('#filesPreviewBody input');
+            inputs.forEach((input, index) => {
+                fileMappings.push({
+                    originalFile: draggedFiles[index],
+                    newName: input.value.trim()
+                });
+            });
+        
+            // Save files with new names
+            for (const mapping of fileMappings) {
+                const fileHandle = await transmittalHandle.getFileHandle(mapping.newName, { create: true });
+                const writable = await fileHandle.createWritable();
+                await writable.write(mapping.originalFile);
+                await writable.close();
+            }
+        
+            // Close modal
+            document.getElementById('dropModal').classList.add('hidden');
+        
+            // Refresh to show new files
+            await window.app.modules.directory.refreshDirectories();
+        
+            alert(`Transmittal created successfully with ${fileMappings.length} files.`);
+        
+        } catch (err) {
+            console.error('Error creating transmittal:', err);
+            alert('Error creating transmittal: ' + err.message);
+        }
+    }
+
+    // Handle drag and drop on table rows (for metadata copy)
+    function setupTableRowDragDrop() {
+        document.getElementById('filesTableBody').addEventListener('dragover', (e) => {
+            const tr = e.target.closest('tr');
+            if (tr) {
+                e.preventDefault();
+                tr.classList.add('drag-over');
+            }
+        });
+    
+        document.getElementById('filesTableBody').addEventListener('dragleave', (e) => {
+            const tr = e.target.closest('tr');
+            if (tr) {
+                tr.classList.remove('drag-over');
+            }
+        });
+    
+        document.getElementById('filesTableBody').addEventListener('drop', async (e) => {
+            const tr = e.target.closest('tr');
+            if (!tr) return;
+        
+            tr.classList.remove('drag-over');
+        
+            // Get tracking number and title from the row
+            const trackingNumber = tr.querySelector('td[data-field="trackingNumber"]').textContent;
+            const title = tr.querySelector('td[data-field="title"]').textContent;
+        
+            const files = Array.from(e.dataTransfer.files);
+            if (files.length === 0) return;
+        
+            // For table row drops, just copy metadata
+            alert(`Would copy metadata:\nTracking Number: ${trackingNumber}\nTitle: ${title}\n\nTo ${files.length} file(s)`);
+        });
+    }
+
+    window.app.modules.dragDrop = {
+        setupDragAndDrop,
+        showTransmittalDialog,
+        updateFilePreview,
+        confirmTransmittal,
+        setupTableRowDragDrop
+    };
+
+})();
diff --git a/archive/js/events.js b/archive/js/events.js
new file mode 100644
index 0000000..64328cc
--- /dev/null
+++ b/archive/js/events.js
@@ -0,0 +1,592 @@
+(function() {
+    'use strict';
+    // Event handling
+
+    // Set up all event listeners
+    function setupEventListeners() {
+        // Header buttons
+        document.getElementById('addDirectoryBtn').addEventListener('click', () => window.app.modules.directory.addDirectory());
+        document.getElementById('refreshHeaderBtn').addEventListener('click', () => window.app.modules.directory.refreshDirectories());
+    
+        // Content area buttons
+        document.getElementById('filterSelectedBtn').addEventListener('click', () => window.app.modules.app.toggleFilterSelected());
+        document.getElementById('downloadSelectedBtn').addEventListener('click', () => window.app.modules.export.downloadSelected());
+        document.getElementById('exportCsvBtn').addEventListener('click', () => window.app.modules.export.exportCSV());
+    
+        // Search and filter inputs
+        document.getElementById('groupingFilter').addEventListener('input', (e) => {
+            window.app.groupingFilter = e.target.value;
+            e.target.classList.toggle('filter-active', e.target.value.length > 0);
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters();
+            window.app.modules.urlState.push();
+        });
+
+        document.getElementById('transmittalFilter').addEventListener('input', (e) => {
+            window.app.transmittalFilter = e.target.value;
+            e.target.classList.toggle('filter-active', e.target.value.length > 0);
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters(); // Re-filter files when transmittal filter changes
+            window.app.modules.urlState.push();
+        });
+    
+        // Select All Grouping Folders checkbox
+        document.getElementById('selectAllGroupingCheckbox').addEventListener('change', (e) => {
+            window.app.selectAllGroupingFolders = e.target.checked;
+            window.app.modules.app.renderGroupingFolders();
+            window.app.modules.app.renderTransmittalFolders();
+            window.app.modules.filtering.applyFilters();
+        });
+    
+        // Folder type toggle bar — global click delegation
+        document.addEventListener('click', (e) => {
+            const btn = e.target.closest('.folder-type-toggle');
+            if (btn) {
+                const type = btn.getAttribute('data-type');
+                if (type) window.app.modules.app.toggleFolderType(type);
+            }
+        });
+    
+        // Select All Transmittals checkbox
+        document.getElementById('selectAllTransmittalsCheckbox').addEventListener('change', (e) => {
+            window.app.selectAllTransmittals = e.target.checked;
+            window.app.modules.app.renderTransmittalFolders();
+            window.app.modules.filtering.applyFilters();
+        });
+    
+        // Modifier filter dropdown
+        document.getElementById('modifierFilterBtn').addEventListener('click', () => window.app.modules.app.toggleModifierDropdown());
+        document.getElementById('modifierSelectAll').addEventListener('change', (e) => {
+            window.app.modules.app.toggleAllModifiers(e.target.checked);
+        });
+    
+        // Close modifier dropdown when clicking outside
+        document.addEventListener('click', (e) => {
+            const container = document.querySelector('.modifier-filter-container');
+            const dropdown = document.getElementById('modifierFilterDropdown');
+            if (container && dropdown && !container.contains(e.target)) {
+                dropdown.classList.add('hidden');
+            }
+        });
+    
+        // Select all visible files checkbox
+        document.getElementById('selectAllVisibleCheckbox').addEventListener('change', (e) => {
+            e.stopPropagation();
+            window.app.modules.table.toggleSelectAllVisible(e.target.checked);
+        });
+        
+        // Reset filters button
+        document.getElementById('resetFiltersBtn').addEventListener('click', () => window.app.modules.filtering.clearFilters());
+    
+        // Column filters — delegated from thead
+        const thead = document.querySelector('thead');
+        if (thead) {
+            thead.addEventListener('input', (e) => {
+                if (e.target.matches('.column-filter[data-filter-field]')) {
+                    const field = e.target.getAttribute('data-filter-field');
+                    const raw = e.target.value.trim();
+                    window.app.columnFilters[field] = raw;
+                    window.app.columnFilterASTs[field] = zddc.filter.parse(raw);
+                    
+                    // Add/remove filter-active class based on non-empty value
+                    if (raw) {
+                        e.target.classList.add('filter-active');
+                    } else {
+                        e.target.classList.remove('filter-active');
+                    }
+                    
+                    window.app.modules.filtering.applyFilters();
+                    window.app.modules.urlState.push();
+                }
+            });
+            thead.addEventListener('keydown', (e) => {
+                if (!e.target.matches('.column-filter[data-filter-field]')) return;
+                if (e.key === 'Escape') {
+                    e.target.value = '';
+                    e.target.classList.remove('filter-active');
+                    const field = e.target.getAttribute('data-filter-field');
+                    window.app.columnFilters[field] = '';
+                    window.app.columnFilterASTs[field] = null;
+                    window.app.modules.filtering.applyFilters();
+                    window.app.modules.urlState.push();
+                    e.preventDefault();
+                } else if (e.key === 'Enter') {
+                    e.preventDefault();
+                    const inputs = Array.from(thead.querySelectorAll('.column-filter'));
+                    const idx = inputs.indexOf(e.target);
+                    if (idx !== -1) {
+                        inputs[(idx + 1) % inputs.length].focus();
+                    }
+                }
+            });
+            thead.addEventListener('click', (e) => {
+                if (e.target.matches('.column-filter')) {
+                    e.stopPropagation();
+                }
+            });
+        }
+    
+        // Table sorting
+        document.querySelectorAll('.sortable').forEach(th => {
+            th.querySelector('.th-content').addEventListener('click', () => {
+                const field = th.getAttribute('data-field');
+                window.app.modules.table.sortTable(field);
+            });
+        });
+    
+        // Initialize column resize
+        window.app.modules.table.initializeColumnResize();
+    
+        // Modal close buttons
+        document.querySelectorAll('.modal-close').forEach(btn => {
+            btn.addEventListener('click', closeModal);
+        });
+    
+        // Modal backdrop clicks
+        document.querySelectorAll('.modal-backdrop').forEach(backdrop => {
+            backdrop.addEventListener('click', closeModal);
+        });
+    
+        // Drop modal buttons
+        const dropModal = document.getElementById('dropModal');
+        dropModal.querySelector('.modal-cancel').addEventListener('click', closeModal);
+        dropModal.querySelector('.modal-confirm').addEventListener('click', () => window.app.modules.dragDrop.confirmTransmittal());
+    
+        // Drag and drop (local mode only — requires write access)
+        if (window.app.sourceMode === 'local') {
+            window.app.modules.dragDrop.setupDragAndDrop();
+        }
+    
+        // Multi-select for folders
+        setupFolderMultiSelect();
+    
+        // Date group toggle handlers
+        setupDateGroupToggles();
+    
+        // Grouping section collapse toggle
+        setupGroupingToggle();
+    
+        // Resizable panes
+        setupResizablePanes();
+    
+        // Keyboard shortcuts
+        document.addEventListener('keydown', handleKeyboardShortcuts);
+    }
+
+
+
+    // Handle grouping filter
+    function handleGroupingFilter(e) {
+        window.app.groupingFilter = e.target.value;
+        window.app.modules.app.renderGroupingFolders();
+        // Re-render transmittal folders as they depend on grouping selection
+        window.app.modules.app.renderTransmittalFolders();
+        // Re-filter files based on updated folder selections
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Handle transmittal filter
+    function handleTransmittalFilter(e) {
+        window.app.transmittalFilter = e.target.value;
+        window.app.modules.app.renderTransmittalFolders();
+        // Re-filter files based on updated folder selections
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Close modal
+    function closeModal(e) {
+        const modal = e.target.closest('.modal');
+        if (modal) {
+            modal.classList.add('hidden');
+        }
+    }
+
+    // Handle keyboard shortcuts
+    function handleKeyboardShortcuts(e) {
+        // Escape closes modals
+        if (e.key === 'Escape') {
+            document.querySelectorAll('.modal:not(.hidden)').forEach(modal => {
+                modal.classList.add('hidden');
+            });
+        }
+    
+        // Ctrl+A selects all visible files
+        if (e.ctrlKey && e.key === 'a' && e.target.tagName !== 'INPUT') {
+            e.preventDefault();
+            toggleSelectAll();
+        }
+    
+        // F5 refreshes
+        if (e.key === 'F5') {
+            e.preventDefault();
+            window.app.modules.directory.refreshDirectories();
+        }
+    }
+
+    // Utility: Debounce function
+    function debounce(func, wait) {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    }
+
+    // Multi-select handling for folder lists
+    function setupFolderMultiSelect() {
+        let lastSelectedGroupingIndex = -1;
+        let lastSelectedTransmittalIndex = -1;
+    
+        // Handle grouping folders
+        const groupingList = document.getElementById('groupingFoldersList');
+        groupingList.addEventListener('click', (e) => {
+            const result = handleFolderClick(e, window.app.selectedGroupingFolders, lastSelectedGroupingIndex);
+            if (result !== undefined) {
+                lastSelectedGroupingIndex = result;
+                // Turn off "Select All" mode when user manually selects
+                if (window.app.selectAllGroupingFolders) {
+                    window.app.selectAllGroupingFolders = false;
+                    document.getElementById('selectAllGroupingCheckbox').checked = false;
+                }
+                // Update selection state first
+                window.app.modules.app.updateFolderSelectionState('groupingFoldersList');
+                // Then update transmittal folder list based on new selection
+                window.app.modules.app.renderTransmittalFolders();
+                window.app.modules.filtering.applyFilters(); // Re-filter files
+                // Check presets dirty state
+                if (window.app.modules.presets) {
+                    window.app.modules.presets.checkDirty();
+                }
+                // Reset transmittal index since list may have changed
+                lastSelectedTransmittalIndex = -1;
+            }
+        });
+    
+        // Handle transmittal folders
+        const transmittalList = document.getElementById('transmittalFoldersList');
+        transmittalList.addEventListener('click', (e) => {
+            const result = handleFolderClick(e, window.app.selectedTransmittalFolders, lastSelectedTransmittalIndex);
+            if (result !== undefined) {
+                lastSelectedTransmittalIndex = result;
+                // Turn off "Select All" mode when user manually selects
+                if (window.app.selectAllTransmittals) {
+                    window.app.selectAllTransmittals = false;
+                    document.getElementById('selectAllTransmittalsCheckbox').checked = false;
+                }
+                // Update selection state without rebuilding DOM
+                window.app.modules.app.updateFolderSelectionState('transmittalFoldersList');
+                window.app.modules.filtering.applyFilters(); // Update file display
+            }
+        });
+    
+        // Handle Ctrl+A for folder lists
+        groupingList.addEventListener('keydown', (e) => {
+            if (e.ctrlKey && e.key === 'a') {
+                e.preventDefault();
+                selectAllVisibleFolders('grouping');
+            }
+        });
+    
+        transmittalList.addEventListener('keydown', (e) => {
+            if (e.ctrlKey && e.key === 'a') {
+                e.preventDefault();
+                selectAllVisibleFolders('transmittal');
+            }
+        });
+    
+        // Make lists focusable
+        groupingList.setAttribute('tabindex', '0');
+        transmittalList.setAttribute('tabindex', '0');
+    }
+
+    /**
+     * Handle folder click with multi-select support (Shift/Ctrl)
+     * @param {Event} e - Click event
+     * @param {Set} selectedSet - Set of selected folder paths
+     * @param {number} lastIndex - Index of last clicked item
+     * @returns {number|undefined} Current index if valid click, undefined otherwise
+     */
+    function handleFolderClick(e, selectedSet, lastIndex) {
+        const folderItem = e.target.closest('.folder-item');
+        if (!folderItem) return undefined;
+    
+        const path = folderItem.getAttribute('data-path');
+        if (!path) return undefined;
+    
+        const container = folderItem.parentElement;
+        const items = Array.from(container.children);
+        const currentIndex = items.indexOf(folderItem);
+    
+        if (e.shiftKey && lastIndex !== -1 && lastIndex < items.length) {
+            // Shift+click: select range from last to current
+            e.preventDefault();
+            const start = Math.min(lastIndex, currentIndex);
+            const end = Math.max(lastIndex, currentIndex);
+        
+            if (!e.ctrlKey) {
+                selectedSet.clear();
+            }
+        
+            for (let i = start; i <= end; i++) {
+                const itemPath = items[i]?.getAttribute('data-path');
+                if (itemPath) {
+                    selectedSet.add(itemPath);
+                }
+            }
+        } else if (e.ctrlKey || e.metaKey) {
+            // Ctrl+click: toggle individual selection
+            e.preventDefault();
+            if (selectedSet.has(path)) {
+                selectedSet.delete(path);
+            } else {
+                selectedSet.add(path);
+            }
+        } else {
+            // Regular click: clear and select single item
+            selectedSet.clear();
+            selectedSet.add(path);
+        }
+    
+        return currentIndex;
+    }
+
+    /**
+     * Toggle expand/collapse state of a grouping folder
+     * @param {string} path - Folder path to toggle
+     * @param {boolean} recursive - If true, also toggle all descendants
+     */
+    function toggleGroupingFolder(path, recursive) {
+        const isCurrentlyCollapsed = window.app.collapsedGroupingFolders.has(path);
+    
+        if (recursive) {
+            // Get all descendant folder paths
+            const descendants = window.app.groupingFolders
+                .filter(f => f.path.startsWith(path + '/'))
+                .map(f => f.path);
+        
+            if (isCurrentlyCollapsed) {
+                // Expand this folder and all descendants
+                window.app.collapsedGroupingFolders.delete(path);
+                descendants.forEach(p => window.app.collapsedGroupingFolders.delete(p));
+            } else {
+                // Collapse this folder and all descendants
+                window.app.collapsedGroupingFolders.add(path);
+                descendants.forEach(p => window.app.collapsedGroupingFolders.add(p));
+            }
+        } else {
+            // Just toggle this folder
+            if (isCurrentlyCollapsed) {
+                window.app.collapsedGroupingFolders.delete(path);
+            } else {
+                window.app.collapsedGroupingFolders.add(path);
+            }
+        }
+    
+        window.app.modules.app.renderGroupingFolders();
+    }
+
+    // Select all visible folders
+    function selectAllVisibleFolders(folderType) {
+        const container = folderType === 'grouping' ? 
+            document.getElementById('groupingFoldersList') : 
+            document.getElementById('transmittalFoldersList');
+    
+        const selectedSet = folderType === 'grouping' ? 
+            window.app.selectedGroupingFolders : 
+            window.app.selectedTransmittalFolders;
+    
+        selectedSet.clear();
+    
+        const items = container.querySelectorAll('.folder-item');
+        items.forEach(item => {
+            const path = item.getAttribute('data-path');
+            if (path) {
+                selectedSet.add(path);
+            }
+        });
+    
+        if (folderType === 'grouping') {
+            // Update UI to reflect grouping changes
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters();
+        } else {
+            // For transmittal folders, just update selection state
+            window.app.modules.app.updateFolderSelectionState('transmittalFoldersList');
+            window.app.modules.filtering.applyFilters();
+        }
+    }
+
+    // Setup date group toggle handlers
+    function setupDateGroupToggles() {
+        // Toggle all dates button
+        const toggleAllBtn = document.getElementById('toggleAllDatesBtn');
+        if (toggleAllBtn) {
+            toggleAllBtn.addEventListener('click', toggleAllDateGroups);
+        }
+    
+        // Individual date group headers (using event delegation)
+        const transmittalList = document.getElementById('transmittalFoldersList');
+        transmittalList.addEventListener('click', (e) => {
+            const header = e.target.closest('.date-group-header');
+            if (header) {
+                const date = header.getAttribute('data-date');
+                if (date) {
+                    toggleDateGroup(date);
+                }
+            }
+        });
+    }
+
+    // Toggle a single date group
+    function toggleDateGroup(date) {
+        if (window.app.collapsedDateGroups.has(date)) {
+            window.app.collapsedDateGroups.delete(date);
+        } else {
+            window.app.collapsedDateGroups.add(date);
+        }
+        window.app.modules.app.renderTransmittalFolders();
+        updateToggleAllIcon();
+    }
+
+    // Toggle all date groups
+    function toggleAllDateGroups() {
+        const headers = document.querySelectorAll('.date-group-header');
+        const allDates = Array.from(headers).map(h => h.getAttribute('data-date')).filter(Boolean);
+    
+        // If all are collapsed, expand all. Otherwise, collapse all.
+        const allCollapsed = allDates.length > 0 && allDates.every(date => window.app.collapsedDateGroups.has(date));
+    
+        if (allCollapsed) {
+            // Expand all
+            window.app.collapsedDateGroups.clear();
+        } else {
+            // Collapse all
+            allDates.forEach(date => window.app.collapsedDateGroups.add(date));
+        }
+    
+        window.app.modules.app.renderTransmittalFolders();
+        updateToggleAllIcon();
+    }
+
+    // Update the toggle all icon based on current state
+    function updateToggleAllIcon() {
+        const icon = document.getElementById('toggleAllDatesIcon');
+        if (!icon) return;
+    
+        const headers = document.querySelectorAll('.date-group-header');
+        const allDates = Array.from(headers).map(h => h.getAttribute('data-date')).filter(Boolean);
+        const allCollapsed = allDates.length > 0 && allDates.every(date => window.app.collapsedDateGroups.has(date));
+    
+        icon.textContent = allCollapsed ? '▶' : '▼';
+    }
+
+    // Setup grouping section collapse toggle
+    function setupGroupingToggle() {
+        const toggleBtn = document.getElementById('toggleGroupingBtn');
+        const groupingSection = document.getElementById('groupingSection');
+        const icon = document.getElementById('toggleGroupingIcon');
+    
+        if (toggleBtn && groupingSection && icon) {
+            toggleBtn.addEventListener('click', () => {
+                groupingSection.classList.toggle('collapsed');
+                icon.textContent = groupingSection.classList.contains('collapsed') ? '▶' : '▼';
+            });
+        }
+    }
+
+    // Setup resizable panes
+    function setupResizablePanes() {
+        // Resize nav sections (vertical divider between grouping and transmittal)
+        const navSectionsHandle = document.querySelector('[data-resize="nav-sections"]');
+        if (navSectionsHandle) {
+            let isResizing = false;
+            let startY = 0;
+            let startHeight = 0;
+            let groupingSection = null;
+        
+            navSectionsHandle.addEventListener('mousedown', (e) => {
+                isResizing = true;
+                startY = e.clientY;
+                groupingSection = document.getElementById('groupingSection');
+                startHeight = groupingSection.offsetHeight;
+                navSectionsHandle.classList.add('resizing');
+                e.preventDefault();
+            });
+        
+            document.addEventListener('mousemove', (e) => {
+                if (!isResizing) return;
+            
+                const deltaY = e.clientY - startY;
+                const newHeight = startHeight + deltaY;
+            
+                // Set min/max heights
+                if (newHeight >= 100 && newHeight <= window.innerHeight - 250) {
+                    groupingSection.style.flex = 'none';
+                    groupingSection.style.height = newHeight + 'px';
+                }
+            });
+        
+            document.addEventListener('mouseup', () => {
+                if (isResizing) {
+                    isResizing = false;
+                    navSectionsHandle.classList.remove('resizing');
+                }
+            });
+        }
+    
+        // Resize nav pane (horizontal divider between nav and content)
+        const navPaneHandle = document.querySelector('[data-resize="nav-pane"]');
+        if (navPaneHandle) {
+            let isResizing = false;
+            let startX = 0;
+            let startWidth = 0;
+            let navPane = null;
+        
+            navPaneHandle.addEventListener('mousedown', (e) => {
+                isResizing = true;
+                startX = e.clientX;
+                navPane = document.getElementById('navigationPane');
+                startWidth = navPane.offsetWidth;
+                navPaneHandle.classList.add('resizing');
+                e.preventDefault();
+            });
+        
+            document.addEventListener('mousemove', (e) => {
+                if (!isResizing) return;
+            
+                const deltaX = e.clientX - startX;
+                const newWidth = startWidth + deltaX;
+            
+                // Set min/max widths
+                if (newWidth >= 200 && newWidth <= window.innerWidth - 400) {
+                    navPane.style.width = newWidth + 'px';
+                }
+            });
+        
+            document.addEventListener('mouseup', () => {
+                if (isResizing) {
+                    isResizing = false;
+                    navPaneHandle.classList.remove('resizing');
+                }
+            });
+        }
+    }
+
+    window.app.modules.events = {
+        setupEventListeners,
+        handleFolderClick,
+        toggleGroupingFolder,
+        selectAllVisibleFolders,
+        setupDateGroupToggles,
+        toggleDateGroup,
+        toggleAllDateGroups,
+        updateToggleAllIcon,
+        setupGroupingToggle,
+        setupResizablePanes
+    };
+
+})();
diff --git a/archive/js/export.js b/archive/js/export.js
new file mode 100644
index 0000000..380504d
--- /dev/null
+++ b/archive/js/export.js
@@ -0,0 +1,272 @@
+(function() {
+    'use strict';
+    // Export functionality
+
+    // Escape a single value for RFC-4180 CSV
+    function csvCell(value) {
+        const str = String(value == null ? '' : value);
+        if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+            return '"' + str.replace(/"/g, '""') + '"';
+        }
+        return str;
+    }
+
+    // Convert an array of row arrays to a CSV string
+    function rowsToCSV(rows) {
+        return rows.map(row => row.map(csvCell).join(',')).join('\n');
+    }
+
+    // Export selected files to CSV
+    function exportCSV() {
+        if (window.app.selectedFiles.size === 0) {
+            alert('No files selected for export.');
+            return;
+        }
+    
+        const headers = ['Tracking Number', 'Title', 'Revision', 'Status', 'Extension', 'Size', 'Size (bytes)', 'Path', 'Modified'];
+        const rows = [headers];
+    
+        // Add data rows for selected files only
+        window.app.files.forEach(file => {
+            if (!window.app.selectedFiles.has(file.id)) return;
+        
+            rows.push([
+                file.trackingNumber || '',
+                file.title || '',
+                file.revision || '',
+                file.status || '',
+                file.extension || '',
+                formatFileSize(file.size),
+                file.size != null ? file.size : '',
+                file.path,
+                file.modified ? new Date(file.modified).toLocaleString() : '—'
+            ]);
+        });
+    
+        downloadFile(rowsToCSV(rows), 'archive-export.csv', 'text/csv');
+    }
+
+    // Download selected files as ZIP
+    async function downloadSelected() {
+        if (window.app.selectedFiles.size === 0) {
+            alert('No files selected for download.');
+            return;
+        }
+    
+        // Check if JSZip is loaded
+        if (typeof JSZip === 'undefined') {
+            // Dynamically load JSZip
+            await loadJSZip();
+        }
+    
+        const zip = new JSZip();
+        const selectedFiles = [];
+    
+        // Get selected file objects
+        window.app.files.forEach(file => {
+            if (window.app.selectedFiles.has(file.id)) {
+                selectedFiles.push(file);
+            }
+        });
+    
+        // Show progress
+        showProgress('Preparing ZIP file...', 0, selectedFiles.length);
+    
+        try {
+            // Add files to ZIP
+            for (let i = 0; i < selectedFiles.length; i++) {
+                const file = selectedFiles[i];
+                showProgress(`Adding ${file.name}...`, i + 1, selectedFiles.length);
+            
+                try {
+                    let arrayBuffer;
+                    if (file.handle) {
+                        // Local mode: read via File System Access API
+                        const fileData = await file.handle.getFile();
+                        arrayBuffer = await fileData.arrayBuffer();
+                    } else if (file.url) {
+                        // HTTP mode: fetch from server
+                        const resp = await fetch(file.url);
+                        if (!resp.ok) throw new Error('HTTP ' + resp.status);
+                        arrayBuffer = await resp.arrayBuffer();
+                    } else {
+                        throw new Error('No file handle or URL available');
+                    }
+                
+                    // Create folder structure in ZIP
+                    const relativePath = file.path.substring(file.path.indexOf('/') + 1); // Remove root directory
+                    zip.file(relativePath, arrayBuffer);
+                } catch (err) {
+                    console.error(`Error adding file ${file.name}:`, err);
+                }
+            }
+        
+            showProgress('Generating ZIP...', selectedFiles.length, selectedFiles.length);
+        
+            // Generate ZIP
+            const blob = await zip.generateAsync({ 
+                type: 'blob',
+                compression: 'DEFLATE',
+                compressionOptions: { level: 6 }
+            });
+        
+            // Download
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+            downloadBlob(blob, `archive-${timestamp}.zip`);
+        
+            hideProgress();
+        
+        } catch (err) {
+            hideProgress();
+            console.error('Error creating ZIP:', err);
+            alert('Error creating ZIP file: ' + err.message);
+        }
+    }
+
+    // Load JSZip library dynamically
+    function loadJSZip() {
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = 'https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js';
+            script.onload = resolve;
+            script.onerror = reject;
+            document.head.appendChild(script);
+        });
+    }
+
+    // Show progress indicator
+    function showProgress(message, current, total) {
+        let progressDiv = document.getElementById('progressIndicator');
+    
+        if (!progressDiv) {
+            progressDiv = document.createElement('div');
+            progressDiv.id = 'progressIndicator';
+            progressDiv.className = 'progress-indicator';
+            document.body.appendChild(progressDiv);
+        }
+    
+        const percentage = Math.round((current / total) * 100);
+    
+        progressDiv.innerHTML =
+            '<div class="progress-indicator__message">' + window.app.modules.app.escapeHtml(message) + '</div>' +
+            '<div class="progress-indicator__track">' +
+                '<div class="progress-indicator__fill" style="width:' + percentage + '%"></div>' +
+            '</div>' +
+            '<div class="progress-indicator__label">' + current + ' / ' + total + '</div>';
+    }
+
+    // Hide progress indicator
+    function hideProgress() {
+        const progressDiv = document.getElementById('progressIndicator');
+        if (progressDiv) {
+            progressDiv.remove();
+        }
+    }
+
+    // Download file utility
+    function downloadFile(content, filename, mimeType) {
+        const blob = new Blob([content], { type: mimeType });
+        downloadBlob(blob, filename);
+    }
+
+    // Download blob utility
+    function downloadBlob(blob, filename) {
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    }
+
+    // Format file size
+    function formatFileSize(bytes) {
+        if (bytes === 0) return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+
+    // Export to HTML report
+    function exportHTMLReport() {
+        // Group files by tracking number
+        const grouped = window.app.modules.parser.groupFilesByTrackingNumber(window.app.filteredFiles);
+        const sorted = window.app.modules.parser.sortGroupedFiles(grouped);
+    
+        const html = `
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <title>Archive Report - ${new Date().toLocaleDateString()}</title>
+        <style>
+            body { font-family: Arial, sans-serif; margin: 20px; }
+            h1 { color: #333; }
+            table { border-collapse: collapse; width: 100%; margin-top: 20px; }
+            th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+            th { background-color: #f2f2f2; font-weight: bold; }
+            tr:nth-child(even) { background-color: #f9f9f9; }
+            .revision { font-family: monospace; }
+            .status { color: #666; font-size: 0.9em; }
+            @media print {
+                body { margin: 0; }
+                h1 { font-size: 18pt; }
+                table { font-size: 10pt; }
+            }
+        </style>
+    </head>
+    <body>
+        <h1>Archive Report</h1>
+        <p>Generated: ${new Date().toLocaleString()}</p>
+        <p>Total Files: ${window.app.filteredFiles.length}</p>
+    
+        <table>
+            <thead>
+                <tr>
+                    <th>Tracking Number</th>
+                    <th>Title</th>
+                    <th>Revisions</th>
+                </tr>
+            </thead>
+            <tbody>
+                ${sorted.map(group => `
+                    <tr>
+                        <td>${window.app.modules.app.escapeHtml(group.trackingNumber)}</td>
+                        <td>${window.app.modules.app.escapeHtml(group.title)}</td>
+                        <td>
+                            ${group.sortedRevisions.map(rev => `
+                                <div>
+                                    <span class="revision">${window.app.modules.app.escapeHtml(rev.revision)}</span>
+                                    <span class="status">(${window.app.modules.app.escapeHtml(rev.status)})</span>
+                                    ${rev.files.map(f => f.extension.toUpperCase()).join(', ')}
+                                </div>
+                            `).join('')}
+                        </td>
+                    </tr>
+                `).join('')}
+            </tbody>
+        </table>
+    </body>
+    </html>`;
+    
+        downloadFile(html, 'archive-report.html', 'text/html');
+    }
+
+    window.app.modules.export = {
+        csvCell,
+        rowsToCSV,
+        exportCSV,
+        downloadSelected,
+        loadJSZip,
+        showProgress,
+        hideProgress,
+        downloadFile,
+        downloadBlob,
+        formatFileSize,
+        exportHTMLReport
+    };
+
+})();
diff --git a/archive/js/filtering.js b/archive/js/filtering.js
new file mode 100644
index 0000000..58573d7
--- /dev/null
+++ b/archive/js/filtering.js
@@ -0,0 +1,141 @@
+// Filtering functionality
+
+// Apply all filters
+function applyFilters() {
+    // Start with files from selected transmittal folders AND selected grouping folders
+    let filtered = window.app.files.filter(file => {
+        // Must have at least one grouping folder selected (if grouping folders exist)
+        if (window.app.groupingFolders.length > 0 && window.app.selectedGroupingFolders.size === 0) {
+            return false;
+        }
+        
+        // Must have at least one transmittal folder selected
+        if (window.app.selectedTransmittalFolders.size === 0) {
+            return false;
+        }
+        
+        // File must be in a selected transmittal folder
+        if (!window.app.selectedTransmittalFolders.has(file.folderPath)) {
+            return false;
+        }
+        
+        // Outstanding files: actualPath must be under a selected grouping folder that is
+        // itself visible (not hidden by folder type toggles).
+        if (file.folderPath === '__outstanding__') {
+            if (!window.app.modules.app.outstandingFileIsVisible(file)) return false;
+        }
+        
+        // If grouping folders exist and are selected, the file's transmittal folder must be within one.
+        // Outstanding files are exempt — their grouping scope is enforced by the actualPath check above.
+        if (file.folderPath !== '__outstanding__' && window.app.groupingFolders.length > 0 && window.app.selectedGroupingFolders.size > 0) {
+            const inSelectedGrouping = Array.from(window.app.selectedGroupingFolders).some(groupingPath => 
+                file.folderPath.startsWith(groupingPath + '/')
+            );
+            if (!inSelectedGrouping) {
+                return false;
+            }
+        }
+        
+        return true;
+    });
+    
+
+    
+    // Apply column filters
+    filtered = applyColumnFilters(filtered);
+    
+    // Apply modifier filter
+    if (window.app.selectedModifiers.size < window.app.availableModifiers.size) {
+        filtered = filtered.filter(file => window.app.modules.app.filePassesModifierFilter(file));
+    }
+    
+    updateResetFiltersBtn();
+    
+    // Apply selected-only filter
+    if (window.app.showSelectedOnly) {
+        filtered = filtered.filter(file => window.app.selectedFiles.has(file.id));
+    }
+    
+    window.app.filteredFiles = filtered;
+    window.app.modules.table.updateFileTable();
+    window.app.modules.app.updateStatusBar();
+    window.app.modules.table.updateSelectAllVisibleCheckbox();
+}
+
+
+
+// Apply column filters using stored ASTs
+function applyColumnFilters(files) {
+    const asts = window.app.columnFilterASTs;
+    
+    if (asts.trackingNumber && asts.trackingNumber.length > 0) {
+        files = files.filter(file =>
+            zddc.filter.matches(file.trackingNumber || '', asts.trackingNumber)
+        );
+    }
+    
+    if (asts.title && asts.title.length > 0) {
+        files = files.filter(file =>
+            zddc.filter.matches(file.title || '', asts.title)
+        );
+    }
+    
+    if (asts.revisions && asts.revisions.length > 0) {
+        files = files.filter(file => {
+            const revisionText = [
+                file.revision,
+                file.status,
+                file.extension
+            ].join(' ');
+            return zddc.filter.matches(revisionText, asts.revisions);
+        });
+    }
+    
+    return files;
+}
+
+// Clear all filters
+function clearFilters() {
+    window.app.columnFilters = {
+        trackingNumber: '',
+        title: '',
+        revisions: ''
+    };
+    window.app.columnFilterASTs = {
+        trackingNumber: null,
+        title: null,
+        revisions: null
+    };
+    window.app.groupingFilter = '';
+    window.app.transmittalFilter = '';
+    
+    // Clear UI inputs
+    const groupingFilterEl = document.getElementById('groupingFilter');
+    groupingFilterEl.value = '';
+    groupingFilterEl.classList.remove('filter-active');
+    const transmittalFilterEl = document.getElementById('transmittalFilter');
+    transmittalFilterEl.value = '';
+    transmittalFilterEl.classList.remove('filter-active');
+    document.querySelectorAll('.column-filter').forEach(input => {
+        input.value = '';
+        input.classList.remove('filter-active');
+    });
+    
+    window.app.modules.app.toggleAllModifiers(true);
+    updateResetFiltersBtn();
+    applyFilters();
+    window.app.modules.urlState.push();
+}
+
+// Update reset filters button visibility
+function updateResetFiltersBtn() {
+    // Button is always visible — no show/hide logic needed
+}
+
+// Register filtering module
+window.app.modules.filtering = {
+    applyFilters,
+    applyColumnFilters,
+    clearFilters,
+    updateResetFiltersBtn
+};
diff --git a/archive/js/hash.js b/archive/js/hash.js
new file mode 100644
index 0000000..f41fa16
--- /dev/null
+++ b/archive/js/hash.js
@@ -0,0 +1,194 @@
+(function() {
+    'use strict';
+    // SHA-256 hashing and cache management
+
+    const HASH_CACHE_FILENAME = '.hashes.json';
+
+    // Calculate SHA-256 hash for a file (delegates to shared/hash.js)
+    async function calculateFileHash(file) {
+        return zddc.crypto.sha256File(file);
+    }
+
+    // Load hash cache for a directory
+    async function loadHashCache(dirHandle) {
+        try {
+            const cacheHandle = await dirHandle.getFileHandle(HASH_CACHE_FILENAME);
+            const cacheFile = await cacheHandle.getFile();
+            const cacheText = await cacheFile.text();
+            return JSON.parse(cacheText);
+        } catch (err) {
+            // Cache doesn't exist or can't be read
+            return {};
+        }
+    }
+
+    // Save hash cache for a directory
+    async function saveHashCache(dirHandle, cache) {
+        try {
+            const cacheHandle = await dirHandle.getFileHandle(HASH_CACHE_FILENAME, { create: true });
+            const writable = await cacheHandle.createWritable();
+            await writable.write(JSON.stringify(cache, null, 2));
+            await writable.close();
+            return true;
+        } catch (err) {
+            console.warn('Unable to save hash cache:', err);
+            return false;
+        }
+    }
+
+    // Hash files in a directory with caching
+    async function hashDirectoryFiles(dirHandle, files) {
+        const cache = await loadHashCache(dirHandle);
+        const updatedCache = {};
+        const results = {};
+    
+        for (const fileInfo of files) {
+            try {
+                const file = await fileInfo.handle.getFile();
+                const cacheKey = file.name;
+                const lastModified = file.lastModified;
+            
+                // Check if we have a cached hash
+                if (cache[cacheKey] && cache[cacheKey].lastModified === lastModified) {
+                    // Use cached hash
+                    results[fileInfo.id] = cache[cacheKey].hash;
+                    updatedCache[cacheKey] = cache[cacheKey];
+                } else {
+                    // Calculate new hash
+                    const hash = await calculateFileHash(file);
+                    results[fileInfo.id] = hash;
+                    updatedCache[cacheKey] = {
+                        hash: hash,
+                        lastModified: lastModified,
+                        size: file.size
+                    };
+                }
+            } catch (err) {
+                console.error(`Error hashing file ${fileInfo.name}:`, err);
+            }
+        }
+    
+        // Try to save updated cache
+        await saveHashCache(dirHandle, updatedCache);
+    
+        return results;
+    }
+
+    // Add hash information to files
+    async function addHashesToFiles() {
+        if (!window.app.files.length) return;
+    
+        // Hash operations require local file handles — not available in HTTP mode
+        if (window.app.sourceMode === 'http') {
+            console.log('Hash operations not available in HTTP mode.');
+            return;
+        }
+    
+        window.app.modules.export.showProgress('Calculating file hashes...', 0, window.app.files.length);
+    
+        try {
+            // Group files by directory
+            const filesByDir = {};
+            window.app.files.forEach(file => {
+                const dirPath = file.folderPath;
+                if (!filesByDir[dirPath]) {
+                    filesByDir[dirPath] = {
+                        handle: null,
+                        files: []
+                    };
+                }
+                filesByDir[dirPath].files.push(file);
+            });
+        
+            // Find directory handles
+            for (const dirPath in filesByDir) {
+                const folder = window.app.transmittalFolders.find(f => f.path === dirPath);
+                if (folder) {
+                    filesByDir[dirPath].handle = folder.handle;
+                }
+            }
+        
+            // Hash files in each directory
+            let processed = 0;
+            for (const dirPath in filesByDir) {
+                const dirInfo = filesByDir[dirPath];
+                if (dirInfo.handle) {
+                    const hashes = await hashDirectoryFiles(dirInfo.handle, dirInfo.files);
+                
+                    // Update file objects with hashes
+                    dirInfo.files.forEach(file => {
+                        if (hashes[file.id]) {
+                            file.hash = hashes[file.id];
+                        }
+                    });
+                }
+            
+                processed += dirInfo.files.length;
+                window.app.modules.export.showProgress('Calculating file hashes...', processed, window.app.files.length);
+            }
+        
+            window.app.modules.export.hideProgress();
+        
+        } catch (err) {
+            window.app.modules.export.hideProgress();
+            console.error('Error calculating hashes:', err);
+        }
+    }
+
+    // Verify file integrity
+    async function verifyFileIntegrity(fileId) {
+        const file = window.app.files.find(f => f.id === fileId);
+        if (!file || !file.hash) {
+            alert('No hash available for this file.');
+            return;
+        }
+    
+        if (!file.handle) {
+            alert('File integrity verification is not available in HTTP mode.');
+            return;
+        }
+    
+        try {
+            const fileData = await file.handle.getFile();
+            const currentHash = await calculateFileHash(fileData);
+        
+            if (currentHash === file.hash) {
+                alert('File integrity verified. Hash matches.');
+            } else {
+                alert('WARNING: File has been modified! Hash does not match.');
+            }
+        } catch (err) {
+            alert('Error verifying file: ' + err.message);
+        }
+    }
+
+    // Export hash report
+    function exportHashReport() {
+        const headers = ['File Path', 'SHA-256 Hash', 'Size', 'Last Modified'];
+        const rows = [headers];
+    
+        window.app.filteredFiles.forEach(file => {
+            if (file.hash) {
+                rows.push([
+                    file.path,
+                    file.hash,
+                    window.app.modules.export.formatFileSize(file.size),
+                    new Date(file.modified).toISOString()
+                ]);
+            }
+        });
+    
+        window.app.modules.export.downloadFile(window.app.modules.export.rowsToCSV(rows), 'file-hashes.csv', 'text/csv');
+    }
+
+    window.app.modules.hash = {
+        calculateFileHash,
+        loadHashCache,
+        saveHashCache,
+        hashDirectoryFiles,
+        addHashesToFiles,
+        verifyFileIntegrity,
+        exportHashReport
+    };
+
+})();
diff --git a/archive/js/init.js b/archive/js/init.js
new file mode 100644
index 0000000..3cf175d
--- /dev/null
+++ b/archive/js/init.js
@@ -0,0 +1,41 @@
+/**
+ * ZDDC Archive - Initialization
+ * Sets up window.app and window.app.modules before other modules run.
+ * Must be the first JS file in the build.
+ */
+(function() {
+    'use strict';
+
+    window.app = {
+        sourceMode: null,
+        directories: [],
+        groupingFolders: [],
+        transmittalFolders: [],
+        files: [],
+        filteredFiles: [],
+        selectedFiles: new Set(),
+        isScanning: false,
+        scanProgress: '',
+
+        columnFilters: { trackingNumber: '', title: '', revisions: '' },
+        columnFilterASTs: { trackingNumber: null, title: null, revisions: null },
+        groupingFilter: '',
+        transmittalFilter: '',
+        enabledFolderTypes: new Set(['issued', 'received']),
+        sortField: 'trackingNumber',
+        sortDirection: 'asc',
+        selectedGroupingFolders: new Set(),
+        selectedTransmittalFolders: new Set(),
+        collapsedDateGroups: new Set(),
+        collapsedGroupingFolders: new Set(),
+        selectAllGroupingFolders: true,
+        selectAllTransmittals: true,
+        availableModifiers: new Set(),
+        selectedModifiers: new Set(),
+        showSelectedOnly: false,
+        projectFilter: new Set(),
+        FOLDER_TYPE_NAMES: ['issued', 'received', 'mdl', 'incoming'],
+        modules: {}
+    };
+
+})();
diff --git a/archive/js/parser.js b/archive/js/parser.js
new file mode 100644
index 0000000..73c76f3
--- /dev/null
+++ b/archive/js/parser.js
@@ -0,0 +1,65 @@
+// Archive grouping/sorting helpers — ZDDC parsing comes from window.zddc directly.
+(function() {
+    'use strict';
+
+    function isTransmittalFolder(name) {
+        var parsed = zddc.parseFolder(name);
+        return !!(parsed && parsed.valid);
+    }
+
+    function groupFilesByTrackingNumber(files) {
+        const groups = {};
+        files.forEach(file => {
+            if (!file.trackingNumber) return;
+            if (!groups[file.trackingNumber]) {
+                groups[file.trackingNumber] = { trackingNumber: file.trackingNumber, title: file.title, revisions: {} };
+            }
+            if (file.title.length > groups[file.trackingNumber].title.length) {
+                groups[file.trackingNumber].title = file.title;
+            }
+            const revKey = `${file.revision}_${file.status}`;
+            if (!groups[file.trackingNumber].revisions[revKey]) {
+                groups[file.trackingNumber].revisions[revKey] = {
+                    revision: file.revision, status: file.status, title: file.title,
+                    hasModifier: file.revision.includes('+'), files: []
+                };
+            }
+            if (file.title.length > groups[file.trackingNumber].revisions[revKey].title.length) {
+                groups[file.trackingNumber].revisions[revKey].title = file.title;
+            }
+            groups[file.trackingNumber].revisions[revKey].files.push(file);
+        });
+        return groups;
+    }
+
+    function sortGroupedFiles(groups) {
+        const field = window.app.sortField || 'trackingNumber';
+        const direction = window.app.sortDirection === 'desc' ? -1 : 1;
+        const sorted = Object.values(groups).sort((a, b) => {
+            let comparison = 0;
+            if (field === 'trackingNumber') comparison = a.trackingNumber.localeCompare(b.trackingNumber);
+            else if (field === 'title') comparison = a.title.localeCompare(b.title);
+            else if (field === 'revisions') {
+                const aRevs = Object.keys(a.revisions), bRevs = Object.keys(b.revisions);
+                comparison = zddc.compareRevisions(
+                    aRevs.length > 0 ? aRevs[aRevs.length - 1] : '',
+                    bRevs.length > 0 ? bRevs[bRevs.length - 1] : ''
+                );
+            }
+            return comparison * direction;
+        });
+        sorted.forEach(group => {
+            const revisions = Object.values(group.revisions);
+            revisions.sort((a, b) => zddc.compareRevisions(b.revision, a.revision));
+            group.sortedRevisions = revisions;
+        });
+        return sorted;
+    }
+
+    window.app.modules.parser = {
+        isTransmittalFolder,
+        groupFilesByTrackingNumber,
+        sortGroupedFiles,
+    };
+
+})();
diff --git a/archive/js/presets.js b/archive/js/presets.js
new file mode 100644
index 0000000..0e879d3
--- /dev/null
+++ b/archive/js/presets.js
@@ -0,0 +1,437 @@
+(function() {
+    'use strict';
+    // Party presets for archive browser — IIFE module
+
+    // State (module scope, NOT on window.app)
+    let presets = [];
+    let activePresetName = null;
+    let isOpen = false;
+    let isNamingMode = false;
+
+    // Get localStorage key based on source mode and directory
+    function getStorageKey() {
+        if (window.app.sourceMode === 'http' && window.app.directories.length > 0) {
+            var u = window.app.directories[0].url || '';
+            return 'zddc-presets:http:' + u;
+        } else if (window.app.sourceMode === 'local' && window.app.directories.length > 0) {
+            return 'zddc-presets:local:' + window.app.directories[0].name;
+        }
+        return 'zddc-presets:default';
+    }
+
+    // Load presets from localStorage
+    function loadFromStorage() {
+        try {
+            var stored = localStorage.getItem(getStorageKey());
+            if (stored) {
+                var parsed = JSON.parse(stored);
+                if (parsed && Array.isArray(parsed.presets)) {
+                    presets = parsed.presets;
+                } else {
+                    presets = [];
+                }
+            } else {
+                presets = [];
+            }
+        } catch (e) {
+            presets = [];
+        }
+    }
+
+    // Save presets to localStorage
+    function saveToStorage() {
+        try {
+            localStorage.setItem(getStorageKey(), JSON.stringify({ presets: presets }));
+        } catch (e) {
+            // Silently fail on storage errors
+        }
+    }
+
+    // Load a preset by name
+    function loadPreset(name) {
+        var preset = presets.find(p => p.name === name);
+        if (!preset) return;
+
+        // Filter paths to only include folders that exist in groupingFolders
+        var validPaths = preset.paths.filter(p =>
+            window.app.groupingFolders.some(f => f.path === p)
+        );
+
+        window.app.selectedGroupingFolders = new Set(validPaths);
+        window.app.selectAllGroupingFolders = false;
+
+        var checkbox = document.getElementById('selectAllGroupingCheckbox');
+        if (checkbox) checkbox.checked = false;
+
+        activePresetName = name;
+
+        // Trigger UI updates
+        window.app.modules.app.updateFolderSelectionState('groupingFoldersList');
+        window.app.modules.app.renderTransmittalFolders();
+        window.app.modules.filtering.applyFilters();
+
+        renderButton();
+        renderDropdown();
+    }
+
+    // Save current selection as a preset
+    function savePreset(name) {
+        // Build paths array from current selection
+        var paths = Array.from(window.app.selectedGroupingFolders);
+
+        // Upsert preset
+        var existingIndex = presets.findIndex(p => p.name === name);
+        if (existingIndex >= 0) {
+            presets[existingIndex] = { name: name, paths: paths };
+        } else {
+            presets.push({ name: name, paths: paths });
+        }
+
+        saveToStorage();
+        activePresetName = name;
+        isNamingMode = false;
+
+        renderButton();
+        renderDropdown();
+    }
+
+    // Delete a preset by name
+    function deletePreset(name) {
+        presets = presets.filter(p => p.name !== name);
+        if (activePresetName === name) {
+            activePresetName = null;
+        }
+        saveToStorage();
+        renderButton();
+        renderDropdown();
+    }
+
+    // Check if current selection differs from active preset
+    function checkDirty() {
+        if (activePresetName === null) return;
+
+        var preset = presets.find(p => p.name === activePresetName);
+        if (!preset) return;
+
+        var currentPaths = new Set(window.app.selectedGroupingFolders);
+        var presetPaths = new Set(preset.paths || []);
+
+        // Compare sets
+        var dirty = currentPaths.size !== presetPaths.size ||
+            !Array.from(currentPaths).every(p => presetPaths.has(p));
+
+        if (dirty) {
+            renderButton();
+        }
+    }
+
+    // Get minimum depth of grouping folders (for top-level Only)
+    function getMinDepth() {
+        if (window.app.groupingFolders.length === 0) return 1;
+        return Math.min.apply(null, window.app.groupingFolders.map(f => f.path.split('/').length));
+    }
+
+    // Render the preset button label
+    function renderButton() {
+        var btn = document.getElementById('presetBtn');
+        if (!btn) return;
+
+        if (activePresetName !== null) {
+            // Check if dirty
+            var preset = presets.find(p => p.name === activePresetName);
+            var dirty = false;
+            if (preset) {
+                var currentPaths = new Set(window.app.selectedGroupingFolders);
+                var presetPaths = new Set(preset.paths || []);
+                dirty = currentPaths.size !== presetPaths.size ||
+                    !Array.from(currentPaths).every(p => presetPaths.has(p));
+            }
+            btn.textContent = '▾ ' + activePresetName + (dirty ? '*' : '');
+        } else {
+            btn.textContent = '▾ Presets';
+        }
+    }
+
+    // Escape HTML for safe insertion
+    function escapeHtml(text) {
+        var div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    // Render the dropdown panel
+    function renderDropdown() {
+        var dropdown = document.getElementById('presetDropdown');
+        if (!dropdown) return;
+
+        var minDepth = getMinDepth();
+
+        // Build presets list HTML
+        var presetsHtml = '';
+        if (presets.length === 0) {
+            presetsHtml = '<div class="preset-no-presets"><i>No saved presets</i></div>';
+        } else {
+            presetsHtml = presets.map(preset => {
+                var escapedName = escapeHtml(preset.name);
+                return (
+                    '<div class="preset-item" data-name="' + escapedName + '">' +
+                        '<span>' + escapedName + '</span>' +
+                        '<button class="preset-delete" data-name="' + escapedName + '">×</button>' +
+                    '</div>'
+                );
+            }).join('');
+        }
+
+        // Build project checkboxes HTML
+        var projectsHtml = '';
+        window.app.groupingFolders.forEach(folder => {
+            // Only include top-level folders (minDepth)
+            var pathParts = folder.path.split('/');
+            if (pathParts.length !== minDepth) return;
+
+            var isSelected = window.app.selectedGroupingFolders.has(folder.path);
+            var escapedPath = escapeHtml(folder.path);
+            var escapedName = escapeHtml(folder.name);
+
+            projectsHtml += (
+                '<div class="preset-project-item">' +
+                    '<label class="preset-project-label">' +
+                        '<input type="checkbox" class="preset-checkbox" data-path="' + escapedPath + '"' +
+                            (isSelected ? ' checked' : '') + '>' +
+                        ' ' + escapedName +
+                    '</label>' +
+                '</div>'
+            );
+        });
+
+        // Footer HTML
+        var footerHtml = '';
+        if (activePresetName !== null) {
+            // Check if dirty
+            var preset = presets.find(p => p.name === activePresetName);
+            var dirty = false;
+            if (preset) {
+                var currentPaths = new Set(window.app.selectedGroupingFolders);
+                var presetPaths = new Set(preset.paths || []);
+                dirty = currentPaths.size !== presetPaths.size ||
+                    !Array.from(currentPaths).every(p => presetPaths.has(p));
+            }
+
+            if (isNamingMode) {
+                footerHtml = (
+                    '<div class="preset-footer-naming">' +
+                        '<input type="text" class="preset-name-input" placeholder="Preset name" autoFocus>' +
+                        '<button class="preset-confirm-name btn btn-sm">✓</button>' +
+                        '<button class="preset-cancel-name btn btn-sm">✗</button>' +
+                    '</div>'
+                );
+            } else if (dirty) {
+                footerHtml = (
+                    '<div class="preset-footer-actions">' +
+                        '<button class="preset-update-btn btn btn-primary btn-sm">Update "' + escapeHtml(activePresetName) + '"</button>' +
+                        '<button class="preset-save-new-btn btn btn-secondary btn-sm">Save as New</button>' +
+                    '</div>'
+                );
+            } else {
+                footerHtml = (
+                    '<div class="preset-footer-actions">' +
+                        '<button class="preset-save-new-btn btn btn-primary btn-sm">Save as New</button>' +
+                    '</div>'
+                );
+            }
+        } else {
+            // No active preset — disabled if nothing selected
+            var selectedCount = window.app.selectedGroupingFolders.size;
+            var disabledAttr = selectedCount === 0 ? ' disabled' : '';
+            footerHtml = (
+                '<div class="preset-footer-actions">' +
+                    '<button class="preset-save-btn btn btn-primary btn-sm' + (selectedCount === 0 ? ' btn-disabled' : '') + '" ' +
+                        'data-disabled="' + (selectedCount === 0 ? 'true' : 'false') + '">Save as Preset</button>' +
+                '</div>'
+            );
+        }
+
+        dropdown.innerHTML = (
+            '<div class="preset-section-top">' +
+                '<div class="preset-section-label">Saved Presets:</div>' +
+                '<div class="preset-list">' + presetsHtml + '</div>' +
+            '</div>' +
+            '<div class="preset-divider"></div>' +
+            '<div class="preset-section-bottom">' +
+                '<div class="preset-section-label">Projects:</div>' +
+                '<div class="preset-projects-list">' + projectsHtml + '</div>' +
+            '</div>' +
+            footerHtml
+        );
+    }
+
+    // Toggle dropdown visibility
+    function toggleDropdown() {
+        var dropdown = document.getElementById('presetDropdown');
+        if (isOpen) {
+            closeDropdown();
+        } else {
+            isOpen = true;
+            if (dropdown) dropdown.classList.remove('hidden');
+            renderDropdown();
+        }
+    }
+
+    // Close dropdown
+    function closeDropdown() {
+        isOpen = false;
+        var dropdown = document.getElementById('presetDropdown');
+        if (dropdown) dropdown.classList.add('hidden');
+        isNamingMode = false;
+    }
+
+    // Set up event delegation on dropdown
+    function setupDropdownDelegation() {
+        var dropdown = document.getElementById('presetDropdown');
+        if (!dropdown) return;
+
+        dropdown.addEventListener('click', function(e) {
+            // Close on clicks inside dropdown
+            e.stopPropagation();
+
+            // Preset item click — load preset (do NOT close dropdown)
+            var presetItem = e.target.closest('.preset-item');
+            if (presetItem && !e.target.classList.contains('preset-delete')) {
+                var name = presetItem.getAttribute('data-name');
+                if (name) loadPreset(name);
+                return;
+            }
+
+            // Delete button
+            var deleteBtn = e.target.closest('.preset-delete');
+            if (deleteBtn) {
+                e.stopPropagation();
+                var name = deleteBtn.getAttribute('data-name');
+                if (name) deletePreset(name);
+                return;
+            }
+
+            // Checkbox click
+            var checkbox = e.target.closest('.preset-checkbox');
+            if (checkbox) {
+                var path = checkbox.getAttribute('data-path');
+                if (path) {
+                    if (checkbox.checked) {
+                        window.app.selectedGroupingFolders.add(path);
+                    } else {
+                        window.app.selectedGroupingFolders.delete(path);
+                    }
+                    window.app.modules.app.updateFolderSelectionState('groupingFoldersList');
+                    window.app.modules.app.renderTransmittalFolders();
+                    window.app.modules.filtering.applyFilters();
+                    checkDirty();
+                    renderButton();
+                    renderDropdown(); // Re-render to update checkbox states and footer
+                }
+                return;
+            }
+
+            // Save button (not in naming mode)
+            var saveBtn = e.target.closest('.preset-save-btn');
+            if (saveBtn && !isNamingMode) {
+                if (saveBtn.getAttribute('data-disabled') !== 'true') {
+                    isNamingMode = true;
+                    renderDropdown();
+                }
+                return;
+            }
+
+            // Update button — save current selection as active preset
+            var updateBtn = e.target.closest('.preset-update-btn');
+            if (updateBtn) {
+                if (activePresetName) savePreset(activePresetName);
+                return;
+            }
+
+            // Save as New button
+            var saveNewBtn = e.target.closest('.preset-save-new-btn');
+            if (saveNewBtn) {
+                isNamingMode = true;
+                renderDropdown();
+                return;
+            }
+
+            // Confirm name input
+            var confirmBtn = e.target.closest('.preset-confirm-name');
+            if (confirmBtn) {
+                var input = dropdown.querySelector('.preset-name-input');
+                if (input && input.value.trim()) {
+                    savePreset(input.value.trim());
+                }
+                return;
+            }
+
+            // Cancel name input
+            var cancelBtn = e.target.closest('.preset-cancel-name');
+            if (cancelBtn) {
+                isNamingMode = false;
+                renderDropdown();
+                return;
+            }
+        });
+
+        // Keydown on name input
+        dropdown.addEventListener('keydown', function(e) {
+            var input = e.target.closest('.preset-name-input');
+            if (!input) return;
+
+            if (e.key === 'Enter') {
+                e.stopPropagation();
+                if (input.value.trim()) {
+                    savePreset(input.value.trim());
+                }
+            } else if (e.key === 'Escape') {
+                e.stopPropagation();
+                isNamingMode = false;
+                renderDropdown();
+            }
+        });
+    }
+
+    // Handle outside click to close dropdown
+    function setupOutsideClickHandler() {
+        document.addEventListener('click', function(e) {
+            var section = document.getElementById('presetSection');
+            var dropdown = document.getElementById('presetDropdown');
+            if (isOpen && section && dropdown && !section.contains(e.target)) {
+                closeDropdown();
+            }
+        });
+    }
+
+    // Initialize presets module — called after first scan completes
+    function init() {
+        // Idempotent: skip if button listener already attached
+        var btn = document.getElementById('presetBtn');
+        if (!btn || btn.dataset.presetInit) return;
+        btn.dataset.presetInit = '1';
+
+        btn.addEventListener('click', function(e) {
+            e.stopPropagation();
+            toggleDropdown();
+        });
+
+        setupDropdownDelegation();
+        setupOutsideClickHandler();
+        loadFromStorage();
+        renderButton();
+    }
+
+    // Register module
+    window.app.modules.presets = {
+        init: init,
+        loadPreset: loadPreset,
+        savePreset: savePreset,
+        deletePreset: deletePreset,
+        checkDirty: checkDirty,
+        renderButton: renderButton,
+        toggleDropdown: toggleDropdown,
+        closeDropdown: closeDropdown
+    };
+
+})();
diff --git a/archive/js/source.js b/archive/js/source.js
new file mode 100644
index 0000000..336f825
--- /dev/null
+++ b/archive/js/source.js
@@ -0,0 +1,432 @@
+(function() {
+    'use strict';
+    // Source abstraction — local (File System Access API) and HTTP (Caddy JSON browse)
+    //
+    // Shared utility used by both source implementations
+    function getDisplayPath(fullPath) {
+        if (fullPath.length <= 100) {
+            return fullPath;
+        }
+        const parts = fullPath.split('/');
+        if (parts.length > 3) {
+            return parts[0] + '/.../' + parts.slice(-2).join('/');
+        }
+        return '...' + fullPath.substring(fullPath.length - 80);
+    }
+
+    // createSource(type, options) returns a source object:
+    //   source.type       — 'local' | 'http'
+    //   source.canWrite   — boolean
+    //   source.scan(rootIdentifier, callbacks) — Promise; walks tree calling:
+    //       callbacks.onGroupingFolder(folder)     folder: { name, path, displayPath, handle? }
+    //       callbacks.onTransmittalFolder(folder)  folder: { name, path, displayPath, handle?, url? }
+    //       callbacks.onFile(file)                 file:   full file object (parsed + metadata)
+    //       callbacks.onProgress(message)
+    //   source.fetchFile(fileRef) — Promise<ArrayBuffer>
+
+    function createSource(type, options) {
+        if (type === 'local') {
+            return createLocalSource();
+        } else if (type === 'http') {
+            return createHttpSource(options.baseUrl);
+        }
+        throw new Error('Unknown source type: ' + type);
+    }
+
+    // ---------------------------------------------------------------------------
+    // Local source — wraps File System Access API
+    // ---------------------------------------------------------------------------
+
+    function createLocalSource() {
+        return {
+            type: 'local',
+            canWrite: true,
+
+            scan: function(dirHandle, callbacks) {
+                return scanLocalRecursive(dirHandle, dirHandle.name, 0, callbacks);
+            },
+
+            fetchFile: function(fileRef) {
+                return fileRef.handle.getFile().then(function(f) {
+                    return f.arrayBuffer();
+                });
+            }
+        };
+    }
+
+    async function scanLocalRecursive(dirHandle, currentPath, depth, callbacks) {
+        if (currentPath.length > 200) {
+            console.warn('Path too long, skipping deeper scan: ' + currentPath);
+            return;
+        }
+        if (depth > 10) {
+            console.warn('Directory depth limit reached at: ' + currentPath);
+            return;
+        }
+
+        callbacks.onProgress('Scanning ' + currentPath + '...');
+
+        const entries = [];
+        try {
+            for await (const entry of dirHandle.values()) {
+                entries.push(entry);
+            }
+        } catch (err) {
+            console.warn('Could not read directory ' + currentPath + ':', err);
+            return;
+        }
+
+        for (const entry of entries) {
+            if (entry.kind === 'directory') {
+                const subPath = currentPath + '/' + entry.name;
+                try {
+                    if (window.app.modules.parser.isTransmittalFolder(entry.name)) {
+                        const folder = {
+                            name: entry.name,
+                            path: subPath,
+                            displayPath: getDisplayPath(subPath),
+                            handle: entry
+                        };
+                        callbacks.onTransmittalFolder(folder);
+                        await scanLocalTransmittalFolder(entry, subPath, 0, subPath, callbacks);
+                    } else {
+                        const folder = {
+                            name: entry.name,
+                            path: subPath,
+                            displayPath: entry.name,
+                            handle: entry
+                        };
+                        callbacks.onGroupingFolder(folder);
+                        await scanLocalRecursive(entry, subPath, depth + 1, callbacks);
+                    }
+                } catch (err) {
+                    console.warn('Could not process directory ' + entry.name + ':', err);
+                }
+            } else if (entry.kind === 'file') {
+                // File directly in a grouping folder — assign to the Outstanding virtual transmittal.
+                // actualPath records the real containing folder for grouping-folder-scoped filtering.
+                try {
+                    const file = await entry.getFile();
+                    const parsed = zddc.parseFilename(file.name) || {};
+
+                    if (!parsed.trackingNumber) {
+                        console.warn('File does not match ZDDC naming convention: ' + file.name);
+                    }
+
+                    const fullPath = currentPath + '/' + file.name;
+                    const displayPath = fullPath.length > 250
+                        ? '...' + fullPath.substring(fullPath.length - 200)
+                        : fullPath;
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: file.name,
+                        path: fullPath,
+                        displayPath: displayPath,
+                        url: null,
+                        size: file.size,
+                        modified: file.lastModified,
+                        handle: entry,
+                        folderPath: '__outstanding__',
+                        actualPath: currentPath,
+                        hasPathError: false,
+                        ...parsed
+                    });
+                } catch (fileErr) {
+                    const fullPath = currentPath + '/' + entry.name;
+                    const displayPath = fullPath.length > 250
+                        ? '...' + fullPath.substring(fullPath.length - 200)
+                        : fullPath;
+                    const parsed = zddc.parseFilename(entry.name) || {};
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: entry.name,
+                        path: fullPath,
+                        displayPath: displayPath,
+                        url: null,
+                        size: null,
+                        modified: null,
+                        handle: null,
+                        folderPath: '__outstanding__',
+                        actualPath: currentPath,
+                        hasPathError: true,
+                        pathErrorMessage: fileErr.message || 'File access error',
+                        ...parsed
+                    });
+
+                    console.warn('Could not access file ' + entry.name + ' (path error):', fileErr.message);
+                }
+            }
+        }
+    }
+
+    async function scanLocalTransmittalFolder(dirHandle, folderPath, depth, transmittalPath, callbacks) {
+        if (depth > 10) {
+            console.warn('Directory depth limit reached in transmittal folder: ' + folderPath);
+            return;
+        }
+
+        try {
+            if (folderPath.length > 240) {
+                console.warn('Path approaching Windows limit (' + folderPath.length + ' chars): ' + folderPath);
+            }
+
+            for await (const entry of dirHandle.values()) {
+                if (entry.kind === 'file') {
+                    try {
+                        const file = await entry.getFile();
+                        const parsed = zddc.parseFilename(file.name) || {};
+
+                        if (!parsed.trackingNumber) {
+                            console.warn('File does not match ZDDC naming convention: ' + file.name);
+                        }
+
+                        const fullPath = folderPath + '/' + file.name;
+                        const displayPath = fullPath.length > 250
+                            ? '...' + fullPath.substring(fullPath.length - 200)
+                            : fullPath;
+
+                        callbacks.onFile({
+                            id: crypto.randomUUID(),
+                            name: file.name,
+                            path: fullPath,
+                            displayPath: displayPath,
+                            url: null,
+                            size: file.size,
+                            modified: file.lastModified,
+                            handle: entry,
+                            folderPath: transmittalPath,
+                            actualPath: folderPath,
+                            hasPathError: false,
+                            ...parsed
+                        });
+                    } catch (fileErr) {
+                        const fullPath = folderPath + '/' + entry.name;
+                        const displayPath = fullPath.length > 250
+                            ? '...' + fullPath.substring(fullPath.length - 200)
+                            : fullPath;
+                        const parsed = zddc.parseFilename(entry.name) || {};
+
+                        callbacks.onFile({
+                            id: crypto.randomUUID(),
+                            name: entry.name,
+                            path: fullPath,
+                            displayPath: displayPath,
+                            url: null,
+                            size: null,
+                            modified: null,
+                            handle: null,
+                            folderPath: transmittalPath,
+                            actualPath: folderPath,
+                            hasPathError: true,
+                            pathErrorMessage: fileErr.message || 'File access error',
+                            ...parsed
+                        });
+
+                        console.warn('Could not access file ' + entry.name + ' (path error):', fileErr.message);
+                    }
+                } else if (entry.kind === 'directory') {
+                    const subPath = folderPath + '/' + entry.name;
+                    try {
+                        await scanLocalTransmittalFolder(entry, subPath, depth + 1, transmittalPath, callbacks);
+                    } catch (err) {
+                        console.warn('Could not scan subdirectory ' + entry.name + ' in ' + folderPath + ':', err);
+                    }
+                }
+            }
+        } catch (err) {
+            console.error('Error scanning folder ' + folderPath + ':', err);
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // HTTP source — uses Caddy JSON browse (Accept: application/json)
+    // ---------------------------------------------------------------------------
+
+    function createHttpSource(baseUrl) {
+        // Normalise: ensure baseUrl ends with /
+        const root = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
+
+        return {
+            type: 'http',
+            canWrite: false,
+
+            scan: function(rootUrl, callbacks) {
+                const scanRoot = (rootUrl && rootUrl !== root) ? rootUrl : root;
+                return scanHttpRecursive(scanRoot, root, 0, null, callbacks);
+            },
+
+            fetchFile: function(fileRef) {
+                return fetch(fileRef.url).then(function(r) {
+                    if (!r.ok) throw new Error('HTTP ' + r.status + ' fetching ' + fileRef.url);
+                    return r.arrayBuffer();
+                });
+            }
+        };
+    }
+
+    async function scanHttpRecursive(dirUrl, rootUrl, depth, transmittalPath, callbacks) {
+        if (depth > 10) {
+            console.warn('HTTP directory depth limit reached at: ' + dirUrl);
+            return;
+        }
+
+        let items;
+        try {
+            // Caddy returns JSON when the Accept header requests it
+            const resp = await fetch(dirUrl, {
+                headers: { 'Accept': 'application/json' }
+            });
+            if (!resp.ok) {
+                throw new Error('HTTP ' + resp.status + ' listing ' + dirUrl);
+            }
+            // Caddy encodes listing.Items directly — a bare JSON array of fileInfo objects
+            // fileInfo fields: name (dirs have trailing "/"), size, url, mod_time, mode, is_dir, is_symlink
+            items = await resp.json();
+            if (!Array.isArray(items)) {
+                throw new Error('Unexpected response format (expected JSON array)');
+            }
+        } catch (err) {
+            console.warn('Could not fetch directory listing for ' + dirUrl + ':', err);
+            return;
+        }
+
+        // Collect subdirectory scan promises so siblings run in parallel
+        const subdirPromises = [];
+
+        for (const item of items) {
+            // Caddy appends "/" to directory names; strip it to get the bare name for matching
+            const rawName = item.name.endsWith('/') ? item.name.slice(0, -1) : item.name;
+
+            // Skip hidden files
+            if (rawName.startsWith('.')) continue;
+
+            const isDir = item.is_dir === true;
+            // Project filter: at root depth, skip directories not in the allowed set
+            if (depth === 0 && isDir && window.app.projectFilter && window.app.projectFilter.size > 0) {
+                if (!window.app.projectFilter.has(rawName)) continue;
+            }
+
+            const itemUrl = resolveHttpUrl(dirUrl, rawName, isDir);
+            const logicalPath = urlToLogicalPath(itemUrl, rootUrl);
+
+            if (isDir) {
+                if (transmittalPath !== null) {
+                    // Inside a transmittal folder — recurse into subdirectories
+                    subdirPromises.push(
+                        scanHttpRecursive(itemUrl, rootUrl, depth + 1, transmittalPath, callbacks)
+                    );
+                } else if (window.app.modules.parser.isTransmittalFolder(rawName)) {
+                    const folder = {
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: getDisplayPath(logicalPath),
+                        handle: null,
+                        url: itemUrl
+                    };
+                    callbacks.onTransmittalFolder(folder);
+                    subdirPromises.push(
+                        scanHttpRecursive(itemUrl, rootUrl, depth + 1, logicalPath, callbacks)
+                    );
+                } else {
+                    const folder = {
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: rawName,
+                        handle: null,
+                        url: itemUrl
+                    };
+                    callbacks.onGroupingFolder(folder);
+                    subdirPromises.push(
+                        scanHttpRecursive(itemUrl, rootUrl, depth + 1, null, callbacks)
+                    );
+                }
+            } else {
+                // It's a file
+                if (transmittalPath === null) {
+                    // File directly in a grouping folder — assign to Outstanding virtual transmittal.
+                    // actualPath records the real containing folder for grouping-folder-scoped filtering.
+                    const dirLogicalPath = urlToLogicalPath(dirUrl, rootUrl);
+                    const parsed = zddc.parseFilename(rawName) || {};
+                    if (!parsed.trackingNumber) {
+                        console.warn('File does not match ZDDC naming convention: ' + rawName);
+                    }
+
+                    const modified = item.mod_time ? new Date(item.mod_time).getTime() : null;
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: logicalPath,
+                        url: itemUrl,
+                        size: item.size || null,
+                        modified: modified,
+                        handle: null,
+                        folderPath: '__outstanding__',
+                        actualPath: dirLogicalPath,
+                        hasPathError: false,
+                        ...parsed
+                    });
+                } else {
+                    // Inside a transmittal folder
+                    const parsed = zddc.parseFilename(rawName) || {};
+                    if (!parsed.trackingNumber) {
+                        console.warn('File does not match ZDDC naming convention: ' + rawName);
+                    }
+
+                    // mod_time is an ISO 8601 string from Go's time.Time.UTC()
+                    const modified = item.mod_time ? new Date(item.mod_time).getTime() : null;
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: logicalPath,
+                        url: itemUrl,
+                        size: item.size || null,
+                        modified: modified,
+                        handle: null,
+                        folderPath: transmittalPath,
+                        actualPath: logicalPath.substring(0, logicalPath.lastIndexOf('/')),
+                        hasPathError: false,
+                        ...parsed
+                    });
+                }
+            }
+        }
+
+        // Wait for all sibling subdirectory scans to complete in parallel
+        if (subdirPromises.length > 0) {
+            await Promise.all(subdirPromises);
+        }
+    }
+
+    // Build an absolute URL for an item inside a directory listing URL
+    function resolveHttpUrl(dirUrl, name, isDir) {
+        const base = dirUrl.endsWith('/') ? dirUrl : dirUrl + '/';
+        const encoded = encodeURIComponent(name);
+        return base + encoded + (isDir ? '/' : '');
+    }
+
+    // Convert an absolute item URL to a logical relative path (for display / filtering)
+    function urlToLogicalPath(itemUrl, rootUrl) {
+        const root = rootUrl.endsWith('/') ? rootUrl : rootUrl + '/';
+        let rel = itemUrl;
+        if (rel.startsWith(root)) {
+            rel = rel.substring(root.length);
+        }
+        // Decode percent-encoding for display
+        try { rel = decodeURIComponent(rel); } catch (e) { /* leave encoded */ }
+        // Strip trailing slash for directories
+        if (rel.endsWith('/')) rel = rel.slice(0, -1);
+        return rel;
+    }
+
+    window.app.modules.source = {
+        getDisplayPath,
+        createSource
+    };
+
+})();
diff --git a/archive/js/table.js b/archive/js/table.js
new file mode 100644
index 0000000..c3ae276
--- /dev/null
+++ b/archive/js/table.js
@@ -0,0 +1,873 @@
+// Table management functionality
+
+(function() {
+    'use strict';
+
+
+    // FileBlobCache, processedLinks, preview state, and utilities
+    const fileBlobCache = new Map();
+    const processedLinks = new WeakSet();
+    let fileLinkHandlersAttached = false;
+    let filePreviewWindow = null;
+    const PREVIEW_EXTENSIONS = ['pdf', 'docx', 'xlsx', 'xls'];
+    const loadedLibraries = new Map();
+    let resizing = null;
+
+
+    /**
+     * Get or create a blob URL for a file.
+     * - Local files: reads via File System Access API, caches the blob URL.
+     * - HTTP files: fetches the remote URL, caches the blob URL.
+     * Returns a Promise<string> resolving to a blob: URL.
+     */
+    async function getFileBlobUrl(file) {
+        if (fileBlobCache.has(file.id)) {
+            return fileBlobCache.get(file.id);
+        }
+        let blob;
+        if (file.handle) {
+            // Local file via File System Access API
+            const f = await file.handle.getFile();
+            blob = f;
+        } else if (file.url) {
+            // HTTP file — fetch and convert to blob
+            const resp = await fetch(file.url);
+            if (!resp.ok) throw new Error('HTTP ' + resp.status + ' fetching ' + file.url);
+            blob = await resp.blob();
+        } else {
+            throw new Error('File has neither a handle nor a URL');
+        }
+        const url = URL.createObjectURL(blob);
+        fileBlobCache.set(file.id, url);
+        return url;
+    }
+
+    /**
+     * Clean up blob URLs for files no longer displayed
+     */
+    function cleanupUnusedBlobUrls() {
+        const displayedFileIds = new Set(window.app.filteredFiles.map(f => f.id));
+        for (const [fileId, url] of fileBlobCache.entries()) {
+            if (!displayedFileIds.has(fileId)) {
+                URL.revokeObjectURL(url);
+                fileBlobCache.delete(fileId);
+            }
+        }
+    }
+
+    /**
+     * Revoke all blob URLs and clear cache
+     */
+    function cleanupAllBlobUrls() {
+        for (const url of fileBlobCache.values()) {
+            URL.revokeObjectURL(url);
+        }
+        fileBlobCache.clear();
+    }
+
+    // Update file table
+    function updateFileTable() {
+        const tbody = document.getElementById('filesTableBody');
+        
+        if (window.app.filteredFiles.length === 0) {
+            tbody.innerHTML = `
+                <tr>
+                    <td colspan="3" class="empty-table">
+                        No files found matching the current filters.
+                    </td>
+                </tr>
+            `;
+            cleanupUnusedBlobUrls(); // Clean up all blob URLs
+            return;
+        }
+        
+        // Group and sort files
+        const grouped = window.app.modules.parser.groupFilesByTrackingNumber(window.app.filteredFiles);
+        const sorted = window.app.modules.parser.sortGroupedFiles(grouped);
+        
+        // Build table rows
+        const rows = [];
+        sorted.forEach(group => {
+            rows.push(createFileGroupRow(group));
+        });
+        
+        tbody.innerHTML = rows.join('');
+        
+        // Clean up blob URLs for files no longer visible
+        cleanupUnusedBlobUrls();
+    }
+
+    // Create row for a file group
+    function createFileGroupRow(group) {
+        // Generate one <tr> per revision; last row gets class group-last for border
+        const lastIndex = group.sortedRevisions.length - 1;
+        return group.sortedRevisions.map((revision, i) => {
+            const titleClass = revision.hasModifier ? 'revision-title-modifier' : 'revision-title-base';
+            const titleHtml = `<div class="${titleClass}">${window.app.modules.app.escapeHtml(revision.title)}</div>`;
+            const revisionHtml = createRevisionHtml(group.trackingNumber, revision);
+            const lastClass = i === lastIndex ? ' group-last' : '';
+
+            // First row includes trackingNumber cell with rowspan
+            if (i === 0) {
+                return `
+                    <tr class="group-row${lastClass}">
+                        <td data-field="trackingNumber" rowspan="${group.sortedRevisions.length}">${window.app.modules.app.escapeHtml(group.trackingNumber)}</td>
+                        <td data-field="title">${titleHtml}</td>
+                        <td data-field="revisions">${revisionHtml}</td>
+                    </tr>
+                `;
+            }
+            // Subsequent rows omit trackingNumber cell
+            return `
+                <tr class="group-row${lastClass}">
+                    <td data-field="title">${titleHtml}</td>
+                    <td data-field="revisions">${revisionHtml}</td>
+                </tr>
+            `;
+        }).join('');
+    }
+
+    // Create HTML for a revision
+    function createRevisionHtml(trackingNumber, revision) {
+        const filesHtml = revision.files.map(file => 
+            createFileHtml(file)
+        ).join(' ');
+        
+        return `
+            <div class="revision-group">
+                <div class="revision-item">
+                    <span class="revision-info">
+                        <span class="revision-id">${window.app.modules.app.escapeHtml(revision.revision)}</span>
+                        <span class="revision-status">(${window.app.modules.app.escapeHtml(revision.status)})</span>
+                    </span>
+                    ${filesHtml}
+                </div>
+            </div>
+        `;
+    }
+
+    // Create HTML for a file
+    function createFileHtml(file) {
+        const checked = window.app.selectedFiles.has(file.id) ? 'checked' : '';
+        const fullPath = file.path || file.folderPath + '/' + file.name;
+        
+        // Handle files with path errors (Windows 260-char limit)
+        if (file.hasPathError) {
+            const errorTitle = `⚠️ Cannot access: Microsoft Windows path length limit (260 chars)\n\nPath: ${fullPath}\n\nUse 'subst' to map archive to a drive letter, or shorten folder names.`;
+            return `
+                <span class="revision-file">
+                    <input type="checkbox" 
+                           data-file-id="${file.id}"
+                           ${checked}
+                           onchange="toggleFileSelection('${file.id}')">
+                    <span class="path-error-indicator" title="${window.app.modules.app.escapeHtml(errorTitle)}">⚠️</span>
+                    <span class="file-link-disabled"
+                          title="${window.app.modules.app.escapeHtml(errorTitle)}">
+                        <span class="file-ext">${window.app.modules.app.escapeHtml(file.extension.toUpperCase())}</span>
+                        ${file.size != null ? `<span class="file-size">${window.app.modules.export.formatFileSize(file.size)}</span>` : ''}
+                    </span>
+                </span>
+            `;
+        }
+        
+        return `
+            <span class="revision-file">
+                <input type="checkbox" 
+                       data-file-id="${file.id}"
+                       ${checked}
+                       onchange="toggleFileSelection('${file.id}')">
+                <a href="#" 
+                   class="file-link"
+                   data-file-id="${file.id}"
+                   data-file-name="${window.app.modules.app.escapeHtml(file.name)}"
+                   title="${window.app.modules.app.escapeHtml(fullPath)}">
+                    <span class="file-ext">${window.app.modules.app.escapeHtml(file.extension.toUpperCase())}</span>
+                    ${file.size != null ? `<span class="file-size">${window.app.modules.export.formatFileSize(file.size)}</span>` : ''}
+                </a>
+            </span>
+        `;
+    }
+
+    // Toggle file selection
+    function toggleFileSelection(fileId) {
+        if (window.app.selectedFiles.has(fileId)) {
+            window.app.selectedFiles.delete(fileId);
+        } else {
+            window.app.selectedFiles.add(fileId);
+        }
+        window.app.modules.app.updateStatusBar();
+        updateSelectAllVisibleCheckbox();
+    }
+
+    // Toggle selection of all visible files based on checkbox state
+    function toggleSelectAllVisible(selectAll) {
+        window.app.filteredFiles.forEach(file => {
+            if (selectAll) {
+                window.app.selectedFiles.add(file.id);
+            } else {
+                window.app.selectedFiles.delete(file.id);
+            }
+        });
+        
+        updateFileTable();
+        window.app.modules.app.updateStatusBar();
+        updateSelectAllVisibleCheckbox();
+    }
+
+    // Update the select all visible checkbox to reflect current state
+    function updateSelectAllVisibleCheckbox() {
+        const checkbox = document.getElementById('selectAllVisibleCheckbox');
+        if (!checkbox) return;
+        
+        const visibleCount = window.app.filteredFiles.length;
+        if (visibleCount === 0) {
+            checkbox.checked = false;
+            checkbox.indeterminate = false;
+            return;
+        }
+        
+        const selectedVisibleCount = window.app.filteredFiles.filter(f => 
+            window.app.selectedFiles.has(f.id)
+        ).length;
+        
+        if (selectedVisibleCount === 0) {
+            checkbox.checked = false;
+            checkbox.indeterminate = false;
+        } else if (selectedVisibleCount === visibleCount) {
+            checkbox.checked = true;
+            checkbox.indeterminate = false;
+        } else {
+            checkbox.checked = false;
+            checkbox.indeterminate = true;
+        }
+    }
+
+    /**
+     * Memory-efficient blob URL management
+     * 
+     * fileBlobCache: Maps file IDs to blob URLs for reuse
+     * processedLinks: WeakSet tracks DOM elements that already have blob URLs
+     *   - Automatically garbage collected when DOM elements are removed
+     *   - Prevents redundant async operations on mouseover
+     */
+
+    /**
+     * Lazily load a script from CDN. Returns a promise that resolves when loaded.
+     * Caches the promise so subsequent calls return immediately.
+     */
+    function loadLibrary(url) {
+        if (loadedLibraries.has(url)) return loadedLibraries.get(url);
+        const promise = new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = url;
+            script.onload = resolve;
+            script.onerror = () => reject(new Error(`Failed to load library: ${url}`));
+            document.head.appendChild(script);
+        });
+        loadedLibraries.set(url, promise);
+        return promise;
+    }
+
+    /**
+     * Check if file preview mode is enabled
+     */
+    function isFilePreviewEnabled() {
+        const toggle = document.getElementById('filePreviewToggle');
+        return toggle && toggle.checked;
+    }
+
+    /**
+     * Show file preview in a separate popup window
+     * Supports PDF (iframe), DOCX (docx-preview), XLSX/XLS (SheetJS)
+     */
+    async function showFilePreview(file) {
+        const ext = file.extension.toLowerCase();
+        
+        try {
+            const url = await getFileBlobUrl(file);
+            
+            // Mirror the parent window's theme in the popup
+            const parentTheme = document.documentElement.getAttribute('data-theme') || '';
+            const themeAttr = parentTheme ? ` data-theme="${parentTheme}"` : '';
+
+            // Base HTML shell for the preview window
+            const previewHtml = `
+<!DOCTYPE html>
+<html${themeAttr}>
+<head>
+    <title>${window.app.modules.app.escapeHtml(file.name)} - Preview</title>
+    <style>
+        :root {
+            --bg: #ffffff;
+            --bg-secondary: #f5f5f5;
+            --bg-hover: #e8e8e8;
+            --text: #212529;
+            --text-muted: #666666;
+            --border: #dddddd;
+            --primary: #2a5a8a;
+        }
+        @media (prefers-color-scheme: dark) {
+            :root:not([data-theme="light"]) {
+                --bg: #1e1e1e;
+                --bg-secondary: #252526;
+                --bg-hover: #2d2d30;
+                --text: #d4d4d4;
+                --text-muted: #9d9d9d;
+                --border: #3e3e42;
+                --primary: #4a90c4;
+            }
+        }
+        [data-theme="dark"] {
+            --bg: #1e1e1e;
+            --bg-secondary: #252526;
+            --bg-hover: #2d2d30;
+            --text: #d4d4d4;
+            --text-muted: #9d9d9d;
+            --border: #3e3e42;
+            --primary: #4a90c4;
+        }
+        [data-theme="light"] {
+            --bg: #ffffff;
+            --bg-secondary: #f5f5f5;
+            --bg-hover: #e8e8e8;
+            --text: #212529;
+            --text-muted: #666666;
+            --border: #dddddd;
+            --primary: #2a5a8a;
+        }
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            display: flex;
+            flex-direction: column;
+            height: 100vh;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: var(--bg);
+            color: var(--text);
+        }
+        .toolbar {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.5rem 1rem;
+            background: var(--bg-secondary);
+            border-bottom: 1px solid var(--border);
+            flex-shrink: 0;
+        }
+        .toolbar h1 {
+            flex: 1;
+            font-size: 0.95rem;
+            font-weight: 500;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            color: var(--text);
+        }
+        .btn {
+            padding: 0.4rem 0.8rem;
+            font-size: 0.85rem;
+            border: 1px solid var(--border);
+            border-radius: 4px;
+            background: var(--bg);
+            color: var(--text);
+            cursor: pointer;
+        }
+        .btn:hover { background: var(--bg-hover); }
+        iframe {
+            flex: 1;
+            width: 100%;
+            border: none;
+        }
+        #previewContent {
+            flex: 1;
+            overflow: auto;
+            background: var(--bg);
+        }
+        .loading {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: var(--text-muted);
+            font-size: 1.1rem;
+        }
+        /* docx-preview container */
+        .docx-wrapper { padding: 1rem; }
+        /* xlsx table styling */
+        .xlsx-table { border-collapse: collapse; width: 100%; font-size: 0.85rem; }
+        .xlsx-table th, .xlsx-table td {
+            border: 1px solid var(--border);
+            padding: 0.35rem 0.5rem;
+            text-align: left;
+            white-space: nowrap;
+            color: var(--text);
+        }
+        .xlsx-table th { background: var(--bg-secondary); font-weight: 600; position: sticky; top: 0; }
+        .xlsx-table tr:nth-child(even) { background: var(--bg-secondary); }
+        .xlsx-table tr:hover { background: var(--bg-hover); }
+        .sheet-tabs { display: flex; gap: 0; border-bottom: 1px solid var(--border); background: var(--bg-secondary); }
+        .sheet-tab {
+            padding: 0.4rem 1rem;
+            cursor: pointer;
+            border: 1px solid transparent;
+            border-bottom: none;
+            font-size: 0.85rem;
+            background: transparent;
+            color: var(--text);
+        }
+        .sheet-tab:hover { background: var(--bg-hover); }
+        .sheet-tab.active {
+            background: var(--bg);
+            border-color: var(--border);
+            border-bottom-color: var(--bg);
+            margin-bottom: -1px;
+            font-weight: 500;
+        }
+    </style>
+</head>
+<body>
+    <div class="toolbar">
+        <h1>${window.app.modules.app.escapeHtml(file.name)}</h1>
+        <button class="btn" onclick="downloadFile()">Download</button>
+    </div>
+    ${ext === 'pdf' ? '<iframe src="' + url + '"></iframe>' : '<div id="previewContent"><div class="loading">Loading preview...</div></div>'}
+    <script>
+        var blobUrl = "${url}";
+        var fileName = "${window.app.modules.app.escapeHtml(file.name).replace(/"/g, '\\"')}";
+        
+        function downloadFile() {
+            const a = document.createElement('a');
+            a.href = blobUrl;
+            a.download = fileName;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+        }
+    <\/script>
+</body>
+</html>`;
+            
+            // Open or reuse the preview window
+            if (filePreviewWindow && !filePreviewWindow.closed) {
+                filePreviewWindow.document.open();
+                filePreviewWindow.document.write(previewHtml);
+                filePreviewWindow.document.close();
+                filePreviewWindow.focus();
+            } else {
+                const width = Math.round(screen.width * 0.6);
+                const height = Math.round(screen.height * 0.8);
+                const left = Math.round((screen.width - width) / 2);
+                const top = Math.round((screen.height - height) / 2);
+                
+                filePreviewWindow = window.open('', 'filePreview', 
+                    `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`);
+                
+                if (!filePreviewWindow) {
+                    window.open(url, '_blank');
+                    return;
+                }
+                
+                filePreviewWindow.document.write(previewHtml);
+                filePreviewWindow.document.close();
+                filePreviewWindow.focus();
+            }
+            
+            // For non-PDF types, render content into the preview window
+            if (ext === 'docx') {
+                await renderDocxInWindow(file);
+            } else if (ext === 'xlsx' || ext === 'xls') {
+                await renderXlsxInWindow(file);
+            }
+            
+        } catch (err) {
+            console.error('Error loading file preview:', err);
+            alert(`Error loading preview: ${err.message}`);
+        }
+    }
+
+    /**
+     * Render a DOCX file in the preview window using docx-preview library
+     */
+    async function renderDocxInWindow(file) {
+        const container = filePreviewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js');
+            await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+            
+            const arrayBuffer = await (file.handle
+                ? file.handle.getFile().then(f => f.arrayBuffer())
+                : fetch(file.url).then(r => r.arrayBuffer()));
+            
+            container.innerHTML = '';
+            await window.docx.renderAsync(arrayBuffer, container);
+        } catch (err) {
+            console.error('Error rendering DOCX:', err);
+            container.innerHTML = `<div class="loading">Error rendering DOCX: ${err.message}<br>Click Download to view in Word.</div>`;
+        }
+    }
+
+    /**
+     * Render an XLSX/XLS file in the preview window using SheetJS
+     */
+    async function renderXlsxInWindow(file) {
+        const container = filePreviewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+            
+            const arrayBuffer = await (file.handle
+                ? file.handle.getFile().then(f => f.arrayBuffer())
+                : fetch(file.url).then(r => r.arrayBuffer()));
+            const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+            
+            container.innerHTML = '';
+            
+            // Build sheet tabs if multiple sheets
+            if (workbook.SheetNames.length > 1) {
+                const tabs = filePreviewWindow.document.createElement('div');
+                tabs.className = 'sheet-tabs';
+                workbook.SheetNames.forEach((name, i) => {
+                    const tab = filePreviewWindow.document.createElement('button');
+                    tab.className = 'sheet-tab' + (i === 0 ? ' active' : '');
+                    tab.textContent = name;
+                    tab.onclick = () => {
+                        tabs.querySelectorAll('.sheet-tab').forEach(t => t.classList.remove('active'));
+                        tab.classList.add('active');
+                        renderSheet(workbook, name, tableContainer);
+                    };
+                    tabs.appendChild(tab);
+                });
+                container.appendChild(tabs);
+            }
+            
+            const tableContainer = filePreviewWindow.document.createElement('div');
+            tableContainer.style.flex = '1';
+            tableContainer.style.overflow = 'auto';
+            container.appendChild(tableContainer);
+            
+            renderSheet(workbook, workbook.SheetNames[0], tableContainer);
+        } catch (err) {
+            console.error('Error rendering XLSX:', err);
+            container.innerHTML = `<div class="loading">Error rendering spreadsheet: ${err.message}<br>Click Download to view in Excel.</div>`;
+        }
+    }
+
+    /**
+     * Render a single sheet as an HTML table
+     */
+    function renderSheet(workbook, sheetName, container) {
+        const sheet = workbook.Sheets[sheetName];
+        const html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+        container.innerHTML = html;
+        // Apply styling to the generated table
+        const table = container.querySelector('table');
+        if (table) table.className = 'xlsx-table';
+    }
+
+    /**
+     * Setup event delegation for file links
+     * Left-click: Download file (or preview if PDF and preview mode enabled)
+     * Right-click: Allow "Open in new tab" with blob URL
+     */
+    function setupFileLinkHandlers() {
+        if (fileLinkHandlersAttached) return;
+        
+        const table = document.getElementById('filesTable');
+        if (!table) {
+            console.warn('Files table not found');
+            return;
+        }
+        
+        // Handle clicks - download file or show preview
+        table.addEventListener('click', async (e) => {
+            const link = e.target.closest('.file-link');
+            if (!link) return;
+            
+            e.preventDefault();
+            e.stopPropagation();
+            
+            const fileId = link.getAttribute('data-file-id');
+            const fileName = link.getAttribute('data-file-name');
+            
+            if (!fileId || !fileName) {
+                console.error('Invalid link data');
+                return;
+            }
+            
+            const file = window.app.files.find(f => f.id === fileId);
+            
+            if (!file) {
+                console.error(`File not found: ${fileId}`);
+                alert('File not found. Please refresh and try again.');
+                return;
+            }
+            
+            // Check if file preview is enabled and file type is previewable
+            if (isFilePreviewEnabled() && PREVIEW_EXTENSIONS.includes(file.extension.toLowerCase())) {
+                await showFilePreview(file);
+                return;
+            }
+            
+            try {
+                if (!file.handle && file.url) {
+                    // HTTP mode: open the file URL directly in a new tab
+                    window.open(file.url, '_blank');
+                } else {
+                    // Local mode: create blob URL and trigger download
+                    const url = await getFileBlobUrl(file);
+                    const downloadLink = document.createElement('a');
+                    downloadLink.href = url;
+                    downloadLink.download = fileName;
+                    document.body.appendChild(downloadLink);
+                    downloadLink.click();
+                    document.body.removeChild(downloadLink);
+                }
+            } catch (err) {
+                console.error('Error opening file:', err);
+                alert(`Error opening file: ${err.message}`);
+            }
+        }, true); // Use capture phase
+        
+        // Handle mouseover - pre-load URL for fast right-click / middle-click
+        table.addEventListener('mouseover', async (e) => {
+            const link = e.target.closest('.file-link');
+            if (!link) return;
+            
+            // Skip if already processed (prevents redundant operations)
+            if (processedLinks.has(link)) return;
+            
+            const fileId = link.getAttribute('data-file-id');
+            if (!fileId) return;
+            
+            const file = window.app.files.find(f => f.id === fileId);
+            if (!file) {
+                console.warn(`File not found for pre-load: ${fileId}`);
+                return;
+            }
+            
+            try {
+                if (!file.handle && file.url) {
+                    // HTTP mode: set href directly — no async needed
+                    link.href = file.url;
+                    link.target = '_blank';
+                    processedLinks.add(link);
+                } else {
+                    // Local mode: pre-load blob URL asynchronously
+                    const url = await getFileBlobUrl(file);
+                    link.href = url;
+                    link.target = '_blank';
+                    processedLinks.add(link);
+                }
+            } catch (err) {
+                console.error('Error pre-loading file link:', err);
+                // Don't mark as processed so it can retry
+            }
+        }, true); // Use capture phase
+        
+        // Handle context menu - ensure blob URL is set (fallback if mouseover didn't fire)
+        table.addEventListener('contextmenu', async (e) => {
+            const link = e.target.closest('.file-link');
+            if (!link) return;
+            
+            // If already processed, blob URL is set - allow context menu to work
+            if (processedLinks.has(link)) return;
+            
+            const fileId = link.getAttribute('data-file-id');
+            if (!fileId) return;
+            
+            const file = window.app.files.find(f => f.id === fileId);
+            if (!file) {
+                console.warn(`File not found for context menu: ${fileId}`);
+                return;
+            }
+            
+            try {
+                // Get blob URL and set it as href synchronously as possible
+                const url = await getFileBlobUrl(file);
+                link.href = url;
+                link.target = '_blank';
+                
+                // Mark as processed
+                processedLinks.add(link);
+            } catch (err) {
+                console.error('Error preparing file for context menu:', err);
+                // Don't mark as processed so it can retry
+            }
+        }, true); // Use capture phase
+        
+        fileLinkHandlersAttached = true;
+    }
+
+    // Get MIME type from extension
+    function getMimeType(extension) {
+        const ext = extension.toLowerCase();
+        const mimeTypes = {
+            // Documents
+            'pdf': 'application/pdf',
+            'doc': 'application/msword',
+            'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'xls': 'application/vnd.ms-excel',
+            'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            'ppt': 'application/vnd.ms-powerpoint',
+            'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            
+            // Text
+            'txt': 'text/plain',
+            'csv': 'text/csv',
+            'html': 'text/html',
+            'htm': 'text/html',
+            'xml': 'text/xml',
+            'json': 'application/json',
+            
+            // Code
+            'js': 'text/javascript',
+            'css': 'text/css',
+            'py': 'text/plain',
+            'java': 'text/plain',
+            'cpp': 'text/plain',
+            'c': 'text/plain',
+            'h': 'text/plain',
+            
+            // Images
+            'jpg': 'image/jpeg',
+            'jpeg': 'image/jpeg',
+            'png': 'image/png',
+            'gif': 'image/gif',
+            'bmp': 'image/bmp',
+            'svg': 'image/svg+xml',
+            'webp': 'image/webp',
+            'ico': 'image/x-icon',
+            
+            // Archives
+            'zip': 'application/zip',
+            'rar': 'application/x-rar-compressed',
+            '7z': 'application/x-7z-compressed',
+            'tar': 'application/x-tar',
+            'gz': 'application/gzip',
+            
+            // CAD
+            'dwg': 'application/acad',
+            'dxf': 'application/dxf',
+            'dwf': 'model/vnd.dwf',
+            'dgn': 'application/x-dgn',
+            
+            // Other
+            'mp4': 'video/mp4',
+            'mp3': 'audio/mpeg',
+            'wav': 'audio/wav',
+            'avi': 'video/x-msvideo',
+            'mov': 'video/quicktime',
+            'md': 'text/markdown',
+            'log': 'text/plain',
+            'ini': 'text/plain',
+            'cfg': 'text/plain',
+            'conf': 'text/plain',
+            'yaml': 'text/yaml',
+            'yml': 'text/yaml'
+        };
+        
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+
+    // Sort table
+    function sortTable(field) {
+        if (window.app.sortField === field) {
+            // Toggle direction
+            window.app.sortDirection = window.app.sortDirection === 'asc' ? 'desc' : 'asc';
+        } else {
+            // New field, default to ascending
+            window.app.sortField = field;
+            window.app.sortDirection = 'asc';
+        }
+        
+        updateSortIndicators();
+        window.app.modules.filtering.applyFilters(); // Re-apply filters which will trigger table update
+        window.app.modules.urlState.push();
+    }
+
+    // Update sort indicators
+    function updateSortIndicators() {
+        // Remove all sort indicators
+        document.querySelectorAll('th[data-sort]').forEach(th => {
+            th.removeAttribute('data-sort');
+        });
+        
+        // Add current sort indicator
+        const th = document.querySelector(`th[data-field="${window.app.sortField}"]`);
+        if (th) {
+            th.setAttribute('data-sort', window.app.sortDirection);
+        }
+    }
+
+    // Column resize functionality
+    function initializeColumnResize() {
+        const handles = document.querySelectorAll('.resize-handle');
+        handles.forEach(handle => {
+            handle.addEventListener('mousedown', startResize);
+        });
+        
+        document.addEventListener('mousemove', doResize);
+        document.addEventListener('mouseup', stopResize);
+    }
+
+    function startResize(e) {
+        const th = e.target.parentElement;
+        resizing = {
+            th: th,
+            startX: e.clientX,
+            startWidth: th.offsetWidth
+        };
+        
+        document.body.style.cursor = 'col-resize';
+        document.body.style.userSelect = 'none';
+    }
+
+    function doResize(e) {
+        if (! resizing) return;
+        
+        const diff = e.clientX - resizing.startX;
+        const newWidth = Math.max(100, resizing.startWidth + diff);
+        resizing.th.style.width = newWidth + 'px';
+        
+        // Update corresponding column
+        const field = resizing.th.getAttribute('data-field');
+        const cells = document.querySelectorAll(`td[data-field="${field}"]`);
+        cells.forEach(cell => {
+            cell.style.width = newWidth + 'px';
+        });
+    }
+
+    function stopResize() {
+        if (resizing) {
+            document.body.style.cursor = '';
+            document.body.style.userSelect = '';
+            resizing = null;
+        }
+    }
+
+    // Toggle all files (Ctrl+A shortcut handler)
+    // wrapper around toggleSelectAllVisible for keyboard shortcuts
+    function toggleSelectAll() {
+        toggleSelectAllVisible(true);
+    }
+
+    /**
+     * Clean up resources when page unloads
+     */
+    window.addEventListener('beforeunload', () => {
+        cleanupAllBlobUrls();
+    });
+
+    window.app.modules.table = {
+        updateFileTable,
+        toggleFileSelection,
+        toggleSelectAllVisible,
+        updateSelectAllVisibleCheckbox,
+        setupFileLinkHandlers,
+        updateSortIndicators,
+        sortTable,
+        initializeColumnResize
+    };
+})();
diff --git a/archive/js/url-state.js b/archive/js/url-state.js
new file mode 100644
index 0000000..daef3fd
--- /dev/null
+++ b/archive/js/url-state.js
@@ -0,0 +1,200 @@
+(function() {
+    'use strict';
+    // URL state sync module for ZDDC Archive
+
+    // Default values for URL params
+    var DEFAULT_SORT_FIELD = 'trackingNumber';
+    var DEFAULT_SORT_DIRECTION = 'asc';
+    var DEFAULT_ENABLED_TYPES = ['issued', 'received'];
+
+    // Map URL param names to state paths
+    var PARAM_MAP = {
+        sort: 'sortField',
+        dir: 'sortDirection',
+        tn: 'columnFilters.trackingNumber',
+        ti: 'columnFilters.title',
+        rv: 'columnFilters.revisions',
+        types: 'enabledFolderTypes',
+        gf: 'groupingFilter',
+        tf: 'transmittalFilter'
+    };
+
+    // Serialize current state to URL query string
+    function serialize() {
+        var params = new URLSearchParams();
+
+        // Sort field
+        if (window.app.sortField !== DEFAULT_SORT_FIELD) {
+            params.set('sort', window.app.sortField);
+        }
+
+        // Sort direction
+        if (window.app.sortDirection !== DEFAULT_SORT_DIRECTION) {
+            params.set('dir', window.app.sortDirection);
+        }
+
+        // Column filters
+        if (window.app.columnFilters.trackingNumber !== '') {
+            params.set('tn', window.app.columnFilters.trackingNumber);
+        }
+        if (window.app.columnFilters.title !== '') {
+            params.set('ti', window.app.columnFilters.title);
+        }
+        if (window.app.columnFilters.revisions !== '') {
+            params.set('rv', window.app.columnFilters.revisions);
+        }
+
+        // Folder types (only if different from default [issued, received])
+        var enabledTypes = Array.from(window.app.enabledFolderTypes).sort();
+        var defaultTypes = DEFAULT_ENABLED_TYPES.slice().sort();
+        if (JSON.stringify(enabledTypes) !== JSON.stringify(defaultTypes)) {
+            params.set('types', enabledTypes.join(','));
+        }
+
+        // Grouping filter
+        if (window.app.groupingFilter !== '') {
+            params.set('gf', window.app.groupingFilter);
+        }
+
+        // Transmittal filter
+        if (window.app.transmittalFilter !== '') {
+            params.set('tf', window.app.transmittalFilter);
+        }
+
+        // Project filter — always preserved if set (for shareable URLs)
+        if (window.app.projectFilter && window.app.projectFilter.size > 0) {
+            params.set('projects', Array.from(window.app.projectFilter).join(','));
+        }
+
+        // Build query string
+        var qs = params.toString();
+        return qs ? '?' + qs : '';
+    }
+
+    // Push state to URL without triggering popstate
+    function push() {
+        var result = serialize();
+        if (result === location.search) {
+            return;
+        }
+        try {
+            history.replaceState(null, '', location.pathname + result);
+        } catch (e) {
+            // Silently swallow errors (e.g., file:// protocol restrictions)
+        }
+    }
+
+    // Restore state from URL query string
+    function restore() {
+        var params = new URLSearchParams(location.search);
+
+        // Restore sort field
+        if (params.has('sort')) {
+            var sortValue = params.get('sort');
+            if (sortValue === 'trackingNumber' || sortValue === 'title') {
+                window.app.sortField = sortValue;
+            }
+        }
+
+        // Restore sort direction
+        if (params.has('dir')) {
+            var dirValue = params.get('dir');
+            if (dirValue === 'asc' || dirValue === 'desc') {
+                window.app.sortDirection = dirValue;
+            }
+        }
+
+        // Restore column filters with AST parsing
+        if (params.has('tn')) {
+            var tnValue = params.get('tn');
+            window.app.columnFilters.trackingNumber = tnValue;
+            window.app.columnFilterASTs.trackingNumber = zddc.filter.parse(tnValue);
+        }
+        if (params.has('ti')) {
+            var tiValue = params.get('ti');
+            window.app.columnFilters.title = tiValue;
+            window.app.columnFilterASTs.title = zddc.filter.parse(tiValue);
+        }
+        if (params.has('rv')) {
+            var rvValue = params.get('rv');
+            window.app.columnFilters.revisions = rvValue;
+            window.app.columnFilterASTs.revisions = zddc.filter.parse(rvValue);
+        }
+
+        // Restore folder types
+        if (params.has('types')) {
+            var typesValue = params.get('types');
+            var typeValues = typesValue.split(',').map(function(t) { return t.trim(); });
+            // Validate against app.FOLDER_TYPE_NAMES
+            var validTypes = typeValues.filter(function(t) {
+                return window.app.FOLDER_TYPE_NAMES.indexOf(t) !== -1;
+            });
+            window.app.enabledFolderTypes = new Set(validTypes);
+        }
+
+        // Restore grouping filter
+        if (params.has('gf')) {
+            window.app.groupingFilter = params.get('gf');
+        }
+
+        // Restore transmittal filter
+        if (params.has('tf')) {
+            window.app.transmittalFilter = params.get('tf');
+        }
+
+        // Restore project filter
+        if (params.has('projects')) {
+            var projValue = params.get('projects');
+            var projNames = projValue.split(',').map(function(p) { return p.trim(); }).filter(Boolean);
+            window.app.projectFilter = new Set(projNames);
+        }
+
+        // Update DOM inputs to reflect restored values
+        updateFilterInputs();
+    }
+
+    // Update DOM filter inputs to match restored state
+    function updateFilterInputs() {
+        // Column filter inputs
+        document.querySelectorAll('.column-filter[data-filter-field]').forEach(function(input) {
+            var field = input.getAttribute('data-filter-field');
+            var filterValue = window.app.columnFilters[field] || '';
+            input.value = filterValue;
+            if (filterValue !== '') {
+                input.classList.add('filter-active');
+            } else {
+                input.classList.remove('filter-active');
+            }
+        });
+
+        // Grouping filter
+        var groupingFilterEl = document.getElementById('groupingFilter');
+        if (groupingFilterEl) {
+            groupingFilterEl.value = window.app.groupingFilter;
+            if (window.app.groupingFilter !== '') {
+                groupingFilterEl.classList.add('filter-active');
+            } else {
+                groupingFilterEl.classList.remove('filter-active');
+            }
+        }
+
+        // Transmittal filter
+        var transmittalFilterEl = document.getElementById('transmittalFilter');
+        if (transmittalFilterEl) {
+            transmittalFilterEl.value = window.app.transmittalFilter;
+            if (window.app.transmittalFilter !== '') {
+                transmittalFilterEl.classList.add('filter-active');
+            } else {
+                transmittalFilterEl.classList.remove('filter-active');
+            }
+        }
+    }
+
+    // Register module
+    window.app.modules.urlState = {
+        serialize: serialize,
+        push: push,
+        restore: restore
+    };
+
+})();
diff --git a/archive/template.html b/archive/template.html
new file mode 100644
index 0000000..d82a2d8
--- /dev/null
+++ b/archive/template.html
@@ -0,0 +1,359 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Archive</title>
+    <style>
+        {{CSS_PLACEHOLDER}}
+    </style>
+</head>
+<body>
+    <div id="appContainer">
+        <!-- Project access warning banner (shown when URL contains inaccessible projects) -->
+        <div id="projectWarningBanner" class="project-warning-banner hidden" role="alert">
+            <span class="project-warning-text"></span>
+            <button class="project-warning-dismiss" onclick="dismissProjectWarning()" aria-label="Dismiss">×</button>
+        </div>
+
+        <!-- Header -->
+        <header class="app-header">
+            <div class="header-left">
+                <div class="header-title-group">
+                    <span class="app-header__title">ZDDC Archive</span>
+                    <span class="build-timestamp">{{BUILD_LABEL}}</span>
+                </div>
+                <button id="addDirectoryBtn" class="btn btn-primary">Add Local Directory</button>
+                <button id="refreshHeaderBtn" class="btn btn-secondary hidden" title="Refresh Data" style="font-size:1.1rem;">⟳</button>
+            </div>
+            <div class="header-right">
+                <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+                <button id="help-btn" class="btn btn-secondary" title="Help">?</button>
+            </div>
+        </header>
+
+        <!-- Main Container -->
+        <div class="main-container">
+            <!-- Navigation Pane -->
+            <nav id="navigationPane" class="nav-pane">
+                <!-- Grouping Folders Section -->
+                <div class="nav-section" id="groupingSection">
+                    <div class="nav-section-header">
+                        <h3>Parties</h3>
+                        <div class="preset-section" id="presetSection">
+                            <button id="presetBtn" class="btn btn-secondary btn-sm" title="Party presets">▾ Presets</button>
+                            <div id="presetDropdown" class="preset-dropdown hidden"></div>
+                        </div>
+                        <button id="toggleGroupingBtn" class="btn-icon" title="Collapse/Expand">
+                            <span id="toggleGroupingIcon">▼</span>
+                        </button>
+                    </div>
+                    <div id="groupingContent" class="nav-section-content">
+                        <!-- Global folder type toggle bar -->
+                        <div id="folderTypeBar" class="folder-type-bar">
+                            <!-- Dynamically populated by renderFolderTypeBar() -->
+                        </div>
+                        <div class="filter-select-row">
+                            <input type="text" 
+                                   id="groupingFilter" 
+                                   class="filter-input" 
+                                   placeholder="Filter parties...">
+                            <label class="select-all-label select-all-inline" title="Auto-select all visible parties">
+                                <span>Select<br>All</span>
+                                <input type="checkbox" id="selectAllGroupingCheckbox" checked>
+                            </label>
+                        </div>
+                        <div id="groupingFoldersList" class="folder-list">
+                            <!-- Dynamically populated -->
+                        </div>
+                    </div>
+                    <div class="resize-handle-vertical" data-resize="nav-sections"></div>
+                </div>
+
+                <!-- Transmittal Folders Section -->
+                <div class="nav-section" id="transmittalSection">
+                    <div class="nav-section-header">
+                        <h3>Transmittal Folders</h3>
+                        <button id="toggleAllDatesBtn" class="btn-icon" title="Expand/Collapse All">
+                            <span id="toggleAllDatesIcon">▼</span>
+                        </button>
+                    </div>
+                    <div class="filter-select-row">
+                        <input type="text" 
+                               id="transmittalFilter" 
+                               class="filter-input" 
+                               placeholder="Filter transmittal folders...">
+                        <label class="select-all-label select-all-inline" title="Auto-select all visible transmittals">
+                            <span>Select<br>All</span>
+                            <input type="checkbox" id="selectAllTransmittalsCheckbox" checked>
+                        </label>
+                    </div>
+                    <div id="transmittalFoldersList" class="folder-list">
+                        <!-- Dynamically populated -->
+                    </div>
+                </div>
+                <div class="resize-handle-horizontal" data-resize="nav-pane"></div>
+            </nav>
+
+            <!-- Content Area -->
+            <main class="content-area">
+                <!-- Content Header -->
+                <div class="content-header">
+                    <!-- Reset Filters -->
+                    <button id="resetFiltersBtn" class="btn btn-secondary btn-icon-only" title="Reset all column filters">↺</button>
+
+                    <!-- Preview toggle -->
+                    <label class="preview-toggle-label" title="Preview PDF, Word, and Excel files in a popup window instead of downloading">
+                        <input type="checkbox" id="filePreviewToggle">
+                        <span>Preview</span>
+                    </label>
+
+                    <!-- Modifier Filter Dropdown -->
+                    <div class="modifier-filter-container">
+                        <button id="modifierFilterBtn" class="btn btn-secondary modifier-filter-btn">
+                            Modifiers ▼
+                        </button>
+                        <div id="modifierFilterDropdown" class="modifier-filter-dropdown hidden">
+                            <div class="modifier-filter-header">
+                                <label><input type="checkbox" id="modifierSelectAll" checked> Select All</label>
+                            </div>
+                            <div id="modifierFilterList" class="modifier-filter-list">
+                                <!-- Dynamically populated -->
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="toolbar-separator"></div>
+
+                    <div class="content-actions">
+                        <button id="filterSelectedBtn" class="btn btn-secondary">Filter Selected</button>
+                        <button id="downloadSelectedBtn" class="btn btn-secondary">Download (ZIP)</button>
+                        <button id="exportCsvBtn" class="btn btn-secondary">Export (CSV)</button>
+                    </div>
+                </div>
+
+                <!-- Files Table -->
+                <div class="table-container">
+                    <table id="filesTable" class="files-table">
+                        <thead>
+                            <tr>
+                                <th class="sortable resizable" data-field="trackingNumber">
+                                    <div class="th-content">
+                                        <span>Tracking Number</span>
+                                        <span class="sort-indicator"></span>
+                                    </div>
+<input type="text" 
+       class="column-filter" 
+       data-filter-field="trackingNumber"
+       placeholder="Filter...">
+                                    <div class="resize-handle"></div>
+                                </th>
+                                <th class="sortable resizable" data-field="title">
+                                    <div class="th-content">
+                                        <span>Title</span>
+                                        <span class="sort-indicator"></span>
+                                    </div>
+<input type="text" 
+       class="column-filter" 
+       data-filter-field="title"
+       placeholder="Filter...">
+                                    <div class="resize-handle"></div>
+                                </th>
+                                <th class="resizable" data-field="revisions">
+                                    <div class="th-content" style="justify-content: flex-start;">
+                                        <input type="checkbox" 
+                                               id="selectAllVisibleCheckbox" 
+                                               title="Select/deselect all visible files"
+                                               style="margin-right: 0.5rem;">
+                                        <span>Revisions</span>
+                                    </div>
+<input type="text" 
+       class="column-filter" 
+       data-filter-field="revisions"
+       placeholder="Filter...">
+                                    <div class="resize-handle"></div>
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody id="filesTableBody">
+                            <!-- Dynamically populated -->
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- Status Bar -->
+                <div class="status-bar">
+                    <span id="fileCount">0 files</span>
+                    <span id="selectedCount">0 selected</span>
+                    <span id="scanStatus"></span><span id="scanSpinner" class="scan-spinner hidden"></span>
+                </div>
+            </main>
+        </div>
+
+        <!-- Drop Modal -->
+        <div id="dropModal" class="modal hidden">
+            <div class="modal-backdrop"></div>
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h2>Create Transmittal</h2>
+                    <button class="modal-close">&times;</button>
+                </div>
+                <div class="modal-body">
+                    <div class="form-group">
+                        <label>Transmittal Folder Name:</label>
+                        <input type="text" id="transmittalName" class="form-input">
+                        <small class="form-help">Format: YYYY-MM-DD_TRACKINGNUMBER (STATUS) - TITLE</small>
+                    </div>
+                    <div class="files-preview">
+                        <h3>Files to Add:</h3>
+                        <table class="preview-table">
+                            <thead>
+                                <tr>
+                                    <th>Original Name</th>
+                                    <th>New Name</th>
+                                    <th>Status</th>
+                                </tr>
+                            </thead>
+                            <tbody id="filesPreviewBody">
+                                <!-- Dynamically populated -->
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button class="btn btn-secondary modal-cancel">Cancel</button>
+                    <button class="btn btn-primary modal-confirm">Create Transmittal</button>
+                </div>
+            </div>
+        </div>
+
+        <!-- No Directory Selected Message -->
+        <div id="noDirectoryMessage" class="empty-state">
+            <div class="empty-state-content">
+                <h2>Welcome to ZDDC Archive</h2>
+                <p>Click <strong>Add Local Directory</strong> to select an archive folder to browse.</p>
+                <p>This browser provides a convenient interface for searching and retrieving files from ZDDC-compliant archives.</p>
+                <p><strong>How to navigate:</strong></p>
+                <ul class="welcome-list">
+                    <li>Select a party to see their transmittal folders; toggle folder types (Issued, Received, MDL, Incoming) above the list</li>
+                    <li>Select transmittal folders to see their files</li>
+                    <li>Use <kbd>Ctrl+Click</kbd> to select multiple folders</li>
+                    <li>Use <kbd>Shift+Click</kbd> to select a range</li>
+                    <li><kbd>Ctrl+Click</kbd> chevrons to recursively expand/collapse</li>
+                </ul>
+                
+                <details class="windows-tip">
+                    <summary><strong>⚠️ Windows Path Length Deficiency</strong></summary>
+                    <div class="windows-tip__body">
+                        <p>Microsoft Windows has a legacy 260-character path limit that affects most applications. If you see "files skipped" warnings, use Microsoft's own workaround:</p>
+                        <ol>
+                            <li>Open Command Prompt as Administrator</li>
+                            <li>Map your archive to a short drive letter:<br>
+                                <code class="windows-tip__code">subst Z: "C:\Your\Long\Path\To\Archive"</code>
+                            </li>
+                            <li>Use the <strong>Z:</strong> drive in Archive Browser</li>
+                            <li>To remove later: <code>subst Z: /d</code></li>
+                        </ol>
+                        <p class="windows-tip__note">This limitation dates back to Windows 95. The mapping persists until reboot.</p>
+                    </div>
+                </details>
+                
+                <p class="note">Note: This application works entirely in your browser and does not transmit any data.</p>
+            </div>
+        </div>
+
+
+        <!-- Help Panel -->
+        <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+            <div class="help-panel__header">
+                <h2 id="help-panel-title" class="help-panel__title">Help — ZDDC Archive</h2>
+                <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+            </div>
+            <div class="help-panel__body">
+                <h3>What is the Archive Browser?</h3>
+                <p>The Archive Browser lets you search and retrieve files from a ZDDC-compliant archive stored on your local file system. Everything runs in your browser — no data is transmitted anywhere.</p>
+
+                <h3>Getting Started</h3>
+                <ol>
+                    <li>When opened from a web server, the archive loads automatically from that server.</li>
+                    <li>Click <strong>Add Local Directory</strong> to open a local archive folder — works in both offline and online modes, and local files are merged with any server files already loaded.</li>
+                    <li>The browser scans for grouping folders and transmittal folders automatically.</li>
+                    <li>Select folders in the left panel to see their files in the main table.</li>
+                </ol>
+
+                <h3>Navigating Folders</h3>
+                <p>The left panel has two sections:</p>
+                <dl>
+                    <dt>Parties</dt>
+                    <dd>Top-level folders representing other parties. Select one or more to filter which transmittals are shown. Use the folder type buttons above the list to show or hide Issued, Received, MDL, and Incoming folder content.</dd>
+                    <dt>Transmittal Folders</dt>
+                    <dd>Grouped by date. Select one or more to filter which files appear in the table.</dd>
+                </dl>
+                <p><strong>Multi-select:</strong> Hold <kbd>Ctrl</kbd> and click to toggle individual folders. Hold <kbd>Shift</kbd> and click to select a range. <kbd>Ctrl+Click</kbd> a chevron (&#9654;) to recursively expand or collapse all sub-folders.</p>
+
+                <h3>Searching and Filtering</h3>
+                <dl>
+                    <dt>Column Filters</dt>
+                    <dd>Type in the filter row under each column header to filter by tracking number, title, or revision/status/extension. Filters support the expression syntax below. Active filters are highlighted in blue; use the ↺ reset button in the toolbar to clear all filters at once.</dd>
+                </dl>
+                <dl>
+                    <dt><code>term</code></dt>
+                    <dd>Contains "term" (case-insensitive)</dd>
+                    <dt><code>!term</code></dt>
+                    <dd>Does not contain "term"</dd>
+                    <dt><code>^term</code></dt>
+                    <dd>Starts with "term"</dd>
+                    <dt><code>term$</code></dt>
+                    <dd>Ends with "term"</dd>
+                    <dt><code>a b</code></dt>
+                    <dd>Matches both (AND)</dd>
+                    <dt><code>a | b</code></dt>
+                    <dd>Matches either (OR)</dd>
+                    <dt><code>^IFA | ^IFB</code></dt>
+                    <dd>Starts with IFA or IFB</dd>
+                    <dt><code>pdf !draft</code></dt>
+                    <dd>Contains "pdf" and not "draft"</dd>
+                    <dt><code>!^~</code></dt>
+                    <dd>Does not start with ~ (excludes drafts)</dd>
+                    <dt><code>el.*spc</code></dt>
+                    <dd>Regex: contains "el" followed by "spc" (use <code>.</code> for any char, <code>.*</code> for any sequence)</dd>
+                    <dt><code>[ei]fa</code></dt>
+                    <dd>Regex character class: matches "efa" or "ifa"</dd>
+                </dl>
+                <dl>
+                    <dt>Modifiers</dt>
+                    <dd>Use the Modifiers dropdown to show or hide files by revision modifier type (+B, +C, +N, +Q, or base).</dd>
+                </dl>
+
+                <h3>Downloading Files</h3>
+                <dl>
+                    <dt>Download Selected (ZIP)</dt>
+                    <dd>Packages all checked files into a ZIP archive for download.</dd>
+                    <dt>Export Selected (CSV)</dt>
+                    <dd>Exports the visible file list as a CSV spreadsheet.</dd>
+                    <dt>File Preview</dt>
+                    <dd>When enabled, clicking a PDF, Word, or Excel file opens a preview popup instead of downloading it.</dd>
+                </dl>
+
+                <h3>Keyboard Shortcuts</h3>
+                <dl>
+                    <dt><kbd>Ctrl+A</kbd></dt>
+                    <dd>Select / deselect all visible files in the table.</dd>
+                    <dt><kbd>F5</kbd></dt>
+                    <dd>Refresh — rescan the current directory.</dd>
+                    <dt><kbd>Escape</kbd></dt>
+                    <dd>Close this help panel (or any open modal).</dd>
+                </dl>
+
+                <h3>Windows Path Length Note</h3>
+                <p>Windows limits file paths to 260 characters by default. If files are skipped during scanning, map your archive to a short drive letter using <code>subst Z: "C:\Your\Long\Path"</code> in an Administrator Command Prompt, then open the <strong>Z:</strong> drive in the Archive Browser.</p>
+            </div>
+        </aside>
+
+    </div>
+
+    <script>
+        {{JS_PLACEHOLDER}}
+    </script>
+</body>
+</html>
diff --git a/bootstrap/README.md b/bootstrap/README.md
new file mode 100644
index 0000000..7c041d6
--- /dev/null
+++ b/bootstrap/README.md
@@ -0,0 +1,125 @@
+# Deployment bootstrap
+
+ZDDC tools (archive, transmittal, classifier, mdedit, landing) are single-file
+HTML bundles. The bootstrap pattern lets you install once on a deployment and
+update by editing a few lines, without re-uploading multi-megabyte HTML files.
+
+## The two-level model
+
+A typical `zddc-server` deployment looks like this:
+
+```
+<ZDDC_ROOT>/
+  index.html                # landing tool (or bootstrap)
+  archive.html              # archive tool (or bootstrap; site-wide channel switch lives here)
+  transmittal.html
+  classifier.html
+  mdedit.html
+  <project-A>/
+    archive.html            # level-1 bootstrap → fetches ../archive.html
+    transmittal.html
+    classifier.html
+    mdedit.html
+    <project files…>
+  <project-B>/
+    archive.html            # level-1 bootstrap (or pinned to a specific version)
+    …
+```
+
+- **Level-1 stubs** at `<project>/<tool>.html` always fetch the same-origin
+  `../<tool>.html`. They never touch `zddc.varasys.io`. Install them once;
+  they don't need to change.
+- **At deployment root** (`<ZDDC_ROOT>/<tool>.html`), put either:
+  - the actual built tool HTML — fully self-contained install, no external
+    dependencies; or
+  - a level-2 bootstrap — fetches a specific channel or pinned version from
+    `https://zddc.varasys.io/releases/<tool>_<channel|v…>.html`.
+
+The site administrator switches the whole site to a channel by replacing
+the file at `<ZDDC_ROOT>/<tool>.html` with the matching level-2 stub from
+`track-<channel>.zip`. A single project can override one tool by editing
+just `<project-X>/<tool>.html` (replace the relative `upstream` URL with an
+absolute zddc.varasys.io URL).
+
+## Why two levels
+
+The level-1 stubs let projects share a single source of truth for "which
+build of the archive tool runs here." Switching channels is one file change
+at the root; pinning a single project is one file change in that directory.
+
+`document.write()` chains across both levels: level-1 fetches and writes,
+the new document's level-2 script runs and writes again, the third write
+is the actual tool. Origin stays at the deployment domain throughout, so
+File System Access API, `crypto.subtle`, and `localStorage` all work and
+preferences stay scoped to the deployment.
+
+## Pinning options
+
+There are two ways to choose a version: edit the stub for a permanent
+pin, or pass a `?v=` URL parameter for a per-request override.
+
+### 1. Permanent pin (edit the stub)
+
+Each stub has one `fallback`/`upstream` constant. Edit it once and the
+choice sticks for everyone using that file.
+
+| URL                                                              | Behavior                                |
+|------------------------------------------------------------------|-----------------------------------------|
+| `https://zddc.varasys.io/releases/<tool>_latest.html`            | current stable; auto-updates within stable |
+| `https://zddc.varasys.io/releases/<tool>_beta.html`              | latest beta build (mutable)             |
+| `https://zddc.varasys.io/releases/<tool>_alpha.html`             | latest alpha build (mutable)            |
+| `https://zddc.varasys.io/releases/<tool>_v1.2.3.html`            | pinned to exact stable version          |
+
+### 2. Per-request `?v=` parameter
+
+Both stub levels honor a `?v=` URL parameter. The parameter survives the
+`document.write()` chain, so it flows through level-1 → level-2 →
+upstream automatically.
+
+| URL parameter                  | Behavior                                              |
+|--------------------------------|-------------------------------------------------------|
+| `?v=0.0.4` (or `?v=v0.0.4`)    | tries `<tool>_v0.0.4.html` locally, then upstream     |
+| `?v=alpha`                     | switches to alpha channel                             |
+| `?v=beta`                      | switches to beta channel                              |
+| `?v=latest`                    | latest stable                                         |
+| (omitted)                      | the default baked into the stub                       |
+
+When level-1 has `?v=…`, it tries `../<tool>_<suffix>.html` first (useful
+when the admin has staged specific versions locally) and falls back to
+`../<tool>.html` if 404 — which then forwards the parameter via level-2
+if one is installed. So the same URL works whether the version is
+staged locally, served by a level-2 stub, or both.
+
+Stable releases are immutable. Alpha and beta channel files are
+overwritten in place each time their channel is rebuilt; expect them to
+change without notice. The build label rendered on the tool page tells
+you what you are running (date + commit SHA for alpha/beta, version
+number for stable).
+
+## Auditing what's installed
+
+Every stub contains a `fallback` (level-1) or `upstream` (level-2)
+constant. To see what each tool / project on the deployment points at:
+
+```sh
+grep -rn "fallback\|upstream" <ZDDC_ROOT>
+```
+
+## CORS prerequisite (level-2 only)
+
+A level-2 fetch is cross-origin (deployment → `zddc.varasys.io`). The
+upstream must serve `Access-Control-Allow-Origin: *` (or a list including
+your deployment origin) on the released HTML files. Verify with:
+
+```sh
+curl -I https://zddc.varasys.io/releases/archive_latest.html | grep -i access-control
+```
+
+Level-1 fetches are same-origin so no CORS is involved.
+
+## Templates
+
+`level1.html.tmpl` and `level2.html.tmpl` are the source of truth. The
+project's top-level `build.sh` substitutes `{{TOOL}}`, `{{TOOL_TITLE}}`,
+and `{{CHANNEL}}` to produce the per-tool stubs that ship in
+`install.zip` and `track-<channel>.zip`.
diff --git a/bootstrap/level1.html.tmpl b/bootstrap/level1.html.tmpl
new file mode 100644
index 0000000..9fb3824
--- /dev/null
+++ b/bootstrap/level1.html.tmpl
@@ -0,0 +1,73 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Loading {{TOOL_TITLE}}…</title>
+  <style>html,body{margin:0;font:14px system-ui,sans-serif;color:#666;padding:1rem}</style>
+</head>
+<body>
+  Loading…
+  <script>
+    // Level-1 bootstrap. Fetches the tool from the deployment root (same
+    // origin) and document.write()s it in place. The target may be the real
+    // built tool HTML or a level-2 bootstrap that fetches from upstream.
+    //
+    // URL parameter ?v= selects a specific version or channel:
+    //   ?v=0.0.4 (or v0.0.4)      tries ../{{TOOL}}_v0.0.4.html locally
+    //   ?v=alpha|beta|latest      tries ../{{TOOL}}_<channel>.html locally
+    //   (none)                    fetches ../{{TOOL}}.html (default)
+    //
+    // If the requested version is not staged locally, falls back to the
+    // root entry (../{{TOOL}}.html) — which, if it is a level-2 stub,
+    // forwards the param upstream to zddc.varasys.io. So ?v=0.0.4 works
+    // whether admins staged it locally OR a level-2 stub is at root.
+    //
+    // To pin this single tool to a fixed version permanently, replace the
+    // `fallback` constant below with an absolute URL like
+    // https://zddc.varasys.io/releases/{{TOOL}}_v0.0.4.html.
+    (async function () {
+      const params = new URLSearchParams(location.search);
+      const v = params.get('v');
+      const tool = '{{TOOL}}';
+      const channels = { alpha: '_alpha', beta: '_beta', latest: '_latest', stable: '_latest' };
+
+      function suffixFor(value) {
+        if (!value) return '';
+        if (value in channels) return channels[value];
+        const ver = value.startsWith('v') ? value.slice(1) : value;
+        return '_v' + ver;
+      }
+
+      const versioned = '../' + tool + suffixFor(v) + '.html';
+      const fallback  = '../' + tool + '.html';
+
+      async function fetchHTML(url) {
+        const resp = await fetch(url, { cache: 'no-cache', credentials: 'omit' });
+        if (!resp.ok) throw new Error(resp.status + ' ' + resp.statusText);
+        return resp.text();
+      }
+
+      try {
+        let html;
+        if (v && versioned !== fallback) {
+          try {
+            html = await fetchHTML(versioned);
+          } catch (_) {
+            // Versioned copy not staged locally — let the root entry forward
+            // the request (level-2 stub will see ?v= and fetch upstream).
+            html = await fetchHTML(fallback);
+          }
+        } else {
+          html = await fetchHTML(fallback);
+        }
+        document.open();
+        document.write(html);
+        document.close();
+      } catch (err) {
+        document.body.textContent = 'Failed to load {{TOOL_TITLE}}: ' + err.message;
+      }
+    })();
+  </script>
+</body>
+</html>
diff --git a/bootstrap/level2.html.tmpl b/bootstrap/level2.html.tmpl
new file mode 100644
index 0000000..3333967
--- /dev/null
+++ b/bootstrap/level2.html.tmpl
@@ -0,0 +1,50 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Loading {{TOOL_TITLE}}…</title>
+  <style>html,body{margin:0;font:14px system-ui,sans-serif;color:#666;padding:1rem}</style>
+</head>
+<body>
+  Loading…
+  <script>
+    // Level-2 bootstrap. Fetches {{TOOL}} from zddc.varasys.io and
+    // document.write()s it in place. The default upstream is the
+    // {{CHANNEL}} channel; the URL parameter ?v= overrides it:
+    //
+    //   ?v=alpha|beta|latest      switches to that channel
+    //   ?v=0.0.4 (or v0.0.4)      pins to that exact stable version
+    //   (none)                    uses the {{CHANNEL}} default
+    //
+    // Requires zddc.varasys.io to serve Access-Control-Allow-Origin: *.
+    (async function () {
+      const params = new URLSearchParams(location.search);
+      const v = params.get('v');
+      const tool = '{{TOOL}}';
+      const defaultChannel = '{{CHANNEL}}';
+      const channels = { alpha: '_alpha', beta: '_beta', latest: '_latest', stable: '_latest' };
+
+      function suffixFor(value) {
+        if (!value) return '_' + defaultChannel;
+        if (value in channels) return channels[value];
+        const ver = value.startsWith('v') ? value.slice(1) : value;
+        return '_v' + ver;
+      }
+
+      const upstream = 'https://zddc.varasys.io/releases/' + tool + suffixFor(v) + '.html';
+
+      try {
+        const resp = await fetch(upstream, { cache: 'no-cache', credentials: 'omit' });
+        if (!resp.ok) throw new Error(resp.status + ' ' + resp.statusText);
+        const html = await resp.text();
+        document.open();
+        document.write(html);
+        document.close();
+      } catch (err) {
+        document.body.textContent = 'Failed to load from ' + upstream + ': ' + err.message;
+      }
+    })();
+  </script>
+</body>
+</html>
diff --git a/build.sh b/build.sh
new file mode 100755
index 0000000..1440a32
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,146 @@
+#!/bin/sh
+set -eu
+
+# Top-level build script — builds all ZDDC HTML tools, the zddc-server
+# binaries, and the downloadable bundles (install.zip and track-*.zip).
+
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+
+echo "=== Building ZDDC tools ==="
+
+sh "$SCRIPT_DIR/transmittal/build.sh" "${1:-}" "${2:-}"
+sh "$SCRIPT_DIR/archive/build.sh" "${1:-}" "${2:-}"
+sh "$SCRIPT_DIR/classifier/build.sh" "${1:-}" "${2:-}"
+sh "$SCRIPT_DIR/mdedit/build.sh" "${1:-}" "${2:-}"
+sh "$SCRIPT_DIR/landing/build.sh" "${1:-}" "${2:-}"
+
+echo ""
+echo "=== Building zddc-server binaries ==="
+mkdir -p "$SCRIPT_DIR/zddc/dist/web"
+podman build --target binaries -o "$SCRIPT_DIR/zddc/dist/" "$SCRIPT_DIR/zddc/" 2>&1 | grep -v "^-->"
+
+echo ""
+echo "=== Assembling zddc/dist/web/ ==="
+# Only landing and archive ship inside the server bundle: they call the
+# server's JSON API (GET / for the project list, directory listings for the
+# archive) and are useless without it. transmittal, classifier, and mdedit
+# are pure client-side tools that work from file:// or any static host;
+# they are released to website/ for download but not bundled with the server.
+cp "$SCRIPT_DIR/landing/dist/index.html"   "$SCRIPT_DIR/zddc/dist/web/index.html"
+cp "$SCRIPT_DIR/archive/dist/archive.html" "$SCRIPT_DIR/zddc/dist/web/archive.html"
+echo "Wrote zddc/dist/web/index.html"
+echo "Wrote zddc/dist/web/archive.html"
+
+# ─── Bootstrap zips ──────────────────────────────────────────────────────────
+# Generated from bootstrap/level{1,2}.html.tmpl on every build so they are
+# always in sync with the current bootstrap pattern.
+#
+#   install.zip          — drop into deployment root for self-contained install.
+#                          Contains the 5 current-stable HTMLs at root plus a
+#                          _template/ directory with 4 level-1 stubs that
+#                          projects can use as their starting layout.
+#   track-<channel>.zip  — drop the level-2 stubs over deployment root to make
+#                          the whole site track <channel> from zddc.varasys.io.
+#
+# install.zip needs at least one stable release to exist under
+# website/releases/; if none exist yet, that zip is skipped with a warning.
+
+WEBSITE_DIR="$SCRIPT_DIR/website"
+RELEASES_DIR="$WEBSITE_DIR/releases"
+BOOTSTRAP_DIR="$SCRIPT_DIR/bootstrap"
+
+mkdir -p "$WEBSITE_DIR"
+
+# tool|filename|title
+TOOL_TABLE='archive|archive.html|Archive
+transmittal|transmittal.html|Transmittal
+classifier|classifier.html|Classifier
+mdedit|mdedit.html|Markdown Editor
+landing|index.html|ZDDC'
+
+# Substitute {{TOOL}}, {{TOOL_TITLE}}, {{CHANNEL}} in a template.
+# Substitute {{TOOL}}, {{TOOL_TITLE}}, {{CHANNEL}} in a template.
+render_stub() {
+    sed \
+        -e "s|{{TOOL_TITLE}}|$3|g" \
+        -e "s|{{TOOL}}|$2|g" \
+        -e "s|{{CHANNEL}}|${4:-}|g" \
+        "$1" > "$5"
+}
+
+build_install_zip() {
+    # Verify a stable release exists for every tool before staging.
+    _missing=""
+    while IFS='|' read -r _tool _file _title; do
+        [ -e "$RELEASES_DIR/${_tool}_latest.html" ] || _missing="$_missing $_tool"
+    done <<EOF
+$TOOL_TABLE
+EOF
+
+    if [ -n "$_missing" ]; then
+        echo "Skipping install.zip — no stable release for:$_missing"
+        return 0
+    fi
+
+    _staging=$(mktemp -d)
+    while IFS='|' read -r _tool _file _title; do
+        cp "$RELEASES_DIR/${_tool}_latest.html" "$_staging/$_file"
+    done <<EOF
+$TOOL_TABLE
+EOF
+
+    # _template/ holds level-1 bootstraps for the four interactive tools
+    # (landing only lives at deployment root; project directories do not
+    # have their own landing page).
+    mkdir -p "$_staging/_template"
+    while IFS='|' read -r _tool _file _title; do
+        render_stub "$BOOTSTRAP_DIR/level1.html.tmpl" "$_tool" "$_title" "" "$_staging/_template/$_file"
+    done <<EOF
+archive|archive.html|Archive
+transmittal|transmittal.html|Transmittal
+classifier|classifier.html|Classifier
+mdedit|mdedit.html|Markdown Editor
+EOF
+
+    cp "$BOOTSTRAP_DIR/README.md" "$_staging/README.md"
+
+    rm -f "$WEBSITE_DIR/install.zip"
+    (cd "$_staging" && zip -qr "$WEBSITE_DIR/install.zip" .)
+    echo "Wrote $WEBSITE_DIR/install.zip"
+    rm -rf "$_staging"
+}
+
+build_track_zip() {
+    _channel="$1"
+    _staging=$(mktemp -d)
+    while IFS='|' read -r _tool _file _title; do
+        render_stub "$BOOTSTRAP_DIR/level2.html.tmpl" "$_tool" "$_title" "$_channel" "$_staging/$_file"
+    done <<EOF
+$TOOL_TABLE
+EOF
+
+    rm -f "$WEBSITE_DIR/track-$_channel.zip"
+    (cd "$_staging" && zip -qr "$WEBSITE_DIR/track-$_channel.zip" .)
+    echo "Wrote $WEBSITE_DIR/track-$_channel.zip"
+    rm -rf "$_staging"
+}
+
+echo ""
+echo "=== Building install.zip and track-*.zip ==="
+build_install_zip
+build_track_zip alpha
+build_track_zip beta
+build_track_zip latest
+
+echo ""
+echo "=== All tools built successfully ==="
+echo ""
+echo "Server deployment package: zddc/dist/"
+echo "  Binaries:  zddc-server-{linux,darwin,windows}-*"
+echo "  Web files: web/  (copy contents to ZDDC_ROOT)"
+echo ""
+echo "Bootstrap downloads: website/"
+echo "  install.zip       — self-contained install for deployment root"
+echo "  track-alpha.zip   — level-2 stubs that track the alpha channel"
+echo "  track-beta.zip    — level-2 stubs that track the beta channel"
+echo "  track-latest.zip  — level-2 stubs that track the latest stable"
diff --git a/classifier/README.md b/classifier/README.md
new file mode 100644
index 0000000..ca1e897
--- /dev/null
+++ b/classifier/README.md
@@ -0,0 +1,244 @@
+# Document Classifier
+
+[← Back to ZDDC](../README.md)
+
+Turn chaos into order - a spreadsheet-like tool for bulk renaming files to ZDDC format. Copy/paste with Excel for lightning-fast text operations. The entire app fits in a single HTML file that works forever.
+
+**[🔗 Open Document Classifier](dist/classifier.html)** - Click to use online, or right-click → "Save Link As" to keep your own copy.
+
+## Why This Tool?
+
+Got a folder full of "spec_final_v2_REALLY_FINAL.pdf" files? This tool transforms them into properly named, searchable documents. It's like Excel for file names - edit hundreds at once, paste from spreadsheets, and save hours of manual renaming.
+
+## What You Can Do
+
+📋 **Excel-Like Editing**
+- Edit file names like a spreadsheet
+- Copy/paste entire columns to/from Excel
+- Select ranges just like Excel (click and drag)
+- Tab through cells, sort columns, resize as needed
+
+🚀 **Bulk Operations**
+- Rename hundreds of files in seconds
+- Auto-populate from existing ZDDC names
+- Hide already-compliant files to focus on the rest
+- Save all changes with one click
+
+🎯 **Smart Features**  
+- Real-time validation shows errors instantly
+- Files stay in their folders - just get new names
+- Preview any file with a single click
+- Automatic folder expansion shows everything at once
+
+## Quick Start
+
+1. **Click "Select Directory"** - Pick the folder with messy file names
+2. **See the magic** - Files appear in a spreadsheet, auto-parsed if already ZDDC
+3. **Double-click to edit** - Just like Excel, or paste from a spreadsheet  
+4. **Click "Save All"** - All files renamed instantly
+5. **That's it!** - Your files are now organized and searchable
+
+## ZDDC Naming Convention
+
+### File Format
+```
+trackingNumber_revision (status) - title.extension
+```
+
+**Example:**
+```
+CE-BYR-ALL-EL-SPC-0001_A (IFC) - Cable Specification.pdf
+```
+
+**Components:**
+- **Tracking Number**: Project identifier (e.g., CE-BYR-ALL-EL-SPC-0001)
+- **Revision**: Document revision (e.g., A, B, 0, 1, A+C1)
+- **Status**: Status code (IFC, IFR, IFI, AFD, AFC, ASB, etc.)
+- **Title**: Descriptive title
+- **Extension**: File type (.pdf, .docx, .dwg, etc.)
+
+### Folder Format (Transmittal)
+```
+YYYY-MM-DD_trackingNumber (status) - title
+```
+
+**Example:**
+```
+2024-10-15_CE-BYR-ALL (IFC) - October Specifications
+```
+
+## How to Use
+
+### 1. Select Directory
+Click "Select Directory" and choose the root folder containing files to organize. The tool will:
+- Scan all subdirectories
+- Expand all folders automatically
+- Load all files into the spreadsheet
+- Parse existing ZDDC filenames into editable fields (shown in gray)
+
+### 2. Navigate and Filter
+
+**Folder Tree:**
+- All folders start expanded
+- Click folder names to select/deselect
+- Click ▼/▶ icons to collapse/expand
+- Selected folders show their files in the spreadsheet
+
+**Filtering:**
+- Type in column header filter boxes to filter rows
+- Check "Hide Compliant Files" to focus on non-compliant files only
+- Sort by clicking column headers (Shift+Click for multi-column sort)
+
+### 3. Edit Files
+
+**Spreadsheet Interface:**
+- Auto-populated fields appear in gray italic text
+- Double-click any cell to edit
+- Press Enter or Tab to move to next cell
+- Changes mark the row as modified (✓ ✗ buttons appear)
+
+**Excel Integration:**
+1. Select cells (click and drag)
+2. Copy (Ctrl+C) and paste into Excel
+3. Edit in Excel (e.g., convert to proper case)
+4. Copy from Excel and paste back (Ctrl+V)
+5. Click "Save All" to apply all changes
+
+### 4. Save Changes
+
+**Individual Files:**
+- Edit fields for a file
+- Click ✓ button to save that file
+- Click ✗ button to cancel changes
+
+**Batch Save:**
+- Edit multiple files
+- Click "Save All" button to rename all modified files at once
+- Click "Cancel All" to discard all changes
+
+### 5. Preview Files
+- Click any filename link to open the file in a new tab
+- Works with PDFs, images, and browser-viewable files
+
+### 6. Keyboard Shortcuts
+- **Tab**: Move to next cell
+- **Shift+Tab**: Move to previous cell
+- **Enter**: Move down one row
+- **Escape**: Cancel editing
+- **Ctrl+A** (in tree): Select all visible folders
+- **Ctrl+S**: Save all (when files are modified)
+
+## Common Status Codes
+
+- **IFR** - Issued for Review
+- **IFC** - Issued for Construction
+- **IFI** - Issued for Information
+- **AFD** - Approved for Design
+- **AFC** - Approved for Construction
+- **ASB** - As-Built
+
+## Real-World Examples
+
+### 🔧 Fix ALL CAPS Titles
+Have files like "CABLE SPECIFICATION.PDF"? Use the Excel trick:
+1. Select the Title column → Copy to Excel
+2. Use `=PROPER(A1)` to fix casing
+3. Paste back → Save All → Done!
+
+### 📝 Organize Random Files  
+Transform `spec001.pdf` → `CE-BYR-ALL-EL-SPC-0001_A (IFC) - Cable Specification.pdf`
+- Just fill in the spreadsheet cells
+- Copy/paste common values
+- Save All when ready
+
+### 🔄 Update Revisions
+Change revision A to B across multiple files:
+- Gray text = current values
+- Edit only what needs changing  
+- Batch save or save individually
+
+## Browser Compatibility
+
+Requires:
+- Modern Chromium-based browser (Chrome, Edge, Brave, etc.)
+- File System Access API support
+- JavaScript enabled
+
+## Privacy & Security
+
+- All processing happens locally in your browser
+- No data transmitted to any server
+- File System Access API requires explicit user permission
+- No tracking or analytics
+
+## Limitations
+
+### Folder Renaming
+Due to browser API limitations, folders cannot be renamed directly. The tool will provide the correct folder name format for manual renaming in your file system.
+
+### File Preview
+- PDFs open in browser tab
+- Other file types download for viewing in native applications
+- Browser cannot preview most file formats
+
+### File System Access
+- Requires user permission for each directory
+- Some file systems may have restrictions
+- Network drives may not be fully supported
+
+## Tips for Efficient Use
+
+1. **Use Hide Compliant Filter**: Check to focus only on non-compliant files
+2. **Excel Integration**: Copy/paste columns to Excel for bulk text operations
+3. **Auto-Population**: Gray fields are auto-parsed - edit only what needs changing
+4. **Column Sorting**: Click headers to sort, Shift+Click for multi-level sorting
+5. **Column Filtering**: Type in header filter boxes to narrow down files
+6. **Resize Columns**: Drag column borders to see full content
+7. **Save All**: Edit multiple files then save all at once
+
+## Troubleshooting
+
+### "Permission denied" errors
+- Ensure you've granted browser permission
+- Try selecting the directory again
+- Check file system permissions
+
+### Files not appearing
+- Click "Refresh" button to rescan
+- Ensure files aren't hidden by OS
+- Check that directory handle is valid
+
+### Rename fails
+- Check if file with that name already exists
+- Ensure file isn't open in another application
+- Verify you have write permissions
+
+### Gray fields not appearing
+- Fields only auto-populate if filename matches ZDDC pattern
+- Pattern: `TRACKING_REV (STATUS) - TITLE.ext`
+
+## Technical Details
+
+- **Architecture**: Single-page HTML application with centralized state management
+- **API**: File System Access API (Chromium browsers only)
+- **Build**: Concatenated from modular source files
+- **No Dependencies**: Pure vanilla JavaScript
+- **State Management**: Event-driven store pattern for predictable updates
+
+## Development
+
+Build: `sh build.sh` produces `dist/classifier.html` — a single self-contained file with all CSS, JS, and shared modules inlined.
+
+The canonical CSS and JS load order lives in `build.sh`. See the root `ARCHITECTURE.md` for the build system and module pattern, and `AGENTS.md` for shared helpers (`shared/zddc.js`, `shared/zddc-filter.js`, `shared/theme.js`, `shared/help.js`) and ZDDC parser API.
+
+## Design Philosophy
+
+This tool follows simple, reliable best practices:
+- **Single Purpose**: Classify and rename files to ZDDC format
+- **Spreadsheet Paradigm**: Familiar Excel-like interface for batch editing
+- **Simplicity = Reliability**: Centralized state, unidirectional data flow
+- **No Magic**: Deterministic, user-controlled operations with live validation
+- **Portable**: Single HTML file, works offline, no server required
+- **Excel Integration**: Copy/paste workflow for bulk text operations
+
+Use this tool to prepare files for the ZDDC Archive Browser.
diff --git a/classifier/build.sh b/classifier/build.sh
new file mode 100644
index 0000000..0e21a25
--- /dev/null
+++ b/classifier/build.sh
@@ -0,0 +1,86 @@
+#!/bin/sh
+set -eu
+
+root_dir=$(cd "$(dirname "$0")" && pwd)
+. "$root_dir/../shared/build-lib.sh"
+
+src_html="$root_dir/template.html"
+output_dir="$root_dir/dist"
+output_html="$output_dir/classifier.html"
+
+mkdir -p "$output_dir"
+ensure_exists "$src_html"
+
+css_temp=$(mktemp)
+js_raw=$(mktemp)
+js_temp=$(mktemp)
+cleanup() { rm -f "$css_temp" "$js_raw" "$js_temp"; }
+trap cleanup EXIT
+
+# CSS files to concatenate in order
+concat_files \
+  "../shared/base.css" \
+  "css/base.css" \
+  "css/layout.css" \
+  "css/spreadsheet.css" \
+  > "$css_temp"
+
+# JavaScript files to concatenate in order
+concat_files \
+  "../shared/zddc.js" \
+  "../shared/hash.js" \
+  "../shared/theme.js" \
+  "js/app.js" \
+  "js/utils.js" \
+  "../shared/zddc-filter.js" \
+  "js/store.js" \
+  "js/validator.js" \
+  "js/scanner.js" \
+  "js/tree.js" \
+  "js/spreadsheet.js" \
+  "js/selection.js" \
+  "js/preview.js" \
+  "js/resize.js" \
+  "js/filter.js" \
+  "js/sort.js" \
+  "js/excel.js" \
+  "../shared/help.js" \
+  > "$js_raw"
+
+# Escape '</' in inlined JS so the HTML parser cannot mistake string contents
+# for a closing </script> tag. Required for any tool with template literals.
+escape_js_close_tags "$js_raw" "$js_temp"
+
+compute_build_label "classifier" "${1:-}" "${2:-}"
+
+# Process template: inject CSS/JS, substitute build label, strip CDN refs.
+awk -v css_file="$css_temp" -v js_file="$js_temp" -v build_label="$build_label" -v is_red="$is_red" '
+  /\{\{CSS_PLACEHOLDER\}\}/ {
+    while ((getline line < css_file) > 0) print line
+    close(css_file)
+    next
+  }
+  /\{\{JS_PLACEHOLDER\}\}/ {
+    while ((getline line < js_file) > 0) print line
+    close(js_file)
+    next
+  }
+  /\{\{BUILD_LABEL\}\}/ {
+    if (is_red == "1") {
+      gsub(/\{\{BUILD_LABEL\}\}/, "<span style=\"color:red;font-weight:bold\">" build_label "</span>")
+    } else {
+      gsub(/\{\{BUILD_LABEL\}\}/, build_label)
+    }
+    print
+    next
+  }
+  /<script src="https?:\/\// { next }
+  /<link rel="stylesheet" href="https?:\/\// { next }
+  { print }
+' "$src_html" > "$output_html"
+
+echo "Wrote $output_html"
+
+if [ "$is_release" = "1" ]; then
+    promote_release "classifier"
+fi
diff --git a/classifier/css/base.css b/classifier/css/base.css
new file mode 100644
index 0000000..3274e62
--- /dev/null
+++ b/classifier/css/base.css
@@ -0,0 +1,65 @@
+/* Classifier-specific base overrides
+   Reset, tokens, buttons, and font are provided by shared/base.css */
+
+#app {
+    width: 100vw;
+    height: 100vh;
+    display: flex;
+    flex-direction: column;
+}
+
+/* Utility */
+.text-muted    { color: var(--text-muted); }
+.text-success  { color: var(--success); }
+.text-warning  { color: var(--warning); }
+.text-danger   { color: var(--danger); }
+
+/* Checkbox label */
+.checkbox-label {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+    user-select: none;
+    font-size: 0.875rem;
+}
+
+.checkbox-label input[type="checkbox"] {
+    cursor: pointer;
+}
+
+/* ── Toast notifications (classifier-only) ───────────────────────────────── */
+/* shared/base.css intentionally omits toast CSS; only classifier uses toasts. */
+.toast {
+    position: fixed;
+    bottom: 2rem;
+    right: 2rem;
+    background: var(--bg);
+    color: var(--text);
+    padding: 0.875rem 1.25rem;
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    z-index: 9000;
+    max-width: 400px;
+    font-size: 0.875rem;
+    animation: zddc-toast-in 0.3s ease-out;
+}
+
+.toast-success { border-left: 4px solid var(--success); }
+.toast-error   { border-left: 4px solid var(--danger); }
+.toast-info    { border-left: 4px solid var(--info); }
+.toast-warning { border-left: 4px solid var(--warning); }
+
+.toast-fade {
+    animation: zddc-toast-out 0.3s ease-out forwards;
+}
+
+@keyframes zddc-toast-in {
+    from { transform: translateX(100%); opacity: 0; }
+    to   { transform: translateX(0);   opacity: 1; }
+}
+
+@keyframes zddc-toast-out {
+    from { transform: translateX(0);   opacity: 1; }
+    to   { transform: translateX(100%); opacity: 0; }
+}
diff --git a/classifier/css/layout.css b/classifier/css/layout.css
new file mode 100644
index 0000000..c59dbb5
--- /dev/null
+++ b/classifier/css/layout.css
@@ -0,0 +1,319 @@
+/* Classifier layout — tokens from shared/base.css */
+
+/* Empty State — positioned below the app header */
+.empty-state {
+    position: absolute;
+    top: 50px; /* clear the header */
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--bg);
+    z-index: 10;
+}
+
+.empty-state-content {
+    text-align: center;
+    max-width: 500px;
+    padding: 2rem;
+}
+
+.empty-state-content h2 {
+    color: var(--text);
+    margin-bottom: 1rem;
+}
+
+.empty-state-content p {
+    margin-bottom: 1rem;
+    color: var(--text-muted);
+}
+
+.empty-state-content .note {
+    font-size: 0.85rem;
+    font-style: italic;
+}
+
+.welcome-list {
+    text-align: left;
+    margin: 0.5rem auto;
+    max-width: 400px;
+}
+
+.empty-state.drag-over {
+    background: var(--primary-light);
+    outline: 2px dashed var(--primary);
+    outline-offset: -4px;
+}
+
+/* Browser Warning */
+.browser-warning {
+    background-color: rgba(217, 119, 6, 0.08);
+    border: 2px solid var(--warning);
+    border-radius: var(--radius);
+    padding: 1.5rem;
+    margin: 1.5rem 0;
+    text-align: left;
+}
+
+.browser-warning h3 {
+    color: var(--warning);
+    margin-top: 0;
+}
+
+.browser-warning ul {
+    margin: 0.5rem 0;
+    padding-left: 1.5rem;
+}
+
+/* Main App */
+.main-app {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    background-color: var(--bg);
+    position: relative;
+}
+
+/* Header — shared/base.css provides .app-header base */
+.app-header {
+    padding: 0.5rem 1rem;
+}
+
+.header-left,
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.header-divider {
+    color: var(--border);
+    margin: 0 0.25rem;
+}
+
+/* Main Content */
+.main-content {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+}
+
+/* Folder Tree Pane */
+.folder-tree-pane {
+    width: 300px;
+    min-width: 150px;
+    display: flex;
+    flex-direction: column;
+    background-color: var(--bg-secondary);
+    border-right: 1px solid var(--border);
+    flex-shrink: 0;
+    position: relative;
+    transition: width 0.2s ease, min-width 0.2s ease;
+}
+
+.folder-tree-pane.collapsed {
+    width: 40px !important;
+    min-width: 40px !important;
+    max-width: 40px !important;
+    overflow: hidden;
+}
+
+.folder-tree-pane.collapsed .pane-header-controls,
+.folder-tree-pane.collapsed .folder-tree,
+.folder-tree-pane.collapsed .pane-header h3 {
+    display: none;
+}
+
+.folder-tree-pane.collapsed .pane-header {
+    padding: 0.5rem;
+    justify-content: center;
+}
+
+.folder-tree-pane.collapsed .pane-header-title {
+    flex-direction: column;
+}
+
+.pane-header-title {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.collapse-tree-btn {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.8rem;
+}
+
+/* Resize Handle */
+.resize-handle {
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 5px;
+    cursor: col-resize;
+    background-color: transparent;
+    z-index: 10;
+}
+
+.resize-handle:hover {
+    background-color: var(--primary);
+}
+
+.pane-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    background-color: var(--bg);
+    border-bottom: 1px solid var(--border);
+}
+
+.pane-header-left,
+.pane-header-right {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.pane-header h3 {
+    font-size: 1rem;
+    font-weight: 600;
+    margin: 0;
+}
+
+.pane-header-controls {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    align-items: flex-end;
+}
+
+.folder-stats,
+.file-stats {
+    display: flex;
+    gap: 1rem;
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.folder-tree {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+}
+
+/* Folder Item */
+.folder-item {
+    display: flex;
+    align-items: center;
+    padding: 0.5rem;
+    cursor: pointer;
+    border-radius: var(--radius);
+    user-select: none;
+    transition: background-color 0.15s;
+}
+
+.folder-item:hover {
+    background-color: var(--bg-hover);
+}
+
+.folder-item.selected {
+    background-color: var(--bg-selected);
+    font-weight: 500;
+}
+
+.folder-item.folder-hover-highlight {
+    background-color: rgba(217, 119, 6, 0.12);
+    border-left: 3px solid var(--warning);
+    transition: background-color 0.2s, border-left 0.2s;
+}
+
+.folder-item.has-unsaved {
+    border-left: 3px solid var(--warning);
+}
+
+.folder-toggle {
+    width: 20px;
+    height: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.folder-icon {
+    margin-right: 0.5rem;
+    color: var(--text-muted);
+}
+
+.folder-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.folder-count {
+    font-size: 11px;
+    color: var(--text-muted);
+    margin-left: 0.5rem;
+}
+
+.folder-children {
+    margin-left: 1.5rem;
+}
+
+/* Spreadsheet Pane */
+.spreadsheet-pane {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.spreadsheet-container {
+    flex: 1;
+    overflow: auto;
+    background-color: var(--bg);
+}
+
+/* ZIP Extract Button in Tree */
+.zip-extract-btn {
+    margin-left: auto;
+    padding: 0.15rem 0.4rem;
+    font-size: 0.7rem;
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.folder-item:hover .zip-extract-btn {
+    opacity: 1;
+}
+
+.zip-extract-btn:disabled {
+    opacity: 0.5;
+    cursor: wait;
+}
+
+/* ZIP Extract All Button */
+.zip-extract-all-btn {
+    margin-left: auto;
+    padding: 0.15rem 0.4rem;
+    font-size: 0.7rem;
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.folder-item:hover .zip-extract-all-btn {
+    opacity: 1;
+}
+
+.zip-extract-all-btn:disabled {
+    opacity: 0.5;
+    cursor: wait;
+}
diff --git a/classifier/css/spreadsheet.css b/classifier/css/spreadsheet.css
new file mode 100644
index 0000000..c568b77
--- /dev/null
+++ b/classifier/css/spreadsheet.css
@@ -0,0 +1,463 @@
+/**
+ * Spreadsheet Styles
+ * Table, cells, editing, and row states
+ */
+
+.spreadsheet {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.875rem;
+    background-color: var(--bg);
+}
+
+/* Selected cells */
+.selected-cell {
+    background-color: rgba(0, 123, 255, 0.2) !important;
+    outline: 1px solid var(--primary);
+}
+
+/* Auto-populated cells (gray text to indicate matches filename) */
+.cell-editable.auto-populated {
+    color: var(--text-muted);
+}
+
+/* Changed fields (blue text to indicate value differs from original filename) */
+.cell-editable.field-changed {
+    color: var(--primary);
+    font-weight: 500;
+}
+
+.spreadsheet thead {
+    position: sticky;
+    top: 0;
+    z-index: 10;
+    background-color: var(--bg-secondary);
+}
+
+.spreadsheet th {
+    padding: 0.75rem 0.5rem;
+    text-align: left;
+    font-weight: 600;
+    border-bottom: 2px solid var(--border);
+    background-color: var(--bg-secondary);
+    position: relative;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.spreadsheet th:hover:not(.col-row-num) {
+    background-color: var(--border);
+}
+
+/* Sort indicator */
+.sort-indicator {
+    display: inline-block;
+    font-size: 0.75rem;
+    color: var(--primary);
+    margin-left: 0.25rem;
+    margin-right: 0.25rem;
+    font-weight: bold;
+    vertical-align: middle;
+}
+
+.spreadsheet td {
+    padding: 0.5rem;
+    border-bottom: 1px solid var(--border);
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+/* Column resizer */
+.column-resizer {
+    position: absolute;
+    top: 0;
+    right: 0;
+    width: 5px;
+    height: 100%;
+    cursor: col-resize;
+    user-select: none;
+    z-index: 1;
+}
+
+.column-resizer:hover {
+    background-color: var(--primary);
+}
+
+/* Column Widths */
+.col-row-num {
+    width: 50px;
+    text-align: center;
+    background-color: var(--bg-secondary);
+    font-weight: 600;
+    color: var(--text-muted);
+    user-select: none;
+    -webkit-user-select: none;
+}
+
+.col-original {
+    min-width: 250px;
+}
+
+.col-extension {
+    width: 60px;
+    text-align: center;
+}
+
+.col-new {
+    min-width: 250px;
+}
+
+.col-trackingNumber {
+    min-width: 200px;
+    width: 200px;
+}
+
+.col-revision {
+    width: 80px;
+}
+
+.col-status {
+    width: 100px;
+}
+
+.col-title {
+    min-width: 200px;
+}
+
+.col-sha256 {
+    min-width: 150px;
+    font-family: var(--font-mono);
+    font-size: 11px;
+}
+
+.col-actions {
+    width: 100px;
+    text-align: center;
+}
+
+/* Row States */
+.spreadsheet tbody tr {
+    transition: background-color 0.15s;
+}
+
+.spreadsheet tbody tr:hover {
+    background-color: var(--bg-hover);
+}
+
+.spreadsheet tbody tr.modified {
+    border-left: 3px solid var(--warning);
+}
+
+.spreadsheet tbody tr.error {
+    border-left: 3px solid var(--danger);
+    background-color: rgba(220, 53, 69, 0.08);
+}
+
+.spreadsheet tbody tr.saving {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+/* Cell Content */
+.cell-content {
+    display: block;
+    width: 100%;
+}
+
+.cell-link {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+.cell-link:hover {
+    text-decoration: underline;
+}
+
+.cell-extension {
+    font-family: var(--font-mono);
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.cell-computed {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+/* Editable Cells */
+.cell-editable {
+    cursor: text;
+    position: relative;
+}
+
+.cell-editable:hover {
+    background-color: var(--bg-hover);
+}
+
+.cell-content[contenteditable="true"] {
+    outline: 2px solid var(--primary);
+    outline-offset: 0;
+    background-color: var(--bg);
+    min-height: 1.5em;
+}
+
+.cell-content[contenteditable="true"]:focus {
+    outline: 2px solid var(--primary);
+    outline-offset: 0;
+}
+
+.cell-content.editing {
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+/* Computed cells */
+.cell-editable.computed {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+.cell-editable.computed:hover {
+    font-style: normal;
+    color: var(--text);
+}
+
+/* Validation states */
+.validation-error {
+    background-color: rgba(220, 53, 69, 0.1);
+    border-left: 3px solid var(--danger);
+}
+
+.validation-warning {
+    background-color: rgba(255, 193, 7, 0.1);
+    border-left: 3px solid #ffc107;
+}
+
+/* Inline Actions */
+.inline-actions {
+    position: absolute;
+    right: 0.25rem;
+    top: 50%;
+    transform: translateY(-50%);
+    display: flex;
+    gap: 0.25rem;
+    background-color: var(--bg);
+    padding: 0.125rem;
+    border-radius: 3px;
+}
+
+.cell-editable {
+    position: relative;
+    padding-right: 3.5rem; /* Space for buttons */
+}
+
+.btn-inline {
+    border: none;
+    background: rgba(255, 255, 255, 0.9);
+    cursor: pointer;
+    font-size: 14px;
+    padding: 0.25rem 0.5rem;
+    border-radius: 3px;
+    transition: all 0.15s;
+    font-weight: bold;
+    box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+}
+
+.btn-save {
+    color: var(--success);
+}
+
+.btn-save:hover {
+    background-color: var(--success);
+    color: white;
+}
+
+.btn-cancel {
+    color: var(--danger);
+}
+
+.btn-cancel:hover {
+    background-color: var(--danger);
+    color: white;
+}
+
+/* Formula Preview */
+.formula-preview {
+    position: absolute;
+    bottom: 100%;
+    left: 0;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 4px;
+    padding: 0.5rem;
+    font-size: 12px;
+    min-width: 200px;
+    z-index: 100;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.formula-preview-label {
+    font-weight: 600;
+    color: var(--text-muted);
+    margin-bottom: 0.25rem;
+}
+
+.formula-preview-value {
+    color: var(--text);
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.formula-preview-value.valid {
+    color: var(--success);
+}
+
+.formula-preview-value.invalid {
+    color: var(--danger);
+}
+
+.preview-check {
+    color: var(--success);
+    font-size: 16px;
+    cursor: pointer;
+    padding: 0.25rem;
+    border-radius: 3px;
+    transition: background-color 0.15s;
+}
+
+.preview-check:hover {
+    background-color: rgba(40, 167, 69, 0.1);
+}
+
+.preview-error {
+    color: var(--danger);
+    font-size: 16px;
+}
+
+.formula-preview-errors {
+    margin-top: 0.25rem;
+    font-size: 11px;
+    color: var(--danger);
+    white-space: normal;
+}
+
+/* Validation States */
+.cell-warning {
+    background-color: rgba(255, 193, 7, 0.08);
+    border-left: 3px solid var(--warning);
+}
+
+.cell-error {
+    background-color: rgba(220, 53, 69, 0.08);
+    border-left: 3px solid var(--danger);
+}
+
+.validation-icon {
+    display: inline-block;
+    margin-left: 0.25rem;
+    cursor: help;
+}
+
+/* SHA256 Column */
+.sha256-hash {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--text-muted);
+}
+
+.sha256-calculating {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+/* Action Buttons */
+.row-actions {
+    display: flex;
+    gap: 0.25rem;
+    justify-content: center;
+}
+
+.btn-icon {
+    width: 28px;
+    height: 28px;
+    padding: 0;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    border: 1px solid var(--border);
+    border-radius: 4px;
+    background-color: var(--bg);
+    cursor: pointer;
+    transition: all 0.15s;
+}
+
+.btn-icon:hover:not(:disabled) {
+    background-color: var(--bg-hover);
+    transform: scale(1.1);
+}
+
+.btn-icon:disabled {
+    opacity: 0.3;
+    cursor: not-allowed;
+}
+
+.btn-save {
+    color: var(--success);
+}
+
+.btn-cancel {
+    color: var(--danger);
+}
+
+/* Empty State */
+.empty-state {
+    padding: 3rem;
+    text-align: center;
+    color: var(--text-muted);
+}
+
+.empty-state h3 {
+    margin-bottom: 0.5rem;
+}
+
+/* Spreadsheet Empty State */
+.spreadsheet-empty {
+    text-align: center;
+    color: var(--text-muted);
+    padding: 1.5rem;
+}
+
+/* Selection Highlight */
+.cell-selected {
+    outline: 2px solid var(--primary);
+    outline-offset: -2px;
+    z-index: 1;
+}
+
+/* Scrollbar Styling */
+.spreadsheet-container::-webkit-scrollbar {
+    width: 12px;
+    height: 12px;
+}
+
+.spreadsheet-container::-webkit-scrollbar-track {
+    background-color: var(--bg-secondary);
+}
+
+.spreadsheet-container::-webkit-scrollbar-thumb {
+    background-color: var(--border-dark);
+    border-radius: 6px;
+}
+
+.spreadsheet-container::-webkit-scrollbar-thumb:hover {
+    background-color: var(--text-muted);
+}
+
+/* Preview button active state */
+#togglePreviewBtn.preview-active {
+    background-color: var(--primary);
+    color: white;
+    border-color: var(--primary);
+}
diff --git a/classifier/js/app.js b/classifier/js/app.js
new file mode 100644
index 0000000..4af13a5
--- /dev/null
+++ b/classifier/js/app.js
@@ -0,0 +1,449 @@
+/**
+ * ZDDC Classifier - Main Application
+ * Spreadsheet-based file renaming with Excel-like formulas
+ */
+(function() {
+    'use strict';
+
+    // Global application state
+    window.app = {
+        // File System
+        rootHandle: null,
+        
+        // Data
+        folderTree: [],
+        selectedFolders: new Set(), // Multi-select support
+        lastSelectedFolderPath: null,
+        hideCompliant: false,
+        calculateSha256: false,
+        
+        // DOM elements (populated on init)
+        dom: {},
+        
+        // Modules (populated by other files)
+        modules: {}
+    };
+
+    /**
+     * Initialize the application
+     */
+    function init() {
+
+        
+        // Check browser compatibility
+        if (!checkBrowserCompatibility()) {
+            showBrowserWarning();
+            return;
+        }
+        
+        // Cache DOM elements
+        cacheDOMElements();
+        
+        // Set up event listeners
+        setupEventListeners();
+        
+        // Show welcome screen
+        showWelcomeScreen();
+        
+
+    }
+
+    /**
+     * Check if browser supports File System Access API
+     */
+    function checkBrowserCompatibility() {
+        return 'showDirectoryPicker' in window;
+    }
+
+    /**
+     * Show browser compatibility warning
+     */
+    function showBrowserWarning() {
+        const warning = document.getElementById('browserWarning');
+        const selectBtn = document.getElementById('selectDirectoryBtn');
+        if (warning) {
+            warning.classList.remove('hidden');
+        }
+        if (selectBtn) {
+            selectBtn.disabled = true;
+            selectBtn.textContent = 'Browser Not Supported';
+        }
+    }
+
+    /**
+     * Cache DOM element references
+     */
+    function cacheDOMElements() {
+        app.dom = {
+            // Screens
+            welcomeScreen: document.getElementById('welcomeScreen'),
+            mainApp: document.getElementById('mainApp'),
+            
+            // Header buttons
+            selectDirectoryBtn: document.getElementById('selectDirectoryBtn'),
+            refreshBtn: document.getElementById('refreshBtn'),
+            saveAllBtn: document.getElementById('saveAllBtn'),
+            cancelAllBtn: document.getElementById('cancelAllBtn'),
+            exportHashesBtn: document.getElementById('exportHashesBtn'),
+            sha256Checkbox: document.getElementById('sha256Checkbox'),
+            hideCompliantCheckbox: document.getElementById('hideCompliantCheckbox'),
+            
+            // Folder tree
+            folderTree: document.getElementById('folderTree'),
+            folderTreePane: document.getElementById('folderTreePane'),
+            collapseTreeBtn: document.getElementById('collapseTreeBtn'),
+            autoScrollCheckbox: document.getElementById('autoScrollCheckbox'),
+            selectedFoldersCount: document.getElementById('selectedFoldersCount'),
+            
+            // Spreadsheet
+            spreadsheet: document.getElementById('spreadsheet'),
+            spreadsheetBody: document.getElementById('spreadsheetBody'),
+            sha256Column: document.getElementById('sha256Column'),
+            
+            // Stats
+            totalFiles: document.getElementById('totalFiles'),
+            modifiedFiles: document.getElementById('modifiedFiles'),
+            errorFiles: document.getElementById('errorFiles'),
+            
+            // Preview
+            togglePreviewBtn: document.getElementById('togglePreviewBtn')
+        };
+    }
+
+    /**
+     * Set up event listeners
+     */
+    function setupEventListeners() {
+        // Directory selection
+        app.dom.selectDirectoryBtn.addEventListener('click', handleSelectDirectory);
+        app.dom.refreshBtn.addEventListener('click', handleRefresh);
+        
+        // Drag and drop on welcome screen
+        setupWelcomeDragDrop();
+        
+        // Bulk actions
+        app.dom.saveAllBtn.addEventListener('click', handleSaveAll);
+        app.dom.cancelAllBtn.addEventListener('click', handleCancelAll);
+        
+        // Export hashes
+        app.dom.exportHashesBtn.addEventListener('click', handleExportHashes);
+        
+        // SHA256 toggle
+        app.dom.sha256Checkbox.addEventListener('change', handleSha256Toggle);
+        
+        // Hide compliant toggle
+        app.dom.hideCompliantCheckbox.addEventListener('change', handleHideCompliantToggle);
+        
+        // Collapse tree button
+        app.dom.collapseTreeBtn.addEventListener('click', handleCollapseTree);
+        
+        // Keyboard shortcuts
+        document.addEventListener('keydown', handleKeyDown);
+        
+        // Resize handle
+        setupResizeHandle();
+    }
+    
+    /**
+     * Handle collapse/expand folder tree pane
+     */
+    function handleCollapseTree() {
+        const pane = app.dom.folderTreePane;
+        const btn = app.dom.collapseTreeBtn;
+        
+        pane.classList.toggle('collapsed');
+        
+        if (pane.classList.contains('collapsed')) {
+            // Clear any inline width from resize handle
+            pane.style.width = '';
+            btn.textContent = '▶';
+            btn.title = 'Expand folder tree';
+        } else {
+            btn.textContent = '◀';
+            btn.title = 'Collapse folder tree';
+        }
+    }
+
+    /**
+     * Set up folder tree resize handle
+     */
+    function setupResizeHandle() {
+        const handle = document.getElementById('treeResizeHandle');
+        const pane = document.getElementById('folderTreePane');
+        
+        if (!handle || !pane) return;
+        
+        let isResizing = false;
+        let startX = 0;
+        let startWidth = 0;
+        
+        handle.addEventListener('mousedown', (e) => {
+            isResizing = true;
+            startX = e.clientX;
+            startWidth = pane.offsetWidth;
+            document.body.style.cursor = 'col-resize';
+            e.preventDefault();
+        });
+        
+        document.addEventListener('mousemove', (e) => {
+            if (!isResizing) return;
+            
+            const delta = e.clientX - startX;
+            const newWidth = startWidth + delta;
+            
+            // Respect min width only
+            if (newWidth >= 150) {
+                pane.style.width = newWidth + 'px';
+            }
+        });
+        
+        document.addEventListener('mouseup', () => {
+            if (isResizing) {
+                isResizing = false;
+                document.body.style.cursor = '';
+            }
+        });
+    }
+
+    /**
+     * Set up drag-and-drop on the welcome screen
+     */
+    function setupWelcomeDragDrop() {
+        const screen = app.dom.welcomeScreen;
+        if (!screen) return;
+        
+        ['dragenter', 'dragover'].forEach(evt => {
+            screen.addEventListener(evt, (e) => {
+                e.preventDefault();
+                screen.classList.add('drag-over');
+            });
+        });
+        
+        ['dragleave', 'drop'].forEach(evt => {
+            screen.addEventListener(evt, (e) => {
+                e.preventDefault();
+                screen.classList.remove('drag-over');
+            });
+        });
+        
+        screen.addEventListener('drop', async (e) => {
+            const item = e.dataTransfer.items && e.dataTransfer.items[0];
+            if (!item) return;
+            
+            const handle = await item.getAsFileSystemHandle();
+            if (!handle || handle.kind !== 'directory') {
+                alert('Please drop a folder, not a file.');
+                return;
+            }
+            
+            await openDirectory(handle);
+        });
+    }
+
+    /**
+     * Handle directory selection via button click
+     */
+    async function handleSelectDirectory() {
+        try {
+            const dirHandle = await window.showDirectoryPicker();
+            await openDirectory(dirHandle);
+        } catch (err) {
+            if (err.name !== 'AbortError') {
+                console.error('Error selecting directory:', err);
+                alert('Error selecting directory: ' + err.message);
+            }
+        }
+    }
+
+    /**
+     * Open a directory handle and initialize the application
+     */
+    async function openDirectory(dirHandle) {
+        app.rootHandle = dirHandle;
+        
+        // Hide welcome screen and show main UI
+        hideWelcomeScreen();
+        showMainUI();
+        
+        // Initialize modules BEFORE scanning (so they're ready for store updates)
+        app.modules.spreadsheet.init();  // Subscribe to store
+        app.modules.selection.init();
+        app.modules.preview.init();  // After selection so it can listen for rowfocused
+        app.modules.resize.init();
+        app.modules.filter.init();
+        app.modules.sort.init();
+        app.modules.tree.setupKeyboardShortcuts();
+        
+        // Now scan directory (this will trigger store updates and renders)
+        await app.modules.scanner.scanDirectory(dirHandle);
+        
+        // Show refresh button now that a directory is loaded
+        if (app.dom.refreshBtn) { app.dom.refreshBtn.classList.remove('hidden'); }
+    }
+
+    /**
+     * Handle Refresh button - rescan current directory
+     */
+    async function handleRefresh() {
+        if (!app.rootHandle) {
+            alert('No directory selected');
+            return;
+        }
+
+        try {
+            // Clear current data
+            app.folderTree = [];
+            app.selectedFolders.clear();
+            app.lastSelectedFolderPath = null;
+            
+            // Reset store
+            app.modules.store.reset();
+
+            // Rescan directory (modules already initialized, just rescan)
+            await app.modules.scanner.scanDirectory(app.rootHandle);
+
+        } catch (err) {
+            console.error('Error refreshing directory:', err);
+            alert('Error refreshing directory: ' + err.message);
+        }
+    }
+
+    /**
+     * Handle Save All button
+     */
+    async function handleSaveAll() {
+        if (!confirm('Save all modified files?')) return;
+        
+        try {
+            app.dom.saveAllBtn.disabled = true;
+            await app.modules.spreadsheet.saveAllFiles();
+        } catch (err) {
+            console.error('Error saving files:', err);
+            alert('Error saving files: ' + err.message);
+        } finally {
+            app.dom.saveAllBtn.disabled = false;
+        }
+    }
+
+    /**
+     * Handle Cancel All button
+     */
+    function handleCancelAll() {
+        if (!confirm('Cancel all changes?')) return;
+        app.modules.spreadsheet.cancelAllChanges();
+    }
+
+    /**
+     * Handle Export Hashes button
+     */
+    function handleExportHashes() {
+        app.modules.excel.exportHashes();
+    }
+
+    /**
+     * Handle SHA256 checkbox toggle
+     */
+    function handleSha256Toggle() {
+        app.calculateSha256 = app.dom.sha256Checkbox.checked;
+        
+        // Show/hide SHA256 column
+        if (app.calculateSha256) {
+            app.dom.sha256Column.classList.remove('hidden');
+        } else {
+            app.dom.sha256Column.classList.add('hidden');
+        }
+        
+        // Re-render table
+        app.modules.spreadsheet.render();
+    }
+
+    /**
+     * Handle Hide Compliant checkbox toggle
+     */
+    function handleHideCompliantToggle() {
+        app.hideCompliant = app.dom.hideCompliantCheckbox.checked;
+        app.modules.store.setHideCompliant(app.hideCompliant);
+    }
+
+    /**
+     * Handle keyboard shortcuts
+     */
+    function handleKeyDown(e) {
+        // Ctrl+S - Save All
+        if (e.ctrlKey && e.key === 's') {
+            e.preventDefault();
+            if (!app.dom.saveAllBtn.disabled) {
+                handleSaveAll();
+            }
+        }
+        
+        // Escape - Cancel editing
+        if (e.key === 'Escape') {
+            app.modules.spreadsheet.cancelEditing();
+        }
+    }
+
+    /**
+     * Show welcome screen (empty-state overlay)
+     */
+    function showWelcomeScreen() {
+        if (app.dom.welcomeScreen) {
+            app.dom.welcomeScreen.classList.remove('hidden');
+        }
+    }
+
+    /**
+     * Hide welcome screen (empty-state overlay)
+     */
+    function hideWelcomeScreen() {
+        if (app.dom.welcomeScreen) {
+            app.dom.welcomeScreen.classList.add('hidden');
+        }
+    }
+
+    /**
+     * Show main UI (no-op: main UI is always rendered)
+     */
+    function showMainUI() {
+        // Main app is always visible; only the empty-state overlay is toggled
+    }
+
+    /**
+     * Update stats display
+     */
+    function updateStats() {
+        const files = app.modules.store.getDisplayFiles();
+        const totalFiles = files.length;
+        const modifiedFiles = files.filter(f => f.isDirty).length;
+        const errorFiles = files.filter(f => f.error).length;
+        
+        app.dom.totalFiles.textContent = `${totalFiles} file${totalFiles !== 1 ? 's' : ''}`;
+        app.dom.modifiedFiles.textContent = `${modifiedFiles} modified`;
+        
+        if (errorFiles > 0) {
+            app.dom.errorFiles.textContent = `${errorFiles} error${errorFiles !== 1 ? 's' : ''}`;
+            app.dom.errorFiles.classList.remove('hidden');
+        } else {
+            app.dom.errorFiles.classList.add('hidden');
+        }
+        
+        // Enable/disable bulk action buttons
+        app.dom.saveAllBtn.disabled = modifiedFiles === 0;
+        app.dom.cancelAllBtn.disabled = modifiedFiles === 0;
+        
+        // Enable/disable export hashes button
+        app.dom.exportHashesBtn.disabled = totalFiles === 0 || !app.calculateSha256;
+    }
+
+    // Export functions for use by other modules
+    app.modules.app = {
+        updateStats
+    };
+
+    // Initialize when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+})();
diff --git a/classifier/js/excel.js b/classifier/js/excel.js
new file mode 100644
index 0000000..97a48f7
--- /dev/null
+++ b/classifier/js/excel.js
@@ -0,0 +1,134 @@
+/**
+ * Excel Integration Module
+ * Toast notifications and hash export
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Show toast notification
+     */
+    function showToast(message, type = 'info') {
+        // Remove existing toast
+        const existing = document.querySelector('.toast');
+        if (existing) {
+            existing.remove();
+        }
+
+        // Create toast
+        const toast = document.createElement('div');
+        toast.className = `toast toast-${type}`;
+        toast.textContent = message;
+        document.body.appendChild(toast);
+
+        // Auto-remove after 5 seconds
+        setTimeout(() => {
+            toast.classList.add('toast-fade');
+            setTimeout(() => toast.remove(), 300);
+        }, 5000);
+    }
+
+    /**
+     * Export SHA256 hashes in sha256sum format
+     */
+    async function exportHashes() {
+        const files = window.app.modules.store.getDisplayFiles();
+        if (files.length === 0) {
+            alert('No files to export');
+            return;
+        }
+
+        // Check if SHA256 is enabled
+        if (!window.app.calculateSha256) {
+            alert('Please enable SHA256 checkbox first and wait for hashes to calculate');
+            return;
+        }
+
+        try {
+            // Build sha256sum format: hash *filepath
+            const lines = [];
+            
+            // Get root path
+            const rootPath = await getFullPath(window.app.rootHandle);
+            
+            for (const file of files) {
+                if (!file.sha256 || file.sha256 === 'calculating...' || file.sha256 === 'error') {
+                    continue; // Skip files without calculated hash
+                }
+                
+                // Get full path from root
+                const folderPath = await getFullPath(file.folderHandle);
+                const fullPath = `${folderPath}/${zddc.joinExtension(file.originalFilename, file.extension)}`;
+                
+                // Format: hash *filepath (asterisk indicates binary mode)
+                lines.push(`${file.sha256} *${fullPath}`);
+            }
+
+            if (lines.length === 0) {
+                alert('No SHA256 hashes available. Enable SHA256 and wait for calculation to complete.');
+                return;
+            }
+
+            // Create output
+            const output = lines.join('\n');
+
+            // Generate filename with timestamp
+            const now = new Date();
+            const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, -5); // YYYY-MM-DDTHH-MM-SS
+            const filename = `sha256sums_${timestamp}.txt`;
+
+            // Download as file
+            const blob = new Blob([output], { type: 'text/plain' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = filename;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+
+            // Show success message
+            showToast(`✓ Downloaded ${lines.length} hash(es) to ${filename}`, 'success');
+
+        } catch (err) {
+            console.error('Error exporting hashes:', err);
+            alert('Error exporting hashes: ' + err.message);
+        }
+    }
+
+    /**
+     * Get full path from directory handle (all the way to root)
+     */
+    async function getFullPath(dirHandle) {
+        const parts = [];
+        let current = dirHandle;
+        
+        // Walk up to root - collect ALL parent folders
+        while (current) {
+            parts.unshift(current.name);
+            
+            try {
+                // Try to get parent
+                if (typeof current.getParent === 'function') {
+                    const parent = await current.getParent();
+                    if (parent && parent !== current) {
+                        current = parent;
+                        continue;
+                    }
+                }
+                break;
+            } catch {
+                break;
+            }
+        }
+        
+        return parts.join('/');
+    }
+
+    // Export module
+    window.app.modules.excel = {
+        showToast,
+        exportHashes
+    };
+})();
diff --git a/classifier/js/filter.js b/classifier/js/filter.js
new file mode 100644
index 0000000..3f73297
--- /dev/null
+++ b/classifier/js/filter.js
@@ -0,0 +1,64 @@
+/**
+ * Filter Module
+ * Column filter UI: initialises static inputs in thead, wires events.
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Initialize filtering — wire delegated events on thead.
+     * Filter inputs already exist in the static template; no dynamic injection needed.
+     */
+    function init() {
+        const thead = window.app.dom.spreadsheet
+            ? window.app.dom.spreadsheet.querySelector('thead')
+            : document.querySelector('#spreadsheet thead');
+        if (!thead) return;
+
+        thead.addEventListener('input', (e) => {
+            if (e.target.matches('.column-filter[data-filter-field]')) {
+                e.stopPropagation();
+                const field = e.target.getAttribute('data-filter-field');
+                const raw = e.target.value.trim();
+                const ast = window.zddc.filter.parse(raw);
+                window.app.modules.store.setFilter(field, raw, ast);
+            }
+        });
+
+        thead.addEventListener('keydown', (e) => {
+            if (!e.target.matches('.column-filter[data-filter-field]')) return;
+            if (e.key === 'Escape') {
+                e.target.value = '';
+                const field = e.target.getAttribute('data-filter-field');
+                window.app.modules.store.setFilter(field, '', null);
+                e.preventDefault();
+            } else if (e.key === 'Enter') {
+                e.preventDefault();
+                const inputs = Array.from(thead.querySelectorAll('.column-filter'));
+                const idx = inputs.indexOf(e.target);
+                if (idx !== -1) inputs[(idx + 1) % inputs.length].focus();
+            }
+        });
+
+        thead.addEventListener('click', (e) => {
+            if (e.target.matches('.column-filter')) {
+                e.stopPropagation();
+            }
+        });
+    }
+
+    /**
+     * Clear all filters — reset inputs and store.
+     */
+    function clearFilters() {
+        document.querySelectorAll('.column-filter').forEach(input => {
+            input.value = '';
+        });
+        window.app.modules.store.setAllFilters({});
+    }
+
+    window.app.modules.filter = {
+        init,
+        clearFilters
+    };
+})();
diff --git a/classifier/js/preview.js b/classifier/js/preview.js
new file mode 100644
index 0000000..6ef8e38
--- /dev/null
+++ b/classifier/js/preview.js
@@ -0,0 +1,492 @@
+/**
+ * Preview Module
+ * Opens file preview in a separate popup window
+ */
+(function() {
+    'use strict';
+
+    let currentBlobUrl = null;
+    let currentFile = null;
+    let currentRowIndex = null;
+    let previewWindow = null;
+
+    // File type mappings (extensions stored without leading dot, matching shared/zddc.js)
+    const IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'gif', 'svg', 'webp', 'bmp', 'ico'];
+    const TEXT_EXTENSIONS = ['txt', 'md', 'json', 'xml', 'csv', 'log', 'html', 'css', 'js', 'ts', 'py', 'sh', 'bat', 'yaml', 'yml', 'ini', 'cfg', 'conf'];
+    const PDF_EXTENSIONS = ['pdf'];
+    const ZIP_EXTENSIONS = ['zip'];
+
+    // Cache for lazily loaded CDN libraries
+    const loadedLibraries = new Map();
+
+    /**
+     * Lazily load a script from CDN. Returns a promise that resolves when loaded.
+     * Caches the promise so subsequent calls return immediately.
+     */
+    function loadLibrary(url) {
+        if (loadedLibraries.has(url)) return loadedLibraries.get(url);
+        const promise = new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = url;
+            script.onload = resolve;
+            script.onerror = () => reject(new Error(`Failed to load library: ${url}`));
+            document.head.appendChild(script);
+        });
+        loadedLibraries.set(url, promise);
+        return promise;
+    }
+
+    /**
+     * Initialize preview module
+     */
+    function init() {
+        // Listen for row focused events from selection module
+        document.addEventListener('rowfocused', handleRowFocused);
+        
+        // Set up toggle button to open/close preview window
+        const toggleBtn = document.getElementById('togglePreviewBtn');
+        if (toggleBtn) {
+            toggleBtn.addEventListener('click', () => {
+                if (previewWindow && !previewWindow.closed) {
+                    // Close preview window
+                    previewWindow.close();
+                    previewWindow = null;
+                    toggleBtn.classList.remove('preview-active');
+                } else if (currentFile) {
+                    openPreviewWindow(currentFile);
+                    toggleBtn.classList.add('preview-active');
+                }
+            });
+        }
+    }
+
+    /**
+     * Handle row focused event
+     */
+    function handleRowFocused(e) {
+        const { rowIndex, file } = e.detail;
+        
+        currentRowIndex = rowIndex;
+        
+        if (file && file !== currentFile) {
+            currentFile = file;
+            
+            // Update preview window if open
+            if (previewWindow && !previewWindow.closed) {
+                openPreviewWindow(file);
+            }
+        }
+    }
+
+    /**
+     * Open preview in a separate popup window
+     */
+    async function openPreviewWindow(file) {
+        if (!file) return;
+        
+        currentFile = file;
+        
+        try {
+            const blob = await getFileBlob(file);
+            
+            // Clean up previous blob URL
+            if (currentBlobUrl) {
+                URL.revokeObjectURL(currentBlobUrl);
+            }
+            currentBlobUrl = URL.createObjectURL(blob);
+            
+            const fileName = zddc.joinExtension(file.originalFilename, file.extension);
+            
+            // Build preview HTML with toolbar
+            const previewHtml = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>${escapeHtml(fileName)} - Preview</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { 
+            display: flex; 
+            flex-direction: column; 
+            height: 100vh; 
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        }
+        .toolbar {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.5rem 1rem;
+            background: #f5f5f5;
+            border-bottom: 1px solid #ddd;
+        }
+        .toolbar h1 {
+            flex: 1;
+            font-size: 0.95rem;
+            font-weight: 500;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+        .btn {
+            padding: 0.4rem 0.8rem;
+            font-size: 0.85rem;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            background: white;
+            cursor: pointer;
+        }
+        .btn:hover { background: #e8e8e8; }
+        iframe, img {
+            flex: 1;
+            width: 100%;
+            border: none;
+        }
+        img {
+            object-fit: contain;
+            background: #f0f0f0;
+        }
+        pre {
+            flex: 1;
+            padding: 1rem;
+            overflow: auto;
+            background: #fafafa;
+            font-family: 'Consolas', 'Monaco', monospace;
+            font-size: 0.9rem;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+        .unsupported {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            color: #666;
+        }
+        .unsupported .icon { font-size: 3rem; margin-bottom: 1rem; }
+        #previewContent {
+            flex: 1;
+            overflow: auto;
+        }
+        .loading {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: #666;
+            font-size: 1.1rem;
+        }
+        .docx-wrapper { padding: 1rem; }
+        .xlsx-table { border-collapse: collapse; width: 100%; font-size: 0.85rem; }
+        .xlsx-table th, .xlsx-table td {
+            border: 1px solid #ddd;
+            padding: 0.35rem 0.5rem;
+            text-align: left;
+            white-space: nowrap;
+        }
+        .xlsx-table th { background: #f0f0f0; font-weight: 600; position: sticky; top: 0; }
+        .xlsx-table tr:nth-child(even) { background: #fafafa; }
+        .xlsx-table tr:hover { background: #f0f7ff; }
+        .sheet-tabs { display: flex; gap: 0; border-bottom: 1px solid #ddd; background: #f5f5f5; }
+        .sheet-tab {
+            padding: 0.4rem 1rem;
+            cursor: pointer;
+            border: 1px solid transparent;
+            border-bottom: none;
+            font-size: 0.85rem;
+            background: transparent;
+        }
+        .sheet-tab:hover { background: #e8e8e8; }
+        .sheet-tab.active {
+            background: white;
+            border-color: #ddd;
+            border-bottom-color: white;
+            margin-bottom: -1px;
+            font-weight: 500;
+        }
+    </style>
+</head>
+<body>
+    <div class="toolbar">
+        <h1>${escapeHtml(fileName)}</h1>
+        <button class="btn" onclick="downloadFile()">Download</button>
+    </div>
+    ${await getPreviewContent(file, currentBlobUrl)}
+    <script>
+        var blobUrl = "${currentBlobUrl}";
+        var fileName = "${escapeHtml(fileName).replace(/"/g, '\\"')}";
+        
+        function downloadFile() {
+            const a = document.createElement('a');
+            a.href = blobUrl;
+            a.download = fileName;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+        }
+    <\/script>
+</body>
+</html>`;
+            
+            // Reuse existing window if open, otherwise create new one
+            if (previewWindow && !previewWindow.closed) {
+                previewWindow.document.open();
+                previewWindow.document.write(previewHtml);
+                previewWindow.document.close();
+                previewWindow.focus();
+            } else {
+                // Calculate window size
+                const width = Math.round(screen.width * 0.6);
+                const height = Math.round(screen.height * 0.8);
+                const left = Math.round((screen.width - width) / 2);
+                const top = Math.round((screen.height - height) / 2);
+                
+                previewWindow = window.open('', 'classifierPreview', 
+                    `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`);
+                
+                if (!previewWindow) {
+                    // Popup blocked - fall back to new tab
+                    window.open(currentBlobUrl, '_blank');
+                    return;
+                }
+                
+                // Poll for window close — beforeunload is unreliable for popup close buttons
+                const closePoll = setInterval(() => {
+                    if (previewWindow && previewWindow.closed) {
+                        clearInterval(closePoll);
+                        previewWindow = null;
+                        const btn = document.getElementById('togglePreviewBtn');
+                        if (btn) btn.classList.remove('preview-active');
+                    }
+                }, 500);
+                
+                previewWindow.document.write(previewHtml);
+                previewWindow.document.close();
+                previewWindow.focus();
+            }
+            
+            // For office types, render content after window is ready
+            const ext = (file.extension || '').toLowerCase();
+            if (ext === 'docx') {
+                await renderDocxInWindow(file);
+            } else if (ext === 'xlsx' || ext === 'xls') {
+                await renderXlsxInWindow(file);
+            }
+        } catch (err) {
+            console.error('Error opening preview:', err);
+            alert(`Error opening preview: ${err.message}`);
+        }
+    }
+    
+    /**
+     * Get preview content HTML based on file type
+     */
+    async function getPreviewContent(file, blobUrl) {
+        const ext = file.extension.toLowerCase();
+        const previewType = getPreviewType(ext);
+        
+        switch (previewType) {
+            case 'pdf':
+                return `<iframe src="${blobUrl}#view=FitV"></iframe>`;
+            case 'image':
+                return `<img src="${blobUrl}" alt="${escapeHtml(file.originalFilename)}" />`;
+            case 'text':
+                const text = await getFileText(file);
+                const maxLength = 100000;
+                const displayText = text.length > maxLength 
+                    ? text.substring(0, maxLength) + '\n\n... (truncated)'
+                    : text;
+                return `<pre>${escapeHtml(displayText)}</pre>`;
+            case 'docx':
+            case 'xlsx':
+                return `<div id="previewContent"><div class="loading">Loading preview...</div></div>`;
+            default:
+                return `
+                    <div class="unsupported">
+                        <div class="icon">📄</div>
+                        <p>Preview not available for ${ext} files</p>
+                        <p style="margin-top: 0.5rem;">Click Download to view in external application</p>
+                    </div>
+                `;
+        }
+    }
+    
+    /**
+     * Get preview type from extension
+     */
+    function getPreviewType(ext) {
+        if (PDF_EXTENSIONS.includes(ext)) return 'pdf';
+        if (IMAGE_EXTENSIONS.includes(ext)) return 'image';
+        if (TEXT_EXTENSIONS.includes(ext)) return 'text';
+        if (ext === 'docx') return 'docx';
+        if (ext === 'xlsx' || ext === 'xls') return 'xlsx';
+        if (ZIP_EXTENSIONS.includes(ext)) return 'zip';
+        return 'none';
+    }
+
+    function getMimeType(ext) {
+        return window.app.modules.utils.getMimeType(ext);
+    }
+    
+    /**
+     * Get file content as blob (handles both real and virtual files)
+     */
+    async function getFileBlob(file) {
+        if (file.isVirtual) {
+            // Get from ZIP cache
+            const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+            if (!cached) throw new Error('ZIP not found in cache');
+            
+            const zipEntry = cached.zip.file(file.zipEntryPath);
+            if (!zipEntry) throw new Error('File not found in ZIP');
+            
+            // Get as arraybuffer and create blob with correct MIME type
+            const arrayBuffer = await zipEntry.async('arraybuffer');
+            const mimeType = getMimeType(file.extension);
+            return new Blob([arrayBuffer], { type: mimeType });
+        } else {
+            // Get from file handle
+            if (!file.handle) {
+                throw new Error('File handle not available');
+            }
+            return await file.handle.getFile();
+        }
+    }
+    
+    /**
+     * Get file content as text (handles both real and virtual files)
+     */
+    async function getFileText(file) {
+        if (file.isVirtual) {
+            const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+            if (!cached) throw new Error('ZIP not found in cache');
+            
+            const zipEntry = cached.zip.file(file.zipEntryPath);
+            if (!zipEntry) throw new Error('File not found in ZIP');
+            
+            return await zipEntry.async('string');
+        } else {
+            if (!file.handle) {
+                throw new Error('File handle not available');
+            }
+            const fileObj = await file.handle.getFile();
+            return await fileObj.text();
+        }
+    }
+
+    /**
+     * Render a DOCX file in the preview window using docx-preview library
+     */
+    async function renderDocxInWindow(file) {
+        const container = previewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+            await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+            
+            const blob = await getFileBlob(file);
+            const arrayBuffer = await blob.arrayBuffer();
+            
+            container.innerHTML = '';
+            await window.docx.renderAsync(arrayBuffer, container);
+        } catch (err) {
+            console.error('Error rendering DOCX:', err);
+            container.innerHTML = `<div class="loading">Error rendering DOCX: ${err.message}<br>Click Download to view in Word.</div>`;
+        }
+    }
+
+    /**
+     * Render an XLSX/XLS file in the preview window using SheetJS
+     */
+    async function renderXlsxInWindow(file) {
+        const container = previewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+            
+            const blob = await getFileBlob(file);
+            const arrayBuffer = await blob.arrayBuffer();
+            const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+            
+            container.innerHTML = '';
+            
+            if (workbook.SheetNames.length > 1) {
+                const tabs = previewWindow.document.createElement('div');
+                tabs.className = 'sheet-tabs';
+                workbook.SheetNames.forEach((name, i) => {
+                    const tab = previewWindow.document.createElement('button');
+                    tab.className = 'sheet-tab' + (i === 0 ? ' active' : '');
+                    tab.textContent = name;
+                    tab.onclick = () => {
+                        tabs.querySelectorAll('.sheet-tab').forEach(t => t.classList.remove('active'));
+                        tab.classList.add('active');
+                        renderSheetInWindow(workbook, name, tableContainer);
+                    };
+                    tabs.appendChild(tab);
+                });
+                container.appendChild(tabs);
+            }
+            
+            const tableContainer = previewWindow.document.createElement('div');
+            tableContainer.style.flex = '1';
+            tableContainer.style.overflow = 'auto';
+            container.appendChild(tableContainer);
+            
+            renderSheetInWindow(workbook, workbook.SheetNames[0], tableContainer);
+        } catch (err) {
+            console.error('Error rendering XLSX:', err);
+            container.innerHTML = `<div class="loading">Error rendering spreadsheet: ${err.message}<br>Click Download to view in Excel.</div>`;
+        }
+    }
+
+    /**
+     * Render a single sheet as an HTML table in the preview window
+     */
+    function renderSheetInWindow(workbook, sheetName, container) {
+        const sheet = workbook.Sheets[sheetName];
+        const html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+        container.innerHTML = html;
+        const table = container.querySelector('table');
+        if (table) table.className = 'xlsx-table';
+    }
+
+    /**
+     * Escape HTML for safe display
+     */
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    /**
+     * Download current file
+     */
+    async function downloadFile() {
+        if (!currentFile) return;
+        
+        try {
+            const blob = await getFileBlob(currentFile);
+            const url = URL.createObjectURL(blob);
+            
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = zddc.joinExtension(currentFile.originalFilename, currentFile.extension);
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            
+            setTimeout(() => URL.revokeObjectURL(url), 1000);
+        } catch (err) {
+            console.error('Error downloading file:', err);
+            alert('Error downloading file: ' + err.message);
+        }
+    }
+
+    // Export module
+    window.app.modules.preview = {
+        init
+    };
+})();
diff --git a/classifier/js/resize.js b/classifier/js/resize.js
new file mode 100644
index 0000000..76be460
--- /dev/null
+++ b/classifier/js/resize.js
@@ -0,0 +1,70 @@
+/**
+ * Column Resize Module
+ * Handles resizable table columns
+ */
+(function() {
+    'use strict';
+
+    let resizingColumn = null;
+    let startX = 0;
+    let startWidth = 0;
+
+    /**
+     * Initialize column resizing
+     */
+    function init() {
+        const table = window.app.dom.spreadsheet;
+        const headers = table.querySelectorAll('thead th');
+        
+        headers.forEach(th => {
+            // Skip if resize handle already exists
+            if (th.querySelector('.column-resizer')) return;
+            
+            // Add resize handle
+            const resizer = document.createElement('div');
+            resizer.className = 'column-resizer';
+            th.appendChild(resizer);
+            
+            // Mouse down on resizer
+            resizer.addEventListener('mousedown', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                
+                resizingColumn = th;
+                startX = e.pageX;
+                startWidth = th.offsetWidth;
+                
+                document.addEventListener('mousemove', handleMouseMove);
+                document.addEventListener('mouseup', handleMouseUp);
+            });
+        });
+    }
+
+    /**
+     * Handle mouse move during resize
+     */
+    function handleMouseMove(e) {
+        if (!resizingColumn) return;
+        
+        const diff = e.pageX - startX;
+        const newWidth = Math.max(50, startWidth + diff);
+        
+        resizingColumn.style.width = newWidth + 'px';
+        resizingColumn.style.minWidth = newWidth + 'px';
+        resizingColumn.style.maxWidth = newWidth + 'px';
+    }
+
+    /**
+     * Handle mouse up - end resize
+     */
+    function handleMouseUp() {
+        resizingColumn = null;
+        document.removeEventListener('mousemove', handleMouseMove);
+        document.removeEventListener('mouseup', handleMouseUp);
+    }
+
+    // Export module
+    window.app.modules.resize = {
+        init
+    };
+})();
diff --git a/classifier/js/scanner.js b/classifier/js/scanner.js
new file mode 100644
index 0000000..187f6ab
--- /dev/null
+++ b/classifier/js/scanner.js
@@ -0,0 +1,436 @@
+/**
+ * Directory Scanner Module
+ * Scans directories and collects files
+ */
+(function() {
+    'use strict';
+    
+    // Store ZIP data for later access
+    const zipCache = new Map();  // path -> { zip: JSZip, fileHandle: FileSystemFileHandle }
+
+    /**
+     * Scan directory and build folder tree with files
+     */
+    async function scanDirectory(dirHandle, preserveState = false) {
+
+        
+        // Save current state if preserving
+        let savedExpanded = new Set();
+        let savedSelected = new Set();
+        if (preserveState) {
+            savedExpanded = getExpandedPaths(window.app.folderTree);
+            savedSelected = new Set(window.app.selectedFolders);
+        }
+        
+        // Clear ZIP cache
+        zipCache.clear();
+        
+        // Map to store files by folder handle (or ZIP path for virtual folders)
+        const foldersMap = new Map();
+        
+        // Recursively scan
+        await scanFolder(dirHandle, foldersMap, dirHandle.name);
+        
+        // Build tree structure
+        window.app.folderTree = window.app.modules.tree.buildTree(dirHandle, foldersMap);
+        
+        // Set in store
+        window.app.modules.store.setFolderTree(window.app.folderTree);
+        
+        if (preserveState) {
+            // Restore expanded state
+            restoreExpandedPaths(window.app.folderTree, savedExpanded);
+            // Restore selection
+            window.app.selectedFolders = savedSelected;
+            // Render without changing selection
+            window.app.modules.tree.render();
+            window.app.modules.store.setSelectedFolders(savedSelected);
+        } else {
+            // Render tree
+            window.app.modules.tree.render();
+            // Auto-expand and select all folders
+            window.app.modules.tree.expandAll();
+            window.app.modules.tree.selectAll();
+        }
+        
+
+    }
+    
+    /**
+     * Get all expanded folder paths from tree
+     */
+    function getExpandedPaths(folders, paths = new Set()) {
+        for (const folder of folders) {
+            if (folder.expanded) {
+                paths.add(folder.path);
+            }
+            if (folder.children) {
+                getExpandedPaths(folder.children, paths);
+            }
+        }
+        return paths;
+    }
+    
+    /**
+     * Restore expanded state to tree
+     */
+    function restoreExpandedPaths(folders, expandedPaths) {
+        for (const folder of folders) {
+            folder.expanded = expandedPaths.has(folder.path);
+            if (folder.children) {
+                restoreExpandedPaths(folder.children, expandedPaths);
+            }
+        }
+    }
+
+    /**
+     * Recursively scan a folder
+     */
+    async function scanFolder(dirHandle, foldersMap, currentPath) {
+        const items = [];
+        
+        try {
+            for await (const entry of dirHandle.values()) {
+                if (entry.kind === 'file') {
+                    // Create file object
+                    const file = await createFileObject(entry, dirHandle);
+                    if (file) {
+                        items.push(file);
+                        
+                        // Check if it's a ZIP file - scan its contents
+                        if (file.extension === 'zip' && typeof JSZip !== 'undefined') {
+                            await scanZipFile(file, foldersMap, currentPath, items);
+                        }
+                    }
+                } else if (entry.kind === 'directory') {
+                    // Add directory reference
+                    items.push({
+                        handle: entry,
+                        isDirectory: true
+                    });
+                    
+                    // Recursively scan subdirectory
+                    const childPath = currentPath + '/' + entry.name;
+                    await scanFolder(entry, foldersMap, childPath);
+                }
+            }
+        } catch (err) {
+            console.error('Error scanning folder:', dirHandle.name, err);
+        }
+        
+        // Store files for this folder
+        foldersMap.set(dirHandle, items);
+    }
+    
+    /**
+     * Scan a ZIP file and add its contents as virtual folders
+     */
+    async function scanZipFile(zipFileObj, foldersMap, parentPath, parentItems) {
+        try {
+            const fileObj = await zipFileObj.handle.getFile();
+            const arrayBuffer = await fileObj.arrayBuffer();
+            const zip = await JSZip.loadAsync(arrayBuffer);
+            
+            const zipPath = parentPath + '/' + zddc.joinExtension(zipFileObj.originalFilename, zipFileObj.extension);
+            
+            // Cache the ZIP for later extraction
+            zipCache.set(zipPath, {
+                zip: zip,
+                fileHandle: zipFileObj.handle,
+                folderHandle: zipFileObj.folderHandle
+            });
+            
+            // Mark the file as a ZIP container
+            zipFileObj.isZipContainer = true;
+            zipFileObj.zipPath = zipPath;
+            
+            // Build virtual folder structure from ZIP contents
+            const virtualFolders = new Map();  // path -> { files: [], subdirs: Set }
+            virtualFolders.set(zipPath, { files: [], subdirs: new Set() });
+            
+            zip.forEach((relativePath, zipEntry) => {
+                if (zipEntry.dir) {
+                    // It's a directory
+                    const dirPath = zipPath + '/' + relativePath.replace(/\/$/, '');
+                    if (!virtualFolders.has(dirPath)) {
+                        virtualFolders.set(dirPath, { files: [], subdirs: new Set() });
+                    }
+                    // Add to parent's subdirs
+                    const parentDir = dirPath.substring(0, dirPath.lastIndexOf('/'));
+                    if (virtualFolders.has(parentDir)) {
+                        virtualFolders.get(parentDir).subdirs.add(dirPath);
+                    }
+                } else {
+                    // It's a file
+                    const fileName = relativePath.split('/').pop();
+                    const fileDir = relativePath.includes('/') 
+                        ? zipPath + '/' + relativePath.substring(0, relativePath.lastIndexOf('/'))
+                        : zipPath;
+                    
+                    // Ensure parent directories exist
+                    ensureVirtualPath(virtualFolders, zipPath, fileDir);
+                    
+                    // Create virtual file object
+                    const split = zddc.splitExtension(fileName);
+
+                    const virtualFile = {
+                        originalFilename: split.name,
+                        extension: split.extension,
+                        size: zipEntry._data ? zipEntry._data.uncompressedSize : 0,
+                        lastModified: zipEntry.date ? zipEntry.date.getTime() : Date.now(),
+                        
+                        // Virtual file markers
+                        isVirtual: true,
+                        zipPath: zipPath,
+                        zipEntryPath: relativePath,
+                        
+                        // Editable fields
+                        trackingNumber: '',
+                        revision: '',
+                        status: '',
+                        title: '',
+                        
+                        // State
+                        isDirty: false,
+                        error: false,
+                        errorMessage: '',
+                        validation: null,
+                        sha256: null
+                    };
+                    
+                    virtualFolders.get(fileDir).files.push(virtualFile);
+                }
+            });
+            
+            // Convert virtual folders to format compatible with tree builder
+            // Create a virtual handle for the ZIP root
+            const zipVirtualHandle = {
+                name: zddc.joinExtension(zipFileObj.originalFilename, zipFileObj.extension),
+                kind: 'directory',
+                isZipRoot: true,
+                zipPath: zipPath
+            };
+            
+            // Store virtual folder data
+            buildVirtualFolderMap(virtualFolders, zipPath, foldersMap, zipVirtualHandle);
+            
+            // Add ZIP as a virtual directory in parent
+            parentItems.push({
+                handle: zipVirtualHandle,
+                isDirectory: true,
+                isZipRoot: true
+            });
+            
+        } catch (err) {
+            console.error('Error scanning ZIP file:', zipFileObj.originalFilename, err);
+        }
+    }
+    
+    /**
+     * Ensure all parent directories exist in virtual folder map
+     */
+    function ensureVirtualPath(virtualFolders, zipPath, targetPath) {
+        if (virtualFolders.has(targetPath)) return;
+        
+        const parts = targetPath.substring(zipPath.length + 1).split('/').filter(p => p);
+        let currentPath = zipPath;
+        
+        for (const part of parts) {
+            const parentPath = currentPath;
+            currentPath = currentPath + '/' + part;
+            
+            if (!virtualFolders.has(currentPath)) {
+                virtualFolders.set(currentPath, { files: [], subdirs: new Set() });
+            }
+            
+            if (virtualFolders.has(parentPath)) {
+                virtualFolders.get(parentPath).subdirs.add(currentPath);
+            }
+        }
+    }
+    
+    /**
+     * Build virtual folder entries for the foldersMap
+     * Uses path strings as keys for virtual folders to avoid object reference issues
+     */
+    function buildVirtualFolderMap(virtualFolders, zipPath, foldersMap, zipVirtualHandle) {
+        const rootData = virtualFolders.get(zipPath);
+        if (!rootData) return;
+        
+        // Create items array for ZIP root
+        const rootItems = [...rootData.files];
+        
+        // Add subdirectories
+        for (const subdirPath of rootData.subdirs) {
+            const subdirName = subdirPath.split('/').pop();
+            const subdirHandle = {
+                name: subdirName,
+                kind: 'directory',
+                isVirtualDir: true,
+                virtualPath: subdirPath,
+                zipPath: zipPath
+            };
+            rootItems.push({
+                handle: subdirHandle,
+                isDirectory: true,
+                isVirtualDir: true
+            });
+            
+            // Recursively add subdir contents
+            buildVirtualSubfolder(virtualFolders, subdirPath, foldersMap, zipPath);
+        }
+        
+        // Store with both the handle object AND the path string as keys
+        // This ensures lookup works regardless of which reference is used
+        foldersMap.set(zipVirtualHandle, rootItems);
+        foldersMap.set(zipPath, rootItems);  // Path-based key for tree building
+    }
+    
+    /**
+     * Recursively build virtual subfolder entries
+     */
+    function buildVirtualSubfolder(virtualFolders, folderPath, foldersMap, zipPath) {
+        const folderData = virtualFolders.get(folderPath);
+        if (!folderData) return;
+        
+        const folderName = folderPath.split('/').pop();
+        const folderHandle = {
+            name: folderName,
+            kind: 'directory',
+            isVirtualDir: true,
+            virtualPath: folderPath,
+            zipPath: zipPath
+        };
+        
+        const items = [...folderData.files];
+        
+        // Store with path string key for tree building lookup
+        foldersMap.set(folderPath, items);
+        
+        // Add subdirectories
+        for (const subdirPath of folderData.subdirs) {
+            const subdirName = subdirPath.split('/').pop();
+            const subdirHandle = {
+                name: subdirName,
+                kind: 'directory',
+                isVirtualDir: true,
+                virtualPath: subdirPath,
+                zipPath: zipPath
+            };
+            items.push({
+                handle: subdirHandle,
+                isDirectory: true,
+                isVirtualDir: true
+            });
+            
+            // Recursively add subdir contents
+            buildVirtualSubfolder(virtualFolders, subdirPath, foldersMap, zipPath);
+        }
+        
+        foldersMap.set(folderHandle, items);
+    }
+    
+    /**
+     * Get cached ZIP data
+     */
+    function getZipCache(zipPath) {
+        return zipCache.get(zipPath);
+    }
+    
+    /**
+     * Extract a ZIP file to its parent directory
+     */
+    async function extractZip(zipPath) {
+        const cached = zipCache.get(zipPath);
+        if (!cached) {
+            throw new Error('ZIP not found in cache');
+        }
+        
+        const { zip, folderHandle } = cached;
+        
+        // Get the ZIP filename without extension for the extract folder name
+        const zipName = zipPath.split('/').pop();
+        const extractFolderName = zipName.replace(/\.zip$/i, '');
+        
+        // Create extraction folder
+        const extractFolder = await folderHandle.getDirectoryHandle(extractFolderName, { create: true });
+        
+        // Extract all files
+        const entries = [];
+        zip.forEach((relativePath, zipEntry) => {
+            if (!zipEntry.dir) {
+                entries.push({ path: relativePath, entry: zipEntry });
+            }
+        });
+        
+        for (const { path, entry } of entries) {
+            try {
+                // Create subdirectories if needed
+                const parts = path.split('/');
+                const fileName = parts.pop();
+                
+                let currentDir = extractFolder;
+                for (const part of parts) {
+                    if (part) {
+                        currentDir = await currentDir.getDirectoryHandle(part, { create: true });
+                    }
+                }
+                
+                // Write file
+                const content = await entry.async('arraybuffer');
+                const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
+                const writable = await fileHandle.createWritable();
+                await writable.write(content);
+                await writable.close();
+            } catch (err) {
+                console.error('Error extracting file:', path, err);
+            }
+        }
+        
+        return extractFolderName;
+    }
+
+    /**
+     * Create file object with metadata
+     */
+    async function createFileObject(fileHandle, folderHandle) {
+        try {
+            const file = await fileHandle.getFile();
+            const split = zddc.splitExtension(file.name);
+
+            return {
+                handle: fileHandle,
+                folderHandle: folderHandle,
+                originalFilename: split.name,
+                extension: split.extension,
+                size: file.size,
+                lastModified: file.lastModified,
+                
+                // Editable fields
+                trackingNumber: '',
+                revision: '',
+                status: '',
+                title: '',
+                
+                // State
+                isDirty: false,
+                error: false,
+                errorMessage: '',
+                validation: null,
+                sha256: null
+                // folderPath will be added later in buildTree
+            };
+        } catch (err) {
+            console.error('Error reading file:', fileHandle.name, err);
+            return null;
+        }
+    }
+
+    // Export module
+    window.app.modules.scanner = {
+        scanDirectory,
+        getZipCache,
+        extractZip
+    };
+})();
+
diff --git a/classifier/js/selection.js b/classifier/js/selection.js
new file mode 100644
index 0000000..41a00e2
--- /dev/null
+++ b/classifier/js/selection.js
@@ -0,0 +1,715 @@
+/**
+ * Selection Module
+ * Handles Excel-style cell selection and copy/paste
+ */
+(function() {
+    'use strict';
+
+    let selectionStart = null;
+    let selectionEnd = null;
+    let isSelecting = false;
+    let initialized = false;
+    let autoScrollInterval = null;
+    let lastMouseY = 0;
+    let startMouseX = 0;
+    let startMouseY = 0;
+    let dragDistance = 0;
+
+    /**
+     * Initialize selection handlers
+     */
+    function init() {
+        // Only initialize once
+        if (initialized) return;
+        initialized = true;
+        
+        const table = window.app.dom.spreadsheet;
+        
+        // Make table focusable so clipboard events fire
+        if (!table.hasAttribute('tabindex')) {
+            table.setAttribute('tabindex', '-1');
+            table.style.outline = 'none';
+        }
+        
+        // Mouse down on cell - start selection
+        table.addEventListener('mousedown', handleMouseDown);
+        
+        // Mouse move - extend selection
+        document.addEventListener('mousemove', handleMouseMove);
+        
+        // Mouse up - end selection
+        document.addEventListener('mouseup', handleMouseUp);
+        
+        // Selectstart handler - prevent only when dragging (multi-cell selection)
+        document.addEventListener('selectstart', (e) => {
+            if (isSelecting && dragDistance > 4) {
+                e.preventDefault();
+            }
+        });
+        
+        // Copy/paste handlers
+        document.addEventListener('copy', handleCopy);
+        document.addEventListener('paste', handlePaste);
+        document.addEventListener('cut', handleCut);
+    }
+
+    /**
+     * Handle mouse down on cell
+     */
+    function handleMouseDown(e) {
+        const cell = e.target.closest('td');
+        if (!cell) return;
+        
+        // Ignore if clicking action buttons
+        if (e.target.closest('.inline-actions')) return;
+        
+        // Ignore if cell is being edited (contenteditable)
+        if (cell.isContentEditable || cell.classList.contains('editing')) return;
+        
+        // Don't start selection if double-clicking to edit
+        if (e.detail === 2) return;
+        
+        const row = cell.closest('tr');
+        if (!row) return;
+        
+        const rowIndex = parseInt(row.dataset.index);
+        const colIndex = Array.from(row.children).indexOf(cell);
+        
+        // Shift+Click: extend selection from existing start to clicked cell
+        if (e.shiftKey && selectionStart) {
+            selectionEnd = { row: rowIndex, col: colIndex };
+            updateSelection();
+            updateButtonStates();
+            e.preventDefault();
+            return;
+        }
+        
+        // Clear previous selection
+        clearSelection();
+        
+        // Start new selection
+        selectionStart = { row: rowIndex, col: colIndex };
+        selectionEnd = { row: rowIndex, col: colIndex };
+        isSelecting = true;
+        dragDistance = 0;
+        startMouseX = e.clientX;
+        startMouseY = e.clientY;
+        
+        // Highlight cell
+        updateSelection();
+        updateButtonStates();
+        
+        // Focus the table so clipboard events (Ctrl+V) fire
+        window.app.dom.spreadsheet.focus();
+        
+        // Only prevent default for shift-click (extending selection)
+        // Single click should allow text selection to work normally
+        if (e.shiftKey) {
+            e.preventDefault();
+        }
+    }
+
+    /**
+     * Handle mouse move during selection
+     */
+    function handleMouseMove(e) {
+        if (!isSelecting) return;
+        
+        // Store mouse position for auto-scroll
+        lastMouseY = e.clientY;
+        
+        // Track drag distance from mousedown
+        const dx = e.clientX - startMouseX;
+        const dy = e.clientY - startMouseY;
+        dragDistance = Math.sqrt(dx*dx + dy*dy);
+        
+        const cell = e.target.closest('td');
+        if (!cell) return;
+        
+        const row = cell.closest('tr');
+        if (!row) return;
+        
+        const rowIndex = parseInt(row.dataset.index);
+        const colIndex = Array.from(row.children).indexOf(cell);
+        
+        if (rowIndex === undefined || colIndex === -1) return;
+        
+        // Update selection end
+        selectionEnd = { row: rowIndex, col: colIndex };
+        
+        // Highlight selected cells
+        updateSelection();
+        
+        // Start auto-scroll if not already running
+        if (!autoScrollInterval) {
+            startAutoScroll();
+        }
+    }
+
+    /**
+     * Start continuous auto-scroll
+     */
+    function startAutoScroll() {
+        const scrollThreshold = 50; // pixels from edge
+        const scrollSpeed = 5; // pixels per frame
+        
+        const scroll = () => {
+            if (!isSelecting) {
+                autoScrollInterval = null;
+                return;
+            }
+            
+            const viewport = document.querySelector('.spreadsheet-pane');
+            if (!viewport) {
+                autoScrollInterval = null;
+                return;
+            }
+            
+            const rect = viewport.getBoundingClientRect();
+            
+            // Determine scroll direction based on last mouse position
+            if (lastMouseY > rect.bottom - scrollThreshold) {
+                viewport.scrollTop += scrollSpeed; // Scroll down
+            } else if (lastMouseY < rect.top + scrollThreshold) {
+                viewport.scrollTop -= scrollSpeed; // Scroll up
+            }
+            
+            // Continue scrolling
+            autoScrollInterval = requestAnimationFrame(scroll);
+        };
+        
+        autoScrollInterval = requestAnimationFrame(scroll);
+    }
+
+    /**
+     * Handle mouse up - end selection
+     */
+    function handleMouseUp(e) {
+        isSelecting = false;
+        dragDistance = 0;
+        
+        // Stop auto-scrolling
+        if (autoScrollInterval) {
+            cancelAnimationFrame(autoScrollInterval);
+            autoScrollInterval = null;
+        }
+        
+        updateButtonStates();
+    }
+
+    /**
+     * Update visual selection highlighting
+     */
+    function updateSelection() {
+        if (!selectionStart || !selectionEnd) return;
+        
+        // Clear all previous highlights
+        document.querySelectorAll('.selected-cell').forEach(cell => {
+            cell.classList.remove('selected-cell');
+        });
+        
+        // Calculate selection bounds
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        // Highlight selected cells
+        const tbody = window.app.dom.spreadsheetBody;
+        const rows = tbody.querySelectorAll('tr');
+        
+        for (let r = minRow; r <= maxRow; r++) {
+            const row = rows[r];
+            if (!row) continue;
+            
+            const cells = row.children;
+            for (let c = minCol; c <= maxCol; c++) {
+                const cell = cells[c];
+                if (cell) {
+                    cell.classList.add('selected-cell');
+                }
+            }
+        }
+        
+        // Emit rowfocused event for preview pane
+        emitRowFocused(minRow);
+    }
+    
+    /**
+     * Emit row focused event for preview pane
+     */
+    function emitRowFocused(rowIndex) {
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        
+        if (file) {
+            const event = new CustomEvent('rowfocused', {
+                detail: { rowIndex, file }
+            });
+            document.dispatchEvent(event);
+        }
+    }
+
+    /**
+     * Clear selection
+     */
+    function clearSelection() {
+        selectionStart = null;
+        selectionEnd = null;
+        document.querySelectorAll('.selected-cell').forEach(cell => {
+            cell.classList.remove('selected-cell');
+        });
+        updateButtonStates();
+    }
+
+    /**
+     * Check if there is an active selection
+     */
+    function hasSelection() {
+        return selectionStart !== null && selectionEnd !== null;
+    }
+
+    /**
+     * Update Copy/Paste button enabled states
+     */
+    function updateButtonStates() {
+        const copyBtn = document.getElementById('copyBtn');
+        const pasteBtn = document.getElementById('pasteBtn');
+        const active = hasSelection();
+        if (copyBtn) copyBtn.disabled = !active;
+        if (pasteBtn) pasteBtn.disabled = !active;
+    }
+
+    /**
+     * Get column headers for selected columns
+     */
+    function getColumnHeaders(minCol, maxCol) {
+        const headerCells = window.app.dom.spreadsheet.querySelectorAll('thead th');
+        const headers = [];
+        for (let c = minCol; c <= maxCol; c++) {
+            const th = headerCells[c];
+            if (th) {
+                // Get the text content, excluding filter inputs
+                const text = th.childNodes[0]?.textContent?.trim() || th.textContent.trim();
+                headers.push(text);
+            } else {
+                headers.push('');
+            }
+        }
+        return headers;
+    }
+
+    /**
+     * Check if first row looks like a header row
+     */
+    function isHeaderRow(row) {
+        const headerPatterns = ['#', 'Original', 'Ext', 'New', 'Tracking', 'Rev', 'Status', 'Title', 'SHA256'];
+        return row.some(cell => headerPatterns.includes(cell.trim()));
+    }
+
+    /**
+     * Convert 2D array of rows to an HTML table string.
+     * Excel prefers text/html over text/plain, so providing a
+     * proper <table> ensures cell boundaries are preserved.
+     */
+    function rowsToHtml(allRows) {
+        const esc = s => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        const headerRow = allRows[0];
+        const dataRows = allRows.slice(1);
+        let html = '<table>';
+        html += '<tr>' + headerRow.map(c => '<th>' + esc(c) + '</th>').join('') + '</tr>';
+        for (const row of dataRows) {
+            html += '<tr>' + row.map(c => '<td>' + esc(c) + '</td>').join('') + '</tr>';
+        }
+        html += '</table>';
+        return html;
+    }
+
+    /**
+     * Handle copy event
+     */
+    function handleCopy(e) {
+        if (!selectionStart || !selectionEnd) return;
+        
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        // Get column headers for selected range
+        const headers = getColumnHeaders(minCol, maxCol);
+        
+        const data = getSelectionData();
+        if (!data) return;
+        
+        // Prepend header row
+        const allRows = [headers, ...data];
+        
+        // Convert to TSV and HTML table
+        const tsv = allRows.map(row => row.join('\t')).join('\n');
+        
+        e.clipboardData.setData('text/plain', tsv);
+        e.clipboardData.setData('text/html', rowsToHtml(allRows));
+        e.preventDefault();
+    }
+
+    /**
+     * Handle cut event
+     */
+    function handleCut(e) {
+        if (!selectionStart || !selectionEnd) return;
+        
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        // Get column headers for selected range
+        const headers = getColumnHeaders(minCol, maxCol);
+        
+        const data = getSelectionData();
+        if (!data) return;
+        
+        // Prepend header row
+        const allRows = [headers, ...data];
+        
+        // Convert to TSV
+        const tsv = allRows.map(row => row.join('\t')).join('\n');
+        
+        e.clipboardData.setData('text/plain', tsv);
+        e.clipboardData.setData('text/html', rowsToHtml(allRows));
+        
+        // Clear selected cells (only editable ones)
+        clearSelectionData();
+        
+        e.preventDefault();
+    }
+
+    /**
+     * Handle paste event
+     */
+    function handlePaste(e) {
+        // Don't intercept paste in input fields
+        if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA' || e.target.isContentEditable) {
+            return;
+        }
+        
+        if (!selectionStart) return;
+        
+        const tsv = e.clipboardData.getData('text/plain');
+        if (!tsv) return;
+        
+        e.preventDefault();
+        executePaste(tsv);
+    }
+
+    /**
+     * Execute paste from TSV string into the selected range.
+     * - If pasted cols > selected cols, right-align (user likely copied all but only pastes back editable cols).
+     * - If pasted data includes the first two columns (#, Original), validate they match.
+     * - If pasted row count != selected row count, abort with error.
+     */
+    function executePaste(tsv) {
+        if (!selectionStart || !selectionEnd) return;
+
+        // Parse TSV
+        let rows = tsv.split('\n').map(row => row.split('\t'));
+
+        // Filter out empty trailing rows
+        while (rows.length > 0 && rows[rows.length - 1].every(cell => !cell.trim())) {
+            rows.pop();
+        }
+        if (rows.length === 0) return;
+
+        // Check if first row is a header row and skip it
+        if (rows.length > 1 && isHeaderRow(rows[0])) {
+            rows = rows.slice(1);
+        }
+        if (rows.length === 0) return;
+
+        // Selection bounds
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        const selectedRowCount = maxRow - minRow + 1;
+        const selectedColCount = maxCol - minCol + 1;
+        const pastedColCount = rows[0].length;
+
+        // Row count validation: must match
+        if (rows.length !== selectedRowCount) {
+            alert(`Paste aborted: row count mismatch.\n` +
+                  `Selected ${selectedRowCount} row(s), but clipboard has ${rows.length} row(s).`);
+            return;
+        }
+
+        // Determine column offset for right-alignment
+        let colOffset = 0;
+        if (pastedColCount > selectedColCount) {
+            colOffset = pastedColCount - selectedColCount;
+        }
+
+        // Get column names from header
+        const headerCells = window.app.dom.spreadsheet.querySelectorAll('thead th');
+        const columnNames = Array.from(headerCells).map(th => {
+            const match = th.className.match(/col-(\w+)/);
+            return match ? match[1] : '';
+        });
+
+        // If pasted data includes first two columns (row-num, original), validate they match
+        if (colOffset === 0 && pastedColCount >= selectedColCount) {
+            // Check if pasted range starts at col 0 or col 1 (row-num or original)
+            const files = window.app.modules.store.getDisplayFiles();
+            const startsAtRowNum = (minCol === 0);
+            const startsAtOriginal = (minCol === 1);
+
+            if (startsAtRowNum || startsAtOriginal) {
+                for (let r = 0; r < rows.length; r++) {
+                    const targetRowIndex = minRow + r;
+                    const file = files[targetRowIndex];
+                    if (!file) continue;
+
+                    if (startsAtRowNum) {
+                        // Validate col 0 = row number, col 1 = original filename
+                        const expectedNum = String(targetRowIndex + 1);
+                        const pastedNum = rows[r][0]?.trim();
+                        const pastedOriginal = rows[r][1]?.trim();
+                        if (pastedNum && pastedNum !== expectedNum) {
+                            alert(`Paste aborted: row number mismatch at row ${targetRowIndex + 1}.\n` +
+                                  `Expected "${expectedNum}", got "${pastedNum}".\n` +
+                                  `Data may be shuffled.`);
+                            return;
+                        }
+                        if (pastedOriginal && pastedOriginal !== file.originalFilename) {
+                            alert(`Paste aborted: filename mismatch at row ${targetRowIndex + 1}.\n` +
+                                  `Expected "${file.originalFilename}", got "${pastedOriginal}".\n` +
+                                  `Data may be shuffled.`);
+                            return;
+                        }
+                    } else if (startsAtOriginal) {
+                        // Validate col 0 of paste = original filename
+                        const pastedOriginal = rows[r][0]?.trim();
+                        if (pastedOriginal && pastedOriginal !== file.originalFilename) {
+                            alert(`Paste aborted: filename mismatch at row ${targetRowIndex + 1}.\n` +
+                                  `Expected "${file.originalFilename}", got "${pastedOriginal}".\n` +
+                                  `Data may be shuffled.`);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Editable columns
+        const editableColumns = ['newFilename', 'trackingNumber', 'revision', 'status', 'title'];
+        const files = window.app.modules.store.getDisplayFiles();
+        let updatedCount = 0;
+
+        for (let r = 0; r < rows.length; r++) {
+            const targetRowIndex = minRow + r;
+            if (targetRowIndex >= files.length) continue;
+            const file = files[targetRowIndex];
+            if (!file) continue;
+
+            const rowData = rows[r];
+
+            for (let c = 0; c < selectedColCount; c++) {
+                const pasteIdx = c + colOffset; // right-align: skip leading pasted cols
+                if (pasteIdx >= rowData.length) continue;
+
+                const targetColIndex = minCol + c;
+                if (targetColIndex >= columnNames.length) continue;
+
+                const columnName = columnNames[targetColIndex];
+                if (!editableColumns.includes(columnName)) continue;
+
+                const value = rowData[pasteIdx]?.trim() || '';
+
+                if (columnName === 'newFilename') {
+                    if (value) {
+                        file.manualFilename = value;
+                    } else {
+                        delete file.manualFilename;
+                    }
+                } else {
+                    file[columnName] = value;
+                    if (file.manualFilename) {
+                        delete file.manualFilename;
+                    }
+                }
+
+                file.isDirty = true;
+                file.autoPopulated = false;
+                updatedCount++;
+            }
+        }
+
+        // Re-render and restore selection
+        if (updatedCount > 0) {
+            window.app.modules.spreadsheet.render();
+            // Restore selection highlight
+            updateSelection();
+            showToast(`Pasted ${updatedCount} cell(s)`, 'success');
+        }
+    }
+
+    /**
+     * Show a brief toast notification
+     */
+    function showToast(message, type) {
+        if (window.app.modules.excel && window.app.modules.excel.showToast) {
+            window.app.modules.excel.showToast(message, type);
+            return;
+        }
+        // Fallback: simple toast
+        const toast = document.createElement('div');
+        toast.textContent = message;
+        toast.style.cssText = 'position:fixed;bottom:20px;right:20px;padding:8px 16px;' +
+            'background:' + (type === 'success' ? '#28a745' : '#dc3545') + ';color:#fff;' +
+            'border-radius:4px;z-index:9999;font-size:14px;';
+        document.body.appendChild(toast);
+        setTimeout(() => toast.remove(), 3000);
+    }
+
+    /**
+     * Get data from selected cells
+     */
+    function getSelectionData() {
+        if (!selectionStart || !selectionEnd) return null;
+        
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        const data = [];
+        const tbody = window.app.dom.spreadsheetBody;
+        const rows = tbody.querySelectorAll('tr');
+        
+        for (let r = minRow; r <= maxRow; r++) {
+            const row = rows[r];
+            if (!row) continue;
+            
+            const rowData = [];
+            const cells = row.children;
+            
+            for (let c = minCol; c <= maxCol; c++) {
+                const cell = cells[c];
+                if (cell) {
+                    rowData.push(cell.textContent.trim());
+                } else {
+                    rowData.push('');
+                }
+            }
+            
+            data.push(rowData);
+        }
+        
+        return data;
+    }
+
+    /**
+     * Clear data from selected cells (only editable ones)
+     */
+    function clearSelectionData() {
+        if (!selectionStart || !selectionEnd) return;
+        
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        const tbody = window.app.dom.spreadsheetBody;
+        const rows = tbody.querySelectorAll('tr');
+        
+        // Get column names from header
+        const headerCells = window.app.dom.spreadsheet.querySelectorAll('thead th');
+        const columnNames = Array.from(headerCells).map(th => {
+            const className = th.className.replace('col-', '');
+            return className;
+        });
+        
+        for (let r = minRow; r <= maxRow; r++) {
+            const row = rows[r];
+            if (!row) continue;
+            
+            const rowIndex = parseInt(row.dataset.index);
+            const files = window.app.modules.store.getDisplayFiles();
+            const file = files[rowIndex];
+            if (!file) continue;
+            
+            const cells = row.children;
+            
+            for (let c = minCol; c <= maxCol; c++) {
+                const cell = cells[c];
+                if (!cell || !cell.classList.contains('cell-editable')) continue;
+                
+                const columnName = columnNames[c];
+                
+                // Clear the data
+                if (columnName === 'newFilename') {
+                    delete file.manualFilename;
+                } else {
+                    file[columnName] = '';
+                }
+                
+                file.isDirty = true;
+            }
+        }
+        
+        // Re-render
+        window.app.modules.spreadsheet.render();
+    }
+
+    /**
+     * Copy selection to clipboard via button click
+     */
+    function doCopy() {
+        if (!selectionStart || !selectionEnd) return;
+
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        const headers = getColumnHeaders(minCol, maxCol);
+        const data = getSelectionData();
+        if (!data) return;
+
+        const allRows = [headers, ...data];
+        const tsv = allRows.map(row => row.join('\t')).join('\n');
+        const html = rowsToHtml(allRows);
+
+        // Write both plain text and HTML to clipboard
+        const htmlBlob = new Blob([html], { type: 'text/html' });
+        const textBlob = new Blob([tsv], { type: 'text/plain' });
+        const item = new ClipboardItem({ 'text/html': htmlBlob, 'text/plain': textBlob });
+
+        navigator.clipboard.write([item]).then(() => {
+            showToast(`Copied ${data.length} row(s)`, 'success');
+        }).catch(err => {
+            // Fallback to plain text if ClipboardItem not supported
+            navigator.clipboard.writeText(tsv).then(() => {
+                showToast(`Copied ${data.length} row(s)`, 'success');
+            }).catch(err2 => {
+                console.error('Copy failed:', err2);
+            });
+        });
+    }
+
+    /**
+     * Paste from clipboard via button click
+     */
+    function doPaste() {
+        if (!selectionStart || !selectionEnd) return;
+
+        navigator.clipboard.readText().then(tsv => {
+            if (tsv) executePaste(tsv);
+        }).catch(err => {
+            console.error('Paste failed:', err);
+            alert('Cannot read clipboard. Use Ctrl+V instead, or grant clipboard permission.');
+        });
+    }
+
+    // Export module
+    window.app.modules.selection = {
+        init,
+        clearSelection,
+        hasSelection,
+        doCopy,
+        doPaste
+    };
+})();
diff --git a/classifier/js/sort.js b/classifier/js/sort.js
new file mode 100644
index 0000000..a16649d
--- /dev/null
+++ b/classifier/js/sort.js
@@ -0,0 +1,215 @@
+/**
+ * Sort Module
+ * Handles multi-column sorting for the spreadsheet
+ */
+(function() {
+    'use strict';
+
+    // Sort state: array of {column, direction}
+    let sortState = [];
+
+    /**
+     * Initialize sorting
+     */
+    function init() {
+        const table = window.app.dom.spreadsheet;
+        const headers = table.querySelectorAll('thead th');
+        
+        headers.forEach((th, index) => {
+            // Skip row number column
+            if (th.classList.contains('col-row-num')) return;
+            
+            // Skip if already initialized
+            if (th.querySelector('.sort-indicator')) return;
+            
+            // Make header clickable
+            th.style.cursor = 'pointer';
+            th.style.userSelect = 'none';
+            
+            // Add sort indicator container
+            const sortIndicator = document.createElement('span');
+            sortIndicator.className = 'sort-indicator';
+            
+            // Insert after the text node (before any br or filter)
+            const firstChild = th.firstChild;
+            if (firstChild && firstChild.nodeType === Node.TEXT_NODE) {
+                // Insert after text node
+                firstChild.after(sortIndicator);
+            } else {
+                // Prepend to header
+                th.insertBefore(sortIndicator, firstChild);
+            }
+            
+            // Click to sort (only add once)
+            const handleClick = (e) => {
+                // Don't sort if clicking on resizer or filter input
+                if (e.target.classList.contains('column-resizer')) return;
+                if (e.target.classList.contains('column-filter')) return;
+                
+                const columnName = th.className.replace('col-', '');
+                handleSort(columnName, e.ctrlKey || e.metaKey);
+            };
+            
+            th.addEventListener('click', handleClick);
+        });
+    }
+
+    /**
+     * Apply default sort (called after initial render)
+     */
+    function applyDefaultSort() {
+        const files = window.app.modules.store.getDisplayFiles();
+        if (files.length > 0) {
+            sortState = [{ column: 'original', direction: 'asc' }];
+            applySorts();
+            updateSortIndicators();
+        }
+    }
+
+    /**
+     * Handle sort click
+     */
+    function handleSort(columnName, multiSort) {
+        // Use store to toggle sort
+        window.app.modules.store.toggleSort(columnName, multiSort);
+    }
+
+    /**
+     * Apply sort to files array (pure function - doesn't mutate)
+     */
+    function applySortToFiles(files) {
+        if (sortState.length === 0) {
+            return files;
+        }
+        
+        return [...files].sort((a, b) => {
+            for (const sort of sortState) {
+                const result = compareValues(a, b, sort.column, sort.direction);
+                if (result !== 0) return result;
+            }
+            return 0;
+        });
+    }
+
+    /**
+     * Apply all sorts (legacy - triggers render)
+     */
+    function applySorts() {
+        window.app.modules.spreadsheet.render();
+    }
+    
+    /**
+     * Apply default sort
+     */
+    function applyDefaultSort() {
+        const files = window.app.modules.store.getDisplayFiles();
+        if (files.length > 0 && sortState.length === 0) {
+            sortState = [{ column: 'original', direction: 'asc' }];
+            window.app.modules.spreadsheet.render();
+        }
+    }
+    
+    /**
+     * Get current sort state
+     */
+    function getSortState() {
+        return sortState;
+    }
+    
+    /**
+     * Update sort indicators in headers
+     */
+    function updateIndicators() {
+        const table = window.app.dom.spreadsheet;
+        const headers = table.querySelectorAll('thead th');
+        
+        headers.forEach(th => {
+            const indicator = th.querySelector('.sort-indicator');
+            if (!indicator) return;
+            
+            const columnName = th.className.replace('col-', '');
+            const sortIndex = sortState.findIndex(s => s.column === columnName);
+            
+            if (sortIndex >= 0) {
+                const sort = sortState[sortIndex];
+                const arrow = sort.direction === 'asc' ? '▲' : '▼';
+                const priority = sortState.length > 1 ? (sortIndex + 1) : '';
+                indicator.textContent = ` ${arrow}${priority}`;
+                indicator.style.display = 'inline';
+            } else {
+                indicator.textContent = '';
+                indicator.style.display = 'none';
+            }
+        });
+    }
+
+    /**
+     * Compare two values for sorting
+     */
+    function compareValues(a, b, columnName, direction) {
+        let aVal, bVal;
+        
+        // Get values based on column
+        switch (columnName) {
+            case 'original':
+                aVal = a.originalFilename || '';
+                bVal = b.originalFilename || '';
+                break;
+            case 'extension':
+                aVal = a.extension || '';
+                bVal = b.extension || '';
+                break;
+            case 'new':
+            case 'newFilename':
+                aVal = a.manualFilename || window.app.modules.spreadsheet.computeNewFilename(a, 0);
+                bVal = b.manualFilename || window.app.modules.spreadsheet.computeNewFilename(b, 0);
+                break;
+            case 'trackingNumber':
+                aVal = a.trackingNumber || '';
+                bVal = b.trackingNumber || '';
+                break;
+            case 'revision':
+                aVal = a.revision || '';
+                bVal = b.revision || '';
+                break;
+            case 'status':
+                aVal = a.status || '';
+                bVal = b.status || '';
+                break;
+            case 'title':
+                aVal = a.title || '';
+                bVal = b.title || '';
+                break;
+            case 'sha256':
+                aVal = a.sha256 || '';
+                bVal = b.sha256 || '';
+                break;
+            default:
+                return 0;
+        }
+        
+        // Natural sort for strings (handles numbers within strings)
+        const comparison = aVal.localeCompare(bVal, undefined, { numeric: true, sensitivity: 'base' });
+        
+        return direction === 'asc' ? comparison : -comparison;
+    }
+
+    /**
+     * Clear all sorts
+     */
+    function clearSorts() {
+        sortState = [];
+        applySorts();
+    }
+
+    // Export module
+    window.app.modules.sort = {
+        init,
+        applyDefaultSort,
+        applySorts,
+        applySortToFiles,
+        updateIndicators,
+        getSortState,
+        clearSorts
+    };
+})();
diff --git a/classifier/js/spreadsheet.js b/classifier/js/spreadsheet.js
new file mode 100644
index 0000000..db4b00c
--- /dev/null
+++ b/classifier/js/spreadsheet.js
@@ -0,0 +1,942 @@
+/**
+ * Spreadsheet Module
+ * Handles table rendering, cell editing, and file operations
+ */
+(function() {
+    'use strict';
+
+    let editingCell = null;
+    let editingInput = null;
+
+    /**
+     * Render spreadsheet from store
+     */
+    function render() {
+        const tbody = window.app.dom.spreadsheetBody;
+        tbody.innerHTML = '';
+
+        // Get files from store (already filtered and sorted)
+        const files = window.app.modules.store.getDisplayFiles();
+
+        // Render rows
+        if (files.length === 0) {
+            const message = window.app.modules.store.getDisplayFiles().length === 0 
+                ? '<h3>No files to display</h3><p>Select one or more folders from the tree to view files</p>'
+                : '<h3>No files match filters</h3><p>Adjust or clear filters to see files</p>';
+            
+            tbody.innerHTML = `
+                <tr>
+                    <td colspan="10" class="spreadsheet-empty">
+                        ${message}
+                    </td>
+                </tr>
+            `;
+            return;
+        }
+
+        files.forEach((file, index) => {
+            const row = createRow(file, index);
+            tbody.appendChild(row);
+        });
+
+        // Update UI
+        window.app.modules.app.updateStats();
+        updateSortIndicators();
+
+        // Calculate SHA256 if enabled
+        if (window.app.calculateSha256) {
+            calculateSha256ForAll();
+        }
+    }
+
+    /**
+     * Update sort indicators
+     */
+    function updateSortIndicators() {
+        const sortColumns = window.app.modules.store.getSortColumns();
+        const headers = window.app.dom.spreadsheet.querySelectorAll('thead th');
+
+        headers.forEach(th => {
+            const indicator = th.querySelector('.sort-indicator');
+            if (!indicator) return;
+
+            const columnName = th.className.replace('col-', '');
+            const sortIndex = sortColumns.findIndex(s => s.column === columnName);
+
+            if (sortIndex >= 0) {
+                const sort = sortColumns[sortIndex];
+                const arrow = sort.direction === 'asc' ? '▲' : '▼';
+                const priority = sortColumns.length > 1 ? (sortIndex + 1) : '';
+                indicator.textContent = ` ${arrow}${priority}`;
+                indicator.style.display = 'inline';
+            } else {
+                indicator.textContent = '';
+                indicator.style.display = 'none';
+            }
+        });
+    }
+
+    /**
+     * Create a table row for a file
+     */
+    function createRow(file, index) {
+        const row = document.createElement('tr');
+        row.dataset.index = index;
+        row.dataset.folderPath = file.folderPath; // Store folder path for highlighting
+
+        // Add state classes
+        if (file.isDirty) row.classList.add('modified');
+        if (file.error) row.classList.add('error');
+        
+        // Highlight folder on hover
+        row.addEventListener('mouseenter', () => {
+            highlightFolder(file.folderPath);
+        });
+        
+        row.addEventListener('mouseleave', () => {
+            clearFolderHighlight();
+        });
+
+        // Row number
+        row.appendChild(createCell('row-num', index + 1, false));
+
+        // Original filename — plain text (selectable/copyable, no link)
+        const originalCell = createCell('original', file.originalFilename, false);
+        row.appendChild(originalCell);
+
+        // Extension — hyperlink to open the file
+        const extCell = createCell('extension', '', false);
+        const extLink = document.createElement('a');
+        extLink.className = 'cell-link';
+        extLink.textContent = file.extension;
+        extLink.title = 'Click to open file';
+        extLink.style.cursor = 'pointer';
+        extLink.addEventListener('click', async (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            openFile(file);
+        });
+        extCell.appendChild(extLink);
+        row.appendChild(extCell);
+
+        // Parse original filename to get ZDDC components (always)
+        // Pass full filename (name + extension) so the regex can match the .ext suffix
+        const parsed = zddc.parseFilename(zddc.joinExtension(file.originalFilename, file.extension)) || {};
+
+        // Fill any empty fields from parsed filename (per-field, not all-or-nothing)
+        // Must happen before computeNewFilename so all fields are available
+        if (!file.trackingNumber) file.trackingNumber = parsed.trackingNumber || '';
+        if (!file.revision) file.revision = parsed.revision || '';
+        if (!file.status)   file.status   = parsed.status   || '';
+        if (!file.title)    file.title    = parsed.title    || '';
+
+        // New filename: show only if it would actually change the file
+        const computedFilename = file.manualFilename || computeNewFilename(file, index);
+        const originalFullName = zddc.joinExtension(file.originalFilename, file.extension);
+        const wouldChange = computedFilename !== originalFullName;
+        const newFilenameDisplay = wouldChange ? computedFilename : '';
+        const newFilenameCell = createEditableCell('newFilename', newFilenameDisplay, index);
+        // Use computedFilename (not newFilenameDisplay) for validation
+        const newFilename = computedFilename;
+        if (!file.manualFilename) {
+            newFilenameCell.classList.add('computed');
+        }
+        
+        // Validate and show errors
+        const validation = window.app.modules.validator.validateFilename(newFilename);
+        if (!validation.isValid) {
+            newFilenameCell.classList.add('validation-error');
+            newFilenameCell.title = validation.errors.join('; ');
+        } else if (validation.warnings.length > 0) {
+            newFilenameCell.classList.add('validation-warning');
+            newFilenameCell.title = validation.warnings.join('; ');
+        }
+        
+        // Only show action buttons if row is dirty
+        if (file.isDirty) {
+            const actions = document.createElement('span');
+            actions.className = 'inline-actions';
+            
+            const saveBtn = document.createElement('button');
+            saveBtn.className = 'btn-inline btn-save';
+            saveBtn.textContent = '✓';
+            saveBtn.title = 'Save';
+            saveBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                saveFile(index);
+            });
+            
+            const cancelBtn = document.createElement('button');
+            cancelBtn.className = 'btn-inline btn-cancel';
+            cancelBtn.textContent = '✗';
+            cancelBtn.title = 'Clear all fields';
+            cancelBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                cancelFile(index);
+            });
+            
+            actions.appendChild(saveBtn);
+            actions.appendChild(cancelBtn);
+            newFilenameCell.appendChild(actions);
+        }
+        
+        row.appendChild(newFilenameCell);
+
+        // For each field: use file value (already populated above) for display
+        const displayTracking = file.trackingNumber || '';
+        const displayRevision = file.revision || '';
+        const displayStatus   = file.status   || '';
+        const displayTitle    = file.title    || '';
+
+        const trackingCell = createEditableCell('trackingNumber', displayTracking, index);
+        const revisionCell = createEditableCell('revision', displayRevision, index);
+        const statusCell   = createEditableCell('status',   displayStatus,   index);
+        const titleCell    = createEditableCell('title',    displayTitle,    index);
+
+        // Gray = field value matches what the original filename parses to (no change)
+        // Blue = field value differs from the parsed original (would produce a different filename)
+        if (displayTracking === (parsed.trackingNumber || '')) trackingCell.classList.add('auto-populated');
+        else trackingCell.classList.add('field-changed');
+        if (displayRevision === (parsed.revision || '')) revisionCell.classList.add('auto-populated');
+        else revisionCell.classList.add('field-changed');
+        if (displayStatus === (parsed.status || '')) statusCell.classList.add('auto-populated');
+        else statusCell.classList.add('field-changed');
+        if (displayTitle === (parsed.title || '')) titleCell.classList.add('auto-populated');
+        else titleCell.classList.add('field-changed');
+        
+        row.appendChild(trackingCell);
+        row.appendChild(revisionCell);
+        row.appendChild(statusCell);
+        row.appendChild(titleCell);
+
+        // SHA256 (if enabled)
+        if (window.app.calculateSha256) {
+            const sha256Cell = createCell('sha256', file.sha256 || 'calculating...', false);
+            if (!file.sha256) {
+                sha256Cell.classList.add('sha256-calculating');
+            }
+            row.appendChild(sha256Cell);
+        }
+
+        return row;
+    }
+
+    /**
+     * Create a table cell
+     */
+    function createCell(className, content, editable = false) {
+        const td = document.createElement('td');
+        td.className = `col-${className}`;
+        td.textContent = content;
+        return td;
+    }
+
+    /**
+     * Create an editable cell
+     */
+    function createEditableCell(columnName, value, rowIndex) {
+        const td = document.createElement('td');
+        td.className = `col-${columnName} cell-editable`;
+        td.textContent = value;
+        
+        // Double-click to edit
+        td.addEventListener('dblclick', (e) => {
+            e.stopPropagation();
+            startEditing(td, columnName, rowIndex);
+        });
+        
+        return td;
+    }
+
+
+    /**
+     * Start editing a cell
+     */
+    function startEditing(cell, columnName, rowIndex) {
+        // Cancel any existing edit
+        if (editingCell) {
+            cancelEditing();
+        }
+
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        if (!file) return;
+        
+        const currentValue = file[columnName] || '';
+
+        // Clear any cell selection
+        if (window.app.modules.selection) {
+            window.app.modules.selection.clearSelection();
+        }
+
+        // Store references
+        editingCell = { cell, columnName, rowIndex, originalValue: currentValue };
+
+        // Save original content and make cell contenteditable
+        cell.dataset.originalContent = cell.innerHTML;
+        cell.contentEditable = 'true';
+        cell.classList.add('editing');
+        editingInput = cell;
+
+        // Set content (text only for editing)
+        cell.textContent = currentValue;
+
+        // Focus and select all
+        cell.focus();
+        
+        // Select all text — guard against cell being detached from document
+        // (can happen if a re-render fires between dblclick and this point)
+        if (document.contains(cell)) {
+            const range = document.createRange();
+            range.selectNodeContents(cell);
+            const selection = window.getSelection();
+            selection.removeAllRanges();
+            selection.addRange(range);
+        }
+
+        // Event listeners
+        cell.addEventListener('blur', handleBlur, { once: true });
+        cell.addEventListener('keydown', handleKeyDown);
+    }
+
+    /**
+     * Handle blur event
+     */
+    function handleBlur() {
+        // Small delay to allow click events to fire first
+        setTimeout(() => finishEditing(), 100);
+    }
+
+    /**
+     * Handle keydown in contenteditable
+     */
+    function handleKeyDown(e) {
+        if (e.key === 'Enter') {
+            // Enter exits edit mode
+            e.preventDefault();
+            finishEditing();
+        } else if (e.key === 'Escape') {
+            // Escape undoes and exits edit mode
+            e.preventDefault();
+            cancelEditing();
+        } else if (e.key === 'Tab') {
+            // Tab/Shift+Tab moves to next/prev cell
+            e.preventDefault();
+            const { rowIndex, columnName } = editingCell || {};
+            const shiftKey = e.shiftKey;
+            finishEditingQuiet();  // Don't trigger store update
+            if (rowIndex !== undefined) {
+                if (shiftKey) {
+                    moveToPreviousCell(rowIndex, columnName);
+                } else {
+                    moveToNextCell(rowIndex, columnName);
+                }
+            }
+        } else if (e.key === 'ArrowUp') {
+            e.preventDefault();
+            const { rowIndex, columnName } = editingCell || {};
+            finishEditingQuiet();
+            if (rowIndex !== undefined) {
+                moveUpRow(rowIndex, columnName);
+            }
+        } else if (e.key === 'ArrowDown') {
+            e.preventDefault();
+            const { rowIndex, columnName } = editingCell || {};
+            finishEditingQuiet();
+            if (rowIndex !== undefined) {
+                moveDownRow(rowIndex, columnName);
+            }
+        } else if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') {
+            // Allow normal cursor movement within cell
+            e.stopPropagation();
+        }
+    }
+
+    /**
+     * Finish editing and save value
+     */
+    function finishEditing() {
+        if (!editingCell || !editingInput) return;
+
+        const { cell, columnName, rowIndex } = editingCell;
+        const newValue = editingInput.textContent.trim();
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        if (!file) return;
+        
+        const oldValue = file[columnName] || '';
+
+        // Remove contenteditable
+        editingInput.contentEditable = 'false';
+        editingInput.classList.remove('editing');
+        editingInput.removeEventListener('keydown', handleKeyDown);
+
+        // Update file data if changed
+        if (newValue !== oldValue) {
+            // Special handling for newFilename column
+            if (columnName === 'newFilename') {
+                if (newValue) {
+                    window.app.modules.store.updateFileField(rowIndex, 'manualFilename', newValue);
+                } else {
+                    window.app.modules.store.updateFile(rowIndex, { manualFilename: null });
+                }
+            } else {
+                window.app.modules.store.updateFileField(rowIndex, columnName, newValue);
+            }
+
+            const updatedFile = window.app.modules.store.getDisplayFiles()[rowIndex];
+            validateFile(updatedFile);
+        }
+
+        editingCell = null;
+        editingInput = null;
+    }
+    
+    /**
+     * Finish editing without triggering store update (for Tab/Arrow navigation)
+     */
+    function finishEditingQuiet() {
+        if (!editingCell || !editingInput) return;
+
+        const { columnName, rowIndex } = editingCell;
+        const newValue = editingInput.textContent.trim();
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        
+        // Remove contenteditable
+        editingInput.contentEditable = 'false';
+        editingInput.classList.remove('editing');
+        editingInput.removeEventListener('keydown', handleKeyDown);
+
+        // Update file object directly (no store notification)
+        if (file) {
+            if (columnName === 'newFilename') {
+                file.manualFilename = newValue || null;
+            } else {
+                file[columnName] = newValue;
+            }
+            file.isDirty = true;
+        }
+
+        editingCell = null;
+        editingInput = null;
+    }
+
+    /**
+     * Cancel editing without saving
+     */
+    function cancelEditing() {
+        if (!editingCell) return;
+
+        const { rowIndex } = editingCell;
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        if (!file) return;
+
+        // Clear editing state
+        editingCell = null;
+        editingInput = null;
+
+        // Re-render the row
+        const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex}"]`);
+        if (row) {
+            const newRow = createRow(file, rowIndex);
+            row.replaceWith(newRow);
+        }
+    }
+
+    /**
+     * Move to next editable cell
+     */
+    function moveToNextCell(rowIndex, currentColumn) {
+        const columns = ['newFilename', 'trackingNumber', 'revision', 'status', 'title'];
+        const currentIndex = columns.indexOf(currentColumn);
+        
+        if (currentIndex < columns.length - 1) {
+            // Next column in same row
+            const nextColumn = columns[currentIndex + 1];
+            const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex}"]`);
+            const nextCell = row.querySelector(`.col-${nextColumn}`);
+            if (nextCell) {
+                startEditing(nextCell, nextColumn, rowIndex);
+            }
+        } else if (rowIndex < window.app.modules.store.getDisplayFiles().length - 1) {
+            // First column of next row
+            const nextColumn = columns[0];
+            const nextRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex + 1}"]`);
+            const nextCell = nextRow.querySelector(`.col-${nextColumn}`);
+            if (nextCell) {
+                startEditing(nextCell, nextColumn, rowIndex + 1);
+            }
+        }
+    }
+
+    /**
+     * Move to previous editable cell
+     */
+    function moveToPreviousCell(rowIndex, currentColumn) {
+        const columns = ['newFilename', 'trackingNumber', 'revision', 'status', 'title'];
+        const currentIndex = columns.indexOf(currentColumn);
+        
+        if (currentIndex > 0) {
+            // Previous column in same row
+            const prevColumn = columns[currentIndex - 1];
+            const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex}"]`);
+            const prevCell = row.querySelector(`.col-${prevColumn}`);
+            if (prevCell) {
+                startEditing(prevCell, prevColumn, rowIndex);
+            }
+        } else if (rowIndex > 0) {
+            // Last column of previous row
+            const prevColumn = columns[columns.length - 1];
+            const prevRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex - 1}"]`);
+            const prevCell = prevRow.querySelector(`.col-${prevColumn}`);
+            if (prevCell) {
+                startEditing(prevCell, prevColumn, rowIndex - 1);
+            }
+        }
+    }
+
+    /**
+     * Move up one row, same column
+     */
+    function moveUpRow(rowIndex, currentColumn) {
+        if (rowIndex > 0) {
+            const prevRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex - 1}"]`);
+            const cell = prevRow.querySelector(`.col-${currentColumn}`);
+            if (cell) {
+                startEditing(cell, currentColumn, rowIndex - 1);
+            }
+        }
+    }
+
+    /**
+     * Move down one row, same column
+     */
+    function moveDownRow(rowIndex, currentColumn) {
+        if (rowIndex < window.app.modules.store.getDisplayFiles().length - 1) {
+            const nextRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex + 1}"]`);
+            const cell = nextRow.querySelector(`.col-${currentColumn}`);
+            if (cell) {
+                startEditing(cell, currentColumn, rowIndex + 1);
+            }
+        }
+    }
+
+    function computeNewFilename(file) {
+        return window.app.modules.utils.computeNewFilename(file);
+    }
+
+    /**
+     * Validate a file
+     */
+    function validateFile(file) {
+        const newFilename = computeNewFilename(file, 0);
+        const validation = window.app.modules.validator.validateFilename(newFilename);
+        
+        file.validation = validation;
+        file.error = !validation.isValid;
+    }
+
+    /**
+     * Open file in new tab
+     */
+    async function openFile(file) {
+        try {
+            let blob;
+            if (file.isVirtual) {
+                // Virtual file from ZIP - get from cache
+                const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+                if (!cached) throw new Error('ZIP not found in cache');
+                const zipEntry = cached.zip.file(file.zipEntryPath);
+                if (!zipEntry) throw new Error('File not found in ZIP');
+                const arrayBuffer = await zipEntry.async('arraybuffer');
+                const mimeType = getMimeType(file.extension);
+                blob = new Blob([arrayBuffer], { type: mimeType });
+            } else {
+                blob = await file.handle.getFile();
+            }
+            const url = URL.createObjectURL(blob);
+            window.open(url, '_blank');
+            
+            // Clean up URL after a delay
+            setTimeout(() => URL.revokeObjectURL(url), 60000);
+        } catch (err) {
+            console.error('Error opening file:', err);
+            alert('Cannot open file: ' + err.message);
+        }
+    }
+    
+    function getMimeType(extension) {
+        return window.app.modules.utils.getMimeType(extension);
+    }
+
+    /**
+     * Save a single file
+     */
+    async function saveFile(index, skipValidation = false) {
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[index];
+        if (!file.isDirty) {
+
+            return;
+        }
+        
+        // Virtual files (from ZIPs) cannot be renamed - must extract first
+        if (file.isVirtual) {
+            alert('Cannot rename files inside ZIP archives.\nExtract the ZIP first to rename files.');
+            return;
+        }
+
+        const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${index}"]`);
+        if (!row) {
+            console.error(`Row not found for index ${index}`);
+            return;
+        }
+        row.classList.add('saving');
+
+        try {
+            const newFilename = computeNewFilename(file, index);
+            const currentFilename = zddc.joinExtension(file.originalFilename, file.extension);
+            
+            // Check if already has correct name
+            if (currentFilename === newFilename) {
+
+                row.classList.remove('saving');
+                
+                // Just clear dirty flag and fields
+                file.isDirty = false;
+                file.error = false;
+                delete file.manualFilename;
+                file.trackingNumber = '';
+                file.revision = '';
+                file.status = '';
+                file.title = '';
+                
+                const newRow = createRow(file, index);
+                row.replaceWith(newRow);
+                window.app.modules.app.updateStats();
+                return;
+            }
+            
+            // Validate filename
+            if (!skipValidation) {
+                const validation = window.app.modules.validator.validateFilename(newFilename);
+                if (!validation.isValid) {
+                    const errors = validation.errors.join('\n');
+                    const confirmed = confirm(
+                        `⚠️ Warning: Filename is not ZDDC compliant!\n\n` +
+                        `Errors:\n${errors}\n\n` +
+                        `Current filename: ${newFilename}\n\n` +
+                        `Do you want to save it anyway?`
+                    );
+                    
+                    if (!confirmed) {
+                        row.classList.remove('saving');
+                        return;
+                    }
+                }
+            }
+            
+            // Request write permission for the folder
+            const folderPermission = await file.folderHandle.queryPermission({ mode: 'readwrite' });
+            if (folderPermission !== 'granted') {
+                const granted = await file.folderHandle.requestPermission({ mode: 'readwrite' });
+                if (granted !== 'granted') {
+                    throw new Error('Write permission denied');
+                }
+            }
+            
+            // Rename by copying to new name and deleting old (more reliable than move)
+            const oldFilename = zddc.joinExtension(file.originalFilename, file.extension);
+
+            
+            try {
+                // Get fresh handle for old file
+                const oldHandle = await file.folderHandle.getFileHandle(oldFilename);
+                
+                // Read the file content
+                const fileData = await oldHandle.getFile();
+                
+                // Create new file with new name
+                const newHandle = await file.folderHandle.getFileHandle(newFilename, { create: true });
+                const writable = await newHandle.createWritable();
+                await writable.write(fileData);
+                await writable.close();
+                
+                // Delete old file
+                await file.folderHandle.removeEntry(oldFilename);
+                
+                // Update file handle
+                file.handle = newHandle;
+
+            } catch (err) {
+                console.error(`Failed to rename file:`, err);
+                throw err;
+            }
+            
+            // Update file data directly (don't trigger store notification during batch save)
+            file.originalFilename = zddc.splitExtension(newFilename).name;
+            file.isDirty = false;
+            file.error = false;
+            file.manualFilename = null;
+            file.trackingNumber = '';
+            file.revision = '';
+            file.status = '';
+            file.title = '';
+            file.autoPopulated = false;
+            
+            // Update row UI
+            row.classList.remove('saving');
+            const newRow = createRow(file, index);
+            row.replaceWith(newRow);
+            
+        } catch (err) {
+            console.error('Error saving file:', err);
+            file.error = true;
+            file.errorMessage = err.message;
+            row.classList.remove('saving');
+            row.classList.add('error');
+            // Re-throw so caller can handle
+            throw err;
+        }
+    }
+
+    /**
+     * Cancel/Clear all fields for a single file
+     */
+    function cancelFile(index) {
+        // Clear all fields through store
+        window.app.modules.store.updateFile(index, {
+            trackingNumber: '',
+            revision: '',
+            status: '',
+            title: '',
+            manualFilename: null,
+            isDirty: false,
+            error: false,
+            validation: null,
+            autoPopulated: false
+        });
+    }
+
+    /**
+     * Save all modified files (only ZDDC-compliant ones)
+     */
+    async function saveAllFiles() {
+        const files = window.app.modules.store.getDisplayFiles();
+        const modifiedFiles = files
+            .map((file, index) => ({ file, index }))
+            .filter(({ file }) => file.isDirty);
+
+        if (modifiedFiles.length === 0) {
+            alert('No modified files to save.');
+            return;
+        }
+
+        let successCount = 0;
+        let skippedCount = 0;
+        let errorCount = 0;
+        const errors = [];
+        const skipped = [];
+
+        for (let i = 0; i < modifiedFiles.length; i++) {
+            const { file, index } = modifiedFiles[i];
+            
+            try {
+                // Add small delay between operations to prevent race conditions
+                if (i > 0) {
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                }
+                
+                // Validate before saving
+                const newFilename = computeNewFilename(file, index);
+                const currentFilename = zddc.joinExtension(file.originalFilename, file.extension);
+                
+
+                
+                const validation = window.app.modules.validator.validateFilename(newFilename);
+                
+                if (!validation.isValid) {
+                    // Skip non-compliant files in Save All
+                    skippedCount++;
+                    skipped.push(`${zddc.joinExtension(file.originalFilename, file.extension)}: ${validation.errors[0]}`);
+
+                    continue;
+                }
+                
+                // Check if already has correct name
+                if (currentFilename === newFilename) {
+
+                    // Just clear dirty flag
+                    file.isDirty = false;
+                    file.error = false;
+                    delete file.manualFilename;
+                    file.trackingNumber = '';
+                    file.revision = '';
+                    file.status = '';
+                    file.title = '';
+                    successCount++;
+                    continue;
+                }
+                
+                // Save with validation already done - ensure properly awaited
+                try {
+                    await saveFile(index, true);
+                    successCount++;
+
+                } catch (saveErr) {
+                    console.error(`Error saving file ${index}:`, saveErr);
+                    errorCount++;
+                    errors.push(`${zddc.joinExtension(file.originalFilename, file.extension)}: ${saveErr.message}`);
+                    
+                    // Add delay after errors to let filesystem stabilize
+                    await new Promise(resolve => setTimeout(resolve, 300));
+                }
+            } catch (err) {
+                console.error(`Error processing file ${index}:`, err);
+                errorCount++;
+                errors.push(`${file.originalFilename}${file.extension}: ${err.message}`);
+            }
+        }
+
+        // Trigger store notification to update UI after all saves
+        window.app.modules.store.notify('files');
+        
+        let message = `Saved ${successCount} compliant file(s).`;
+        
+        if (skippedCount > 0) {
+            message += `\n\n⚠️ Skipped ${skippedCount} non-compliant file(s):`;
+            message += `\n${skipped.slice(0, 3).join('\n')}`;
+            if (skipped.length > 3) {
+                message += `\n... and ${skipped.length - 3} more`;
+            }
+            message += `\n\nUse individual save buttons (✓) to save non-compliant files.`;
+        }
+        
+        if (errorCount > 0) {
+            message += `\n\n❌ ${errorCount} error(s):`;
+            message += `\n${errors.slice(0, 3).join('\n')}`;
+            if (errors.length > 3) {
+                message += `\n... and ${errors.length - 3} more`;
+            }
+        }
+        
+        alert(message);
+    }
+
+    /**
+     * Cancel all changes
+     */
+    function cancelAllChanges() {
+        const files = window.app.modules.store.getDisplayFiles();
+        files.forEach((file, index) => {
+            if (file.isDirty) {
+                cancelFile(index);
+            }
+        });
+    }
+
+    /**
+     * Calculate SHA256 for all files
+     */
+    async function calculateSha256ForAll() {
+        const files = window.app.modules.store.getDisplayFiles();
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            if (!file.sha256) {
+                calculateSha256(file, i);
+            }
+        }
+    }
+
+    /**
+     * Calculate SHA256 for a single file
+     */
+    async function calculateSha256(file, index) {
+        try {
+            let hashHex;
+            if (file.isVirtual) {
+                // Virtual file from ZIP
+                const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+                if (!cached) throw new Error('ZIP not found in cache');
+                const zipEntry = cached.zip.file(file.zipEntryPath);
+                if (!zipEntry) throw new Error('File not found in ZIP');
+                const buffer = await zipEntry.async('arraybuffer');
+                hashHex = await zddc.crypto.sha256Hex(buffer);
+            } else {
+                const fileObj = await file.handle.getFile();
+                hashHex = await zddc.crypto.sha256File(fileObj);
+            }
+
+            file.sha256 = hashHex;
+            
+            // Update cell
+            const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${index}"]`);
+            if (row) {
+                const sha256Cell = row.querySelector('.col-sha256');
+                if (sha256Cell) {
+                    sha256Cell.textContent = hashHex.substring(0, 16) + '...';
+                    sha256Cell.title = hashHex;
+                    sha256Cell.classList.remove('sha256-calculating');
+                }
+            }
+        } catch (err) {
+            console.error('Error calculating SHA256:', err);
+        }
+    }
+
+    /**
+     * Highlight folder in tree when hovering over file
+     */
+    function highlightFolder(folderPath) {
+        if (!folderPath) return;
+        
+        // Find folder in tree
+        const folderTree = document.getElementById('folderTree');
+        if (!folderTree) return;
+        
+        // Find the folder item by data-path attribute
+        const folderItem = folderTree.querySelector(`[data-path="${folderPath}"]`);
+        if (!folderItem) return;
+        
+        // Add highlight class
+        folderItem.classList.add('folder-hover-highlight');
+        
+        // Scroll into view if autoscroll is enabled
+        const autoScrollCheckbox = document.getElementById('autoScrollCheckbox');
+        if (autoScrollCheckbox && autoScrollCheckbox.checked) {
+            folderItem.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+        }
+    }
+    
+    /**
+     * Clear folder highlight
+     */
+    function clearFolderHighlight() {
+        const folderTree = document.getElementById('folderTree');
+        if (!folderTree) return;
+        
+        // Remove all highlights
+        const highlighted = folderTree.querySelectorAll('.folder-hover-highlight');
+        highlighted.forEach(el => el.classList.remove('folder-hover-highlight'));
+    }
+
+    /**
+     * Initialize spreadsheet - subscribe to store
+     */
+    function init() {
+        // Subscribe to store changes (only call this after DOM is ready)
+        window.app.modules.store.on('files', render);
+    }
+
+    // Export module
+    window.app.modules.spreadsheet = {
+        init,
+        render,
+        computeNewFilename,
+        saveAllFiles,
+        cancelAllChanges,
+        cancelEditing
+    };
+})();
diff --git a/classifier/js/store.js b/classifier/js/store.js
new file mode 100644
index 0000000..0bd30c2
--- /dev/null
+++ b/classifier/js/store.js
@@ -0,0 +1,451 @@
+/**
+ * Store Module
+ * Single source of truth for all application state
+ * Manages files, folders, sorting, filtering
+ */
+(function() {
+    'use strict';
+
+    // State
+    const state = {
+        // Directory structure
+        rootHandle: null,
+        folderTree: [],
+        selectedFolders: new Set(),
+        
+        // Files
+        allFiles: [],           // All files from selected folders
+        displayFiles: [],       // After sorting and filtering
+        
+        // Sort state
+        sortColumns: [],        // [{column: 'original', direction: 'asc'}]
+        
+        // Filter state
+        filters: {},            // {columnName: AST (from zddc.filter.parse)}
+        
+        // UI state
+        hideCompliant: false,
+        calculateSha256: false
+    };
+
+    // Listeners for state changes
+    const listeners = {
+        'files': [],
+        'folders': [],
+        'sort': [],
+        'filter': []
+    };
+
+    /**
+     * Set sort columns
+     */
+    function on(event, callback) {
+        if (listeners[event]) {
+            listeners[event].push(callback);
+        }
+    }
+
+    /**
+     * Notify listeners of state change
+     */
+    function notify(event) {
+        if (listeners[event]) {
+            listeners[event].forEach(cb => cb());
+        }
+    }
+
+    /**
+     * Set root directory handle
+     */
+    function setRootHandle(handle) {
+        state.rootHandle = handle;
+    }
+
+    /**
+     * Set folder tree
+     */
+    function setFolderTree(tree) {
+        state.folderTree = tree;
+        notify('folders');
+    }
+
+    /**
+     * Select/deselect folder
+     */
+    function toggleFolder(folderPath) {
+        if (state.selectedFolders.has(folderPath)) {
+            state.selectedFolders.delete(folderPath);
+        } else {
+            state.selectedFolders.add(folderPath);
+        }
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Select multiple folders
+     */
+    function setSelectedFolders(folderPaths) {
+        state.selectedFolders.clear();
+        folderPaths.forEach(path => state.selectedFolders.add(path));
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Load files from selected folders
+     */
+    function loadFilesFromSelectedFolders() {
+        state.allFiles = [];
+
+        if (state.selectedFolders.size === 0) {
+            updateDisplayFiles();
+            return;
+        }
+
+        // Collect files from selected folders
+        for (const folderPath of state.selectedFolders) {
+            const folder = findFolderByPath(folderPath);
+            if (folder && folder.files) {
+                const files = folder.files.filter(f => !f.isDirectory);
+                state.allFiles.push(...files);
+            }
+        }
+
+        // Apply default sort if no sort set
+        if (state.sortColumns.length === 0) {
+            state.sortColumns = [{ column: 'original', direction: 'asc' }];
+        }
+
+        updateDisplayFiles();
+    }
+
+    /**
+     * Find folder by path in tree
+     */
+    function findFolderByPath(path) {
+        function search(folders) {
+            for (const folder of folders) {
+                if (folder.path === path) return folder;
+                if (folder.children) {
+                    const found = search(folder.children);
+                    if (found) return found;
+                }
+            }
+            return null;
+        }
+        return search(state.folderTree);
+    }
+
+    /**
+     * Update display files (apply sort, filter, hide compliant)
+     */
+    function updateDisplayFiles() {
+        let files = [...state.allFiles];
+
+        // Apply filters
+        files = applyFilters(files);
+
+        // Apply hide compliant
+        if (state.hideCompliant) {
+            files = files.filter(file => {
+                const newFilename = computeNewFilename(file);
+                const validation = validateFilename(newFilename);
+                return !validation.isValid;
+            });
+        }
+
+        // Apply sort
+        files = applySort(files);
+
+        state.displayFiles = files;
+        notify('files');
+    }
+
+    /**
+     * Apply filters to files using zddc.filter ASTs
+     */
+    function applyFilters(files) {
+        if (Object.keys(state.filters).length === 0) {
+            return files;
+        }
+
+        return files.filter(file => {
+            for (const [columnName, ast] of Object.entries(state.filters)) {
+                const value = getColumnValue(file, columnName);
+                if (!window.zddc.filter.matches(value, ast)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+
+    /**
+     * Apply sort to files
+     */
+    function applySort(files) {
+        if (state.sortColumns.length === 0) {
+            return files;
+        }
+
+        return files.sort((a, b) => {
+            for (const sort of state.sortColumns) {
+                const result = compareValues(a, b, sort.column, sort.direction);
+                if (result !== 0) return result;
+            }
+            return 0;
+        });
+    }
+
+    /**
+     * Compare two values for sorting
+     */
+    function compareValues(a, b, columnName, direction) {
+        let aVal = getColumnValue(a, columnName);
+        let bVal = getColumnValue(b, columnName);
+
+        const comparison = String(aVal).localeCompare(String(bVal), undefined, {
+            numeric: true,
+            sensitivity: 'base'
+        });
+
+        return direction === 'asc' ? comparison : -comparison;
+    }
+
+    /**
+     * Get column value from file (delegates to utils)
+     */
+    function getColumnValue(file, columnName) {
+        return window.app.modules.utils.getColumnValue(file, columnName);
+    }
+
+    function computeNewFilename(file) {
+        return window.app.modules.utils.computeNewFilename(file);
+    }
+
+    /**
+     * Validate filename
+     */
+    function validateFilename(filename) {
+        // Use existing validator module
+        if (window.app.modules.validator) {
+            return window.app.modules.validator.validateFilename(filename);
+        }
+        return { isValid: true, errors: [], warnings: [] };
+    }
+
+    /**
+     * Match filter text against value
+     */
+    function matchesFilter(value, filterText) {
+        // Simple contains for now - can enhance later
+        return String(value).toLowerCase().includes(filterText.toLowerCase());
+    }
+
+    /**
+     * Set sort columns
+     */
+    function setSortColumns(columns) {
+        state.sortColumns = columns;
+        updateDisplayFiles();
+    }
+
+    /**
+     * Toggle sort on column
+     */
+    function toggleSort(columnName, multiSort) {
+        if (!multiSort) {
+            state.sortColumns = [];
+        }
+
+        const existingIndex = state.sortColumns.findIndex(s => s.column === columnName);
+
+        if (existingIndex >= 0) {
+            const current = state.sortColumns[existingIndex];
+            if (current.direction === 'asc') {
+                current.direction = 'desc';
+            } else {
+                state.sortColumns.splice(existingIndex, 1);
+            }
+        } else {
+            state.sortColumns.push({ column: columnName, direction: 'asc' });
+        }
+
+        updateDisplayFiles();
+        notify('sort');
+    }
+
+    /**
+     * Set filter for column. ast is the pre-parsed zddc.filter AST.
+     */
+    function setFilter(columnName, filterText, ast) {
+        if (filterText && ast && ast.length > 0) {
+            state.filters[columnName] = ast;
+        } else {
+            delete state.filters[columnName];
+        }
+        updateDisplayFiles();
+    }
+
+    /**
+     * Replace all filters at once. filtersObj is {columnName: rawString}.
+     * Parses each value. Pass {} to clear all filters.
+     */
+    function setAllFilters(filtersObj) {
+        state.filters = {};
+        for (const [columnName, raw] of Object.entries(filtersObj)) {
+            if (raw) {
+                const ast = window.zddc.filter.parse(raw);
+                if (ast && ast.length > 0) {
+                    state.filters[columnName] = ast;
+                }
+            }
+        }
+        updateDisplayFiles();
+    }
+
+    /**
+     * Set hide compliant flag
+     */
+    function setHideCompliant(hide) {
+        state.hideCompliant = hide;
+        updateDisplayFiles();
+    }
+
+    /**
+     * Update file data
+     */
+    function updateFile(index, updates) {
+        const file = state.displayFiles[index];
+        if (!file) return;
+
+        // Apply updates
+        Object.assign(file, updates);
+        
+        // Mark as dirty unless explicitly set to false
+        if (updates.isDirty !== false) {
+            file.isDirty = true;
+        }
+
+        // Notify listeners (will trigger re-render)
+        notify('files');
+    }
+    
+    /**
+     * Update file field (for editing)
+     */
+    function updateFileField(index, fieldName, value) {
+        const file = state.displayFiles[index];
+        if (!file) return;
+        
+        file[fieldName] = value;
+        file.autoPopulated = false; // Clear auto-populated flag
+
+        // Re-evaluate dirty: if every field still matches the parsed original,
+        // and there is no manual filename override, the file is clean again.
+        file.isDirty = _isFileDirty(file);
+        
+        // Notify listeners
+        notify('files');
+    }
+
+    /**
+     * A file is dirty if its computed filename differs from the original,
+     * or if it has a manual filename override.
+     */
+    function _isFileDirty(file) {
+        if (file.manualFilename) return true;
+        const computed = zddc.formatFilename({
+            trackingNumber: file.trackingNumber || '',
+            revision:       file.revision || '',
+            status:         file.status   || '',
+            title:          file.title    || '',
+            extension:      file.extension || '',
+        });
+        const original = zddc.joinExtension(file.originalFilename, file.extension);
+        // If formatFilename returns '' (missing fields) fall back to original — not dirty
+        return computed !== '' && computed !== original;
+    }
+
+    /**
+     * Get display files (what should be shown in table)
+     */
+    function getDisplayFiles() {
+        return state.displayFiles;
+    }
+
+    /**
+     * Get all files (unfiltered)
+     */
+    function getAllFiles() {
+        return state.allFiles;
+    }
+
+    /**
+     * Get sort columns
+     */
+    function getSortColumns() {
+        return state.sortColumns;
+    }
+
+    /**
+     * Get selected folder count
+     */
+    function getSelectedFolderCount() {
+        return state.selectedFolders.size;
+    }
+
+    /**
+     * Get state (read-only)
+     */
+    function getState() {
+        return {
+            rootHandle: state.rootHandle,
+            folderTree: state.folderTree,
+            selectedFolders: Array.from(state.selectedFolders),
+            allFiles: state.allFiles,
+            displayFiles: state.displayFiles,
+            sortColumns: state.sortColumns,
+            filters: state.filters,
+            hideCompliant: state.hideCompliant
+        };
+    }
+
+    /**
+     * Reset all state
+     */
+    function reset() {
+        state.rootHandle = null;
+        state.folderTree = [];
+        state.selectedFolders.clear();
+        state.allFiles = [];
+        state.displayFiles = [];
+        state.sortColumns = [];
+        state.filters = {};
+        state.hideCompliant = false;
+        
+        notify('files');
+        notify('folders');
+    }
+
+    // Export
+    window.app.modules.store = {
+        on,
+        notify,
+        setRootHandle,
+        setFolderTree,
+        toggleFolder,
+        setSelectedFolders,
+        toggleSort,
+        setFilter,
+        setAllFilters,
+        setHideCompliant,
+        updateFile,
+        updateFileField,
+        getDisplayFiles,
+        getAllFiles,
+        getSortColumns,
+        getSelectedFolderCount,
+        getState,
+        reset
+    };
+})();
diff --git a/classifier/js/tree.js b/classifier/js/tree.js
new file mode 100644
index 0000000..8a886ec
--- /dev/null
+++ b/classifier/js/tree.js
@@ -0,0 +1,520 @@
+/**
+ * Folder Tree Module
+ * Handles folder tree rendering and multi-select
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Render the folder tree
+     */
+    function render() {
+        const container = window.app.dom.folderTree;
+        container.innerHTML = '';
+
+        if (window.app.folderTree.length === 0) {
+            container.innerHTML = '<div class="empty-state">No folders found</div>';
+            return;
+        }
+
+        window.app.folderTree.forEach(folder => {
+            const element = createFolderElement(folder);
+            container.appendChild(element);
+        });
+
+        updateSelectedCount();
+    }
+
+    /**
+     * Create a folder element
+     */
+    function createFolderElement(folder, level = 0) {
+        const div = document.createElement('div');
+        
+        const item = document.createElement('div');
+        item.className = 'folder-item';
+        item.dataset.path = folder.path;
+        item.style.paddingLeft = `${level * 1.5}rem`;
+
+        // Check if selected
+        if (window.app.selectedFolders.has(folder.path)) {
+            item.classList.add('selected');
+        }
+
+        // Toggle button (if has children)
+        const toggle = document.createElement('span');
+        toggle.className = 'folder-toggle';
+        if (folder.children && folder.children.length > 0) {
+            toggle.textContent = folder.expanded ? '▼' : '▶';
+            toggle.addEventListener('click', (e) => {
+                e.stopPropagation();
+                const recursive = e.ctrlKey || e.metaKey;
+                toggleFolder(folder, recursive);
+            });
+        } else {
+            toggle.textContent = ' ';
+        }
+        item.appendChild(toggle);
+
+        // Folder icon (different for ZIP files)
+        const icon = document.createElement('span');
+        icon.className = 'folder-icon';
+        if (folder.isZipRoot) {
+            icon.innerHTML = '&#128230;';  // 📦
+        } else if (folder.isVirtualDir) {
+            icon.innerHTML = '&#128194;';  // 📂
+        } else {
+            icon.innerHTML = '&#128193;';  // 📁
+        }
+        item.appendChild(icon);
+
+        // Folder name
+        const name = document.createElement('span');
+        name.className = 'folder-name';
+        name.textContent = folder.name;
+        item.appendChild(name);
+
+        // File count
+        const count = document.createElement('span');
+        count.className = 'folder-count';
+        count.textContent = `(${folder.fileCount || 0})`;
+        item.appendChild(count);
+        
+        // Extract button for ZIP roots
+        if (folder.isZipRoot) {
+            const extractBtn = document.createElement('button');
+            extractBtn.className = 'btn btn-sm zip-extract-btn';
+            extractBtn.textContent = '📤 Extract';
+            extractBtn.title = 'Extract ZIP contents to folder';
+            extractBtn.addEventListener('click', async (e) => {
+                e.stopPropagation();
+                await handleExtractZip(folder);
+            });
+            item.appendChild(extractBtn);
+        }
+        
+        // Extract All button for folders with ZIP descendants (but not ZIP roots themselves)
+        if (!folder.isZipRoot && !folder.isVirtualDir) {
+            const zipCount = countZipDescendants(folder);
+            if (zipCount > 0) {
+                const extractAllBtn = document.createElement('button');
+                extractAllBtn.className = 'btn btn-sm zip-extract-all-btn';
+                extractAllBtn.textContent = `📤 Extract All (${zipCount})`;
+                extractAllBtn.title = `Extract all ${zipCount} ZIP file(s) in this folder`;
+                extractAllBtn.addEventListener('click', async (e) => {
+                    e.stopPropagation();
+                    await handleExtractAllZips(folder);
+                });
+                item.appendChild(extractAllBtn);
+            }
+        }
+
+        // Click handler for selection
+        item.addEventListener('click', (e) => {
+            handleFolderClick(folder, e);
+        });
+
+        div.appendChild(item);
+
+        // Children (if expanded)
+        if (folder.expanded && folder.children && folder.children.length > 0) {
+            const childrenDiv = document.createElement('div');
+            childrenDiv.className = 'folder-children';
+            folder.children.forEach(child => {
+                const childElement = createFolderElement(child, level + 1);
+                childrenDiv.appendChild(childElement);
+            });
+            div.appendChild(childrenDiv);
+        }
+
+        return div;
+    }
+
+    /**
+     * Handle folder click with multi-select support
+     */
+    function handleFolderClick(folder, event) {
+        if (event.ctrlKey || event.metaKey) {
+            // Ctrl+Click: Toggle selection
+            if (window.app.selectedFolders.has(folder.path)) {
+                window.app.selectedFolders.delete(folder.path);
+            } else {
+                window.app.selectedFolders.add(folder.path);
+            }
+        } else if (event.shiftKey) {
+            // Shift+Click: Range selection
+            const visibleFolders = getVisibleFolders();
+            const currentIndex = visibleFolders.findIndex(f => f.path === folder.path);
+            
+            if (currentIndex >= 0 && window.app.lastSelectedFolderPath) {
+                const lastIndex = visibleFolders.findIndex(f => f.path === window.app.lastSelectedFolderPath);
+                
+                if (lastIndex >= 0) {
+                    const start = Math.min(currentIndex, lastIndex);
+                    const end = Math.max(currentIndex, lastIndex);
+                    
+                    // Select range
+                    for (let i = start; i <= end; i++) {
+                        window.app.selectedFolders.add(visibleFolders[i].path);
+                    }
+                }
+            } else {
+                window.app.selectedFolders.add(folder.path);
+            }
+        } else {
+            // Normal click: Single selection
+            window.app.selectedFolders.clear();
+            window.app.selectedFolders.add(folder.path);
+        }
+
+        // Remember last selected for shift-click
+        window.app.lastSelectedFolderPath = folder.path;
+
+        // Re-render tree
+        render();
+
+        // Load files from selected folders
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Handle ZIP extraction
+     */
+    async function handleExtractZip(folder) {
+        if (!folder.isZipRoot || !folder.zipPath) return;
+        
+        try {
+            const confirmed = confirm(`Extract "${folder.name}" to a new folder?\n\nThis will create a folder named "${folder.name.replace(/\.zip$/i, '')}" with the ZIP contents.`);
+            if (!confirmed) return;
+            
+            // Show extracting state
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-btn`);
+            if (btn) {
+                btn.textContent = '⏳ Extracting...';
+                btn.disabled = true;
+            }
+            
+            await window.app.modules.scanner.extractZip(folder.zipPath);
+            
+            // Auto-refresh preserving tree state
+            await window.app.modules.scanner.scanDirectory(window.app.rootHandle, true);
+        } catch (err) {
+            console.error('Error extracting ZIP:', err);
+            alert('Error extracting ZIP: ' + err.message);
+            
+            // Reset button
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-btn`);
+            if (btn) {
+                btn.textContent = '📤 Extract';
+                btn.disabled = false;
+            }
+        }
+    }
+    
+    /**
+     * Count ZIP descendants in a folder
+     */
+    function countZipDescendants(folder) {
+        let count = 0;
+        if (folder.children) {
+            for (const child of folder.children) {
+                if (child.isZipRoot) {
+                    count++;
+                }
+                count += countZipDescendants(child);
+            }
+        }
+        return count;
+    }
+    
+    /**
+     * Get all ZIP folders as flat list
+     */
+    function getZipDescendants(folder, zips = []) {
+        if (folder.children) {
+            for (const child of folder.children) {
+                if (child.isZipRoot) {
+                    zips.push(child);
+                }
+                getZipDescendants(child, zips);
+            }
+        }
+        return zips;
+    }
+    
+    /**
+     * Handle extracting all ZIPs in a folder
+     */
+    async function handleExtractAllZips(folder) {
+        const zips = getZipDescendants(folder);
+        if (zips.length === 0) return;
+        
+        const confirmed = confirm(`Extract ${zips.length} ZIP file(s)?\n\nThis will create folders for each ZIP with their contents.`);
+        if (!confirmed) return;
+        
+        try {
+            // Show extracting state on button
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-all-btn`);
+            if (btn) {
+                btn.textContent = '⏳ Extracting...';
+                btn.disabled = true;
+            }
+            
+            // Extract all ZIPs
+            for (const zip of zips) {
+                if (zip.zipPath) {
+                    await window.app.modules.scanner.extractZip(zip.zipPath);
+                }
+            }
+            
+            // Auto-refresh preserving tree state
+            await window.app.modules.scanner.scanDirectory(window.app.rootHandle, true);
+        } catch (err) {
+            console.error('Error extracting ZIPs:', err);
+            alert('Error extracting ZIPs: ' + err.message);
+            
+            // Reset button
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-all-btn`);
+            if (btn) {
+                btn.textContent = `📤 Extract All (${zips.length})`;
+                btn.disabled = false;
+            }
+        }
+    }
+
+    /**
+     * Toggle folder expansion
+     */
+    function toggleFolder(folder, recursive = false) {
+        folder.expanded = !folder.expanded;
+        
+        if (recursive && folder.children) {
+            // Recursively expand/collapse all children
+            const newState = folder.expanded;
+            function setAllExpanded(f) {
+                f.expanded = newState;
+                if (f.children) {
+                    f.children.forEach(setAllExpanded);
+                }
+            }
+            folder.children.forEach(setAllExpanded);
+        }
+        
+        render();
+    }
+
+    /**
+     * Load files from all selected folders
+     */
+    async function loadFilesFromSelectedFolders() {
+        // Use store to manage files
+        window.app.modules.store.setSelectedFolders(Array.from(window.app.selectedFolders));
+    }
+
+    /**
+     * Find folder by path in tree
+     */
+    function findFolderByPath(path) {
+        function search(folders) {
+            for (const folder of folders) {
+                if (folder.path === path) {
+                    return folder;
+                }
+                if (folder.children) {
+                    const found = search(folder.children);
+                    if (found) return found;
+                }
+            }
+            return null;
+        }
+        return search(window.app.folderTree);
+    }
+
+    /**
+     * Update selected folders count
+     */
+    function updateSelectedCount() {
+        const count = window.app.selectedFolders.size;
+        window.app.dom.selectedFoldersCount.textContent = 
+            `${count} folder${count !== 1 ? 's' : ''} selected`;
+    }
+
+    /**
+     * Build folder tree from scanned data
+     */
+    function buildTree(rootHandle, foldersMap) {
+        const tree = [];
+        
+        // Convert flat map to tree structure
+        function buildNode(handle, path) {
+            // For virtual folders, look up by path string; for real folders, use handle
+            let files;
+            if (handle.isVirtualDir || handle.isZipRoot) {
+                files = foldersMap.get(handle.virtualPath || handle.zipPath) || [];
+            } else {
+                files = foldersMap.get(handle) || [];
+            }
+            
+            // Add folderPath to each file for folder highlighting (filter out null files)
+            files.filter(file => file !== null).forEach(file => {
+                if (!file.isDirectory) {
+                    file.folderPath = path;
+                }
+            });
+            
+            // Filter out null files for the node
+            const validFiles = files.filter(f => f !== null);
+            
+            const node = {
+                name: handle.name,
+                path: path,
+                handle: handle,
+                files: validFiles,
+                fileCount: validFiles.length,
+                children: [],
+                expanded: false
+            };
+            
+            // Mark ZIP-related nodes
+            if (handle.isZipRoot) {
+                node.isZipRoot = true;
+                node.zipPath = handle.zipPath;
+            }
+            if (handle.isVirtualDir) {
+                node.isVirtualDir = true;
+                node.zipPath = handle.zipPath;
+            }
+            
+            return node;
+        }
+
+        // Recursively build tree
+        function addChildren(node) {
+            // Get subdirectories (filter out null files first)
+            // For virtual folders, look up by path string
+            let files;
+            if (node.handle.isVirtualDir || node.handle.isZipRoot) {
+                files = foldersMap.get(node.handle.virtualPath || node.handle.zipPath) || [];
+            } else {
+                files = foldersMap.get(node.handle) || [];
+            }
+            const validFiles = files.filter(f => f !== null);
+            const subdirs = validFiles.filter(f => f.isDirectory);
+            
+            subdirs.forEach(subdir => {
+                const childPath = node.path + '/' + subdir.handle.name;
+                const childNode = buildNode(subdir.handle, childPath);
+                addChildren(childNode);
+                node.children.push(childNode);
+            });
+            
+            // Update file count to exclude directories and null files
+            node.files = validFiles.filter(f => !f.isDirectory);
+            node.fileCount = node.files.length;
+        }
+
+        // Build root
+        const root = buildNode(rootHandle, rootHandle.name);
+        addChildren(root);
+        
+        // Expand root by default
+        root.expanded = true;
+        
+        tree.push(root);
+        return tree;
+    }
+
+    /**
+     * Get all currently visible folders (expanded tree)
+     */
+    function getVisibleFolders() {
+        const visible = [];
+        
+        function traverse(folders) {
+            for (const folder of folders) {
+                visible.push(folder);
+                if (folder.expanded && folder.children) {
+                    traverse(folder.children);
+                }
+            }
+        }
+        
+        traverse(window.app.folderTree);
+        return visible;
+    }
+
+    /**
+     * Select all visible folders
+     */
+    function selectAllVisible() {
+        const visible = getVisibleFolders();
+        window.app.selectedFolders.clear();
+        visible.forEach(f => window.app.selectedFolders.add(f.path));
+        render();
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Expand all folders in tree
+     */
+    function expandAll() {
+        function setAllExpanded(folder) {
+            folder.expanded = true;
+            if (folder.children) {
+                folder.children.forEach(setAllExpanded);
+            }
+        }
+        
+        window.app.folderTree.forEach(setAllExpanded);
+        render();
+    }
+
+    /**
+     * Select all folders in tree
+     */
+    function selectAll() {
+        function collectAllPaths(folders, paths = []) {
+            folders.forEach(folder => {
+                paths.push(folder.path);
+                if (folder.children) {
+                    collectAllPaths(folder.children, paths);
+                }
+            });
+            return paths;
+        }
+        
+        const allPaths = collectAllPaths(window.app.folderTree);
+        allPaths.forEach(path => window.app.selectedFolders.add(path));
+        
+        render();
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Set up keyboard shortcuts for folder tree
+     */
+    function setupKeyboardShortcuts() {
+        const container = window.app.dom.folderTree;
+        
+        container.addEventListener('keydown', (e) => {
+            // Ctrl+A: Select all visible
+            if ((e.ctrlKey || e.metaKey) && e.key === 'a') {
+                e.preventDefault();
+                selectAllVisible();
+            }
+        });
+        
+        // Make container focusable
+        container.tabIndex = 0;
+    }
+
+    // Export module
+    window.app.modules.tree = {
+        render,
+        buildTree,
+        loadFilesFromSelectedFolders,
+        setupKeyboardShortcuts,
+        expandAll,
+        selectAll
+    };
+})();
diff --git a/classifier/js/utils.js b/classifier/js/utils.js
new file mode 100644
index 0000000..48f7353
--- /dev/null
+++ b/classifier/js/utils.js
@@ -0,0 +1,78 @@
+/**
+ * Classifier utilities — thin convenience layer over window.zddc.
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Compute new filename from file fields.
+     * ZDDC format: trackingNumber_revision (status) - title.ext
+     * Falls back to original filename if any required ZDDC field is missing.
+     */
+    function computeNewFilename(file) {
+        if (file.manualFilename) {
+            return file.manualFilename;
+        }
+
+        const formatted = zddc.formatFilename({
+            trackingNumber: file.trackingNumber || '',
+            revision:       file.revision || '',
+            status:         file.status   || '',
+            title:          file.title    || '',
+            extension:      file.extension || '',
+        });
+
+        return formatted || zddc.joinExtension(file.originalFilename, file.extension);
+    }
+
+    /**
+     * Get column value from file object.
+     */
+    function getColumnValue(file, columnName) {
+        switch (columnName) {
+            case 'original':       return file.originalFilename || '';
+            case 'extension':      return file.extension || '';
+            case 'new':
+            case 'newFilename':    return file.manualFilename || computeNewFilename(file);
+            case 'trackingNumber': return file.trackingNumber || '';
+            case 'revision':       return file.revision || '';
+            case 'status':         return file.status || '';
+            case 'title':          return file.title || '';
+            case 'sha256':         return file.sha256 || '';
+            default:               return '';
+        }
+    }
+
+    /**
+     * Get MIME type from file extension (no leading dot).
+     */
+    const MIME_TYPES = {
+        pdf:  'application/pdf',
+        jpg:  'image/jpeg',
+        jpeg: 'image/jpeg',
+        png:  'image/png',
+        gif:  'image/gif',
+        svg:  'image/svg+xml',
+        webp: 'image/webp',
+        bmp:  'image/bmp',
+        ico:  'image/x-icon',
+        txt:  'text/plain',
+        md:   'text/markdown',
+        json: 'application/json',
+        xml:  'application/xml',
+        csv:  'text/csv',
+        html: 'text/html',
+        css:  'text/css',
+        js:   'text/javascript',
+    };
+
+    function getMimeType(extension) {
+        return MIME_TYPES[(extension || '').toLowerCase()] || 'application/octet-stream';
+    }
+
+    window.app.modules.utils = {
+        computeNewFilename,
+        getColumnValue,
+        getMimeType,
+    };
+})();
diff --git a/classifier/js/validator.js b/classifier/js/validator.js
new file mode 100644
index 0000000..7e500f8
--- /dev/null
+++ b/classifier/js/validator.js
@@ -0,0 +1,48 @@
+/**
+ * ZDDC Validation Module
+ * Validates file names against ZDDC conventions using the shared zddc library.
+ */
+
+(function() {
+    'use strict';
+
+    /**
+     * Validate a filename and return a detailed result.
+     * Delegates ZDDC pattern checking to the shared zddc.parseFilename() library.
+     */
+    function validateFilename(filename) {
+        const errors = [];
+        const warnings = [];
+
+        if (!filename) {
+            errors.push('Filename is empty.');
+            return { isValid: false, warnings, errors };
+        }
+
+        const parsed = zddc.parseFilename(filename);
+        if (!parsed || !parsed.valid) {
+            errors.push('Filename does not match ZDDC format: trackingNumber_revision (status) - title.ext');
+        } else if (!zddc.isValidStatus(parsed.status)) {
+            errors.push('Invalid status code "' + parsed.status + '". Valid codes: ' + zddc.STATUSES.join(', '));
+        }
+
+        if (filename.length > 255) {
+            warnings.push('Filename is very long (>255 characters)');
+        }
+
+        const invalidChars = /[<>:"|?*]/;
+        if (invalidChars.test(filename)) {
+            errors.push('Filename contains invalid characters: < > : " | ? *');
+        }
+
+        return {
+            isValid: errors.length === 0,
+            warnings,
+            errors
+        };
+    }
+
+    window.app.modules.validator = {
+        validateFilename
+    };
+})();
diff --git a/classifier/template.html b/classifier/template.html
new file mode 100644
index 0000000..e3f9690
--- /dev/null
+++ b/classifier/template.html
@@ -0,0 +1,237 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Classifier</title>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+    <style>
+        {{CSS_PLACEHOLDER}}
+    </style>
+</head>
+<body>
+    <div id="app">
+        <!-- Main Application -->
+        <div id="mainApp" class="main-app">
+            <!-- Header -->
+            <header class="app-header">
+                <div class="header-left">
+                    <div class="header-title-group">
+                        <span class="app-header__title">ZDDC Classifier</span>
+                        <span class="build-timestamp">{{BUILD_LABEL}}</span>
+                    </div>
+                    <button id="selectDirectoryBtn" class="btn btn-primary">Select Directory</button>
+                    <button id="refreshBtn" class="btn btn-secondary hidden" title="Refresh and rescan directory">Refresh</button>
+                </div>
+                <div class="header-right">
+                    <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+                    <button id="help-btn" class="btn btn-secondary" title="Help">?</button>
+                </div>
+            </header>
+
+            <!-- Main Content -->
+            <div class="main-content">
+                <!-- Folder Tree -->
+                <aside class="folder-tree-pane" id="folderTreePane">
+                    <div class="pane-header">
+                        <div class="pane-header-title">
+                            <button class="btn btn-sm collapse-tree-btn" id="collapseTreeBtn" title="Collapse folder tree">◀</button>
+                            <h3>Folder Tree</h3>
+                        </div>
+                        <div class="pane-header-controls">
+                            <label class="checkbox-label" title="Auto-scroll folder tree when hovering files">
+                                <input type="checkbox" id="autoScrollCheckbox" checked>
+                                Auto-scroll
+                            </label>
+                            <label class="checkbox-label">
+                                <input type="checkbox" id="hideCompliantCheckbox">
+                                Hide Compliant
+                            </label>
+                            <span id="selectedFoldersCount" class="folder-count">0 folders selected</span>
+                        </div>
+                    </div>
+                    <div id="folderTree" class="folder-tree">
+                        <!-- Dynamically populated -->
+                    </div>
+                    <div class="resize-handle" id="treeResizeHandle"></div>
+                </aside>
+
+                <!-- Spreadsheet Table -->
+                <main class="spreadsheet-pane">
+                    <div class="pane-header">
+                        <div class="pane-header-left">
+                            <h3>Files</h3>
+                            <div class="file-stats">
+                                <span id="totalFiles">0 files</span>
+                                <span id="modifiedFiles">0 modified</span>
+                                <span id="errorFiles" class="hidden">0 errors</span>
+                            </div>
+                        </div>
+                        <div class="pane-header-right">
+                            <button id="saveAllBtn" class="btn btn-success btn-sm" disabled>Save All</button>
+                            <button id="cancelAllBtn" class="btn btn-secondary btn-sm" disabled>Cancel All</button>
+                            <span class="header-divider">|</span>
+                            <label class="checkbox-label">
+                                <input type="checkbox" id="sha256Checkbox">
+                                SHA256
+                            </label>
+                            <button id="exportHashesBtn" class="btn btn-secondary btn-sm" disabled title="Export SHA256 hashes in sha256sum format">💾 Export Hashes</button>
+                            <span class="header-divider">|</span>
+                            <button id="togglePreviewBtn" class="btn btn-secondary btn-sm" title="Toggle file preview panel">👁 Preview</button>
+                        </div>
+                    </div>
+                    <div class="spreadsheet-container">
+                        <table id="spreadsheet" class="spreadsheet">
+                            <thead>
+                                <tr>
+                                    <th class="col-row-num">#</th>
+                                    <th class="col-original">Original Filename
+                                        <input type="text" class="column-filter" data-filter-field="original" placeholder="filter…" spellcheck="false" aria-label="Filter by original filename">
+                                    </th>
+                                    <th class="col-extension">Ext
+                                        <input type="text" class="column-filter" data-filter-field="extension" placeholder="filter…" spellcheck="false" aria-label="Filter by extension">
+                                    </th>
+                                    <th class="col-new">New Filename
+                                        <input type="text" class="column-filter" data-filter-field="newFilename" placeholder="filter…" spellcheck="false" aria-label="Filter by new filename">
+                                    </th>
+                                    <th class="col-trackingNumber">Tracking
+                                        <input type="text" class="column-filter" data-filter-field="trackingNumber" placeholder="filter…" spellcheck="false" aria-label="Filter by tracking number">
+                                    </th>
+                                    <th class="col-revision">Rev
+                                        <input type="text" class="column-filter" data-filter-field="revision" placeholder="filter…" spellcheck="false" aria-label="Filter by revision">
+                                    </th>
+                                    <th class="col-status">Status
+                                        <input type="text" class="column-filter" data-filter-field="status" placeholder="filter…" spellcheck="false" aria-label="Filter by status">
+                                    </th>
+                                    <th class="col-title">Title
+                                        <input type="text" class="column-filter" data-filter-field="title" placeholder="filter…" spellcheck="false" aria-label="Filter by title">
+                                    </th>
+                                    <th class="col-sha256 hidden" id="sha256Column">SHA256
+                                        <input type="text" class="column-filter" data-filter-field="sha256" placeholder="filter…" spellcheck="false" aria-label="Filter by SHA256">
+                                    </th>
+                                </tr>
+                            </thead>
+                            <tbody id="spreadsheetBody">
+                                <!-- Dynamically populated -->
+                            </tbody>
+                        </table>
+                    </div>
+                </main>
+
+            </div>
+
+            <!-- Empty State — shown until a directory is selected -->
+            <div id="welcomeScreen" class="empty-state">
+                <div class="empty-state-content">
+                    <h2>ZDDC Classifier</h2>
+                    <p>Rename a folder of files to ZDDC format using a spreadsheet interface.</p>
+                    <p>Open a directory, fill in tracking number, revision, status, and title for each file, then save — the files are renamed on disk.</p>
+
+                    <!-- Browser Compatibility Warning -->
+                    <div id="browserWarning" class="browser-warning hidden">
+                        <h3>⚠️ Browser Not Supported</h3>
+                        <p>This application requires the File System Access API, available only in Chromium-based browsers (Chrome, Edge, Brave, Opera).</p>
+                    </div>
+
+                    <ul class="welcome-list">
+                        <li>Files already named to ZDDC format are parsed automatically</li>
+                        <li>Edit cells directly, or copy columns to and from Excel</li>
+                        <li>Real-time validation highlights non-compliant names</li>
+                        <li>Rename one file or all modified files at once</li>
+                    </ul>
+
+                    <p>Click <strong>Select Directory</strong> to begin.</p>
+
+                    <p class="note">This application works entirely in your browser. No data is transmitted to any server.</p>
+                </div>
+            </div>
+        </div>
+
+        <!-- Help Panel -->
+        <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+            <div class="help-panel__header">
+                <h2 id="help-panel-title" class="help-panel__title">Help — ZDDC Classifier</h2>
+                <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+            </div>
+            <div class="help-panel__body">
+                <h3>What is the Classifier?</h3>
+                <p>The Classifier is a spreadsheet-based tool for renaming files to ZDDC naming conventions. It reads a folder of files and presents them in an editable grid where you can set tracking number, revision, status, and title — then saves the renamed files back to disk.</p>
+
+                <h3>Getting Started</h3>
+                <ol>
+                    <li>Click <strong>Select Directory</strong> to open a folder containing files to rename.</li>
+                    <li>The folder tree on the left shows all sub-folders. Click a folder to load its files.</li>
+                    <li>Edit cells in the spreadsheet to set the new filename components.</li>
+                    <li>Click <strong>Save All</strong> (or save individual rows) to rename the files on disk.</li>
+                </ol>
+
+                <h3>Folder Tree</h3>
+                <dl>
+                    <dt>Multi-select</dt>
+                    <dd>Hold <kbd>Ctrl</kbd> and click to select multiple folders. Hold <kbd>Shift</kbd> to select a range. Files from all selected folders are shown together.</dd>
+                    <dt>Hide Compliant</dt>
+                    <dd>Hides folders where all files already have valid ZDDC names, letting you focus on work remaining.</dd>
+                    <dt>Auto-scroll</dt>
+                    <dd>When enabled, the folder tree scrolls to highlight the folder containing the row you are editing.</dd>
+                </dl>
+
+                <h3>Spreadsheet Editing</h3>
+                <dl>
+                    <dt>Direct cell editing</dt>
+                    <dd>Click any cell in the New Filename, Tracking, Rev, Status, or Title columns to edit it. Press <kbd>Enter</kbd> to confirm, <kbd>Escape</kbd> to cancel.</dd>
+                    <dt>RC References</dt>
+                    <dd>Type a formula like <code>=R[-1]C</code> to copy the value from the cell one row above in the same column — similar to Excel relative references.</dd>
+                    <dt>Regex capture groups</dt>
+                    <dd>Type a formula like <code>=RE(RC[-3], "(\w+)-(\d+)", "$1")</code> to extract a pattern from another cell using a regular expression.</dd>
+                    <dt>Validation</dt>
+                    <dd>Cells are validated automatically. Invalid values are highlighted in red. The New Filename column shows the composed result.</dd>
+                    <dt>Column Filters</dt>
+                    <dd>Each column header has a filter input. Supported syntax:</dd>
+                </dl>
+                <dl>
+                    <dt><code>term</code></dt>
+                    <dd>Contains "term" (case-insensitive)</dd>
+                    <dt><code>!term</code></dt>
+                    <dd>Does not contain "term"</dd>
+                    <dt><code>^term</code></dt>
+                    <dd>Starts with "term"</dd>
+                    <dt><code>term$</code></dt>
+                    <dd>Ends with "term"</dd>
+                    <dt><code>a b</code></dt>
+                    <dd>Matches both (AND)</dd>
+                    <dt><code>a | b</code></dt>
+                    <dd>Matches either (OR)</dd>
+                    <dt><code>^IFA | ^IFB</code></dt>
+                    <dd>Starts with IFA or IFB</dd>
+                    <dt><code>!^~</code></dt>
+                    <dd>Does not start with ~ (excludes drafts)</dd>
+                    <dt><code>el.*spc</code></dt>
+                    <dd>Regex: contains "el" followed by "spc" (use <code>.</code> for any char, <code>.*</code> for any sequence)</dd>
+                    <dt><code>[ei]fa</code></dt>
+                    <dd>Regex character class: matches "efa" or "ifa"</dd>
+                </dl>
+
+                <h3>Saving Files</h3>
+                <dl>
+                    <dt>Save All</dt>
+                    <dd>Renames all modified files in one operation. Confirms before proceeding.</dd>
+                    <dt>Cancel All</dt>
+                    <dd>Reverts all unsaved edits back to the original filenames.</dd>
+                    <dt>SHA256</dt>
+                    <dd>Enable to compute a cryptographic hash of each file. Use <strong>Export Hashes</strong> to save a <code>sha256sum</code>-compatible file.</dd>
+                </dl>
+
+                <h3>ZDDC Filename Format</h3>
+                <p>The required format is:</p>
+                <p><code>TRACKINGNUMBER_REVISION (STATUS) - Title.ext</code></p>
+                <p>Example: <code>123456-EL-SPC-2623_A (IFR) - Electrical Specification.pdf</code></p>
+                <p>Valid statuses: IFA, IFB, IFC, IFD, IFI, IFP, IFR, IFU, REC, RSA, RSB, RSC, RSD, RSI, ---</p>
+            </div>
+        </aside>
+    </div>
+
+    <script>
+        {{JS_PLACEHOLDER}}
+    </script>
+</body>
+</html>
diff --git a/dev-server b/dev-server
new file mode 100755
index 0000000..7ee5805
--- /dev/null
+++ b/dev-server
@@ -0,0 +1,438 @@
+#!/usr/bin/env python3
+"""
+Development HTTP server with cache-busting headers
+Supports start, status, and stop commands for process management.
+"""
+
+import argparse
+import os
+import signal
+import socketserver
+import sys
+import time
+import urllib.request
+import urllib.error
+from http.server import SimpleHTTPRequestHandler
+from pathlib import Path
+
+class NoCacheHTTPRequestHandler(SimpleHTTPRequestHandler):
+    def end_headers(self):
+        self.send_header('Cache-Control', 'no-cache, no-store, must-revalidate')
+        self.send_header('Pragma', 'no-cache')
+        self.send_header('Expires', '0')
+        super().end_headers()
+
+class DevServer:
+    def __init__(self, port=8000, directory=None):
+        self.port = port
+        self.directory = directory or os.getcwd()
+        self.runtime_dir = self._get_runtime_dir()
+        # Port-specific PID files to allow multiple servers
+        self.pidfile = self.runtime_dir / f"zddc-dev-server-{port}.pid"
+    
+    def _get_runtime_dir(self):
+        """Get appropriate runtime directory for PID files"""
+        # Try user runtime directory first (systemd)
+        import getpass
+        uid = os.getuid()
+        user_runtime = Path(f"/run/user/{uid}")
+        if user_runtime.exists() and user_runtime.is_dir():
+            runtime_dir = user_runtime / "zddc"
+            runtime_dir.mkdir(exist_ok=True)
+            return runtime_dir
+        
+        # Fall back to user's cache directory
+        home = Path.home()
+        cache_dir = home / ".cache" / "zddc"
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        return cache_dir
+    
+    def get_server_pid(self):
+        """Get the PID of running server from pidfile"""
+        pid, _ = self._get_server_info()
+        return pid
+    
+    def _get_server_info(self):
+        """Get PID and serving directory from pidfile"""
+        if not self.pidfile.exists():
+            return None, None
+        
+        try:
+            with open(self.pidfile, 'r') as f:
+                content = f.read().strip()
+            
+            # Handle different formats: PID, PID:PORT, PID:DIRECTORY
+            if ':' in content:
+                pid_str, rest = content.split(':', 1)
+                pid = int(pid_str)
+                # If rest is numeric, it's old PID:PORT format
+                try:
+                    int(rest)
+                    serving_dir = None  # Old format, directory unknown
+                except ValueError:
+                    serving_dir = rest  # New PID:DIRECTORY format
+            else:
+                pid = int(content)
+                serving_dir = None  # Old format, directory unknown
+            
+            # Check if process is actually running using /proc
+            if self._is_process_running(pid):
+                return pid, serving_dir
+            else:
+                # Clean up stale pidfile
+                print(f"  Cleaning up stale PID file for process {pid}")
+                self._cleanup()
+                return None, None
+            
+        except (ValueError, IOError) as e:
+            print(f"  Error reading PID file: {e}")
+            self._cleanup()
+            return None, None
+    
+    def _is_process_running(self, pid):
+        """Check if a process with given PID is running and is our process"""
+        try:
+            # Check if process exists
+            with open(f"/proc/{pid}/comm", 'r') as f:
+                comm = f.read().strip()
+            
+            # Verify it's a python process
+            if 'python' not in comm:
+                return False
+            
+            # Check command line to verify it's our dev-server
+            try:
+                with open(f"/proc/{pid}/cmdline", 'r') as f:
+                    cmdline = f.read()
+                    return 'dev-server.py' in cmdline
+            except (FileNotFoundError, PermissionError):
+                # If we can't read cmdline, assume it's our process if it's python
+                return True
+                
+        except (FileNotFoundError, PermissionError):
+            return False
+    
+    def is_server_running(self):
+        """Check if server is running by making HTTP request"""
+        try:
+            with urllib.request.urlopen(f"http://localhost:{self.port}/", timeout=2) as response:
+                return response.status == 200 or response.status == 403  # 403 for directory listing disabled
+        except (urllib.error.URLError, urllib.error.HTTPError, OSError):
+            return False
+    
+    def start(self, daemon=False):
+        """Start the development server"""
+        # Check if server is already running on this port
+        existing_pid = self.get_server_pid()
+        if existing_pid:
+            print(f"Server is already running (PID: {existing_pid}) at http://localhost:{self.port}")
+            return True  # Exit without error as requested
+        
+        # Check if port is in use by another process
+        if self.is_server_running():
+            print(f"Port {self.port} is already in use by another process")
+            return False
+        
+        if daemon:
+            self._start_daemon()
+        else:
+            self._start_foreground()
+        
+        return True
+    
+    def _start_foreground(self):
+        """Start server in foreground mode"""
+        print(f"Starting dev server on port {self.port}...")
+        print(f"Serving directory: {self.directory}")
+        print("Press Ctrl+C to stop")
+        
+        # Change to the specified directory
+        try:
+            os.chdir(self.directory)
+        except OSError as e:
+            print(f"Failed to change to directory {self.directory}: {e}")
+            return False
+        
+        # Set up signal handler for graceful shutdown
+        def signal_handler(signum, frame):
+            print("\nShutting down server...")
+            sys.exit(0)
+        
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+        
+        try:
+            httpd = socketserver.TCPServer(("", self.port), NoCacheHTTPRequestHandler)
+            httpd.serve_forever()
+        except OSError as e:
+            if e.errno == 98:  # Address already in use
+                print(f"Port {self.port} is already in use")
+            else:
+                print(f"Error starting server: {e}")
+            return False
+        except KeyboardInterrupt:
+            print("\nServer stopped")
+            return True
+        except Exception as e:
+            print(f"Error starting server: {e}")
+        finally:
+            self._cleanup()
+    
+    def _start_daemon(self):
+        """Start server in daemon mode (background)"""
+        try:
+            # Fork the first time (detach from parent)
+            pid = os.fork()
+            if pid > 0:
+                # Parent process - wait a moment then exit
+                time.sleep(0.5)
+                return True
+        except OSError as e:
+            print(f"Fork #1 failed: {e}")
+            return False
+        
+        # Change to the specified directory before daemonizing
+        try:
+            os.chdir(self.directory)
+        except OSError as e:
+            print(f"Failed to change to directory {self.directory}: {e}")
+            return False
+        
+        # Decouple from parent environment
+        os.setsid()
+        os.umask(0)
+        
+        # Fork the second time (prevent zombie processes)
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # Parent process - exit immediately
+                os._exit(0)
+        except OSError as e:
+            print(f"Fork #2 failed: {e}")
+            os._exit(1)
+        
+        # Redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+        
+        with open('/dev/null', 'r') as si:
+            os.dup2(si.fileno(), sys.stdin.fileno())
+        with open('/dev/null', 'w') as so:
+            os.dup2(so.fileno(), sys.stdout.fileno())
+        with open('/dev/null', 'w') as se:
+            os.dup2(se.fileno(), sys.stderr.fileno())
+        
+        # Write PID to file with directory information
+        try:
+            with open(self.pidfile, 'w') as f:
+                f.write(f"{os.getpid()}:{self.directory}")
+            print(f"Dev server started on port {self.port} serving {self.directory}")
+            return True
+        except IOError as e:
+            print(f"Failed to write PID file: {e}")
+            return False
+        
+        # Start the server
+        try:
+            with socketserver.TCPServer(("", self.port), NoCacheHTTPRequestHandler) as httpd:
+                httpd.serve_forever()
+        except Exception:
+            # In daemon mode, errors just cause the process to exit
+            pass
+        finally:
+            self._cleanup()
+    
+    def status(self):
+        """Check server status by testing HTTP connection"""
+        # Check for stale PID files first
+        self._cleanup_if_stale()
+        
+        pid, serving_dir = self._get_server_info()
+        if pid:
+            # Test if the server is actually responding on its port
+            server_responding = self.is_server_running()
+            
+            print(f"Dev server is running")
+            print(f"  PID: {pid}")
+            print(f"  Port: {self.port}")
+            print(f"  URL: http://localhost:{self.port}")
+            print(f"  Directory: {serving_dir or 'Unknown (old PID file format)'}")
+            print(f"  PID file: {self.pidfile}")
+            
+            if server_responding:
+                print(f"  Status: Responding to HTTP requests")
+            else:
+                print(f"  Status: Process running but not responding to HTTP (may be starting up)")
+            
+            # Get process uptime
+            try:
+                uptime_seconds = self._get_process_uptime(pid)
+                print(f"  Uptime: {self._format_uptime(uptime_seconds)}")
+            except (FileNotFoundError, IndexError, ValueError):
+                print(f"  Uptime: Unable to determine")
+            
+            return True
+        else:
+            print("Dev server is not running")
+            return False
+    
+    def _get_process_uptime(self, pid):
+        """Get the actual uptime of a process in seconds"""
+        with open(f"/proc/{pid}/stat", 'r') as f:
+            stat_data = f.read().split()
+            starttime_ticks = int(stat_data[21])  # Process start time in ticks since boot
+        
+        # Get system clock ticks per second
+        clock_ticks = os.sysconf(os.sysconf_names['SC_CLK_TCK'])
+        
+        # Get system boot time
+        with open("/proc/stat", 'r') as f:
+            for line in f:
+                if line.startswith('btime '):
+                    boot_time = int(line.split()[1])
+                    break
+        
+        # Calculate process start time in seconds since epoch
+        process_start_time = boot_time + (starttime_ticks / clock_ticks)
+        
+        # Calculate uptime
+        return time.time() - process_start_time
+    
+
+    
+    def _cleanup_if_stale(self):
+        """Check for and clean up stale PID files"""
+        if self.pidfile.exists():
+            try:
+                with open(self.pidfile, 'r') as f:
+                    content = f.read().strip()
+                
+                # Handle different formats: PID, PID:PORT, PID:DIRECTORY
+                if ':' in content:
+                    pid = int(content.split(':', 1)[0])
+                else:
+                    pid = int(content)
+                
+                if not self._is_process_running(pid):
+                    print(f"  Found stale PID file for process {pid}, cleaning up")
+                    self._cleanup()
+            except (ValueError, IOError):
+                print(f"  Found corrupted PID file, cleaning up")
+                self._cleanup()
+    
+    def stop(self):
+        """Stop the development server"""
+        pid = self.get_server_pid()
+        if not pid:
+            if self.is_server_running():
+                print("Server is running but not managed by this script")
+                print("Cannot stop server started by another process")
+                return False
+            else:
+                print("Dev server is not running")
+                return False
+        
+        try:
+            print(f"Stopping dev server (PID: {pid})...")
+            os.kill(pid, signal.SIGTERM)
+            
+            # Wait for process to stop
+            for i in range(30):  # Wait up to 3 seconds
+                time.sleep(0.1)
+                try:
+                    os.kill(pid, 0)  # Test if process still exists
+                except OSError:
+                    # Process no longer exists
+                    break
+            else:
+                # Force kill if still running
+                print("Process didn't stop gracefully, force killing...")
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                except OSError:
+                    pass  # Process might have died already
+            
+            self._cleanup()
+            print("Dev server stopped")
+            return True
+            
+        except OSError as e:
+            print(f"Error stopping server: {e}")
+            self._cleanup()
+            return False
+    
+    def _cleanup(self):
+        """Clean up PID file"""
+        if self.pidfile.exists():
+            try:
+                self.pidfile.unlink()
+            except OSError as e:
+                print(f"Warning: Could not remove PID file {self.pidfile}: {e}")
+    
+    def _format_uptime(self, seconds):
+        """Format uptime in human readable format"""
+        if seconds < 60:
+            return f"{int(seconds)}s"
+        elif seconds < 3600:
+            return f"{int(seconds // 60)}m {int(seconds % 60)}s"
+        else:
+            hours = int(seconds // 3600)
+            minutes = int((seconds % 3600) // 60)
+            return f"{hours}h {minutes}m"
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="ZDDC Development Server",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""Commands:
+  start     Start the development server (default)
+  status    Show server status
+  stop      Stop the development server
+
+Examples:
+  %(prog)s                # Start server in foreground (default)
+  %(prog)s start -d       # Start server in background
+  %(prog)s status         # Check if server is running
+  %(prog)s stop           # Stop the server
+  %(prog)s -p 8080 start  # Start on port 8080
+  %(prog)s start ~/docs   # Start serving ~/docs directory
+  %(prog)s -p 9000 ~/src  # Start serving ~/src on port 9000"""
+    )
+    
+    parser.add_argument('command', nargs='?', default='start',
+                       choices=['start', 'status', 'stop'],
+                       help='Command to execute (default: start)')
+    parser.add_argument('-p', '--port', type=int, default=8000,
+                       help='Port to run server on (default: 8000)')
+    parser.add_argument('-d', '--daemon', action='store_true',
+                       help='Run server in background (daemon mode)')
+    parser.add_argument('directory', nargs='?', default=None,
+                       help='Directory to serve (default: current directory)')
+    
+    args = parser.parse_args()
+    
+    server = DevServer(port=args.port, directory=args.directory)
+    
+    if args.command == 'start':
+        if not server.start(daemon=args.daemon):
+            sys.exit(1)
+        # After starting (or if already running), show status
+        if not server.status():
+            sys.exit(1)
+    elif args.command == 'status':
+        if not server.status():
+            sys.exit(1)
+    elif args.command == 'stop':
+        if not server.stop():
+            sys.exit(1)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nOperation cancelled")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
diff --git a/landing/build.sh b/landing/build.sh
new file mode 100755
index 0000000..f4aeef7
--- /dev/null
+++ b/landing/build.sh
@@ -0,0 +1,72 @@
+#!/bin/sh
+set -eu
+
+root_dir=$(cd "$(dirname "$0")" && pwd)
+. "$root_dir/../shared/build-lib.sh"
+
+src_html="$root_dir/template.html"
+output_dir="$root_dir/dist"
+output_html="$output_dir/index.html"
+
+mkdir -p "$output_dir"
+ensure_exists "$src_html"
+
+css_temp=$(mktemp)
+js_raw=$(mktemp)
+js_temp=$(mktemp)
+cleanup() { rm -f "$css_temp" "$js_raw" "$js_temp"; }
+trap cleanup EXIT
+
+concat_files \
+  "../shared/base.css" \
+  "css/landing.css" \
+  > "$css_temp"
+
+concat_files \
+  "../shared/theme.js" \
+  "js/landing.js" \
+  > "$js_raw"
+
+# Escape '</' in inlined JS so the HTML parser cannot mistake string contents
+# for a closing </script> tag.
+escape_js_close_tags "$js_raw" "$js_temp"
+
+compute_build_label "landing" "${1:-}" "${2:-}"
+
+# Process template: inject CSS/JS, substitute build label, strip CDN refs
+awk -v css_file="$css_temp" -v js_file="$js_temp" -v build_label="$build_label" -v is_red="$is_red" '
+  /\{\{CSS_PLACEHOLDER\}\}/ {
+    while ((getline line < css_file) > 0) print line
+    close(css_file)
+    next
+  }
+  /\{\{JS_PLACEHOLDER\}\}/ {
+    while ((getline line < js_file) > 0) print line
+    close(js_file)
+    next
+  }
+  /\{\{BUILD_LABEL\}\}/ {
+    if (is_red == "1") {
+      gsub(/\{\{BUILD_LABEL\}\}/, "<span style=\"color:red;font-weight:bold\">" build_label "</span>")
+    } else {
+      gsub(/\{\{BUILD_LABEL\}\}/, build_label)
+    }
+    print
+    next
+  }
+  /<script src="https?:\/\// { next }
+  /<link rel="stylesheet" href="https?:\/\// { next }
+  { print }
+' "$src_html" > "$output_html"
+
+echo "Wrote $output_html"
+
+if [ "$is_release" = "1" ]; then
+    promote_release "landing"
+    # NOTE: website/index.html is a hand-edited intro page for
+    # zddc.varasys.io, not the landing tool. The landing tool ships
+    # only via website/releases/ and install.zip — install.zip puts
+    # landing_latest.html at the customer deployment root, where the
+    # project picker UI is useful (it queries zddc-server for the
+    # project list). See AGENTS.md "Releasing — channels and layout".
+fi
diff --git a/landing/css/landing.css b/landing/css/landing.css
new file mode 100644
index 0000000..f102df4
--- /dev/null
+++ b/landing/css/landing.css
@@ -0,0 +1,180 @@
+/* Landing page layout */
+body {
+    margin: 0;
+    font-family: var(--font);
+    font-size: 14px;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.landing-main {
+    max-width: 640px;
+    margin: 32px auto;
+    padding: 0 16px;
+}
+
+/* Access warning banner */
+.access-warning-banner {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 16px;
+    background: #fff3cd;
+    border: 1px solid #ffc107;
+    border-radius: var(--radius);
+    color: #664d03;
+    font-size: 0.875rem;
+    margin-bottom: 16px;
+    gap: 12px;
+}
+.access-warning-banner.hidden { display: none; }
+.warning-dismiss-btn {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #664d03;
+    font-size: 1rem;
+    padding: 0 4px;
+    flex-shrink: 0;
+}
+
+/* Main card */
+.landing-card {
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    overflow: hidden;
+}
+
+.landing-card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 12px 16px;
+    border-bottom: 1px solid var(--border);
+    gap: 12px;
+    flex-wrap: wrap;
+}
+
+.landing-card-header h2 {
+    margin: 0;
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text);
+}
+
+.landing-header-actions {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+/* Project list */
+.project-list {
+    padding: 8px 0;
+    min-height: 80px;
+}
+
+.project-list-empty {
+    padding: 32px 16px;
+    text-align: center;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
+
+.project-item {
+    display: flex;
+    align-items: center;
+    padding: 8px 16px;
+    gap: 10px;
+    cursor: pointer;
+    border-radius: 0;
+    transition: background 0.1s;
+}
+.project-item:hover { background: var(--bg-hover); }
+.project-item input[type="checkbox"] {
+    width: 16px;
+    height: 16px;
+    cursor: pointer;
+    flex-shrink: 0;
+    accent-color: var(--primary);
+}
+.project-item-name {
+    font-size: 0.9375rem;
+    color: var(--text);
+    user-select: none;
+}
+
+/* Footer */
+.landing-card-footer {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 16px;
+    border-top: 1px solid var(--border);
+    gap: 8px;
+}
+
+/* Preset menu */
+.preset-control {
+    position: relative;
+}
+.preset-menu {
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: 4px;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0,0,0,0.12);
+    min-width: 200px;
+    z-index: 100;
+    padding: 4px 0;
+}
+.preset-menu.hidden { display: none; }
+.preset-menu-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+    cursor: pointer;
+    font-size: 0.875rem;
+    gap: 8px;
+}
+.preset-menu-item:hover { background: var(--bg-hover); }
+.preset-menu-item-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.preset-delete-btn {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+    padding: 0 2px;
+    flex-shrink: 0;
+}
+.preset-delete-btn:hover { color: var(--danger); }
+.preset-menu-empty {
+    padding: 8px 12px;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
+.preset-menu-divider {
+    border: none;
+    border-top: 1px solid var(--border);
+    margin: 4px 0;
+}
+
+/* Loading state */
+.project-list-loading {
+    padding: 32px 16px;
+    text-align: center;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
diff --git a/landing/js/landing.js b/landing/js/landing.js
new file mode 100644
index 0000000..b81bbec
--- /dev/null
+++ b/landing/js/landing.js
@@ -0,0 +1,215 @@
+(function() {
+    'use strict';
+
+    var accessibleProjects = []; // [{name, url}, ...] from server
+    var presets = [];            // [{name, projects[]}, ...] from localStorage
+    var PRESETS_KEY = 'zddc_landing_presets';
+
+    // ── Initialise ──────────────────────────────────────────────────────────
+
+    async function init() {
+        loadPresets();
+
+        var urlProjects = getUrlProjects();
+
+        var projectList = document.getElementById('projectList');
+        projectList.innerHTML = '<div class="project-list-loading">Loading projects…<\/div>';
+
+        try {
+            var resp = await fetch(location.origin + location.pathname.replace(/\/[^\/]*$/, '/'), {
+                headers: { 'Accept': 'application/json' }
+            });
+            if (!resp.ok) throw new Error('HTTP ' + resp.status);
+            accessibleProjects = await resp.json();
+        } catch (e) {
+            projectList.innerHTML = '<div class="project-list-empty">Could not load project list: ' + escapeHtml(e.message) + '<\/div>';
+            return;
+        }
+
+        // Warn about URL projects that are not accessible
+        if (urlProjects.size > 0) {
+            var missing = Array.from(urlProjects).filter(function(p) {
+                return !accessibleProjects.some(function(ap) { return ap.name === p; });
+            });
+            if (missing.length > 0) {
+                showWarning('This link includes projects you don\'t have access to: ' + missing.map(escapeHtml).join(', '));
+            }
+        }
+
+        renderProjects(urlProjects);
+        renderPresetMenu();
+
+        // Close preset menu on outside click
+        document.addEventListener('click', function(e) {
+            var menu = document.getElementById('presetMenu');
+            var btn = document.getElementById('presetMenuBtn');
+            if (menu && !menu.classList.contains('hidden') && !menu.contains(e.target) && e.target !== btn) {
+                menu.classList.add('hidden');
+            }
+        });
+    }
+
+    function getUrlProjects() {
+        var params = new URLSearchParams(location.search);
+        var val = params.get('projects');
+        if (!val) return new Set();
+        return new Set(val.split(',').map(function(p) { return p.trim(); }).filter(Boolean));
+    }
+
+    // ── Rendering ────────────────────────────────────────────────────────────
+
+    function renderProjects(preCheck) {
+        var container = document.getElementById('projectList');
+        if (accessibleProjects.length === 0) {
+            container.innerHTML = '<div class="project-list-empty">No projects available.<\/div>';
+            return;
+        }
+        var html = accessibleProjects.map(function(p) {
+            var checked = (preCheck.size === 0 || preCheck.has(p.name)) ? ' checked' : '';
+            return '<div class="project-item" onclick="LandingApp.toggleProject(this)">' +
+                '<input type="checkbox" value="' + escapeHtml(p.name) + '"' + checked + ' onclick="event.stopPropagation()">' +
+                '<span class="project-item-name">' + escapeHtml(p.name) + '<\/span>' +
+                '<\/div>';
+        }).join('');
+        container.innerHTML = html;
+    }
+
+    function renderPresetMenu() {
+        var menu = document.getElementById('presetMenu');
+        if (!menu) return;
+        if (presets.length === 0) {
+            menu.innerHTML = '<div class="preset-menu-empty">No presets saved.<\/div>';
+            return;
+        }
+        menu.innerHTML = presets.map(function(preset) {
+            return '<div class="preset-menu-item">' +
+                '<span class="preset-menu-item-name" onclick="LandingApp.applyPreset(' + JSON.stringify(preset.name) + ')">' +
+                escapeHtml(preset.name) + '<\/span>' +
+                '<button class="preset-delete-btn" onclick="LandingApp.deletePreset(' + JSON.stringify(preset.name) + ')" title="Delete preset">&times;<\/button>' +
+                '<\/div>';
+        }).join('');
+    }
+
+    // ── Actions ──────────────────────────────────────────────────────────────
+
+    function selectAll() {
+        document.querySelectorAll('#projectList input[type="checkbox"]').forEach(function(cb) {
+            cb.checked = true;
+        });
+    }
+
+    function selectNone() {
+        document.querySelectorAll('#projectList input[type="checkbox"]').forEach(function(cb) {
+            cb.checked = false;
+        });
+    }
+
+    function toggleProject(row) {
+        var cb = row.querySelector('input[type="checkbox"]');
+        if (cb) cb.checked = !cb.checked;
+    }
+
+    function openArchive() {
+        var checked = Array.from(document.querySelectorAll('#projectList input[type="checkbox"]:checked'))
+            .map(function(cb) { return cb.value; });
+        if (checked.length === 0) {
+            alert('Select at least one project to open.');
+            return;
+        }
+        var base = location.pathname.replace(/\/[^\/]*$/, '/');
+        location.href = base + 'archive.html?projects=' + checked.map(encodeURIComponent).join(',');
+    }
+
+    function savePreset() {
+        var name = prompt('Enter a name for this preset:');
+        if (!name || !name.trim()) return;
+        name = name.trim();
+        var checked = Array.from(document.querySelectorAll('#projectList input[type="checkbox"]:checked'))
+            .map(function(cb) { return cb.value; });
+        // Replace existing preset with same name
+        presets = presets.filter(function(p) { return p.name !== name; });
+        presets.push({ name: name, projects: checked });
+        savePresets();
+        renderPresetMenu();
+    }
+
+    function togglePresetMenu() {
+        var menu = document.getElementById('presetMenu');
+        if (menu) menu.classList.toggle('hidden');
+    }
+
+    function applyPreset(name) {
+        var preset = presets.find(function(p) { return p.name === name; });
+        if (!preset) return;
+        var projectSet = new Set(preset.projects);
+        document.querySelectorAll('#projectList input[type="checkbox"]').forEach(function(cb) {
+            cb.checked = projectSet.has(cb.value);
+        });
+        document.getElementById('presetMenu').classList.add('hidden');
+    }
+
+    function deletePreset(name) {
+        presets = presets.filter(function(p) { return p.name !== name; });
+        savePresets();
+        renderPresetMenu();
+    }
+
+    function dismissWarning() {
+        var el = document.getElementById('accessWarningBanner');
+        if (el) el.classList.add('hidden');
+    }
+
+    // ── Warning ───────────────────────────────────────────────────────────────
+
+    function showWarning(message) {
+        var el = document.getElementById('accessWarningBanner');
+        var txt = document.getElementById('accessWarningText');
+        if (!el || !txt) return;
+        txt.textContent = message;
+        el.classList.remove('hidden');
+    }
+
+    // ── Persistence ───────────────────────────────────────────────────────────
+
+    function loadPresets() {
+        try {
+            var raw = localStorage.getItem(PRESETS_KEY);
+            presets = raw ? JSON.parse(raw) : [];
+            if (!Array.isArray(presets)) presets = [];
+        } catch (e) {
+            presets = [];
+        }
+    }
+
+    function savePresets() {
+        try {
+            localStorage.setItem(PRESETS_KEY, JSON.stringify(presets));
+        } catch (e) { /* quota exceeded or private browsing */ }
+    }
+
+    // ── Utilities ─────────────────────────────────────────────────────────────
+
+    function escapeHtml(text) {
+        var div = document.createElement('div');
+        div.textContent = String(text);
+        return div.innerHTML;
+    }
+
+    // ── Bootstrap ─────────────────────────────────────────────────────────────
+
+    document.addEventListener('DOMContentLoaded', init);
+
+    window.LandingApp = {
+        init: init,
+        selectAll: selectAll,
+        selectNone: selectNone,
+        toggleProject: toggleProject,
+        openArchive: openArchive,
+        savePreset: savePreset,
+        togglePresetMenu: togglePresetMenu,
+        applyPreset: applyPreset,
+        deletePreset: deletePreset,
+        dismissWarning: dismissWarning
+    };
+
+})();
diff --git a/landing/template.html b/landing/template.html
new file mode 100644
index 0000000..90df48d
--- /dev/null
+++ b/landing/template.html
@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Archive — Projects</title>
+    <style>
+        {{CSS_PLACEHOLDER}}
+    </style>
+</head>
+<body>
+    <header class="app-header">
+        <div class="header-left">
+            <span class="app-header__title">ZDDC Archive</span>
+            <span class="build-timestamp">{{BUILD_LABEL}}</span>
+        </div>
+        <div class="header-right">
+            <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+        </div>
+    </header>
+
+    <main class="landing-main">
+        <!-- Access warning banner (shown when URL ?projects= contains inaccessible items) -->
+        <div id="accessWarningBanner" class="access-warning-banner hidden" role="alert">
+            <span id="accessWarningText"></span>
+            <button class="warning-dismiss-btn" onclick="LandingApp.dismissWarning()" aria-label="Dismiss">&times;</button>
+        </div>
+
+        <div class="landing-card">
+            <div class="landing-card-header">
+                <h2>Select Projects</h2>
+                <div class="landing-header-actions">
+                    <!-- Presets dropdown -->
+                    <div class="preset-control">
+                        <button id="presetMenuBtn" class="btn btn-secondary btn-sm" onclick="LandingApp.togglePresetMenu()">▾ Presets</button>
+                        <div id="presetMenu" class="preset-menu hidden"></div>
+                    </div>
+                    <button class="btn btn-secondary btn-sm" onclick="LandingApp.selectAll()">Select All</button>
+                    <button class="btn btn-secondary btn-sm" onclick="LandingApp.selectNone()">Select None</button>
+                </div>
+            </div>
+
+            <div id="projectList" class="project-list">
+                <!-- Populated by JS -->
+            </div>
+
+            <div class="landing-card-footer">
+                <button id="savePresetBtn" class="btn btn-secondary" onclick="LandingApp.savePreset()">Save Preset…</button>
+                <button id="openArchiveBtn" class="btn btn-primary" onclick="LandingApp.openArchive()">Open Archive →</button>
+            </div>
+        </div>
+    </main>
+
+    <script>
+        {{JS_PLACEHOLDER}}
+    </script>
+</body>
+</html>
diff --git a/mdedit/README.md b/mdedit/README.md
new file mode 100644
index 0000000..c804baf
--- /dev/null
+++ b/mdedit/README.md
@@ -0,0 +1,131 @@
+# ZDDC Markdown Editor
+
+[← Back to ZDDC](../README.md)
+
+A lightweight, browser-based markdown editor with YAML front matter support.
+
+**[🔗 Open Markdown Editor](dist/mdedit.html)** - Click to use online, or right-click → "Save Link As" to keep your own copy.
+
+## Reliability
+
+This tool follows the "record player with the record" philosophy - the application and your data travel together. The single HTML file contains everything needed to edit markdown files locally in your browser.
+
+## Quick Start
+
+1. Open the editor in your browser
+2. Click **Select Directory** to choose a folder with markdown files
+3. Navigate the file tree on the left
+4. Click any `.md` file to edit it
+5. Click **Save File** or **Save All** to save changes
+
+## Features
+
+### 📂 File Navigation
+- Browse directories using the File System Access API
+- Collapsible folder tree with file type icons
+- Files sorted alphabetically with directories grouped
+
+### ✏️ Markdown Editing
+- Toast UI Editor with live preview
+- Split view (markdown + preview)
+- Full toolbar for formatting
+
+### 📋 YAML Front Matter
+- Separate front matter section at top of editor
+- Auto-parsed and preserved on save
+- Collapsible for more editing space
+
+### 📑 Table of Contents
+- Auto-generated from headings
+- Adjustable depth (H1 only through H6)
+- Click to jump to heading in preview
+
+### 💾 File Operations
+- Save individual files or Save All
+- Reload from disk (discards unsaved changes)
+- External change detection with reload prompt
+- Unsaved change warnings before leaving
+
+### 🖼️ File Previews
+- Image preview for common formats
+- HTML preview in sandboxed iframe
+- Plain text editing for non-markdown files
+
+## Build
+
+The editor is built from modular source files using a bash script:
+
+```bash
+cd mdedit
+./build.sh
+```
+
+This concatenates CSS and JS files into `dist/mdedit.html`.
+
+## Project Structure
+
+```
+mdedit/
+├── css/
+│   ├── base.css                  # Core styles and layout
+│   ├── editor.css                # Toast UI Editor overrides
+│   ├── toc.css                   # Table of Contents styles
+│   └── markdown.css              # Markdown rendering styles
+├── js/
+│   ├── app.js                    # Global state
+│   ├── utils.js                  # Utility functions
+│   ├── front-matter.js           # YAML parsing
+│   ├── file-system.js            # File operations
+│   ├── file-tree.js              # Tree rendering
+│   ├── editor.js                 # Toast UI setup
+│   ├── toc.js                    # TOC generation
+│   ├── resizer.js                # Pane resizing
+│   ├── events.js                 # Event listeners
+│   └── main.js                   # Initialization
+├── vendor/
+│   ├── toastui-editor-all.min.js # Toast UI Editor JS (bundled)
+│   └── toastui-editor.min.css    # Toast UI Editor CSS (bundled)
+├── template.html                 # HTML structure (uses CDN for local dev convenience)
+├── build.sh                      # Build script (inlines vendor files, strips CDN refs)
+└── dist/
+    └── mdedit.html               # Built self-contained file
+```
+
+## Technical Details
+
+- **No server required** - runs entirely in browser
+- **File System Access API** - direct local file access
+- **Toast UI Editor v3.2.2** - bundled from `vendor/` into the built output (no CDN required)
+- **Tailwind CSS** - replaced at build time by `css/tailwind-utils.css`, a hand-written static subset containing only the ~80 utility classes actually used in `template.html` (no runtime overhead, no console warnings)
+- **Fully self-contained** - `dist/mdedit.html` (~850 KB) works offline with no external dependencies
+
+> **Development note**: `template.html` loads Toast UI and Tailwind from CDN for a faster local development
+> experience (open `template.html` directly in a browser). The `build.sh` script replaces the Tailwind CDN
+> `<script>` tag with nothing (utilities come from `css/tailwind-utils.css` instead) and replaces the Toast UI
+> CDN tags with the locally bundled `vendor/` files when producing `dist/mdedit.html`.
+
+### Modules
+
+CSS and JS modules live under `css/` and `js/`. The canonical load order is in `build.sh`. See the root `ARCHITECTURE.md` for the build/module pattern and `AGENTS.md` for shared helpers.
+
+mdedit-specific notes:
+- `css/tailwind-utils.css` is a hand-curated static subset of Tailwind v3 — there is no Tailwind build step. Add a class here when adding it to `template.html`.
+- Toast UI Editor v3.2.2 ships pre-bundled in `vendor/`. `template.html` loads it from CDN for dev convenience; `build.sh` swaps the CDN tag for the bundled file.
+- File operations (create, rename, delete) live in `js/file-ops.js`.
+
+### Build Process
+
+The build script (`build.sh`):
+1. Concatenates all local CSS and JS files in dependency order
+2. **Replaces** the CDN `<script>`/`<link>` tags for Tailwind and Toast UI with the locally bundled files from `vendor/`
+3. Injects everything into `template.html` to produce `dist/mdedit.html`
+
+The final HTML file (~850 KB) is fully self-contained and works offline.
+
+### Architecture Notes
+
+- All local CSS/JS files are inlined into the output HTML
+- Vendor dependencies (Toast UI, Tailwind) are bundled from `vendor/` — no runtime CDN access
+- `template.html` loads dependencies from CDN for convenient local development, but `build.sh` replaces these
+- No npm dependencies required at runtime
+- File System Access API requires Chromium-based browsers
diff --git a/mdedit/build.sh b/mdedit/build.sh
new file mode 100644
index 0000000..f21f3a0
--- /dev/null
+++ b/mdedit/build.sh
@@ -0,0 +1,127 @@
+#!/bin/sh
+set -eu
+
+root_dir=$(cd "$(dirname "$0")" && pwd)
+. "$root_dir/../shared/build-lib.sh"
+
+src_html="$root_dir/template.html"
+output_dir="$root_dir/dist"
+output_html="$output_dir/mdedit.html"
+
+# Vendor files (bundled dependencies — no CDN required at runtime)
+# Note: Tailwind is NOT a vendor file — it's replaced by css/tailwind-utils.css,
+# a hand-written subset of only the utility classes used in template.html.
+toastui_js="$root_dir/vendor/toastui-editor-all.min.js"
+toastui_css="$root_dir/vendor/toastui-editor.min.css"
+
+mkdir -p "$output_dir"
+ensure_exists "$src_html"
+ensure_exists "$toastui_js"
+ensure_exists "$toastui_css"
+
+css_temp=$(mktemp)
+js_raw=$(mktemp)
+js_temp=$(mktemp)
+toastui_js_safe=$(mktemp)
+cleanup() { rm -f "$css_temp" "$js_raw" "$js_temp" "$toastui_js_safe"; }
+trap cleanup EXIT
+
+# CSS files to concatenate in order
+concat_files \
+  "css/tailwind-utils.css" \
+  "../shared/base.css" \
+  "css/base.css" \
+  "css/editor.css" \
+  "css/toc.css" \
+  "css/markdown.css" \
+  > "$css_temp"
+
+# JavaScript files to concatenate in order
+concat_files \
+  "../shared/zddc.js" \
+  "../shared/theme.js" \
+  "js/app.js" \
+  "js/utils.js" \
+  "js/front-matter.js" \
+  "js/file-ops.js" \
+  "js/file-system.js" \
+  "js/file-tree.js" \
+  "js/editor.js" \
+  "js/toc.js" \
+  "js/resizer.js" \
+  "js/events.js" \
+  "js/main.js" \
+  "../shared/help.js" \
+  > "$js_raw"
+
+# Escape '</' in app JS and the Toast UI vendor JS so neither can prematurely
+# close the inline <script> blocks they get embedded in.
+escape_js_close_tags "$js_raw"     "$js_temp"
+escape_js_close_tags "$toastui_js" "$toastui_js_safe"
+
+compute_build_label "mdedit" "${1:-}" "${2:-}"
+
+# Process template:
+#   - Strip the Tailwind CDN <script> tag (css/tailwind-utils.css replaces it)
+#   - Replace CDN <link> for Toast UI CSS with inline bundled CSS
+#   - Replace CDN <script src="...toastui..."> with inline bundled Toast UI JS
+#   - Inject custom CSS/JS at {{CSS_PLACEHOLDER}} and {{JS_PLACEHOLDER}}
+#   - Substitute {{BUILD_LABEL}}
+awk \
+  -v css_file="$css_temp" \
+  -v js_file="$js_temp" \
+  -v toastui_js="$toastui_js_safe" \
+  -v toastui_css="$toastui_css" \
+  -v build_label="$build_label" \
+  -v is_red="$is_red" \
+  '
+  /\{\{CSS_PLACEHOLDER\}\}/ {
+    while ((getline line < css_file) > 0) print line
+    close(css_file)
+    next
+  }
+  /\{\{JS_PLACEHOLDER\}\}/ {
+    while ((getline line < js_file) > 0) print line
+    close(js_file)
+    next
+  }
+  /\{\{BUILD_LABEL\}\}/ {
+    if (is_red == "1") {
+      gsub(/\{\{BUILD_LABEL\}\}/, "<span style=\"color:red;font-weight:bold\">" build_label "</span>")
+    } else {
+      gsub(/\{\{BUILD_LABEL\}\}/, build_label)
+    }
+    print
+    next
+  }
+  /<script src="https:\/\/cdn\.tailwindcss\.com"/ {
+    # Stripped: Tailwind utility classes are in css/tailwind-utils.css instead
+    next
+  }
+  /<link rel="stylesheet" href="https:\/\/uicdn\.toast\.com\/editor\/[^"]*\/toastui-editor\.min\.css"/ {
+    # Inline the bundled Toast UI CSS
+    print "<style>"
+    while ((getline line < toastui_css) > 0) print line
+    close(toastui_css)
+    print "</style>"
+    next
+  }
+  /<script src="https:\/\/uicdn\.toast\.com\/editor\/[^"]*\/toastui-editor/ {
+    # Inline the bundled Toast UI JS (already passed through escape_js_close_tags
+    # so its content cannot contain a literal </script> sequence). We close with
+    # the real </script> because only that exact string terminates a script
+    # block per the HTML5 spec.
+    print "<script>"
+    while ((getline line < toastui_js) > 0) print line
+    close(toastui_js)
+    print "</script>"
+    next
+  }
+  { print }
+' "$src_html" > "$output_html"
+
+echo "Wrote $output_html ($(wc -c < "$output_html") bytes)"
+
+if [ "$is_release" = "1" ]; then
+    promote_release "mdedit"
+fi
diff --git a/mdedit/css/base.css b/mdedit/css/base.css
new file mode 100644
index 0000000..90fa345
--- /dev/null
+++ b/mdedit/css/base.css
@@ -0,0 +1,382 @@
+/* mdedit component styles — reset and tokens from shared/base.css */
+
+/* Pane resizer */
+.pane-resizer:hover {
+    background-color: var(--primary) !important;
+}
+
+/* File tree */
+.file-tree {
+    font-size: 0.9rem;
+}
+
+.directory-item,
+.file-item {
+    transition: background-color 0.15s ease;
+}
+
+.dir-icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    transform: rotate(90deg);
+    transition: transform 0.2s ease;
+    vertical-align: middle;
+}
+
+.dir-icon svg {
+    width: 12px;
+    height: 12px;
+    stroke: currentColor;
+    stroke-width: 2;
+}
+
+.directory-item.collapsed .dir-icon {
+    transform: rotate(0deg);
+}
+
+/* Two-line filename styles */
+.filename-main {
+    font-size: 0.9rem;
+    font-weight: 500;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.filename-secondary {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* Active file highlighting */
+.active-file {
+    background-color: var(--primary) !important;
+    color: var(--text-light) !important;
+    font-weight: 500;
+}
+
+.active-file * {
+    color: var(--text-light) !important;
+}
+
+/* ── File Tree Action Buttons ──────────────────────────────────────────────── */
+.tree-actions {
+    display: flex;
+    gap: 0.25rem;
+    align-items: center;
+    margin-left: auto;
+    opacity: 0;
+    transition: opacity 0.2s ease;
+}
+
+.directory-item:hover .tree-actions,
+.file-item:hover .tree-actions,
+.active-file .tree-actions {
+    opacity: 1;
+}
+
+.tree-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.25rem;
+    height: 1.25rem;
+    padding: 0;
+    border: none;
+    background-color: transparent;
+    color: var(--text-muted);
+    cursor: pointer;
+    border-radius: 0.25rem;
+    transition: background-color 0.15s ease, color 0.15s ease;
+}
+
+.tree-btn:hover {
+    background-color: var(--bg-secondary);
+    color: var(--text);
+}
+
+.tree-btn--danger:hover {
+    background-color: #fee2e2;
+    color: #dc2626;
+}
+
+[data-theme="dark"] .tree-btn--danger:hover {
+    background-color: rgba(127, 29, 29, 0.5);
+    color: #fca5a5;
+}
+
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) .tree-btn--danger:hover {
+        background-color: rgba(127, 29, 29, 0.5);
+        color: #fca5a5;
+    }
+}
+
+.tree-btn svg {
+    width: 1rem;
+    height: 1rem;
+    stroke: currentColor;
+    stroke-width: 2;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+/* Directory toggle indicator */
+.directory-item {
+    position: relative;
+}
+
+.directory-item.collapsed .directory-contents {
+    display: none;
+}
+
+/* File view container */
+.file-view-container {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    width: 100%;
+}
+
+/* File header */
+.file-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.5rem 1rem;
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+}
+
+.file-title {
+    font-size: 1.125rem;
+    font-weight: 500;
+    color: var(--text);
+    margin: 0;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* File content area */
+.file-content-area {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+}
+
+/* Content container */
+#content-container {
+    flex-direction: column;
+    height: 100%;
+}
+
+/* Image preview */
+.image-preview-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--bg-secondary);
+}
+
+.image-preview {
+    max-width: 100%;
+    max-height: 100%;
+    object-fit: contain;
+}
+
+/* HTML preview iframe */
+.html-preview-container {
+    width: 100%;
+    height: 100%;
+}
+
+.html-preview-iframe {
+    width: 100%;
+    height: 100%;
+    border: 0;
+}
+
+/* Dirty indicator */
+.dirty-indicator {
+    margin-left: 0.25rem;
+    color: var(--warning);
+    font-weight: bold;
+}
+
+.is-dirty {
+    font-style: italic;
+}
+
+/* ── App header layout ────────────────────────────────────────────────────── */
+.header-left,
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+/* ── Tailwind class overrides: use CSS tokens instead of hardcoded colours ── */
+/* bg-white / bg-gray-100 are used on the pane backgrounds in template.html.  */
+/* Override them here so they follow the design-token system (light + dark).   */
+.bg-white     { background-color: var(--bg) !important; }
+.bg-gray-100  { background-color: var(--bg-secondary) !important; }
+
+/* ── Front matter nav bar ──────────────────────────────────────────────────── */
+.front-matter-nav {
+    border-bottom: 1px solid var(--border);
+    background-color: var(--bg-secondary);
+}
+
+.front-matter-nav__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.5rem 1rem;
+    cursor: pointer;
+    transition: background-color 0.15s ease;
+}
+
+.front-matter-nav__header:hover {
+    background-color: var(--bg-hover);
+}
+
+.front-matter-toggle {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.25rem;
+    height: 1.25rem;
+    padding: 0;
+    border: none;
+    background: transparent;
+    color: var(--text-muted);
+    cursor: pointer;
+    border-radius: 4px;
+    transition: transform 0.2s ease, color 0.15s ease;
+}
+
+.front-matter-toggle:hover {
+    background-color: var(--bg-secondary);
+    color: var(--text);
+}
+
+.front-matter-toggle svg {
+    width: 0.75rem;
+    height: 0.75rem;
+    stroke: currentColor;
+    stroke-width: 2;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+/* Toggle arrow rotation for collapsed state */
+.front-matter-nav.collapsed .front-matter-toggle .arrow-down {
+    transform: rotate(-90deg);
+}
+
+/* Front matter content area */
+.front-matter-content {
+    overflow: hidden;
+    transition: max-height 0.25s ease, padding 0.25s ease, opacity 0.25s ease;
+    max-height: 500px;
+    padding: 0 1rem;
+}
+
+/* When collapsed, hide content completely */
+.front-matter-nav.collapsed {
+    border-bottom: none;
+}
+
+.front-matter-nav.collapsed .front-matter-content {
+    display: none;
+}
+
+/* Front matter textarea */
+.front-matter-textarea {
+    color: var(--text);
+    background-color: var(--bg);
+    border: none;
+    resize: none;
+    font-family: var(--font-mono);
+    font-size: 0.8rem;
+    white-space: pre;     /* preserve yaml structure, enables horiz scroll */
+    overflow-x: auto;
+    overflow-y: hidden;   /* height is set by JS to fit content exactly */
+    width: 100%;
+    box-sizing: border-box;
+    display: block;
+}
+
+/* ── Hidden utility (for disabled buttons) ─────────────────────────────────── */
+.hide { display: none; }
+
+/* ── File tree row layout ───────────────────────────────────────────────────── */
+.tree-row {
+    display: flex;
+    align-items: center;
+    min-width: 0;
+}
+
+.tree-row__label {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+/* ── New-file modal ─────────────────────────────────────────────────────────── */
+.modal-overlay {
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,0.4);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+}
+.modal-overlay.hidden { display: none; }
+.modal-box {
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    padding: 1.5rem;
+    min-width: 20rem;
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    box-shadow: 0 4px 24px rgba(0,0,0,0.18);
+}
+.modal-title {
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text);
+    margin: 0;
+}
+.modal-input {
+    width: 100%;
+    padding: 0.4rem 0.6rem;
+    border: 1px solid var(--border);
+    border-radius: 0.25rem;
+    font-size: 0.9rem;
+    color: var(--text);
+    background: var(--bg);
+    box-sizing: border-box;
+}
+.modal-input:focus {
+    outline: 2px solid var(--primary);
+    outline-offset: 1px;
+}
+.modal-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.5rem;
+}
diff --git a/mdedit/css/editor.css b/mdedit/css/editor.css
new file mode 100644
index 0000000..1168c4a
--- /dev/null
+++ b/mdedit/css/editor.css
@@ -0,0 +1,25 @@
+/* Toast UI Editor styles */
+#markdown-editor {
+    display: block !important;
+    height: 100% !important;
+    min-height: 500px !important;
+    width: 100% !important;
+    position: relative !important;
+    z-index: 10;
+}
+
+.editor-instance {
+    height: 100% !important;
+    min-height: 500px !important;
+}
+
+.toastui-editor-defaultUI {
+    height: 100% !important;
+}
+
+.toastui-editor-defaultUI-toolbar,
+.toastui-editor-main,
+.toastui-editor-main .ProseMirror,
+.toastui-editor-main .toastui-editor-md-preview {
+    height: 100% !important;
+}
diff --git a/mdedit/css/markdown.css b/mdedit/css/markdown.css
new file mode 100644
index 0000000..a3a9c00
--- /dev/null
+++ b/mdedit/css/markdown.css
@@ -0,0 +1,223 @@
+/* Markdown content rendering styles */
+.markdown-content {
+    line-height: 1.6;
+}
+
+.markdown-content h1,
+.toastui-editor-contents h1 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 2em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 24px;
+    margin-bottom: 16px;
+    padding-bottom: 0.3em;
+    border-bottom: 1px solid var(--border);
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h2,
+.toastui-editor-contents h2 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 1.5em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 24px;
+    margin-bottom: 16px;
+    padding-bottom: 0.3em;
+    border-bottom: 1px solid var(--border);
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h3,
+.toastui-editor-contents h3 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 1.25em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h4,
+.toastui-editor-contents h4 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 1em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h5,
+.toastui-editor-contents h5 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 0.875em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h6,
+.toastui-editor-contents h6 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 0.85em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text-muted);
+    word-wrap: break-word;
+}
+
+/* Reset margin-top for first-child headings */
+.markdown-content h1:first-child,
+.markdown-content h2:first-child,
+.markdown-content h3:first-child,
+.markdown-content h4:first-child,
+.markdown-content h5:first-child,
+.markdown-content h6:first-child,
+.toastui-editor-contents h1:first-child,
+.toastui-editor-contents h2:first-child,
+.toastui-editor-contents h3:first-child,
+.toastui-editor-contents h4:first-child,
+.toastui-editor-contents h5:first-child,
+.toastui-editor-contents h6:first-child {
+    margin-top: 0;
+}
+
+/* Reduce spacing between consecutive headings */
+.markdown-content h1 + h2,
+.toastui-editor-contents h1 + h2 {
+    margin-top: 1rem;
+}
+
+.markdown-content h2 + h3,
+.toastui-editor-contents h2 + h3 {
+    margin-top: 1.5rem;
+}
+
+.markdown-content h3 + h4,
+.toastui-editor-contents h3 + h4 {
+    margin-top: 1.25rem;
+}
+
+.markdown-content h4 + h5,
+.toastui-editor-contents h4 + h5 {
+    margin-top: 1rem;
+}
+
+.markdown-content h5 + h6,
+.toastui-editor-contents h5 + h6 {
+    margin-top: 0.75rem;
+}
+
+.markdown-content p,
+.toastui-editor-contents p {
+    margin-bottom: 1rem;
+}
+
+.markdown-content ul,
+.markdown-content ol,
+.toastui-editor-contents ul,
+.toastui-editor-contents ol {
+    margin-bottom: 1rem;
+    padding-left: 2rem;
+}
+
+.markdown-content ul,
+.toastui-editor-contents ul {
+    list-style-type: disc;
+}
+
+.markdown-content ol,
+.toastui-editor-contents ol {
+    list-style-type: decimal;
+}
+
+.markdown-content li,
+.toastui-editor-contents li {
+    margin-bottom: 0.25rem;
+}
+
+.markdown-content code,
+.toastui-editor-contents code {
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    font-size: 0.9em;
+    padding: 0.2em 0.4em;
+    background-color: var(--bg-secondary);
+    border-radius: 0.25rem;
+}
+
+.markdown-content pre,
+.toastui-editor-contents pre {
+    margin-bottom: 1rem;
+    padding: 1rem;
+    background-color: var(--bg-secondary);
+    border-radius: 0.375rem;
+    overflow-x: auto;
+}
+
+.markdown-content pre code,
+.toastui-editor-contents pre code {
+    background-color: transparent;
+    padding: 0;
+    border-radius: 0;
+}
+
+.markdown-content blockquote,
+.toastui-editor-contents blockquote {
+    border-left: 4px solid var(--border);
+    padding-left: 1rem;
+    margin-left: 0;
+    margin-right: 0;
+    margin-bottom: 1rem;
+    color: var(--text-muted);
+}
+
+.markdown-content a,
+.toastui-editor-contents a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+.markdown-content a:hover,
+.toastui-editor-contents a:hover {
+    text-decoration: underline;
+}
+
+.markdown-content table,
+.toastui-editor-contents table {
+    border-collapse: collapse;
+    width: 100%;
+    margin-bottom: 1rem;
+}
+
+.markdown-content th,
+.markdown-content td,
+.toastui-editor-contents th,
+.toastui-editor-contents td {
+    border: 1px solid var(--border);
+    padding: 0.5rem;
+    text-align: left;
+}
+
+.markdown-content th,
+.toastui-editor-contents th {
+    background-color: var(--bg-secondary);
+    font-weight: 600;
+}
+
+.markdown-content tr:nth-child(even),
+.toastui-editor-contents tr:nth-child(even) {
+    background-color: var(--bg-hover);
+}
diff --git a/mdedit/css/tailwind-utils.css b/mdedit/css/tailwind-utils.css
new file mode 100644
index 0000000..7ff54ab
--- /dev/null
+++ b/mdedit/css/tailwind-utils.css
@@ -0,0 +1,184 @@
+/*
+ * Tailwind utility subset for mdedit
+ *
+ * This file replaces the Tailwind Play CDN. It contains only the utility
+ * classes actually used in template.html, hand-written to match Tailwind v3
+ * output exactly. If new Tailwind classes are needed in template.html, add
+ * them here and remove the class from this comment.
+ *
+ * Generated from: grep -o 'class="[^"]*"' template.html | tr ' ' '\n' | sort -u
+ * Tailwind version parity: v3.x (default spacing scale, gray palette, etc.)
+ */
+
+/* ── Reset ── */
+*, ::before, ::after { box-sizing: border-box; }
+
+/* ── Display ── */
+.flex          { display: flex; }
+.inline-flex   { display: inline-flex; }
+/* .hidden lives in shared/base.css (uses !important) */
+
+/* ── Flex direction ── */
+.flex-col      { flex-direction: column; }
+.flex-row      { flex-direction: row; }
+
+/* ── Flex grow ── */
+.flex-1        { flex: 1 1 0%; }
+
+/* ── Alignment ── */
+.items-center     { align-items: center; }
+.justify-between  { justify-content: space-between; }
+.justify-center   { justify-content: center; }
+
+/* ── Gap ── */
+.gap-1  { gap: 0.25rem; }
+.gap-2  { gap: 0.5rem; }
+.gap-4  { gap: 1rem; }
+.gap-6  { gap: 1.5rem; }
+
+/* ── Overflow ── */
+.overflow-hidden { overflow: hidden; }
+.overflow-auto   { overflow: auto; }
+
+/* ── Sizing ── */
+.h-screen { height: 100vh; }
+.h-full   { height: 100%; }
+.h-12     { height: 3rem; }
+.h-6      { height: 1.5rem; }
+.h-3\.5   { height: 0.875rem; }
+.h-24     { height: 6rem; }
+
+/* ── Resize ── */
+.resize-none { resize: none; }
+
+/* ── Border ── */
+.border-0 { border-width: 0; }
+
+/* ── Outline ── */
+.focus\:outline-none:focus { outline: none; }
+.w-full   { width: 100%; }
+.w-1      { width: 0.25rem; }
+.w-3\.5   { width: 0.875rem; }
+
+/* ── Positioning ── */
+.relative { position: relative; }
+.z-10     { z-index: 10; }
+
+/* ── Spacing ── */
+.p-4  { padding: 1rem; }
+.p-6  { padding: 1.5rem; }
+.px-2 { padding-left: 0.5rem;  padding-right: 0.5rem; }
+.pl-2 { padding-left: 0.5rem; }
+.px-3 { padding-left: 0.75rem; padding-right: 0.75rem; }
+.px-4 { padding-left: 1rem;    padding-right: 1rem; }
+.py-1 { padding-top: 0.25rem;  padding-bottom: 0.25rem; }
+.py-2 { padding-top: 0.5rem;   padding-bottom: 0.5rem; }
+.mt-2 { margin-top: 0.5rem; }
+.mb-2 { margin-bottom: 0.5rem; }
+.mb-4 { margin-bottom: 1rem; }
+
+/* ── Typography ── */
+.text-xl   { font-size: 1.25rem;  line-height: 1.75rem; }
+.text-sm   { font-size: 0.875rem; line-height: 1.25rem; }
+.text-xs   { font-size: 0.75rem;  line-height: 1rem; }
+.font-semibold { font-weight: 600; }
+.font-medium   { font-weight: 500; }
+.text-center   { text-align: center; }
+.leading-none  { line-height: 1; }
+.select-none   { user-select: none; }
+
+/* ── Colors — text ── */
+.text-white      { color: #ffffff; }
+.text-gray-800   { color: #1f2937; }
+.text-gray-700   { color: #374151; }
+.text-gray-500   { color: #6b7280; }
+.text-amber-600  { color: #d97706; }
+
+/* ── Colors — background ── */
+.bg-white        { background-color: #ffffff; }
+.bg-gray-100     { background-color: #f3f4f6; }
+.bg-gray-200     { background-color: #e5e7eb; }
+.bg-transparent  { background-color: transparent; }
+.bg-blue-500     { background-color: #3b82f6; }
+
+/* ── Borders ── */
+.border   { border-width: 1px; border-style: solid; }
+.border-b { border-bottom-width: 1px; border-bottom-style: solid; }
+.border-t { border-top-width: 1px;    border-top-style: solid; }
+.border-gray-200 { border-color: #e5e7eb; }
+.border-gray-300 { border-color: #d1d5db; }
+.rounded  { border-radius: 0.25rem; }
+
+/* ── Opacity ── */
+.opacity-70 { opacity: 0.7; }
+.opacity-80 { opacity: 0.8; }
+
+/* ── SVG ── */
+.fill-current { fill: currentColor; }
+
+/* ── Cursor ── */
+.cursor-pointer    { cursor: pointer; }
+.cursor-col-resize { cursor: col-resize; }
+
+/* ── Transitions ── */
+.transition-all      { transition-property: all;              transition-timing-function: cubic-bezier(0.4,0,0.2,1); transition-duration: 150ms; }
+.transition-colors   { transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke; transition-timing-function: cubic-bezier(0.4,0,0.2,1); transition-duration: 150ms; }
+.transition-opacity  { transition-property: opacity;          transition-timing-function: cubic-bezier(0.4,0,0.2,1); transition-duration: 150ms; }
+
+/* ── Pseudo-class: hover ── */
+.hover\:bg-blue-500:hover  { background-color: #3b82f6; }
+.hover\:bg-blue-600:hover  { background-color: #2563eb; }
+.hover\:bg-gray-200:hover  { background-color: #e5e7eb; }
+.hover\:opacity-80:hover   { opacity: 0.8; }
+
+/* ── Pseudo-class: disabled ── */
+.disabled\:bg-gray-400:disabled   { background-color: #9ca3af; }
+.disabled\:cursor-not-allowed:disabled { cursor: not-allowed; }
+
+/* ── Dark mode (prefers-color-scheme or manual [data-theme="dark"]) ── */
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]) .dark\:bg-gray-700  { background-color: #374151; }
+  :root:not([data-theme="light"]) .dark\:bg-gray-800  { background-color: #1f2937; }
+  :root:not([data-theme="light"]) .dark\:bg-gray-900  { background-color: #111827; }
+  :root:not([data-theme="light"]) .dark\:border-gray-600 { border-color: #4b5563; }
+  :root:not([data-theme="light"]) .dark\:border-gray-700 { border-color: #374151; }
+  :root:not([data-theme="light"]) .dark\:text-gray-200   { color: #e5e7eb; }
+  :root:not([data-theme="light"]) .dark\:text-gray-400   { color: #9ca3af; }
+  :root:not([data-theme="light"]) .dark\:hover\:bg-gray-700:hover { background-color: #374151; }
+  :root:not([data-theme="light"]) .dark\:hover\:bg-gray-800:hover { background-color: #1f2937; }
+}
+
+/* Manual dark override */
+[data-theme="dark"] .dark\:bg-gray-700  { background-color: #374151; }
+[data-theme="dark"] .dark\:bg-gray-800  { background-color: #1f2937; }
+[data-theme="dark"] .dark\:bg-gray-900  { background-color: #111827; }
+[data-theme="dark"] .dark\:border-gray-600 { border-color: #4b5563; }
+[data-theme="dark"] .dark\:border-gray-700 { border-color: #374151; }
+[data-theme="dark"] .dark\:text-gray-200   { color: #e5e7eb; }
+[data-theme="dark"] .dark\:text-gray-400   { color: #9ca3af; }
+[data-theme="dark"] .dark\:hover\:bg-gray-700:hover { background-color: #374151; }
+[data-theme="dark"] .dark\:hover\:bg-gray-800:hover { background-color: #1f2937; }
+
+/* Manual light override — ensure bg-white/bg-gray-100 are NOT overridden by above */
+[data-theme="light"] .dark\:bg-gray-700,
+[data-theme="light"] .dark\:bg-gray-800,
+[data-theme="light"] .dark\:bg-gray-900 { background-color: revert; }
+
+/* ── Directional spacing (used in JS-generated elements) ── */
+.ml-1  { margin-left: 0.25rem; }
+.ml-4  { margin-left: 1rem; }
+.mr-1  { margin-right: 0.25rem; }
+.pl-0  { padding-left: 0; }
+.pl-4  { padding-left: 1rem; }
+
+/* ── Additional missing utilities ── */
+.whitespace-nowrap  { white-space: nowrap; }
+.text-ellipsis      { text-overflow: ellipsis; }
+.font-bold          { font-weight: 700; }
+.border-r           { border-right-width: 1px; border-right-style: solid; }
+.mt-1               { margin-top: 0.25rem; }
+.text-amber-500     { color: #f59e0b; }
+.text-blue-600      { color: #2563eb; }
+.hover\:bg-gray-100:hover  { background-color: #f3f4f6; }
+.hover\:text-blue-800:hover { color: #1e40af; }
+.hover\:underline:hover    { text-decoration: underline; }
diff --git a/mdedit/css/toc.css b/mdedit/css/toc.css
new file mode 100644
index 0000000..ddd06cf
--- /dev/null
+++ b/mdedit/css/toc.css
@@ -0,0 +1,276 @@
+/* Table of Contents styles */
+.toc-pane {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+}
+
+.toc-container,
+.toc-content {
+    flex: 1;
+    overflow-y: auto;
+}
+
+.toc-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px 12px;
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    font-weight: bold;
+}
+
+.toc-depth-selector {
+    font-size: 0.85rem;
+    padding: 2px 6px;
+    border-radius: 3px;
+    border: 1px solid var(--border);
+    background: var(--bg);
+    color: var(--text);
+}
+
+.toc-list {
+    list-style: none;
+    padding-left: 0;
+    margin: 0;
+    font-size: 0.8rem;
+}
+
+.toc-item {
+    padding: 0;
+    margin: 0;
+    line-height: 1.2;
+}
+
+/* TOC heading level styles */
+.toc-level-1 > a {
+    font-size: 0.9rem;
+    font-weight: 600;
+    color: var(--text);
+}
+
+.toc-level-2 > a {
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--text);
+}
+
+.toc-level-3 > a {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+.toc-level-4 > a {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+.toc-level-5 > a,
+.toc-level-6 > a {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+/* Nested list spacing */
+.toc-list ul {
+    list-style: none;
+    padding-left: 6px;
+    margin: 0;
+}
+
+.toc-list li {
+    margin-bottom: 1px;
+    line-height: 1.2;
+}
+
+.toc-list li a {
+    display: block;
+    padding: 2px 6px;
+    color: var(--text-muted);
+    text-decoration: none;
+    border-radius: 3px;
+    transition: background-color 0.15s ease;
+}
+
+.toc-list li a:hover {
+    background-color: var(--bg-hover);
+    color: var(--text);
+}
+
+/* Active TOC item highlighting */
+.toc-list li.toc-active {
+    background-color: var(--primary);
+    border-radius: 3px;
+}
+
+/* Use high-specificity selectors to override per-level color rules */
+.toc-list li.toc-active > a,
+.toc-list li.toc-active > a:hover,
+.toc-list li.toc-level-1.toc-active > a,
+.toc-list li.toc-level-2.toc-active > a,
+.toc-list li.toc-level-3.toc-active > a,
+.toc-list li.toc-level-4.toc-active > a,
+.toc-list li.toc-level-5.toc-active > a,
+.toc-list li.toc-level-6.toc-active > a {
+    color: var(--text-light);
+    border-bottom-color: transparent;
+    background-color: transparent;
+}
+
+.toc-list li.toc-level-1 {
+    font-weight: 700;
+    font-size: 1rem;
+    padding-left: 0px;
+}
+
+.toc-list li.toc-level-1 a {
+    color: var(--text);
+    border-bottom: 1px solid var(--primary);
+    padding-bottom: 2px;
+}
+
+/* Tree-style connecting lines for TOC hierarchy */
+.toc-list li.toc-level-2 {
+    font-weight: 650;
+    font-size: 0.9rem;
+    padding-left: 16px;
+    position: relative;
+}
+
+.toc-list li.toc-level-2::before {
+    content: '';
+    position: absolute;
+    left: 6px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-2 a {
+    color: var(--text);
+}
+
+.toc-list li.toc-level-3 {
+    font-weight: 600;
+    font-size: 0.8rem;
+    padding-left: 32px;
+    position: relative;
+}
+
+.toc-list li.toc-level-3::before {
+    content: '';
+    position: absolute;
+    left: 22px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-3 a {
+    color: var(--text-muted);
+}
+
+.toc-list li.toc-level-4 {
+    font-weight: 600;
+    font-size: 0.75rem;
+    padding-left: 48px;
+    position: relative;
+}
+
+.toc-list li.toc-level-4::before {
+    content: '';
+    position: absolute;
+    left: 38px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-4 a {
+    color: var(--text-muted);
+}
+
+.toc-list li.toc-level-5 {
+    font-weight: 600;
+    font-size: 0.7rem;
+    padding-left: 64px;
+    font-style: italic;
+    position: relative;
+}
+
+.toc-list li.toc-level-5::before {
+    content: '';
+    position: absolute;
+    left: 54px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-5 a {
+    color: var(--text-muted);
+}
+
+.toc-list li.toc-level-6 {
+    font-weight: 600;
+    font-size: 0.65rem;
+    padding-left: 80px;
+    font-style: italic;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    position: relative;
+}
+
+.toc-list li.toc-level-6::before {
+    content: '';
+    position: absolute;
+    left: 70px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-6 a {
+    color: var(--text-muted);
+}
+
+/* Vertical connecting lines */
+.toc-list li:not(.toc-level-1)::after {
+    content: '';
+    position: absolute;
+    left: 6px;
+    top: 50%;
+    bottom: -2px;
+    border-left: 1px solid var(--border);
+    z-index: -1;
+}
+
+.toc-list li.toc-level-3::after {
+    left: 22px;
+}
+
+.toc-list li.toc-level-4::after {
+    left: 38px;
+}
+
+.toc-list li.toc-level-5::after {
+    left: 54px;
+}
+
+.toc-list li.toc-level-6::after {
+    left: 70px;
+}
diff --git a/mdedit/js/app.js b/mdedit/js/app.js
new file mode 100644
index 0000000..90db27c
--- /dev/null
+++ b/mdedit/js/app.js
@@ -0,0 +1,24 @@
+/**
+ * Global application state and constants
+ */
+
+// Set to true to enable verbose console logging for development.
+const DEBUG = false;
+
+// Check if File System Access API is available
+const hasFileSystemAccess = 'showDirectoryPicker' in window;
+
+// Directory and file handles
+let directoryHandle = null;
+let fileTree = {};
+let currentFileHandle = null;
+
+// Map to store editor instances for each file
+// Key: file path, Value: { editor, container, tocContainer, etc. }
+const editorInstances = new Map();
+
+// Current TOC max depth (1-6)
+let tocMaxDepth = 3;
+
+// Scratchpad ID constant
+const SCRATCHPAD_ID = '__scratchpad__';
diff --git a/mdedit/js/editor.js b/mdedit/js/editor.js
new file mode 100644
index 0000000..97350f7
--- /dev/null
+++ b/mdedit/js/editor.js
@@ -0,0 +1,403 @@
+/**
+ * Toast UI Editor initialization and management
+ */
+
+/**
+ * Initialize or update the Toast UI Editor for a file
+ * @param {string} content - Content to display
+ * @param {boolean} isMarkdown - Whether content is markdown
+ * @param {string} filePath - Path of the file
+ * @param {string} fileName - Name of the file
+ * @param {FileSystemFileHandle} fileHandle - File handle for saving
+ * @param {number} lastModified - Timestamp of last modification
+ */
+function initializeEditor(content, isMarkdown = true, filePath = '', fileName = '', fileHandle = null, lastModified = null) {
+    // Parse front matter
+    let frontMatterData = {};
+    let markdownBody = content;
+    
+    if (isMarkdown && content) {
+        try {
+            const parsed = parseFrontMatter(content);
+            frontMatterData = parsed.data;
+            markdownBody = parsed.content;
+        } catch (error) {
+            console.error('Failed to parse front matter:', error);
+        }
+    }
+    
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    // Hide all file view containers
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    // Check if file already has an instance
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return existingInstance.editor;
+    }
+
+    // Create file view container
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    // Create file header
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    // Button container for alignment
+    const buttonContainer = document.createElement('div');
+    buttonContainer.className = 'flex gap-2';
+
+    // Determine if this is a scratchpad (no file handle)
+    const isScratchpad = !fileHandle;
+
+    // Save button (or Save As for scratchpads)
+    const saveButton = document.createElement('button');
+    saveButton.className = 'btn btn-primary btn-sm';
+    saveButton.textContent = isScratchpad ? 'Save As...' : 'Save File';
+    saveButton.disabled = !isScratchpad; // Scratchpads can always save
+    buttonContainer.appendChild(saveButton);
+
+    // Reload button (only for files, not scratchpads)
+    let reloadButton = null;
+    if (!isScratchpad) {
+        reloadButton = document.createElement('button');
+        reloadButton.className = 'btn btn-secondary btn-sm';
+        reloadButton.textContent = 'Reload from Disk';
+        reloadButton.title = 'Reload file from disk (discards unsaved changes)';
+        buttonContainer.appendChild(reloadButton);
+    }
+
+    fileHeader.appendChild(buttonContainer);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    // Content area
+    const contentArea = document.createElement('div');
+    contentArea.className = 'flex flex-col flex-1 overflow-hidden';
+    
+    // Editor area with TOC
+    const editorArea = document.createElement('div');
+    editorArea.className = 'flex flex-row flex-1 overflow-hidden';
+
+    // TOC pane (markdown only)
+    let tocContainer = null;
+    let frontMatterTextarea = null;
+    if (isMarkdown) {
+        const tocPane = document.createElement('div');
+        tocPane.className = 'toc-pane bg-white dark:bg-gray-900 border-r border-gray-200 dark:border-gray-700';
+        tocPane.style.width = '325px';
+        tocPane.style.minWidth = '150px';
+
+        // Front matter nav bar (collapsible)
+        const frontMatterNav = document.createElement('div');
+        frontMatterNav.className = 'front-matter-nav border-b border-gray-200 dark:border-gray-700';
+        
+        const frontMatterHeader = document.createElement('div');
+        frontMatterHeader.className = 'front-matter-header px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700 cursor-pointer flex items-center gap-2';
+        
+        const toggleIcon = document.createElement('span');
+        toggleIcon.textContent = '▼';
+        toggleIcon.className = 'toggle-icon text-sm';
+        frontMatterHeader.appendChild(toggleIcon);
+        
+        const headerText = document.createElement('span');
+        headerText.textContent = 'YAML Front Matter';
+        frontMatterHeader.appendChild(headerText);
+        
+        frontMatterNav.appendChild(frontMatterHeader);
+        
+        frontMatterTextarea = document.createElement('textarea');
+        frontMatterTextarea.className = 'front-matter-textarea w-full px-4 py-2 text-sm focus:outline-none resize-none overflow-x-auto';
+        frontMatterTextarea.placeholder = 'title: Document Title\ndate: 2024-01-01\ntags: [example]';
+        
+        // Set front matter content
+        if (frontMatterData && Object.keys(frontMatterData).length > 0) {
+            try {
+                let yamlText = '';
+                for (const [key, value] of Object.entries(frontMatterData)) {
+                    if (Array.isArray(value)) {
+                        yamlText += `${key}: [${value.map(v => `"${v}"`).join(', ')}]\n`;
+                    } else {
+                        yamlText += `${key}: ${value}\n`;
+                    }
+                }
+                frontMatterTextarea.value = yamlText.trim();
+            } catch (error) {
+                console.warn('Failed to stringify front matter:', error);
+                frontMatterTextarea.value = '';
+            }
+        }
+        
+        frontMatterNav.appendChild(frontMatterTextarea);
+        tocPane.appendChild(frontMatterNav);
+
+        const tocHeader = document.createElement('div');
+        tocHeader.className = 'toc-header px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+        const tocTitle = document.createElement('span');
+        tocTitle.textContent = 'Table of Contents';
+        tocHeader.appendChild(tocTitle);
+
+        const tocDepthSelector = document.createElement('select');
+        tocDepthSelector.className = 'toc-depth-selector';
+        tocDepthSelector.innerHTML = `
+            <option value="6">All Levels</option>
+            <option value="1">H1 Only</option>
+            <option value="2">H1-H2</option>
+            <option value="3" selected>H1-H3</option>
+            <option value="4">H1-H4</option>
+            <option value="5">H1-H5</option>
+        `;
+        tocHeader.appendChild(tocDepthSelector);
+
+        tocPane.appendChild(tocHeader);
+
+        tocContainer = document.createElement('div');
+        tocContainer.className = 'toc-container toc-content p-4 h-full overflow-auto';
+        tocPane.appendChild(tocContainer);
+        
+        // Set up TOC container overflow when front matter is toggled
+        let fmIsCollapsed = false;
+        frontMatterHeader.addEventListener('click', () => {
+            fmIsCollapsed = !fmIsCollapsed;
+            frontMatterNav.classList.toggle('collapsed', fmIsCollapsed);
+            toggleIcon.textContent = fmIsCollapsed ? '▶' : '▼';
+        });
+        
+        // Auto-size textarea: no vertical scroll, horizontal scroll for long lines
+        frontMatterTextarea.style.overflowY = 'hidden';
+        frontMatterTextarea.style.overflowX = 'auto';
+        const autoResizeFm = () => {
+            frontMatterTextarea.style.height = 'auto';
+            frontMatterTextarea.style.height = frontMatterTextarea.scrollHeight + 'px';
+        };
+        frontMatterTextarea.addEventListener('input', autoResizeFm);
+        // Defer initial resize until element is in the DOM and has layout
+        requestAnimationFrame(() => requestAnimationFrame(autoResizeFm));
+
+        editorArea.appendChild(tocPane);
+
+        // TOC resizer
+        const tocResizer = document.createElement('div');
+        tocResizer.className = 'pane-resizer bg-gray-200 dark:bg-gray-700 transition-colors relative z-10 w-1 cursor-col-resize hover:bg-blue-500';
+        tocResizer.setAttribute('data-resizer-for', 'toc-pane');
+        contentArea.appendChild(tocResizer);
+
+        makeResizable(tocResizer, tocPane);
+
+        // TOC depth selector event
+        tocDepthSelector.addEventListener('change', function () {
+            const depth = parseInt(this.value);
+            if (window.updateToc && editorInstance) {
+                const currentContent = editorInstance.getMarkdown();
+                window.updateToc(currentContent, tocContainer, editorInstance, depth);
+            }
+        });
+    }
+
+    // Editor container
+    const editorContainer = document.createElement('div');
+    editorContainer.className = 'editor-instance flex-1 overflow-hidden';
+    editorArea.appendChild(editorContainer);
+    
+    contentArea.appendChild(editorArea);
+    fileViewContainer.appendChild(contentArea);
+    contentContainer.appendChild(fileViewContainer);
+
+    // Check Toast UI availability
+    if (typeof toastui === 'undefined') {
+        alert('Error: Toast UI library not loaded!');
+        editorContainer.innerHTML = '<div style="padding: 20px; background: #ffeeee; color: red;">Error: Toast UI library not loaded!</div>';
+        return;
+    }
+
+    let editorInstance;
+
+    try {
+        // Initialize Toast UI Editor
+        const editor = new toastui.Editor({
+            el: editorContainer,
+            height: '100%',
+            initialEditType: 'markdown',
+            previewStyle: 'vertical',
+            initialValue: markdownBody,
+            toolbarItems: [
+                ['heading', 'bold', 'italic', 'strike'],
+                ['hr', 'quote'],
+                ['ul', 'ol', 'task', 'indent', 'outdent'],
+                ['table', 'image', 'link'],
+                ['code', 'codeblock']
+            ]
+        });
+
+        editorInstance = editor;
+        
+        if (!isMarkdown) {
+            editorInstance.changeMode('wysiwyg');
+        }
+
+        // Generate initial TOC
+        if (isMarkdown && window.updateToc && tocContainer) {
+            try {
+                window.updateToc(markdownBody, tocContainer, editorInstance, tocMaxDepth);
+            } catch (error) {
+                console.error('Error generating TOC:', error);
+            }
+
+            const debouncedUpdateToc = debounce(() => {
+                const currentContent = editorInstance.getMarkdown();
+                window.updateToc(currentContent, tocContainer, editorInstance, tocMaxDepth);
+            }, 300);
+
+            editorInstance.on('change', () => {
+                debouncedUpdateToc();
+
+                const instanceData = editorInstances.get(filePath);
+                if (instanceData && !instanceData.isDirty) {
+                    instanceData.isDirty = true;
+                    updateFileDirtyStatus(filePath, true);
+                    updateUnsavedCount();
+                }
+                saveButton.disabled = false;
+            });
+
+            // Scroll listener for TOC highlighting
+            const mdPreview = editorInstance.getEditorElements().mdPreview;
+            if (mdPreview) {
+                let activeTimeout = null;
+                let lastHeader = null;
+
+                const updateActiveHeader = () => {
+                    // Re-query live headings (TOC may have been regenerated)
+                    const liveHeaders = mdPreview.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    const previewRect = mdPreview.getBoundingClientRect();
+                    // Use a threshold slightly below the top so a header touching
+                    // the top edge counts as "active"
+                    const threshold = previewRect.top + 4;
+                    let activeHeader = null;
+                    for (const header of liveHeaders) {
+                        if (header.getBoundingClientRect().top <= threshold) {
+                            activeHeader = header.textContent.trim();
+                        } else {
+                            break;
+                        }
+                    }
+                    if (activeHeader !== lastHeader) {
+                        lastHeader = activeHeader;
+                        setActiveTocItem(tocContainer, activeHeader);
+                    }
+                };
+
+                const onScroll = () => {
+                    cancelAnimationFrame(activeTimeout);
+                    activeTimeout = requestAnimationFrame(updateActiveHeader);
+                };
+
+                mdPreview.addEventListener('scroll', onScroll);
+            }
+        } else {
+            editorInstance.on('change', () => {
+                const instanceData = editorInstances.get(filePath);
+                if (instanceData && !instanceData.isDirty) {
+                    instanceData.isDirty = true;
+                    updateFileDirtyStatus(filePath, true);
+                    updateUnsavedCount();
+                }
+                saveButton.disabled = false;
+            });
+        }
+
+        // Front matter change listener
+        if (frontMatterTextarea) {
+            frontMatterTextarea.addEventListener('input', () => {
+                const instanceData = editorInstances.get(filePath);
+                if (instanceData && !instanceData.isDirty) {
+                    instanceData.isDirty = true;
+                    updateFileDirtyStatus(filePath, true);
+                    updateUnsavedCount();
+                }
+                saveButton.disabled = false;
+            });
+        }
+
+        // Button event listeners
+        saveButton.addEventListener('click', async () => {
+            if (isScratchpad) {
+                // For scratchpads, use Save As
+                const content = editorInstance.getMarkdown();
+                const savedHandle = await saveFileAs(content, 'untitled.md');
+                if (savedHandle && hasFileSystemAccess) {
+                    // Check if saved to current directory - add to file tree
+                    if (directoryHandle) {
+                        try {
+                            // Try to get the file from the directory to verify it's there
+                            const checkHandle = await directoryHandle.getFileHandle(savedHandle.name);
+                            // File is in current directory, add to tree
+                            fileTree.entries[savedHandle.name] = {
+                                name: savedHandle.name,
+                                type: 'file',
+                                handle: checkHandle
+                            };
+                            renderFileTree();
+
+                        } catch (e) {
+                            // File not in current directory, that's fine
+                        }
+                    }
+                    // Clear scratchpad content after successful save
+                    editorInstance.setMarkdown('');
+                    saveButton.disabled = true;
+                    const instanceData = editorInstances.get(filePath);
+                    if (instanceData) {
+                        instanceData.isDirty = false;
+                    }
+                }
+            } else {
+                saveFile(filePath);
+            }
+        });
+
+        if (reloadButton) {
+            reloadButton.addEventListener('click', async () => {
+                await reloadFileFromDisk(filePath);
+            });
+        }
+
+        // Store instance data
+        const instanceData = {
+            editor: editor,
+            fileViewContainer: fileViewContainer,
+            tocContainer: tocContainer,
+            saveButton: saveButton,
+            reloadButton: reloadButton,
+            frontMatterTextarea: frontMatterTextarea,
+            frontMatterData: frontMatterData,
+            fileHandle: fileHandle,
+            lastModified: lastModified,
+            isDirty: false
+        };
+
+        editorInstances.set(filePath, instanceData);
+
+        return editorInstance;
+    } catch (error) {
+        console.error('Error initializing editor:', error);
+        alert(`Error initializing Toast UI Editor: ${error}`);
+        return null;
+    }
+}
diff --git a/mdedit/js/events.js b/mdedit/js/events.js
new file mode 100644
index 0000000..54ee81a
--- /dev/null
+++ b/mdedit/js/events.js
@@ -0,0 +1,81 @@
+/**
+ * Event listeners setup
+ */
+
+/**
+ * Set up all event listeners for the application
+ */
+function setupEventListeners() {
+    // Select directory button
+    const selectDirectoryBtn = document.getElementById('select-directory');
+    if (selectDirectoryBtn) {
+        selectDirectoryBtn.addEventListener('click', openDirectory);
+    }
+
+    // Refresh directory button
+    const refreshDirectoryBtn = document.getElementById('refresh-directory');
+    if (refreshDirectoryBtn) {
+        refreshDirectoryBtn.addEventListener('click', refreshDirectory);
+    }
+
+    // New file (root) button
+    const newFileRootBtn = document.getElementById('new-file-root');
+    if (newFileRootBtn) {
+        newFileRootBtn.addEventListener('click', () => {
+            if (directoryHandle) {
+                createNewFile('');
+            }
+        });
+    }
+
+    // Save All button
+    const saveAllBtn = document.getElementById('save-all');
+    if (saveAllBtn) {
+        saveAllBtn.addEventListener('click', saveAllFiles);
+    }
+
+    // Warn when leaving with unsaved changes
+    window.addEventListener('beforeunload', function (e) {
+        let hasUnsavedChanges = false;
+
+        editorInstances.forEach((instanceData) => {
+            if (instanceData.isDirty) {
+                hasUnsavedChanges = true;
+            }
+        });
+
+        if (hasUnsavedChanges) {
+            e.preventDefault();
+            return 'You have unsaved changes. If you leave now, your changes will be lost.';
+        }
+    });
+}
+
+/**
+ * Set up TOC depth selector
+ */
+function setupTocDepthSelector() {
+    const depthSelector = document.getElementById('toc-depth-selector');
+    if (!depthSelector) return;
+
+    depthSelector.value = tocMaxDepth.toString();
+
+    depthSelector.addEventListener('change', function () {
+        tocMaxDepth = parseInt(this.value, 10);
+
+        if (currentFileHandle && currentFileHandle.name.match(/\.(md|markdown)$/i)) {
+            const filePath = currentFileHandle.name;
+            const instance = editorInstances.get(filePath);
+
+            if (instance && instance.editor && instance.tocContainer) {
+                const content = instance.editor.getMarkdown();
+
+                try {
+                    window.updateToc(content, instance.tocContainer, instance.editor, tocMaxDepth);
+                } catch (error) {
+                    console.error('Error updating TOC depth:', error);
+                }
+            }
+        }
+    });
+}
diff --git a/mdedit/js/file-ops.js b/mdedit/js/file-ops.js
new file mode 100644
index 0000000..5c2c267
--- /dev/null
+++ b/mdedit/js/file-ops.js
@@ -0,0 +1,400 @@
+/**
+ * File management operations (create, rename, delete)
+ * Plain functions, no module wrapper
+ */
+
+/**
+ * Resolve a node in fileTree by filePath
+ * @param {string} filePath - Path like 'subdir/file.md' or ''
+ * @returns {Object|null} The node object or null if not found
+ */
+function resolveNode(filePath) {
+    if (!filePath) return fileTree;
+    const parts = filePath.split('/');
+    let node = fileTree;
+    for (const part of parts) {
+        if (!node.entries || !node.entries[part]) return null;
+        node = node.entries[part];
+    }
+    return node;
+}
+
+/**
+ * Resolve the parent directory handle for a given file path
+ * @param {string} filePath - Full path like 'subdir/file.md'
+ * @returns {FileSystemDirectoryHandle|null} Parent directory handle or null
+ */
+function resolveParentDirHandle(filePath) {
+    const parts = filePath.split('/');
+    if (parts.length === 1) return directoryHandle;
+    let node = fileTree;
+    for (let i = 0; i < parts.length - 1; i++) {
+        node = node.entries[parts[i]];
+        if (!node) return null;
+    }
+    return node.handle;
+}
+
+/**
+ * Create a new file
+ * @param {string} parentDirPath - '' for root, or 'subdir', 'a/b/c'
+ */
+async function createNewFile(parentDirPath) {
+    // Resolve parent directory handle first (no user activation needed for reads)
+    let parentHandle;
+    if (parentDirPath === '') {
+        parentHandle = directoryHandle;
+    } else {
+        const node = resolveNode(parentDirPath);
+        if (!node || !node.handle) {
+            alert('Could not locate parent directory.');
+            return;
+        }
+        parentHandle = node.handle;
+    }
+
+    // Show in-page modal and wait for user to confirm or cancel.
+    // Returns the filename string, or null if cancelled.
+    const name = await new Promise((resolve) => {
+        const modal = document.getElementById('new-file-modal');
+        const input = document.getElementById('new-file-input');
+        const confirmBtn = document.getElementById('new-file-confirm');
+        const cancelBtn = document.getElementById('new-file-cancel');
+
+        input.value = 'untitled.md';
+        modal.classList.remove('hidden');
+        input.focus();
+        input.select();
+
+        function cleanup() {
+            modal.classList.add('hidden');
+            confirmBtn.removeEventListener('click', onConfirm);
+            cancelBtn.removeEventListener('click', onCancel);
+            input.removeEventListener('keydown', onKey);
+        }
+
+        function onConfirm() {
+            const val = input.value.trim();
+            cleanup();
+            resolve(val || null);
+        }
+
+        function onCancel() {
+            cleanup();
+            resolve(null);
+        }
+
+        function onKey(e) {
+            if (e.key === 'Enter') onConfirm();
+            if (e.key === 'Escape') onCancel();
+        }
+
+        confirmBtn.addEventListener('click', onConfirm);
+        cancelBtn.addEventListener('click', onCancel);
+        input.addEventListener('keydown', onKey);
+    });
+
+    if (!name) {
+        if (DEBUG) console.log('New file creation cancelled');
+        return;
+    }
+
+    // Validate name
+    if (name.includes('/') || name.includes('\\')) {
+        alert('Invalid filename: cannot contain / or \\.');
+        return;
+    }
+
+    // Check if file already exists
+    try {
+        await parentHandle.getFileHandle(name);
+        const overwrite = window.confirm('A file named "' + name + '" already exists. Overwrite it?');
+        if (!overwrite) return;
+    } catch (e) {
+        if (e.name !== 'NotFoundError') throw e;
+    }
+
+    // Create the file — this must happen after the modal's button click
+    // which is the user activation token.
+    try {
+        const newHandle = await parentHandle.getFileHandle(name, { create: true });
+
+        const writable = await newHandle.createWritable();
+        await writable.write('');
+        await writable.close();
+
+        if (DEBUG) console.log(`Created new file: ${parentDirPath ? parentDirPath + '/' : ''}${name}`);
+
+        await refreshDirectory();
+
+        const newFilePath = parentDirPath ? parentDirPath + '/' + name : name;
+        const element = document.querySelector('.file-item[data-path="' + CSS.escape(newFilePath) + '"]');
+        if (element) {
+            handleFileClick(newHandle, newFilePath, element);
+        }
+    } catch (error) {
+        console.error('Error creating new file:', error);
+        alert('Error creating file: ' + error.message);
+    }
+}
+
+/**
+ * Rename a file or directory
+ * @param {string} filePath - Full path like 'subdir/file.md'
+ * @param {boolean} isDirectory - true if renaming a directory (not supported on Chrome)
+ */
+async function renameEntry(filePath, isDirectory) {
+    const currentName = filePath.split('/').pop();
+    const newName = window.prompt('Rename to:', currentName);
+    
+    if (newName === null || newName === currentName) {
+        if (DEBUG) console.log('Rename cancelled or unchanged');
+        return;
+    }
+    
+    // Validate name
+    if (newName.includes('/') || newName.includes('\\') || newName.trim() === '') {
+        alert('Invalid filename: cannot contain / or \\ and must not be empty.');
+        return;
+    }
+    
+    // Resolve parent directory handle
+    const parentHandle = resolveParentDirHandle(filePath);
+    if (!parentHandle) {
+        alert('Could not locate parent directory.');
+        return;
+    }
+    
+    // For files: rename via File System Access API
+    if (!isDirectory) {
+        try {
+            // Check if new name already exists (file or directory)
+            try {
+                const existing = await parentHandle.getFileHandle(newName);
+                // A file with that name exists
+                const overwrite = window.confirm('A file named "' + newName + '" already exists. Overwrite?');
+                if (!overwrite) return;
+            } catch (fileErr) {
+                if (fileErr.name === 'TypeMismatchError') {
+                    // A directory with that name exists
+                    window.alert('A folder named "' + newName + '" already exists. Choose a different name.');
+                    return;
+                }
+                if (fileErr.name !== 'NotFoundError') throw fileErr;
+                // NotFoundError = safe to create
+            }
+            
+            const oldHandle = resolveNode(filePath);
+            if (!oldHandle || !oldHandle.handle) {
+                alert('Could not find file to rename.');
+                return;
+            }
+            
+            const file = await oldHandle.handle.getFile();
+            const content = await file.text();
+            
+            const newHandle = await parentHandle.getFileHandle(newName, { create: true });
+            const writable = await newHandle.createWritable();
+            await writable.write(content);
+            await writable.close();
+            const newFile = await newHandle.getFile();
+            
+            await parentHandle.removeEntry(currentName);
+            
+            // Update editor instances
+            if (editorInstances.has(filePath)) {
+                const instance = editorInstances.get(filePath);
+                const newFilePath = filePath.substring(0, filePath.length - currentName.length) + newName;
+                
+                // Remove old instance
+                const data = editorInstances.get(filePath);
+                if (data.fileViewContainer) {
+                    data.fileViewContainer.classList.add('hidden');
+                }
+                editorInstances.delete(filePath);
+                
+                // Re-add with new path
+                editorInstances.set(newFilePath, { ...data, fileHandle: newHandle, lastModified: newFile.lastModified });
+                
+                // Update active state
+                if (instance.fileViewContainer) {
+                    instance.fileViewContainer.classList.remove('hidden');
+                    instance.fileViewContainer.dataset.path = newFilePath;
+                }
+                
+                // Update fileTree entries
+                const parts = filePath.split('/');
+                const fileName = parts.pop();
+                const dirPath = parts.join('/');
+                let targetEntries = fileTree.entries;
+                if (dirPath) {
+                    const dirParts = dirPath.split('/');
+                    let current = fileTree;
+                    for (const part of dirParts) {
+                        current = current.entries[part];
+                    }
+                    targetEntries = current.entries;
+                }
+                if (targetEntries && targetEntries[currentName]) {
+                    delete targetEntries[currentName];
+                    targetEntries[newName] = {
+                        name: newName,
+                        type: 'file',
+                        handle: newHandle
+                    };
+                }
+                
+                renderFileTree();
+                restoreActiveFile(newFilePath);
+            } else {
+                renderFileTree();
+            }
+            
+        } catch (error) {
+            console.error('Error renaming file:', error);
+            alert('Error renaming file: ' + error.message);
+        }
+    } else {
+        // For directories: not supported by browser API
+        alert('Directory rename is not supported by the browser File System API. Please rename the folder in your OS file manager and refresh.');
+    }
+}
+
+/**
+ * Delete a file or directory
+ * @param {string} filePath - Full path like 'subdir/file.md' or 'subdir'
+ * @param {boolean} isDirectory - true if deleting a directory
+ */
+async function deleteEntry(filePath, isDirectory) {
+    const name = filePath.split('/').pop();
+    
+    const message = isDirectory 
+        ? 'Delete folder "' + name + '" and all its contents?'
+        : 'Delete "' + name + '"?';
+    
+    const ok = window.confirm(message);
+    if (!ok) {
+        if (DEBUG) console.log('Delete cancelled by user');
+        return;
+    }
+    
+    // Resolve parent directory handle
+    const parentHandle = resolveParentDirHandle(filePath);
+    if (!parentHandle) {
+        alert('Could not locate parent directory.');
+        return;
+    }
+    
+    let deleted = false;
+    try {
+        await parentHandle.removeEntry(name, { recursive: isDirectory });
+        deleted = true;
+    } catch (error) {
+        if (error.name === 'NotFoundError') {
+            // Already gone — treat as success for cleanup purposes
+            deleted = true;
+        } else {
+            console.error('Error deleting entry:', error);
+            alert('Error deleting entry: ' + error.message);
+        }
+    }
+
+    if (deleted) {
+        // Close editor if open
+        if (!isDirectory && editorInstances.has(filePath)) {
+            closeEditorInstance(filePath);
+        } else if (isDirectory) {
+            // Close any editors under this directory
+            const dirsToClose = [];
+            editorInstances.forEach(function(instance, key) {
+                if (key === filePath || key.startsWith(filePath + '/')) {
+                    dirsToClose.push(key);
+                }
+            });
+            dirsToClose.forEach(function(key) {
+                closeEditorInstance(key);
+            });
+        }
+        
+        // Remove from fileTree entries
+        const parts = filePath.split('/');
+        const entryName = parts.pop();
+        const dirPath = parts.join('/');
+        let targetEntries = fileTree.entries;
+        if (dirPath) {
+            const dirParts = dirPath.split('/');
+            let current = fileTree;
+            for (const part of dirParts) {
+                current = current.entries[part];
+            }
+            targetEntries = current.entries;
+        }
+        if (targetEntries && targetEntries[entryName]) {
+            delete targetEntries[entryName];
+        }
+        
+        renderFileTree();
+        updateStatusCountsFromTree();
+    }
+}
+
+/**
+ * Close an editor instance and show welcome screen if no files open
+ * @param {string} filePath - Path of file to close
+ */
+function closeEditorInstance(filePath) {
+    const instance = editorInstances.get(filePath);
+    if (!instance) return;
+    
+    if (instance.fileViewContainer) {
+        instance.fileViewContainer.classList.add('hidden');
+    }
+    editorInstances.delete(filePath);
+    
+    // Check if any visible file-view-container children remain
+    const contentContainer = document.getElementById('content-container');
+    if (contentContainer) {
+        const visibleChildren = Array.from(contentContainer.querySelectorAll('.file-view-container'))
+            .filter(function(el) { return !el.classList.contains('hidden'); });
+        if (visibleChildren.length === 0) {
+            document.getElementById('welcome-screen').classList.remove('hidden');
+            contentContainer.classList.add('hidden');
+        }
+    }
+}
+
+/**
+ * Restore active file state after rename
+ * @param {string} newFilePath - New path of the file
+ */
+function restoreActiveFile(newFilePath) {
+    const element = document.querySelector('.file-item[data-path="' + CSS.escape(newFilePath) + '"]');
+    if (element) {
+        element.classList.add('active-file');
+        element.style.backgroundColor = '';
+        element.style.color = '';
+    }
+}
+
+/**
+ * Update status counts from fileTree
+ */
+function updateStatusCountsFromTree() {
+    let folderCount = 0;
+    let fileCount = 0;
+    
+    function countEntries(entries) {
+        if (!entries) return;
+        for (const [name, item] of Object.entries(entries)) {
+            if (item.type === 'directory') {
+                folderCount++;
+                countEntries(item.entries);
+            } else if (item.type === 'file') {
+                fileCount++;
+            }
+        }
+    }
+    
+    countEntries(fileTree.entries);
+    updateStatusCounts(folderCount, fileCount);
+}
diff --git a/mdedit/js/file-system.js b/mdedit/js/file-system.js
new file mode 100644
index 0000000..1fc7eb9
--- /dev/null
+++ b/mdedit/js/file-system.js
@@ -0,0 +1,531 @@
+/**
+ * File system operations using File System Access API
+ */
+
+/**
+ * Open the scratchpad editor
+ */
+function openScratchpad() {
+    // Check if scratchpad already exists
+    if (editorInstances.has(SCRATCHPAD_ID)) {
+        // Just show it
+        const instance = editorInstances.get(SCRATCHPAD_ID);
+        document.getElementById('welcome-screen').classList.add('hidden');
+        document.getElementById('content-container').classList.remove('hidden');
+        
+        // Hide all other editors, show scratchpad
+        editorInstances.forEach((data, path) => {
+            if (data.fileViewContainer) {
+                data.fileViewContainer.style.display = path === SCRATCHPAD_ID ? 'flex' : 'none';
+            }
+        });
+        return;
+    }
+    
+    // Hide welcome screen, show content container
+    document.getElementById('welcome-screen').classList.add('hidden');
+    document.getElementById('content-container').classList.remove('hidden');
+    
+    // Initialize editor with no file handle
+    initializeEditor('', true, SCRATCHPAD_ID, 'Scratchpad', null, null);
+    
+    // Mark as scratchpad
+    const instance = editorInstances.get(SCRATCHPAD_ID);
+    if (instance) {
+        instance.isScratchpad = true;
+    }
+    
+    if (DEBUG) console.log('Opened scratchpad');
+}
+
+/**
+ * Save file using Save As dialog (for scratchpads or new saves)
+ * @param {string} content - Content to save
+ * @param {string} suggestedName - Suggested filename
+ * @returns {Promise<FileSystemFileHandle|null>} File handle if saved, null otherwise
+ */
+async function saveFileAs(content, suggestedName = 'untitled.md') {
+    if (hasFileSystemAccess) {
+        try {
+            const fileHandle = await window.showSaveFilePicker({
+                suggestedName: suggestedName,
+                types: [{
+                    description: 'Markdown files',
+                    accept: { 'text/markdown': ['.md', '.markdown'] }
+                }]
+            });
+            
+            const writable = await fileHandle.createWritable();
+            await writable.write(content);
+            await writable.close();
+            
+            if (DEBUG) console.log(`File saved as: ${fileHandle.name}`);
+            return fileHandle;
+        } catch (error) {
+            if (error.name === 'AbortError') {
+                if (DEBUG) console.log('Save cancelled by user');
+                return null;
+            }
+            throw error;
+        }
+    } else {
+        // Fallback: download as blob
+        const blob = new Blob([content], { type: 'text/markdown' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = suggestedName;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        if (DEBUG) console.log(`File downloaded as: ${suggestedName}`);
+        return null;
+    }
+}
+
+/**
+ * Open directory picker and handle selection
+ */
+async function openDirectory() {
+    try {
+        if (!('showDirectoryPicker' in window)) {
+            throw new Error('The File System API is not supported in this browser.');
+        }
+
+        directoryHandle = await window.showDirectoryPicker();
+        if (DEBUG) console.log('Directory selected:', directoryHandle.name);
+
+        updateDirectoryStatus(directoryHandle.name);
+        await readDirectory(directoryHandle);
+
+    } catch (error) {
+        if (error.name === 'AbortError') {
+            if (DEBUG) console.log('User cancelled the directory selection');
+        } else {
+            console.error('Error selecting directory:', error);
+            alert(`Error: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Update UI to show selected directory
+ * @param {string} directoryName - Name of the selected directory
+ */
+function updateDirectoryStatus(directoryName) {
+    const selectDirectoryBtn = document.getElementById('select-directory');
+    if (selectDirectoryBtn) {
+        selectDirectoryBtn.textContent = `Directory: ${directoryName}`;
+    }
+
+    const refreshBtn = document.getElementById('refresh-directory');
+    if (refreshBtn) {
+        refreshBtn.classList.remove('hidden');
+    }
+
+    // Show new file button when directory is selected
+    const newFileRootBtn = document.getElementById('new-file-root');
+    if (newFileRootBtn) {
+        newFileRootBtn.classList.remove('hidden');
+    }
+}
+
+/**
+ * Read directory contents and build tree structure
+ * @param {FileSystemDirectoryHandle} dirHandle - Directory handle
+ * @param {Object} parentNode - Parent node in tree (for recursion)
+ * @returns {Object} Statistics about the directory
+ */
+async function readDirectory(dirHandle, parentNode = null) {
+    if (parentNode === null) {
+        fileTree = {
+            name: dirHandle.name,
+            type: 'directory',
+            handle: dirHandle,
+            entries: {}
+        };
+
+        const fileTreeElement = document.getElementById('file-tree');
+        if (fileTreeElement) {
+            fileTreeElement.innerHTML = '';
+        }
+
+        parentNode = fileTree;
+    }
+
+    try {
+        let stats = { folderCount: 0, fileCount: 0 };
+
+        for await (const entry of dirHandle.values()) {
+            if (entry.kind === 'file' && !entry.name.startsWith('_')) {
+                parentNode.entries[entry.name] = {
+                    name: entry.name,
+                    type: 'file',
+                    handle: entry
+                };
+                stats.fileCount++;
+            } else if (entry.kind === 'directory' && !entry.name.startsWith('_')) {
+                const dirNode = {
+                    name: entry.name,
+                    type: 'directory',
+                    handle: entry,
+                    entries: {}
+                };
+
+                parentNode.entries[entry.name] = dirNode;
+
+                const subStats = await readDirectory(entry, dirNode);
+                stats.folderCount += subStats.folderCount + 1;
+                stats.fileCount += subStats.fileCount;
+            }
+        }
+
+        if (parentNode === fileTree) {
+            renderFileTree();
+            updateStatusCounts(stats.folderCount, stats.fileCount);
+        }
+
+        return stats;
+    } catch (error) {
+        console.error('Error reading directory:', error);
+        return { folderCount: 0, fileCount: 0 };
+    }
+}
+
+/**
+ * Save a file by its path
+ * @param {string} filePath - Path of the file to save
+ * @returns {Promise<boolean>} Whether save was successful
+ */
+async function saveFile(filePath) {
+    if (!filePath && currentFileHandle) {
+        filePath = currentFileHandle.name;
+    } else if (!filePath) {
+        alert('No file is currently open');
+        return false;
+    }
+
+    try {
+        const editorInstance = editorInstances.get(filePath);
+        if (!editorInstance) {
+            throw new Error('No editor instance found for this file');
+        }
+
+        if (!editorInstance.isDirty) {
+            if (DEBUG) console.log(`File ${filePath} is not dirty, skipping save`);
+            return true;
+        }
+
+        const fileHandle = editorInstance.fileHandle;
+        if (!fileHandle) {
+            throw new Error('No file handle available for this file');
+        }
+
+        // Check for external modifications
+        const file = await fileHandle.getFile();
+        const currentLastModified = file.lastModified;
+        const storedLastModified = editorInstance.lastModified;
+
+        if (storedLastModified && currentLastModified !== storedLastModified) {
+            const confirmSave = confirm(
+                'Warning: This file has been modified outside of the application since you opened it. ' +
+                'Saving will overwrite those changes. Do you want to continue?'
+            );
+
+            if (!confirmSave) {
+                if (DEBUG) console.log('Save aborted by user due to external file modifications');
+                return false;
+            }
+        }
+
+        // Get markdown content from editor
+        const markdownContent = editorInstance.editor.getMarkdown();
+        
+        // Get front matter from textarea
+        let frontMatterData = {};
+        if (editorInstance.frontMatterTextarea) {
+            const frontMatterText = editorInstance.frontMatterTextarea.value.trim();
+            if (frontMatterText) {
+                try {
+                    const yamlContent = `---\n${frontMatterText}\n---\n`;
+                    const parsed = parseFrontMatter(yamlContent);
+                    frontMatterData = parsed.data;
+                } catch (error) {
+                    console.error('Error parsing front matter:', error);
+                    throw new Error(`Invalid YAML front matter: ${error.message}`);
+                }
+            }
+        }
+
+        // Apply before save hooks
+        frontMatterData = await applyBeforeSaveHooks(frontMatterData, markdownContent, fileHandle);
+
+        // Combine front matter with markdown
+        const finalContent = frontMatterData && Object.keys(frontMatterData).length > 0
+            ? stringifyFrontMatter(markdownContent, frontMatterData)
+            : markdownContent;
+
+        // Write to file
+        const writable = await fileHandle.createWritable();
+        await writable.write(finalContent);
+        await writable.close();
+
+        // Update state
+        const updatedFile = await fileHandle.getFile();
+        editorInstance.lastModified = updatedFile.lastModified;
+        editorInstance.isDirty = false;
+        updateFileDirtyStatus(filePath, false);
+        updateUnsavedCount();
+
+        if (editorInstance.saveButton) {
+            editorInstance.saveButton.disabled = true;
+        }
+
+        if (DEBUG) console.log(`File ${filePath} saved successfully!`);
+        
+        await applyAfterSaveHooks(frontMatterData, markdownContent, fileHandle);
+        
+        return true;
+    } catch (error) {
+        console.error(`Error saving file ${filePath}:`, error);
+        alert(`Error saving file: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Save all files with unsaved changes
+ * @returns {Promise<{saved: number, failed: number}>}
+ */
+async function saveAllFiles() {
+    let saved = 0;
+    let failed = 0;
+
+    const dirtyFiles = [];
+    editorInstances.forEach((instance, filePath) => {
+        if (instance.isDirty) {
+            dirtyFiles.push(filePath);
+        }
+    });
+
+    if (dirtyFiles.length === 0) {
+        if (DEBUG) console.log('No files with unsaved changes');
+        return { saved, failed };
+    }
+
+    for (const filePath of dirtyFiles) {
+        try {
+            const success = await saveFile(filePath);
+            if (success) {
+                saved++;
+            } else {
+                failed++;
+            }
+        } catch (error) {
+            console.error(`Error saving file ${filePath}:`, error);
+            failed++;
+        }
+    }
+
+    if (failed === 0) {
+        if (DEBUG) console.log(`All ${saved} files saved successfully`);
+    } else {
+        if (DEBUG) console.log(`Saved ${saved} files, ${failed} files failed to save`);
+    }
+
+    return { saved, failed };
+}
+
+/**
+ * Reload file from disk
+ * @param {string} filePath - Path of file to reload
+ * @returns {Promise<boolean>} Whether reload was successful
+ */
+async function reloadFileFromDisk(filePath) {
+    try {
+        const editorInstance = editorInstances.get(filePath);
+        if (!editorInstance) {
+            throw new Error('No editor instance found for this file');
+        }
+
+        if (editorInstance.isDirty) {
+            const confirmReload = confirm(
+                'This file has unsaved changes. Reloading will discard all changes. ' +
+                'Do you want to continue?'
+            );
+            
+            if (!confirmReload) {
+                if (DEBUG) console.log('Reload cancelled by user');
+                return false;
+            }
+        }
+
+        const fileHandle = editorInstance.fileHandle;
+        if (!fileHandle) {
+            throw new Error('No file handle available for this file');
+        }
+
+        const file = await fileHandle.getFile();
+        const fileContent = await file.text();
+        
+        editorInstance.lastModified = file.lastModified;
+
+        if (filePath.endsWith('.md') || filePath.endsWith('.markdown')) {
+            const parsed = parseFrontMatter(fileContent);
+            
+            if (editorInstance.frontMatterTextarea) {
+                const frontMatterYaml = stringifyFrontMatterToTextarea(parsed.data);
+                editorInstance.frontMatterTextarea.value = frontMatterYaml;
+            }
+            
+            let currentScrollTop = 0;
+            try {
+                currentScrollTop = editorInstance.editor.getScrollTop();
+            } catch (error) {
+                if (DEBUG) console.debug('Could not get scroll position:', error);
+            }
+
+            editorInstance.editor.setMarkdown(parsed.content);
+
+            setTimeout(() => {
+                try {
+                    editorInstance.editor.setScrollTop(currentScrollTop);
+                } catch (error) {
+                    if (DEBUG) console.debug('Could not restore scroll position:', error);
+                }
+            }, 100);
+            
+            if (editorInstance.tocContainer && window.updateToc) {
+                try {
+                    window.updateToc(parsed.content, editorInstance.tocContainer, editorInstance.editor, tocMaxDepth);
+                } catch (error) {
+                    console.error('Error updating TOC during reload:', error);
+                }
+            }
+        } else {
+            editorInstance.editor.setMarkdown(fileContent);
+        }
+
+        editorInstance.isDirty = false;
+        updateFileDirtyStatus(filePath, false);
+        updateUnsavedCount();
+
+        if (editorInstance.saveButton) {
+            editorInstance.saveButton.disabled = true;
+        }
+
+        if (DEBUG) console.log(`File ${filePath} reloaded successfully from disk!`);
+        return true;
+    } catch (error) {
+        console.error(`Error reloading file ${filePath}:`, error);
+        alert(`Error reloading file: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Before save hook - apply modifications before saving
+ */
+async function applyBeforeSaveHooks(frontMatter, markdownContent, fileHandle) {
+    frontMatter.lastModified = new Date().toISOString();
+    
+    if (!frontMatter.title) {
+        const firstHeading = markdownContent.match(/^#\s+(.+)$/m);
+        if (firstHeading) {
+            frontMatter.title = firstHeading[1];
+        }
+    }
+    
+    const customTags = (markdownContent.match(/<(deliverable|meeting|report|trkno)>/g) || []).length;
+    if (customTags > 0) {
+        frontMatter.customTagCount = customTags;
+    }
+    
+    return frontMatter;
+}
+
+/**
+ * After save hook - perform actions after saving
+ */
+async function applyAfterSaveHooks(frontMatter, markdownContent, fileHandle) {
+    const tags = ['deliverable', 'meeting', 'report', 'trkno'];
+    const preservedTags = tags.filter(tag => markdownContent.includes(`<${tag}>`));
+    if (preservedTags.length > 0) {
+        if (DEBUG) console.log(`Preserved custom tags: ${preservedTags.join(', ')}`);
+    }
+}
+
+/**
+ * Refresh directory from disk without losing unsaved work
+ */
+async function refreshDirectory() {
+    if (!directoryHandle) {
+        if (DEBUG) console.log('No directory selected, cannot refresh');
+        return;
+    }
+
+    // Get active file path from DOM before refresh
+    const activeFileEl = document.querySelector('.file-item.active-file');
+    const activeFilePath = activeFileEl ? activeFileEl.dataset.path : null;
+
+    // Get dirty files from editorInstances
+    const dirtyFiles = new Set();
+    editorInstances.forEach((instance, filePath) => {
+        if (instance.isDirty) {
+            dirtyFiles.add(filePath);
+        }
+    });
+
+    // Re-read directory (calls renderFileTree at the end)
+    await readDirectory(directoryHandle);
+
+    // Restore active file state
+    if (activeFilePath) {
+        const activeElement = document.querySelector(`.file-item[data-path="${activeFilePath}"]`);
+        if (activeElement) {
+            activeElement.classList.add('active-file');
+        }
+    }
+
+    // Restore dirty indicators
+    dirtyFiles.forEach(filePath => {
+        updateFileDirtyStatus(filePath, true);
+    });
+}
+
+/**
+ * Start monitoring files for external changes
+ */
+function startFileChangeMonitoring() {
+    setInterval(async () => {
+        for (const [filePath, editorInstance] of editorInstances) {
+            try {
+                const fileHandle = editorInstance.fileHandle;
+                if (!fileHandle) continue;
+
+                const file = await fileHandle.getFile();
+                const currentLastModified = file.lastModified;
+                const storedLastModified = editorInstance.lastModified;
+
+                if (storedLastModified && currentLastModified !== storedLastModified) {
+                    if (DEBUG) console.log(`File ${filePath} changed externally`);
+                    
+                    const action = confirm(
+                        `File "${filePath}" has been modified by another application.\n\n` +
+                        'Click OK to reload from disk (discards unsaved changes)\n' +
+                        'Click Cancel to keep current version'
+                    );
+
+                    if (action) {
+                        await reloadFileFromDisk(filePath);
+                    } else {
+                        editorInstance.lastModified = currentLastModified;
+                    }
+                }
+            } catch (error) {
+                if (DEBUG) console.debug(`Error checking file ${filePath}:`, error.message);
+            }
+        }
+    }, 3000);
+}
diff --git a/mdedit/js/file-tree.js b/mdedit/js/file-tree.js
new file mode 100644
index 0000000..d0065dd
--- /dev/null
+++ b/mdedit/js/file-tree.js
@@ -0,0 +1,731 @@
+/**
+ * File tree rendering and navigation
+ */
+
+// Cache for lazily loaded CDN libraries
+const loadedLibraries = new Map();
+
+/**
+ * Lazily load a script from CDN. Returns a promise that resolves when loaded.
+ * Caches the promise so subsequent calls return immediately.
+ */
+function loadLibrary(url) {
+    if (loadedLibraries.has(url)) return loadedLibraries.get(url);
+    const promise = new Promise((resolve, reject) => {
+        const script = document.createElement('script');
+        script.src = url;
+        script.onload = resolve;
+        script.onerror = () => reject(new Error(`Failed to load library: ${url}`));
+        document.head.appendChild(script);
+    });
+    loadedLibraries.set(url, promise);
+    return promise;
+}
+
+/**
+ * Render the file tree in the UI
+ */
+/**
+ * Create action buttons for file/directory items
+ * @param {string} filePath - Full path of the file/dir
+ * @param {string} type - 'file' or 'directory'
+ */
+function createActionButtons(filePath, type) {
+    const actionsDiv = document.createElement('div');
+    actionsDiv.className = 'tree-actions';
+
+    if (type === 'directory') {
+        // Directory: + (new file) + ✕ (delete)
+        const newFileBtn = document.createElement('button');
+        newFileBtn.className = 'tree-btn';
+        newFileBtn.setAttribute('title', 'New file');
+        newFileBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 5v14M5 12h14"/></svg>';
+        newFileBtn.onclick = (e) => {
+            e.stopPropagation();
+            createNewFile(filePath);
+        };
+
+        const deleteBtn = document.createElement('button');
+        deleteBtn.className = 'tree-btn tree-btn--danger';
+        deleteBtn.setAttribute('title', 'Delete');
+        deleteBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>';
+        deleteBtn.onclick = (e) => {
+            e.stopPropagation();
+            deleteEntry(filePath, true);
+        };
+
+        actionsDiv.appendChild(newFileBtn);
+        actionsDiv.appendChild(deleteBtn);
+    } else {
+        // File: ✎ (rename) + ✕ (delete)
+        const renameBtn = document.createElement('button');
+        renameBtn.className = 'tree-btn';
+        renameBtn.setAttribute('title', 'Rename');
+        renameBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z"/></svg>';
+        renameBtn.onclick = (e) => {
+            e.stopPropagation();
+            renameEntry(filePath, false);
+        };
+
+        const deleteBtn = document.createElement('button');
+        deleteBtn.className = 'tree-btn tree-btn--danger';
+        deleteBtn.setAttribute('title', 'Delete');
+        deleteBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>';
+        deleteBtn.onclick = (e) => {
+            e.stopPropagation();
+            deleteEntry(filePath, false);
+        };
+
+        actionsDiv.appendChild(renameBtn);
+        actionsDiv.appendChild(deleteBtn);
+    }
+
+    return actionsDiv;
+}
+
+function renderFileTree() {
+    const fileTreeElement = document.getElementById('file-tree');
+    if (!fileTreeElement) return;
+
+    fileTreeElement.innerHTML = '';
+    
+    // Always show scratchpad at top
+    const scratchpadElement = document.createElement('div');
+    scratchpadElement.className = 'file-item px-2 py-1 cursor-pointer rounded whitespace-nowrap overflow-hidden hover:bg-gray-100 dark:hover:bg-gray-800 border-b border-gray-200 dark:border-gray-700 mb-2';
+    scratchpadElement.dataset.type = 'file';
+    scratchpadElement.dataset.path = SCRATCHPAD_ID;
+    scratchpadElement.dataset.name = 'Scratchpad';
+    scratchpadElement.innerHTML = '<div class="filename-main">📝 Scratchpad</div><div class="filename-secondary">Quick editing (no file)</div>';
+    
+    scratchpadElement.addEventListener('click', (event) => {
+        event.stopPropagation();
+        openScratchpad();
+        
+        // Update active state
+        document.querySelectorAll('.file-item').forEach(el => el.classList.remove('active-file'));
+        scratchpadElement.classList.add('active-file');
+    });
+    
+    fileTreeElement.appendChild(scratchpadElement);
+
+    function createFileTreeHTML(directory, parentElement, path = '') {
+        if (!directory || !directory.entries) return;
+
+        // Sort entries: files first, then directories, alphabetically
+        const sortedEntries = Object.entries(directory.entries).sort((a, b) => {
+            const [nameA, itemA] = a;
+            const [nameB, itemB] = b;
+
+            if (itemA.type !== itemB.type) {
+                return itemA.type === 'file' ? -1 : 1;
+            }
+
+            return nameA.localeCompare(nameB);
+        });
+
+        for (const [name, item] of sortedEntries) {
+            if (item.type === 'directory') {
+                const dirElement = document.createElement('div');
+                dirElement.className = 'directory-item tree-row px-2 py-1 cursor-pointer rounded hover:bg-gray-100 dark:hover:bg-gray-800 collapsed';
+                dirElement.dataset.type = 'directory';
+                const currentPath = path ? `${path}/${name}` : name;
+                dirElement.dataset.path = currentPath;
+
+                const dirIcon = document.createElement('span');
+                dirIcon.className = 'dir-icon mr-1';
+                dirIcon.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 18 15 12 9 6"></polyline></svg>';
+
+                const dirName = document.createElement('span');
+                dirName.textContent = `📁 ${name}`;
+
+                const dirLabel = document.createElement('span');
+                dirLabel.className = 'tree-row__label';
+                dirLabel.appendChild(dirIcon);
+                dirLabel.appendChild(dirName);
+
+                const dirActions = createActionButtons(currentPath, 'directory');
+
+                dirElement.appendChild(dirLabel);
+                dirElement.appendChild(dirActions);
+                parentElement.appendChild(dirElement);
+
+                const contentsElement = document.createElement('div');
+                contentsElement.className = 'directory-contents ml-4';
+                contentsElement.style.display = 'none';
+                parentElement.appendChild(contentsElement);
+
+                dirElement.addEventListener('click', (event) => {
+                    event.stopPropagation();
+                    dirElement.classList.toggle('collapsed');
+
+                    const contents = dirElement.nextElementSibling;
+                    if (contents && contents.classList.contains('directory-contents')) {
+                        contents.style.display = dirElement.classList.contains('collapsed') ? 'none' : 'block';
+                    }
+                });
+
+                createFileTreeHTML(item, contentsElement, currentPath);
+            } else if (item.type === 'file') {
+                const fileElement = document.createElement('div');
+                fileElement.className = 'file-item tree-row px-2 py-1 cursor-pointer rounded hover:bg-gray-100 dark:hover:bg-gray-800';
+                fileElement.dataset.type = 'file';
+                const filePath = path ? `${path}/${name}` : name;
+                fileElement.dataset.path = filePath;
+                fileElement.dataset.name = name;
+
+                const fileIcon = getFileTypeIcon(name);
+
+                let fileNameDisplay;
+                const parsed = zddc.parseFilename(name);
+                if (parsed && parsed.valid) {
+                    // Strip extension from title for display (it's already in the icon)
+                    const titleDisplay = parsed.title;
+                    const metaDisplay = `${parsed.trackingNumber}_${parsed.revision} (${parsed.status})`;
+                    fileNameDisplay = `<div class="filename-main">${fileIcon} ${titleDisplay}</div><div class="filename-secondary">${metaDisplay}</div>`;
+                } else if (name.includes(' - ')) {
+                    // Fallback: simple split for files with ' - ' but not fully ZDDC-compliant
+                    const dashIdx = name.lastIndexOf(' - ');
+                    const secondary = name.substring(0, dashIdx);
+                    const primary = name.substring(dashIdx + 3).replace(/\.[^.]+$/, '');
+                    fileNameDisplay = `<div class="filename-main">${fileIcon} ${primary}</div><div class="filename-secondary">${secondary}</div>`;
+                } else {
+                    fileNameDisplay = `<span>${fileIcon} ${name}</span>`;
+                }
+
+                const fileLabel = document.createElement('span');
+                fileLabel.className = 'tree-row__label';
+                fileLabel.innerHTML = fileNameDisplay;
+
+                const fileActions = createActionButtons(filePath, 'file');
+
+                fileElement.innerHTML = '';
+                fileElement.appendChild(fileLabel);
+                fileElement.appendChild(fileActions);
+
+                fileElement.addEventListener('click', (event) => {
+                    event.stopPropagation();
+                    handleFileClick(item.handle, filePath, fileElement);
+                });
+
+                parentElement.appendChild(fileElement);
+            }
+        }
+    }
+
+    createFileTreeHTML(fileTree, fileTreeElement);
+}
+
+/**
+ * Handle click on a file in the file tree
+ * @param {FileSystemFileHandle} fileHandle - The file handle
+ * @param {string} filePath - Path of the file
+ * @param {HTMLElement} fileElement - The clicked element
+ */
+async function handleFileClick(fileHandle, filePath, fileElement) {
+    try {
+        currentFileHandle = fileHandle;
+
+        // Remove active class from all file items
+        const allFileItems = document.querySelectorAll('.file-item');
+        allFileItems.forEach(item => {
+            item.classList.remove('active-file');
+            item.style.backgroundColor = '';
+            item.style.color = '';
+        });
+
+        // Add active class to clicked file
+        fileElement.classList.add('active-file');
+        fileElement.style.backgroundColor = '#3b82f6';
+        fileElement.style.color = 'white';
+
+        await displayFileContent(fileHandle, filePath);
+
+    } catch (error) {
+        console.error('Error handling file click:', error);
+        alert(`Error opening file: ${error.message}`);
+    }
+}
+
+/**
+ * Display file content in main area
+ * @param {FileSystemFileHandle} fileHandle - File handle
+ * @param {string} filePath - Path of the file
+ */
+async function displayFileContent(fileHandle, filePath) {
+    try {
+        currentFileHandle = fileHandle;
+
+        const file = await fileHandle.getFile();
+        const fileName = file.name;
+        const lastModified = file.lastModified;
+
+        document.getElementById('welcome-screen').classList.add('hidden');
+        document.getElementById('content-container').classList.remove('hidden');
+
+        const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg'];
+        const isImage = imageExtensions.some(ext => fileName.toLowerCase().endsWith(ext));
+
+        const isHtml = fileName.toLowerCase().endsWith('.html') || fileName.toLowerCase().endsWith('.htm');
+        const isDocx = fileName.toLowerCase().endsWith('.docx');
+        const isXlsx = fileName.toLowerCase().endsWith('.xlsx') || fileName.toLowerCase().endsWith('.xls');
+        const isPdf = fileName.toLowerCase().endsWith('.pdf');
+
+        if (isImage) {
+            displayImagePreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isHtml) {
+            displayHtmlPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isDocx) {
+            displayDocxPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isXlsx) {
+            displayXlsxPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isPdf) {
+            displayPdfPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else {
+            const content = await file.text();
+
+            if (fileName.toLowerCase().endsWith('.md')) {
+                initializeEditor(content, true, filePath, fileName, fileHandle, lastModified);
+            } else {
+                initializeEditor(content, false, filePath, fileName, fileHandle, lastModified);
+            }
+        }
+    } catch (error) {
+        console.error('Error displaying file content:', error);
+        alert(`Error opening file: ${error.message}`);
+    }
+}
+
+/**
+ * Display image preview
+ */
+async function displayImagePreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const imageContainer = document.createElement('div');
+    imageContainer.className = 'image-preview-container flex-1 overflow-auto p-4';
+
+    const imageElement = document.createElement('img');
+    imageElement.className = 'image-preview';
+    imageElement.alt = fileName;
+
+    const objectUrl = URL.createObjectURL(file);
+    imageElement.src = objectUrl;
+
+    imageContainer.appendChild(imageElement);
+    fileViewContainer.appendChild(imageContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false,
+        objectUrl: objectUrl
+    };
+
+    editorInstances.set(filePath, instanceData);
+}
+
+/**
+ * Display HTML preview in sandboxed iframe
+ */
+async function displayHtmlPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const htmlContent = await file.text();
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const htmlContainer = document.createElement('div');
+    htmlContainer.className = 'html-preview-container flex-1 overflow-hidden';
+
+    const iframe = document.createElement('iframe');
+    iframe.className = 'html-preview-iframe w-full h-full border-0';
+
+    iframe.setAttribute('sandbox', 'allow-same-origin allow-scripts allow-forms allow-popups allow-modals');
+    iframe.setAttribute('loading', 'lazy');
+
+    iframe.srcdoc = htmlContent;
+
+    htmlContainer.appendChild(iframe);
+    fileViewContainer.appendChild(htmlContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false,
+        iframe: iframe
+    };
+
+    editorInstances.set(filePath, instanceData);
+
+    iframe.addEventListener('load', () => {
+        try {
+            const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
+            if (iframeDoc) {
+                iframeDoc.addEventListener('click', function (e) {
+                    const link = e.target.closest('a');
+                    if (link && link.getAttribute('href')) {
+                        const href = link.getAttribute('href');
+                        if (href.startsWith('#')) {
+                            e.preventDefault();
+                            const targetId = href.substring(1);
+                            const targetElement = iframeDoc.getElementById(targetId);
+                            if (targetElement) {
+                                targetElement.scrollIntoView({ behavior: 'smooth' });
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (error) {
+            if (DEBUG) console.log('Cannot access iframe content for navigation handling:', error);
+        }
+    });
+}
+
+/**
+ * Display DOCX preview in main content area
+ */
+async function displayDocxPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const docxContainer = document.createElement('div');
+    docxContainer.className = 'flex-1 overflow-auto p-4';
+    docxContainer.innerHTML = '<div style="text-align:center;padding:2rem;color:#666;">Loading preview...</div>';
+    fileViewContainer.appendChild(docxContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false
+    };
+    editorInstances.set(filePath, instanceData);
+
+    try {
+        await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+        await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+
+        const arrayBuffer = await file.arrayBuffer();
+        docxContainer.innerHTML = '';
+        await window.docx.renderAsync(arrayBuffer, docxContainer);
+    } catch (err) {
+        console.error('Error rendering DOCX:', err);
+        docxContainer.innerHTML = `<div style="text-align:center;padding:2rem;color:#c00;">Error rendering DOCX: ${err.message}</div>`;
+    }
+}
+
+/**
+ * Display XLSX/XLS preview in main content area
+ */
+async function displayXlsxPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const xlsxContainer = document.createElement('div');
+    xlsxContainer.className = 'flex-1 overflow-auto';
+    xlsxContainer.innerHTML = '<div style="text-align:center;padding:2rem;color:#666;">Loading preview...</div>';
+    fileViewContainer.appendChild(xlsxContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false
+    };
+    editorInstances.set(filePath, instanceData);
+
+    try {
+        await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+
+        const arrayBuffer = await file.arrayBuffer();
+        const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+
+        xlsxContainer.innerHTML = '';
+
+        if (workbook.SheetNames.length > 1) {
+            const tabs = document.createElement('div');
+            tabs.style.cssText = 'display:flex;gap:0;border-bottom:1px solid #ddd;background:#f5f5f5;';
+            const tableArea = document.createElement('div');
+            tableArea.className = 'flex-1 overflow-auto';
+
+            workbook.SheetNames.forEach((name, i) => {
+                const tab = document.createElement('button');
+                tab.textContent = name;
+                tab.style.cssText = 'padding:0.4rem 1rem;cursor:pointer;border:1px solid transparent;border-bottom:none;font-size:0.85rem;background:transparent;';
+                if (i === 0) tab.style.cssText += 'background:white;border-color:#ddd;border-bottom-color:white;margin-bottom:-1px;font-weight:500;';
+                tab.onclick = () => {
+                    tabs.querySelectorAll('button').forEach(t => { t.style.background = 'transparent'; t.style.borderColor = 'transparent'; t.style.fontWeight = 'normal'; });
+                    tab.style.cssText = 'padding:0.4rem 1rem;cursor:pointer;border:1px solid #ddd;border-bottom-color:white;font-size:0.85rem;background:white;margin-bottom:-1px;font-weight:500;';
+                    renderXlsxSheet(workbook, name, tableArea);
+                };
+                tabs.appendChild(tab);
+            });
+
+            xlsxContainer.appendChild(tabs);
+            xlsxContainer.appendChild(tableArea);
+            renderXlsxSheet(workbook, workbook.SheetNames[0], tableArea);
+        } else {
+            renderXlsxSheet(workbook, workbook.SheetNames[0], xlsxContainer);
+        }
+    } catch (err) {
+        console.error('Error rendering XLSX:', err);
+        xlsxContainer.innerHTML = `<div style="text-align:center;padding:2rem;color:#c00;">Error rendering spreadsheet: ${err.message}</div>`;
+    }
+}
+
+/**
+ * Render a single XLSX sheet as an HTML table
+ */
+function renderXlsxSheet(workbook, sheetName, container) {
+    const sheet = workbook.Sheets[sheetName];
+    const html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+    container.innerHTML = html;
+    const table = container.querySelector('table');
+    if (table) {
+        table.style.cssText = 'border-collapse:collapse;width:100%;font-size:0.85rem;';
+        table.querySelectorAll('th,td').forEach(cell => {
+            cell.style.cssText = 'border:1px solid #ddd;padding:0.35rem 0.5rem;text-align:left;white-space:nowrap;';
+        });
+        table.querySelectorAll('th').forEach(th => {
+            th.style.background = '#f0f0f0';
+            th.style.fontWeight = '600';
+        });
+    }
+}
+
+/**
+ * Display PDF preview using browser's built-in PDF viewer
+ */
+async function displayPdfPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) return;
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName;
+    fileHeader.appendChild(fileTitle);
+    fileViewContainer.appendChild(fileHeader);
+
+    const pdfContainer = document.createElement('div');
+    pdfContainer.className = 'flex-1 overflow-hidden';
+
+    const objectUrl = URL.createObjectURL(file);
+
+    const iframe = document.createElement('iframe');
+    iframe.className = 'w-full h-full border-0';
+    iframe.src = objectUrl;
+    iframe.setAttribute('title', fileName);
+
+    pdfContainer.appendChild(iframe);
+    fileViewContainer.appendChild(pdfContainer);
+    contentContainer.appendChild(fileViewContainer);
+
+    editorInstances.set(filePath, {
+        fileViewContainer,
+        fileHandle,
+        lastModified,
+        isDirty: false,
+        objectUrl
+    });
+}
+
+/**
+ * Update status bar counts
+ */
+function updateStatusCounts(folderCount, fileCount) {
+    const folderCountElement = document.getElementById('folder-count');
+    const fileCountElement = document.getElementById('file-count');
+
+    if (folderCountElement) {
+        folderCountElement.textContent = `${folderCount} folder${folderCount !== 1 ? 's' : ''}`;
+    }
+
+    if (fileCountElement) {
+        fileCountElement.textContent = `${fileCount} file${fileCount !== 1 ? 's' : ''}`;
+    }
+
+    updateUnsavedCount();
+}
+
+/**
+ * Update unsaved count in status bar
+ */
+function updateUnsavedCount() {
+    const unsavedCountElement = document.getElementById('unsaved-count');
+    if (!unsavedCountElement) return;
+
+    let dirtyCount = 0;
+    editorInstances.forEach(instance => {
+        if (instance.isDirty) {
+            dirtyCount++;
+        }
+    });
+
+    unsavedCountElement.textContent = `${dirtyCount} unsaved`;
+
+    if (dirtyCount > 0) {
+        unsavedCountElement.classList.add('text-amber-500', 'font-medium');
+    } else {
+        unsavedCountElement.classList.remove('text-amber-500', 'font-medium');
+    }
+}
+
+/**
+ * Update file dirty status indicator in tree
+ */
+function updateFileDirtyStatus(filePath, isDirty) {
+    const fileElement = document.querySelector(`.file-item[data-path="${filePath}"]`);
+    if (!fileElement) return;
+
+    if (isDirty) {
+        if (!fileElement.querySelector('.dirty-indicator')) {
+            const indicator = document.createElement('span');
+            indicator.className = 'dirty-indicator ml-1 text-amber-500 font-bold';
+            indicator.textContent = '●';
+            fileElement.appendChild(indicator);
+        }
+        fileElement.classList.add('is-dirty');
+    } else {
+        const indicator = fileElement.querySelector('.dirty-indicator');
+        if (indicator) {
+            fileElement.removeChild(indicator);
+        }
+        fileElement.classList.remove('is-dirty');
+    }
+}
diff --git a/mdedit/js/front-matter.js b/mdedit/js/front-matter.js
new file mode 100644
index 0000000..e38ab11
--- /dev/null
+++ b/mdedit/js/front-matter.js
@@ -0,0 +1,106 @@
+/**
+ * YAML front matter parsing and stringification
+ */
+
+/**
+ * Parse YAML front matter from markdown content
+ * @param {string} content - Full markdown content with potential front matter
+ * @returns {{data: Object, content: string}} Parsed front matter data and remaining content
+ */
+function parseFrontMatter(content) {
+    if (!content || !content.startsWith('---\n')) {
+        return {
+            data: {},
+            content: content || ''
+        };
+    }
+    
+    const endMatch = content.indexOf('\n---\n', 4);
+    if (endMatch === -1) {
+        return {
+            data: {},
+            content: content
+        };
+    }
+    
+    const frontMatterText = content.substring(4, endMatch);
+    const markdownBody = content.substring(endMatch + 5);
+    
+    // Parse YAML front matter (basic key: value parsing)
+    const frontMatterData = {};
+    const lines = frontMatterText.split('\n');
+    
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) continue;
+        
+        const colonIndex = trimmedLine.indexOf(':');
+        if (colonIndex > 0) {
+            const key = trimmedLine.substring(0, colonIndex).trim();
+            let value = trimmedLine.substring(colonIndex + 1).trim();
+            
+            // Remove quotes
+            value = value.replace(/^["']|["']$/g, '');
+            
+            // Handle arrays (basic support for [item1, item2])
+            if (value.startsWith('[') && value.endsWith(']')) {
+                value = value.slice(1, -1).split(',').map(item => item.trim().replace(/^["']|["']$/g, ''));
+            }
+            
+            frontMatterData[key] = value;
+        }
+    }
+    
+    return {
+        data: frontMatterData,
+        content: markdownBody
+    };
+}
+
+/**
+ * Stringify front matter data and combine with markdown content
+ * @param {string} content - Markdown content
+ * @param {Object} data - Front matter data object
+ * @returns {string} Combined YAML front matter and markdown
+ */
+function stringifyFrontMatter(content, data) {
+    if (!data || Object.keys(data).length === 0) {
+        return content;
+    }
+    
+    let yamlString = '---\n';
+    
+    for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value)) {
+            yamlString += `${key}: [${value.map(v => `"${v}"`).join(', ')}]\n`;
+        } else {
+            yamlString += `${key}: "${value}"\n`;
+        }
+    }
+    
+    yamlString += '---\n';
+    
+    return yamlString + content;
+}
+
+/**
+ * Convert front matter data to YAML string for textarea display (without delimiters)
+ * @param {Object} data - Front matter data
+ * @returns {string} YAML string for textarea
+ */
+function stringifyFrontMatterToTextarea(data) {
+    if (!data || Object.keys(data).length === 0) {
+        return '';
+    }
+    
+    let yamlString = '';
+    for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value)) {
+            yamlString += `${key}: [${value.map(v => `"${v}"`).join(', ')}]\n`;
+        } else {
+            yamlString += `${key}: "${value}"\n`;
+        }
+    }
+    
+    return yamlString.trim();
+}
diff --git a/mdedit/js/main.js b/mdedit/js/main.js
new file mode 100644
index 0000000..d8a23ce
--- /dev/null
+++ b/mdedit/js/main.js
@@ -0,0 +1,40 @@
+/**
+ * Application initialization
+ */
+
+// Initialize when DOM is loaded
+document.addEventListener('DOMContentLoaded', function () {
+    // Check File System API availability and update UI
+    initializeApiAvailability();
+    
+    setupEventListeners();
+    initializeFileNavResizer();
+    setupTocDepthSelector();
+    startFileChangeMonitoring();
+    
+    // Show scratchpad in file tree on startup
+    renderFileTree();
+    
+
+});
+
+/**
+ * Initialize UI based on File System API availability
+ */
+function initializeApiAvailability() {
+    const selectDirectoryBtn = document.getElementById('select-directory');
+    const welcomeHint = document.getElementById('welcome-hint');
+    const welcomeFirefox = document.getElementById('welcome-firefox');
+    
+    if (!hasFileSystemAccess) {
+        // Disable file system buttons in Firefox and other unsupported browsers
+        if (selectDirectoryBtn) {
+            selectDirectoryBtn.disabled = true;
+            selectDirectoryBtn.title = 'File System API not supported in this browser';
+        }
+        // Show Firefox warning, hide normal hint
+        if (welcomeHint) welcomeHint.classList.add('hidden');
+        if (welcomeFirefox) welcomeFirefox.classList.remove('hidden');
+        
+    }
+}
diff --git a/mdedit/js/resizer.js b/mdedit/js/resizer.js
new file mode 100644
index 0000000..6dd6a5b
--- /dev/null
+++ b/mdedit/js/resizer.js
@@ -0,0 +1,93 @@
+/**
+ * Pane resizing functionality
+ */
+
+/**
+ * Make an element resizable by dragging its resizer
+ * @param {HTMLElement} resizer - The resizer element
+ * @param {HTMLElement} pane - The pane to resize
+ */
+function makeResizable(resizer, pane) {
+    const initialWidth = pane.offsetWidth;
+
+    let x = 0;
+    let paneWidth = initialWidth;
+
+    const mouseDownHandler = function (e) {
+        x = e.clientX;
+        paneWidth = pane.offsetWidth;
+
+        document.addEventListener('mousemove', mouseMoveHandler);
+        document.addEventListener('mouseup', mouseUpHandler);
+
+        resizer.classList.add('active');
+        document.body.style.cursor = 'col-resize';
+        document.body.style.userSelect = 'none';
+    };
+
+    const mouseMoveHandler = function (e) {
+        const dx = e.clientX - x;
+        const newWidth = Math.max(150, paneWidth + dx);
+
+        pane.style.width = `${newWidth}px`;
+    };
+
+    const mouseUpHandler = function () {
+        document.removeEventListener('mousemove', mouseMoveHandler);
+        document.removeEventListener('mouseup', mouseUpHandler);
+
+        resizer.classList.remove('active');
+        document.body.style.cursor = '';
+        document.body.style.userSelect = '';
+    };
+
+    resizer.addEventListener('mousedown', mouseDownHandler);
+}
+
+/**
+ * Initialize the file navigation pane resizer
+ */
+function initializeFileNavResizer() {
+    const fileNavResizer = document.querySelector('.pane-resizer[data-resizer-for="file-nav"]');
+
+    if (fileNavResizer && !fileNavResizer.hasAttribute('data-resizer-initialized')) {
+        fileNavResizer.setAttribute('data-resizer-initialized', 'true');
+
+        let x = 0;
+        let navWidth = 0;
+
+        const mouseDownHandler = function (e) {
+            x = e.clientX;
+
+            const navPane = document.getElementById('file-nav');
+            navWidth = navPane.getBoundingClientRect().width;
+
+            document.addEventListener('mousemove', mouseMoveHandler);
+            document.addEventListener('mouseup', mouseUpHandler);
+
+            fileNavResizer.classList.add('bg-blue-500');
+        };
+
+        const mouseMoveHandler = function (e) {
+            const dx = e.clientX - x;
+
+            const navPane = document.getElementById('file-nav');
+
+            const newWidth = navWidth + dx;
+
+            if (newWidth >= 200) {
+                navPane.style.width = `${newWidth}px`;
+            }
+        };
+
+        const mouseUpHandler = function () {
+            document.removeEventListener('mousemove', mouseMoveHandler);
+            document.removeEventListener('mouseup', mouseUpHandler);
+
+            fileNavResizer.classList.remove('bg-blue-500');
+        };
+
+        fileNavResizer.addEventListener('mousedown', mouseDownHandler);
+    }
+}
+
diff --git a/mdedit/js/toc.js b/mdedit/js/toc.js
new file mode 100644
index 0000000..442ab6f
--- /dev/null
+++ b/mdedit/js/toc.js
@@ -0,0 +1,256 @@
+/**
+ * Table of Contents generation and scroll functionality
+ */
+
+/**
+ * Scroll to header service - uses line numbers for reliable targeting
+ */
+const ScrollToHeaderService = {
+    /**
+     * Scroll to a specific header in the editor by line number
+     * @param {Object} editorInstance - Toast UI Editor instance
+     * @param {string} headerText - Text content of the header (for highlighting)
+     * @param {number} lineIndex - 0-based line index of the header in markdown
+     */
+    scrollToHeader(editorInstance, headerText, lineIndex) {
+        if (!editorInstance) {
+            console.warn('Editor instance not available for scrolling');
+            return;
+        }
+
+        try {
+            const editorElements = editorInstance.getEditorElements();
+            const isWysiwygMode = editorInstance.isWysiwygMode();
+
+            if (isWysiwygMode) {
+                // In WYSIWYG mode, find header by text (no line numbers available)
+                const wysiwygEditor = editorElements.wwEditor;
+                if (wysiwygEditor) {
+                    const headers = wysiwygEditor.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    for (const header of headers) {
+                        if (header.textContent.trim() === headerText.trim()) {
+                            // Scroll the editor container directly with 10px offset
+                            const headerPosition = header.getBoundingClientRect().top - wysiwygEditor.getBoundingClientRect().top;
+                            const offset = 10; // Account for fixed headers or padding
+                            wysiwygEditor.scrollTop = headerPosition - offset;
+                            this._highlightHeader(header);
+                            break;
+                        }
+                    }
+                }
+            } else {
+                // In markdown mode, use line number to position cursor, then scroll preview
+                const lineNumber = lineIndex + 1; // Convert to 1-based
+                
+                // Move cursor to the heading line in the editor
+                try {
+                    editorInstance.setSelection([lineNumber, 1], [lineNumber, 1]);
+                } catch (e) {
+                    if (DEBUG) console.debug('Could not set selection:', e);
+                }
+
+                // Scroll preview to matching header
+                const previewElement = editorElements.mdPreview;
+                if (previewElement) {
+                    const headers = previewElement.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    
+                    for (const header of headers) {
+                        if (header.textContent.trim() === headerText.trim()) {
+                            // Scroll the preview container directly with 10px offset
+                            const headerPosition = header.getBoundingClientRect().top - previewElement.getBoundingClientRect().top;
+                            const offset = 10; // Account for fixed headers or padding
+                            previewElement.scrollTop = headerPosition - offset;
+                            this._highlightHeader(header);
+                            break;
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            console.error('Error scrolling to header:', error);
+        }
+    },
+
+    /**
+     * Highlight header briefly for visual feedback
+     * @param {HTMLElement} headerElement - Header to highlight
+     */
+    _highlightHeader(headerElement) {
+        if (!headerElement) return;
+        
+        headerElement.style.transition = 'background-color 0.3s ease';
+        headerElement.style.backgroundColor = '#fef3c7';
+        
+        setTimeout(() => {
+            headerElement.style.backgroundColor = '';
+            setTimeout(() => {
+                headerElement.style.transition = '';
+            }, 300);
+        }, 1500);
+    }
+};
+
+/**
+ * Generate and update the TOC from markdown content
+ * @param {string} content - Markdown content
+ * @param {HTMLElement} tocContainer - Container for the TOC
+ * @param {Object} editorInstance - Toast UI Editor instance
+ * @param {number} maxDepth - Maximum heading level (1-6)
+ */
+function updateToc(content, tocContainer, editorInstance, maxDepth = 6) {
+    if (content === undefined || content === null || !tocContainer) {
+        console.warn('Missing required params for updateToc');
+        return;
+    }
+
+    tocContainer.innerHTML = '';
+
+    const tocList = document.createElement('ul');
+    tocList.className = 'toc-list pl-0 text-sm';
+
+    if (!content.trim()) {
+        const emptyMessage = document.createElement('p');
+        emptyMessage.className = 'text-gray-500 p-4';
+        emptyMessage.textContent = 'This file is empty.';
+        tocContainer.appendChild(emptyMessage);
+        return;
+    }
+
+    const headings = [];
+    const lines = content.split('\n');
+    
+    lines.forEach((line, index) => {
+        const match = line.match(/^(#{1,6})\s+(.+)$/);
+        if (match) {
+            const level = match[1].length;
+            let text = match[2].trim();
+            
+            // Clean markdown formatting
+            text = text
+                .replace(/\\(.)/g, '$1')
+                .replace(/\*\*(.*?)\*\*/g, '$1')
+                .replace(/\*(.*?)\*/g, '$1')
+                .replace(/`(.*?)`/g, '$1')
+                .replace(/\[(.*?)\]\(.*?\)/g, '$1')
+                .replace(/~~(.*?)~~/g, '$1')
+                .trim();
+            
+            const id = text.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]/g, '');
+            
+            headings.push({
+                level,
+                text,
+                id,
+                lineIndex: index
+            });
+        }
+    });
+
+    let currentList = tocList;
+    let currentLevel = 0;
+    let listsStack = [tocList];
+
+    const filteredHeadings = headings.filter(heading => heading.level <= maxDepth);
+
+    if (filteredHeadings.length === 0) {
+        const noHeadings = document.createElement('p');
+        noHeadings.className = 'text-gray-500 p-4';
+        noHeadings.textContent = maxDepth === 6 ? 'No headings found in this document.' :
+            'No headings at or below level H' + maxDepth + ' found.';
+        tocContainer.appendChild(noHeadings);
+        return;
+    }
+
+    filteredHeadings.forEach(heading => {
+        const li = document.createElement('li');
+        li.className = `toc-item toc-level-${heading.level} py-1`;
+
+        const a = document.createElement('a');
+        a.innerHTML = heading.text;
+        a.href = '#';
+        a.className = 'text-blue-600 hover:text-blue-800 hover:underline cursor-pointer';
+        a.dataset.headerText = heading.text;
+        a.dataset.lineIndex = heading.lineIndex;
+
+        a.addEventListener('click', function(e) {
+            e.preventDefault();
+            
+            if (editorInstance && ScrollToHeaderService) {
+                try {
+                    ScrollToHeaderService.scrollToHeader(
+                        editorInstance, 
+                        heading.text, 
+                        parseInt(heading.lineIndex)
+                    );
+                } catch (error) {
+                    console.error('Error in ScrollToHeaderService.scrollToHeader:', error);
+                }
+            }
+        });
+
+        li.appendChild(a);
+
+        if (heading.level > currentLevel) {
+            const nestedUl = document.createElement('ul');
+            nestedUl.className = 'pl-4 mt-1';
+            listsStack[listsStack.length - 1].appendChild(nestedUl);
+            listsStack.push(nestedUl);
+            currentList = nestedUl;
+            currentLevel = heading.level;
+        } else if (heading.level < currentLevel) {
+            while (heading.level < currentLevel && listsStack.length > 1) {
+                listsStack.pop();
+                currentLevel--;
+            }
+            currentList = listsStack[listsStack.length - 1];
+        }
+
+        currentList.appendChild(li);
+    });
+
+    tocContainer.appendChild(tocList);
+    clearActiveTocItem(tocContainer);
+}
+
+/**
+ * Clear active TOC item from all items within the container
+ * @param {HTMLElement} tocContainer - Container element holding the TOC
+ */
+function clearActiveTocItem(tocContainer) {
+    if (!tocContainer) return;
+    
+    const activeItems = tocContainer.querySelectorAll('.toc-active');
+    activeItems.forEach(item => {
+        item.classList.remove('toc-active');
+    });
+}
+
+/**
+ * Set active TOC item by finding the link matching the header text
+ * @param {HTMLElement} tocContainer - Container element holding the TOC
+ * @param {string} headerText - Text of the header to match and activate
+ */
+function setActiveTocItem(tocContainer, headerText) {
+    if (!tocContainer || !headerText) return;
+    
+    // First clear any existing active items
+    clearActiveTocItem(tocContainer);
+    
+    // Find the link matching the header text
+    const links = tocContainer.querySelectorAll('a[data-header-text]');
+    for (const link of links) {
+        if (link.dataset.headerText === headerText) {
+            // Add toc-active class to the parent li element
+            const li = link.parentElement;
+            if (li) {
+                li.classList.add('toc-active');
+            }
+            break;
+        }
+    }
+}
+
+// Export globally
+window.updateToc = updateToc;
+window.clearActiveTocItem = clearActiveTocItem;
+window.setActiveTocItem = setActiveTocItem;
diff --git a/mdedit/js/utils.js b/mdedit/js/utils.js
new file mode 100644
index 0000000..1e72682
--- /dev/null
+++ b/mdedit/js/utils.js
@@ -0,0 +1,104 @@
+/**
+ * Utility functions
+ */
+
+/**
+ * Debounce function calls
+ * @param {Function} func - Function to debounce
+ * @param {number} wait - Wait time in milliseconds
+ * @returns {Function} Debounced function
+ */
+function debounce(func, wait) {
+    let timeout;
+    return function () {
+        const context = this;
+        const args = arguments;
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func.apply(context, args), wait);
+    };
+}
+
+/**
+ * Get file type icon based on file extension
+ * @param {string} fileName - Name of the file
+ * @returns {string} Emoji icon for the file type
+ */
+function getFileTypeIcon(fileName) {
+    const extension = zddc.splitExtension(fileName).extension;
+    
+    const iconMap = {
+        // Documents
+        'md': '📝',
+        'markdown': '📝',
+        'txt': '📄',
+        'rtf': '📄',
+        'doc': '📘',
+        'docx': '📘',
+        'odt': '📘',
+        
+        // Web files
+        'html': '🌐',
+        'htm': '🌐',
+        'css': '🎨',
+        'js': '⚡',
+        'json': '📋',
+        'xml': '📊',
+        'yaml': '⚙️',
+        'yml': '⚙️',
+        
+        // PDFs and presentations
+        'pdf': '📕',
+        'ppt': '📊',
+        'pptx': '📊',
+        'odp': '📊',
+        
+        // Spreadsheets
+        'xls': '📗',
+        'xlsx': '📗',
+        'csv': '📊',
+        'ods': '📗',
+        
+        // Images
+        'png': '🖼️',
+        'jpg': '🖼️',
+        'jpeg': '🖼️',
+        'gif': '🖼️',
+        'svg': '🖼️',
+        'webp': '🖼️',
+        'bmp': '🖼️',
+        
+        // Archives
+        'zip': '📦',
+        'rar': '📦',
+        'tar': '📦',
+        'gz': '📦',
+        '7z': '📦',
+        
+        // Code files
+        'py': '🐍',
+        'java': '☕',
+        'cpp': '⚙️',
+        'c': '⚙️',
+        'h': '⚙️',
+        'php': '🔧',
+        'rb': '💎',
+        'go': '🔵',
+        'rs': '🦀',
+        'swift': '🧡',
+        'kt': '💜',
+        
+        // Configuration
+        'ini': '⚙️',
+        'conf': '⚙️',
+        'cfg': '⚙️',
+        'env': '⚙️',
+        
+        // Other
+        'log': '📃',
+        'sql': '🗄️',
+        'db': '🗄️',
+        'sqlite': '🗄️',
+    };
+    
+    return iconMap[extension] || '📄';
+}
diff --git a/mdedit/template.html b/mdedit/template.html
new file mode 100644
index 0000000..d8297e0
--- /dev/null
+++ b/mdedit/template.html
@@ -0,0 +1,156 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Markdown</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <!-- Toast UI Editor v3.2.2 -->
+    <link rel="stylesheet" href="https://uicdn.toast.com/editor/3.2.2/toastui-editor.min.css">
+    <script src="https://uicdn.toast.com/editor/3.2.2/toastui-editor-all.min.js"></script>
+    <style>
+        {{CSS_PLACEHOLDER}}
+    </style>
+</head>
+<body>
+    <div id="app" class="flex flex-col h-screen w-full overflow-hidden">
+        <header class="app-header">
+            <div class="header-left">
+                <div class="header-title-group">
+                    <span class="app-header__title">ZDDC Markdown</span>
+                    <span class="build-timestamp">{{BUILD_LABEL}}</span>
+                </div>
+                <button id="select-directory" class="btn btn-primary" title="Select a Directory">Select Directory</button>
+            </div>
+            <div class="header-right">
+                <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+                <button id="help-btn" class="btn btn-secondary" title="Help">?</button>
+            </div>
+        </header>
+
+        <main class="flex-1 overflow-hidden relative">
+            <div class="resizable-pane horizontal flex flex-row relative w-full h-full overflow-hidden" id="root-pane" data-pane-type="root">
+                <div class="pane nav-pane relative flex flex-col bg-white dark:bg-gray-900 overflow-hidden" id="file-nav" data-pane-type="file-nav" style="width: 450px; min-width: 200px;">
+                    <div class="pane-header flex flex-col px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700 select-none">
+                        <div class="flex justify-between items-center w-full">
+                            <span>Files</span>
+                            <div class="flex items-center gap-1">
+                                <button id="new-file-root" class="btn btn-secondary btn-sm hidden" title="New file in root directory">+</button>
+                                <button id="refresh-directory" class="btn btn-secondary btn-sm hidden" title="Refresh directory">↻</button>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="pane-content flex-1 overflow-auto p-4">
+                        <div id="file-tree" class="file-tree py-2">
+                        </div>
+                    </div>
+                </div>
+
+                <div class="pane-resizer bg-gray-200 dark:bg-gray-700 transition-colors relative z-10 w-1 cursor-col-resize hover:bg-blue-500" data-resizer-for="file-nav"></div>
+
+                <div class="pane content-pane flex-1 relative flex flex-col bg-white dark:bg-gray-900 overflow-hidden" id="main-content">
+                    <div id="welcome-screen" class="welcome-screen flex flex-col items-center justify-center h-full text-gray-500 dark:text-gray-400 text-center p-6">
+                        <h2 class="mb-2 text-xl">Welcome to ZDDC Markdown</h2>
+                        <p class="mb-4">All files are edited on your local computer.</p>
+                        <p id="welcome-hint" class="text-sm">Click <strong>Scratchpad</strong> to start editing,<br>or <strong>Select Directory</strong> to work with files.</p>
+                        <p id="welcome-firefox" class="text-sm text-amber-600 hidden mt-2">Your browser doesn't support the File System API.<br>Use <strong>Scratchpad</strong> to edit markdown and save via download.</p>
+                    </div>
+
+                    <div id="content-container" class="content-container flex flex-col h-full hidden">
+                    </div>
+                </div>
+            </div>
+        </main>
+
+        <footer class="status-bar flex justify-between items-center px-4 h-6 text-xs bg-gray-100 dark:bg-gray-800 border-t border-gray-200 dark:border-gray-700">
+            <div class="status-left flex items-center gap-6 py-1">
+                <button id="save-all" class="btn inline-flex items-center gap-2 px-3 py-1 text-sm bg-transparent border border-gray-300 dark:border-gray-600 rounded text-gray-800 dark:text-gray-200 cursor-pointer transition-all hover:bg-gray-200 dark:hover:bg-gray-700 h-6 leading-none" title="Save All">
+                    <svg class="btn-icon w-3.5 h-3.5 fill-current opacity-80" viewBox="0 0 16 16" fill="currentColor">
+                        <path d="M11.5 1H4.5a1.5 1.5 0 0 0-1.5 1.5v11a1.5 1.5 0 0 0 1.5 1.5h7a1.5 1.5 0 0 0 1.5-1.5v-11a1.5 1.5 0 0 0-1.5-1.5zm-7 1h7a.5.5 0 0 1 .5.5V9H4V2.5a.5.5 0 0 1 .5-.5zM4 10h8v3.5a.5.5 0 0 1-.5.5h-7a.5.5 0 0 1-.5-.5V10z"></path>
+                        <path d="M6.5 0a.5.5 0 0 1 .5.5V2h2V.5a.5.5 0 0 1 1 0V2h1.5a.5.5 0 0 1 0 1H10v2.5a.5.5 0 0 1-1 0V3H7v2.5a.5.5 0 0 1-1 0V3H4.5a.5.5 0 0 1 0-1H6V.5a.5.5 0 0 1 .5-.5z"></path>
+                    </svg>
+                    Save All
+                </button>
+                <span id="folder-count" class="status-message text-sm text-gray-800 dark:text-gray-200 opacity-80">0 folders</span>
+                <span id="file-count" class="status-message text-sm text-gray-800 dark:text-gray-200 opacity-80">0 files</span>
+                <span id="unsaved-count" class="status-message text-sm text-gray-800 dark:text-gray-200 opacity-80">0 unsaved</span>
+            </div>
+            <div class="status-right flex items-center gap-4">
+                <a href="https://codeberg.org/VARASYS/ZDDC" target="_blank" rel="noopener noreferrer" class="source-link" title="View source code">
+                    <svg class="source-icon fill-current transition-opacity hover:opacity-80" viewBox="0 0 16 16" width="16" height="16" aria-hidden="true">
+                        <path d="M5.5 11.5L1 8l4.5-3.5L4.4 3 0 8l4.4 5 1.1-1.5zm5 0L15 8l-4.5-3.5L11.6 3 16 8l-4.4 5-1.1-1.5z"></path>
+                    </svg>
+                </a>
+            </div>
+        </footer>
+
+        <!-- Help Panel -->
+        <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+            <div class="help-panel__header">
+                <h2 id="help-panel-title" class="help-panel__title">Help — ZDDC Markdown</h2>
+                <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+            </div>
+            <div class="help-panel__body">
+                <h3>What is ZDDC Markdown?</h3>
+                <p>ZDDC Markdown is a browser-based Markdown editor that reads and writes files directly on your local file system. Everything runs locally — no data is sent to any server.</p>
+
+                <h3>Getting Started</h3>
+                <ol>
+                    <li>Click <strong>Select Directory</strong> to open a folder. The file tree on the left will populate with all files in that folder.</li>
+                    <li>Click any Markdown file (<code>.md</code>) in the tree to open it in the editor.</li>
+                    <li>Use the <strong>Scratchpad</strong> entry (always visible at the top of the tree) for temporary notes without saving to disk.</li>
+                </ol>
+
+                <h3>Editor Modes</h3>
+                <dl>
+                    <dt>WYSIWYG</dt>
+                    <dd>A rich-text view where formatting is rendered live. Good for composing content.</dd>
+                    <dt>Markdown</dt>
+                    <dd>A plain-text view showing raw Markdown syntax. Good for precise control.</dd>
+                </dl>
+                <p>Switch between modes using the toolbar buttons at the top-right of the editor.</p>
+
+                <h3>Saving Files</h3>
+                <dl>
+                    <dt>Auto-save indicator</dt>
+                    <dd>A bullet (•) next to the filename in the tree indicates unsaved changes.</dd>
+                    <dt>Save (Ctrl+S)</dt>
+                    <dd>Saves the currently active file.</dd>
+                    <dt>Save All</dt>
+                    <dd>Saves all files that have unsaved changes in one operation.</dd>
+                </dl>
+
+                <h3>Table of Contents</h3>
+                <p>When a Markdown file is open, a table of contents is generated from its headings and shown on the right side. Use the depth selector to control how many heading levels appear.</p>
+
+                <h3>Browser Compatibility</h3>
+                <p>File system access requires a Chromium-based browser (Chrome, Edge, Brave). In Firefox and other browsers, the <strong>Scratchpad</strong> is available for editing, and files can be saved via download.</p>
+
+                <h3>Keyboard Shortcuts</h3>
+                <dl>
+                    <dt><kbd>Ctrl+S</kbd></dt>
+                    <dd>Save the current file.</dd>
+                    <dt><kbd>Escape</kbd></dt>
+                    <dd>Close this help panel.</dd>
+                </dl>
+            </div>
+        </aside>
+
+        <!-- New-file modal -->
+        <div id="new-file-modal" class="modal-overlay hidden" role="dialog" aria-modal="true" aria-labelledby="new-file-modal-title">
+            <div class="modal-box">
+                <h3 id="new-file-modal-title" class="modal-title">New file name</h3>
+                <input id="new-file-input" type="text" class="modal-input" value="untitled.md" autocomplete="off" spellcheck="false">
+                <div class="modal-actions">
+                    <button id="new-file-cancel" class="btn btn-secondary">Cancel</button>
+                    <button id="new-file-confirm" class="btn btn-primary">Create</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        {{JS_PLACEHOLDER}}
+    </script>
+</body>
+</html>
diff --git a/mdedit/vendor/toastui-editor-all.min.js b/mdedit/vendor/toastui-editor-all.min.js
new file mode 100644
index 0000000..178581e
--- /dev/null
+++ b/mdedit/vendor/toastui-editor-all.min.js
@@ -0,0 +1,24 @@
+/*!
+ * @toast-ui/editor
+ * @version 3.2.2 | Fri Feb 17 2023
+ * @author NHN Cloud FE Development Lab <dl_javascript@nhn.com>
+ * @license MIT
+ */
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.toastui=t():(e.toastui=e.toastui||{},e.toastui.Editor=t())}(self,(function(){return function(){var e={368:function(e){
+/*! @license DOMPurify 2.3.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.3.3/LICENSE */
+e.exports=function(){"use strict";function e(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}var t=Object.hasOwnProperty,n=Object.setPrototypeOf,r=Object.isFrozen,o=Object.getPrototypeOf,i=Object.getOwnPropertyDescriptor,s=Object.freeze,a=Object.seal,l=Object.create,c="undefined"!=typeof Reflect&&Reflect,u=c.apply,d=c.construct;u||(u=function(e,t,n){return e.apply(t,n)}),s||(s=function(e){return e}),a||(a=function(e){return e}),d||(d=function(t,n){return new(Function.prototype.bind.apply(t,[null].concat(e(n))))});var p=x(Array.prototype.forEach),h=x(Array.prototype.pop),f=x(Array.prototype.push),m=x(String.prototype.toLowerCase),g=x(String.prototype.match),v=x(String.prototype.replace),y=x(String.prototype.indexOf),b=x(String.prototype.trim),w=x(RegExp.prototype.test),k=C(TypeError);function x(e){return function(t){for(var n=arguments.length,r=Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];return u(e,t,r)}}function C(e){return function(){for(var t=arguments.length,n=Array(t),r=0;r<t;r++)n[r]=arguments[r];return d(e,n)}}function T(e,t){n&&n(e,null);for(var o=t.length;o--;){var i=t[o];if("string"==typeof i){var s=m(i);s!==i&&(r(t)||(t[o]=s),i=s)}e[i]=!0}return e}function M(e){var n=l(null),r=void 0;for(r in e)u(t,e,[r])&&(n[r]=e[r]);return n}function S(e,t){for(;null!==e;){var n=i(e,t);if(n){if(n.get)return x(n.get);if("function"==typeof n.value)return x(n.value)}e=o(e)}function r(e){return console.warn("fallback value for",e),null}return r}var E=s(["a","abbr","acronym","address","area","article","aside","audio","b","bdi","bdo","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","content","data","datalist","dd","decorator","del","details","dfn","dialog","dir","div","dl","dt","element","em","fieldset","figcaption","figure","font","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","img","input","ins","kbd","label","legend","li","main","map","mark","marquee","menu","menuitem","meter","nav","nobr","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","section","select","shadow","small","source","spacer","span","strike","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","tr","track","tt","u","ul","var","video","wbr"]),N=s(["svg","a","altglyph","altglyphdef","altglyphitem","animatecolor","animatemotion","animatetransform","circle","clippath","defs","desc","ellipse","filter","font","g","glyph","glyphref","hkern","image","line","lineargradient","marker","mask","metadata","mpath","path","pattern","polygon","polyline","radialgradient","rect","stop","style","switch","symbol","text","textpath","title","tref","tspan","view","vkern"]),O=s(["feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence"]),D=s(["animate","color-profile","cursor","discard","fedropshadow","feimage","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","foreignobject","hatch","hatchpath","mesh","meshgradient","meshpatch","meshrow","missing-glyph","script","set","solidcolor","unknown","use"]),A=s(["math","menclose","merror","mfenced","mfrac","mglyph","mi","mlabeledtr","mmultiscripts","mn","mo","mover","mpadded","mphantom","mroot","mrow","ms","mspace","msqrt","mstyle","msub","msup","msubsup","mtable","mtd","mtext","mtr","munder","munderover"]),L=s(["maction","maligngroup","malignmark","mlongdiv","mscarries","mscarry","msgroup","mstack","msline","msrow","semantics","annotation","annotation-xml","mprescripts","none"]),I=s(["#text"]),R=s(["accept","action","align","alt","autocapitalize","autocomplete","autopictureinpicture","autoplay","background","bgcolor","border","capture","cellpadding","cellspacing","checked","cite","class","clear","color","cols","colspan","controls","controlslist","coords","crossorigin","datetime","decoding","default","dir","disabled","disablepictureinpicture","disableremoteplayback","download","draggable","enctype","enterkeyhint","face","for","headers","height","hidden","high","href","hreflang","id","inputmode","integrity","ismap","kind","label","lang","list","loading","loop","low","max","maxlength","media","method","min","minlength","multiple","muted","name","noshade","novalidate","nowrap","open","optimum","pattern","placeholder","playsinline","poster","preload","pubdate","radiogroup","readonly","rel","required","rev","reversed","role","rows","rowspan","spellcheck","scope","selected","shape","size","sizes","span","srclang","start","src","srcset","step","style","summary","tabindex","title","translate","type","usemap","valign","value","width","xmlns","slot"]),P=s(["accent-height","accumulate","additive","alignment-baseline","ascent","attributename","attributetype","azimuth","basefrequency","baseline-shift","begin","bias","by","class","clip","clippathunits","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","cx","cy","d","dx","dy","diffuseconstant","direction","display","divisor","dur","edgemode","elevation","end","fill","fill-opacity","fill-rule","filter","filterunits","flood-color","flood-opacity","font-family","font-size","font-size-adjust","font-stretch","font-style","font-variant","font-weight","fx","fy","g1","g2","glyph-name","glyphref","gradientunits","gradienttransform","height","href","id","image-rendering","in","in2","k","k1","k2","k3","k4","kerning","keypoints","keysplines","keytimes","lang","lengthadjust","letter-spacing","kernelmatrix","kernelunitlength","lighting-color","local","marker-end","marker-mid","marker-start","markerheight","markerunits","markerwidth","maskcontentunits","maskunits","max","mask","media","method","mode","min","name","numoctaves","offset","operator","opacity","order","orient","orientation","origin","overflow","paint-order","path","pathlength","patterncontentunits","patterntransform","patternunits","points","preservealpha","preserveaspectratio","primitiveunits","r","rx","ry","radius","refx","refy","repeatcount","repeatdur","restart","result","rotate","scale","seed","shape-rendering","specularconstant","specularexponent","spreadmethod","startoffset","stddeviation","stitchtiles","stop-color","stop-opacity","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke","stroke-width","style","surfacescale","systemlanguage","tabindex","targetx","targety","transform","text-anchor","text-decoration","text-rendering","textlength","type","u1","u2","unicode","values","viewbox","visibility","version","vert-adv-y","vert-origin-x","vert-origin-y","width","word-spacing","wrap","writing-mode","xchannelselector","ychannelselector","x","x1","x2","xmlns","y","y1","y2","z","zoomandpan"]),B=s(["accent","accentunder","align","bevelled","close","columnsalign","columnlines","columnspan","denomalign","depth","dir","display","displaystyle","encoding","fence","frame","height","href","id","largeop","length","linethickness","lspace","lquote","mathbackground","mathcolor","mathsize","mathvariant","maxsize","minsize","movablelimits","notation","numalign","open","rowalign","rowlines","rowspacing","rowspan","rspace","rquote","scriptlevel","scriptminsize","scriptsizemultiplier","selection","separator","separators","stretchy","subscriptshift","supscriptshift","symmetric","voffset","width","xmlns"]),F=s(["xlink:href","xml:id","xlink:title","xml:space","xmlns:xlink"]),H=a(/\{\{[\s\S]*|[\s\S]*\}\}/gm),z=a(/<%[\s\S]*|[\s\S]*%>/gm),q=a(/^data-[\-\w.\u00B7-\uFFFF]/),V=a(/^aria-[\-\w]+$/),j=a(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),$=a(/^(?:\w+script|data):/i),_=a(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),U="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e};function W(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}var J=function(){return"undefined"==typeof window?null:window},G=function(e,t){if("object"!==(void 0===e?"undefined":U(e))||"function"!=typeof e.createPolicy)return null;var n=null,r="data-tt-policy-suffix";t.currentScript&&t.currentScript.hasAttribute(r)&&(n=t.currentScript.getAttribute(r));var o="dompurify"+(n?"#"+n:"");try{return e.createPolicy(o,{createHTML:function(e){return e}})}catch(e){return console.warn("TrustedTypes policy "+o+" could not be created."),null}};function K(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:J(),t=function(e){return K(e)};if(t.version="2.3.3",t.removed=[],!e||!e.document||9!==e.document.nodeType)return t.isSupported=!1,t;var n=e.document,r=e.document,o=e.DocumentFragment,i=e.HTMLTemplateElement,a=e.Node,l=e.Element,c=e.NodeFilter,u=e.NamedNodeMap,d=void 0===u?e.NamedNodeMap||e.MozNamedAttrMap:u,x=e.Text,C=e.Comment,Z=e.DOMParser,X=e.trustedTypes,Q=l.prototype,Y=S(Q,"cloneNode"),ee=S(Q,"nextSibling"),te=S(Q,"childNodes"),ne=S(Q,"parentNode");if("function"==typeof i){var re=r.createElement("template");re.content&&re.content.ownerDocument&&(r=re.content.ownerDocument)}var oe=G(X,n),ie=oe&&Fe?oe.createHTML(""):"",se=r,ae=se.implementation,le=se.createNodeIterator,ce=se.createDocumentFragment,ue=se.getElementsByTagName,de=n.importNode,pe={};try{pe=M(r).documentMode?r.documentMode:{}}catch(e){}var he={};t.isSupported="function"==typeof ne&&ae&&void 0!==ae.createHTMLDocument&&9!==pe;var fe=H,me=z,ge=q,ve=V,ye=$,be=_,we=j,ke=null,xe=T({},[].concat(W(E),W(N),W(O),W(A),W(I))),Ce=null,Te=T({},[].concat(W(R),W(P),W(B),W(F))),Me=null,Se=null,Ee=!0,Ne=!0,Oe=!1,De=!1,Ae=!1,Le=!1,Ie=!1,Re=!1,Pe=!1,Be=!0,Fe=!1,He=!0,ze=!0,qe=!1,Ve={},je=null,$e=T({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]),_e=null,Ue=T({},["audio","video","img","source","image","track"]),We=null,Je=T({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),Ge="http://www.w3.org/1998/Math/MathML",Ke="http://www.w3.org/2000/svg",Ze="http://www.w3.org/1999/xhtml",Xe=Ze,Qe=!1,Ye=void 0,et=["application/xhtml+xml","text/html"],tt="text/html",nt=void 0,rt=null,ot=r.createElement("form"),it=function(e){rt&&rt===e||(e&&"object"===(void 0===e?"undefined":U(e))||(e={}),e=M(e),ke="ALLOWED_TAGS"in e?T({},e.ALLOWED_TAGS):xe,Ce="ALLOWED_ATTR"in e?T({},e.ALLOWED_ATTR):Te,We="ADD_URI_SAFE_ATTR"in e?T(M(Je),e.ADD_URI_SAFE_ATTR):Je,_e="ADD_DATA_URI_TAGS"in e?T(M(Ue),e.ADD_DATA_URI_TAGS):Ue,je="FORBID_CONTENTS"in e?T({},e.FORBID_CONTENTS):$e,Me="FORBID_TAGS"in e?T({},e.FORBID_TAGS):{},Se="FORBID_ATTR"in e?T({},e.FORBID_ATTR):{},Ve="USE_PROFILES"in e&&e.USE_PROFILES,Ee=!1!==e.ALLOW_ARIA_ATTR,Ne=!1!==e.ALLOW_DATA_ATTR,Oe=e.ALLOW_UNKNOWN_PROTOCOLS||!1,De=e.SAFE_FOR_TEMPLATES||!1,Ae=e.WHOLE_DOCUMENT||!1,Re=e.RETURN_DOM||!1,Pe=e.RETURN_DOM_FRAGMENT||!1,Be=!1!==e.RETURN_DOM_IMPORT,Fe=e.RETURN_TRUSTED_TYPE||!1,Ie=e.FORCE_BODY||!1,He=!1!==e.SANITIZE_DOM,ze=!1!==e.KEEP_CONTENT,qe=e.IN_PLACE||!1,we=e.ALLOWED_URI_REGEXP||we,Xe=e.NAMESPACE||Ze,Ye=Ye=-1===et.indexOf(e.PARSER_MEDIA_TYPE)?tt:e.PARSER_MEDIA_TYPE,nt="application/xhtml+xml"===Ye?function(e){return e}:m,De&&(Ne=!1),Pe&&(Re=!0),Ve&&(ke=T({},[].concat(W(I))),Ce=[],!0===Ve.html&&(T(ke,E),T(Ce,R)),!0===Ve.svg&&(T(ke,N),T(Ce,P),T(Ce,F)),!0===Ve.svgFilters&&(T(ke,O),T(Ce,P),T(Ce,F)),!0===Ve.mathMl&&(T(ke,A),T(Ce,B),T(Ce,F))),e.ADD_TAGS&&(ke===xe&&(ke=M(ke)),T(ke,e.ADD_TAGS)),e.ADD_ATTR&&(Ce===Te&&(Ce=M(Ce)),T(Ce,e.ADD_ATTR)),e.ADD_URI_SAFE_ATTR&&T(We,e.ADD_URI_SAFE_ATTR),e.FORBID_CONTENTS&&(je===$e&&(je=M(je)),T(je,e.FORBID_CONTENTS)),ze&&(ke["#text"]=!0),Ae&&T(ke,["html","head","body"]),ke.table&&(T(ke,["tbody"]),delete Me.tbody),s&&s(e),rt=e)},st=T({},["mi","mo","mn","ms","mtext"]),at=T({},["foreignobject","desc","title","annotation-xml"]),lt=T({},N);T(lt,O),T(lt,D);var ct=T({},A);T(ct,L);var ut=function(e){var t=ne(e);t&&t.tagName||(t={namespaceURI:Ze,tagName:"template"});var n=m(e.tagName),r=m(t.tagName);if(e.namespaceURI===Ke)return t.namespaceURI===Ze?"svg"===n:t.namespaceURI===Ge?"svg"===n&&("annotation-xml"===r||st[r]):Boolean(lt[n]);if(e.namespaceURI===Ge)return t.namespaceURI===Ze?"math"===n:t.namespaceURI===Ke?"math"===n&&at[r]:Boolean(ct[n]);if(e.namespaceURI===Ze){if(t.namespaceURI===Ke&&!at[r])return!1;if(t.namespaceURI===Ge&&!st[r])return!1;var o=T({},["title","style","font","a","script"]);return!ct[n]&&(o[n]||!lt[n])}return!1},dt=function(e){f(t.removed,{element:e});try{e.parentNode.removeChild(e)}catch(t){try{e.outerHTML=ie}catch(t){e.remove()}}},pt=function(e,n){try{f(t.removed,{attribute:n.getAttributeNode(e),from:n})}catch(e){f(t.removed,{attribute:null,from:n})}if(n.removeAttribute(e),"is"===e&&!Ce[e])if(Re||Pe)try{dt(n)}catch(e){}else try{n.setAttribute(e,"")}catch(e){}},ht=function(e){var t=void 0,n=void 0;if(Ie)e="<remove></remove>"+e;else{var o=g(e,/^[\r\n\t ]+/);n=o&&o[0]}"application/xhtml+xml"===Ye&&(e='<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>'+e+"</body></html>");var i=oe?oe.createHTML(e):e;if(Xe===Ze)try{t=(new Z).parseFromString(i,Ye)}catch(e){}if(!t||!t.documentElement){t=ae.createDocument(Xe,"template",null);try{t.documentElement.innerHTML=Qe?"":i}catch(e){}}var s=t.body||t.documentElement;return e&&n&&s.insertBefore(r.createTextNode(n),s.childNodes[0]||null),Xe===Ze?ue.call(t,Ae?"html":"body")[0]:Ae?t.documentElement:s},ft=function(e){return le.call(e.ownerDocument||e,e,c.SHOW_ELEMENT|c.SHOW_COMMENT|c.SHOW_TEXT,null,!1)},mt=function(e){return!(e instanceof x||e instanceof C||"string"==typeof e.nodeName&&"string"==typeof e.textContent&&"function"==typeof e.removeChild&&e.attributes instanceof d&&"function"==typeof e.removeAttribute&&"function"==typeof e.setAttribute&&"string"==typeof e.namespaceURI&&"function"==typeof e.insertBefore)},gt=function(e){return"object"===(void 0===a?"undefined":U(a))?e instanceof a:e&&"object"===(void 0===e?"undefined":U(e))&&"number"==typeof e.nodeType&&"string"==typeof e.nodeName},vt=function(e,n,r){he[e]&&p(he[e],(function(e){e.call(t,n,r,rt)}))},yt=function(e){var n=void 0;if(vt("beforeSanitizeElements",e,null),mt(e))return dt(e),!0;if(g(e.nodeName,/[\u0080-\uFFFF]/))return dt(e),!0;var r=nt(e.nodeName);if(vt("uponSanitizeElement",e,{tagName:r,allowedTags:ke}),!gt(e.firstElementChild)&&(!gt(e.content)||!gt(e.content.firstElementChild))&&w(/<[/\w]/g,e.innerHTML)&&w(/<[/\w]/g,e.textContent))return dt(e),!0;if("select"===r&&w(/<template/i,e.innerHTML))return dt(e),!0;if(!ke[r]||Me[r]){if(ze&&!je[r]){var o=ne(e)||e.parentNode,i=te(e)||e.childNodes;if(i&&o)for(var s=i.length-1;s>=0;--s)o.insertBefore(Y(i[s],!0),ee(e))}return dt(e),!0}return e instanceof l&&!ut(e)?(dt(e),!0):"noscript"!==r&&"noembed"!==r||!w(/<\/no(script|embed)/i,e.innerHTML)?(De&&3===e.nodeType&&(n=e.textContent,n=v(n,fe," "),n=v(n,me," "),e.textContent!==n&&(f(t.removed,{element:e.cloneNode()}),e.textContent=n)),vt("afterSanitizeElements",e,null),!1):(dt(e),!0)},bt=function(e,t,n){if(He&&("id"===t||"name"===t)&&(n in r||n in ot))return!1;if(Ne&&!Se[t]&&w(ge,t));else if(Ee&&w(ve,t));else{if(!Ce[t]||Se[t])return!1;if(We[t]);else if(w(we,v(n,be,"")));else if("src"!==t&&"xlink:href"!==t&&"href"!==t||"script"===e||0!==y(n,"data:")||!_e[e])if(Oe&&!w(ye,v(n,be,"")));else if(n)return!1}return!0},wt=function(e){var n=void 0,r=void 0,o=void 0,i=void 0;vt("beforeSanitizeAttributes",e,null);var s=e.attributes;if(s){var a={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:Ce};for(i=s.length;i--;){var l=n=s[i],c=l.name,u=l.namespaceURI;if(r=b(n.value),o=nt(c),a.attrName=o,a.attrValue=r,a.keepAttr=!0,a.forceKeepAttr=void 0,vt("uponSanitizeAttribute",e,a),r=a.attrValue,!a.forceKeepAttr&&(pt(c,e),a.keepAttr))if(w(/\/>/i,r))pt(c,e);else{De&&(r=v(r,fe," "),r=v(r,me," "));var d=nt(e.nodeName);if(bt(d,o,r))try{u?e.setAttributeNS(u,c,r):e.setAttribute(c,r),h(t.removed)}catch(e){}}}vt("afterSanitizeAttributes",e,null)}},kt=function e(t){var n=void 0,r=ft(t);for(vt("beforeSanitizeShadowDOM",t,null);n=r.nextNode();)vt("uponSanitizeShadowNode",n,null),yt(n)||(n.content instanceof o&&e(n.content),wt(n));vt("afterSanitizeShadowDOM",t,null)};return t.sanitize=function(r,i){var s=void 0,l=void 0,c=void 0,u=void 0,d=void 0;if((Qe=!r)&&(r="\x3c!--\x3e"),"string"!=typeof r&&!gt(r)){if("function"!=typeof r.toString)throw k("toString is not a function");if("string"!=typeof(r=r.toString()))throw k("dirty is not a string, aborting")}if(!t.isSupported){if("object"===U(e.toStaticHTML)||"function"==typeof e.toStaticHTML){if("string"==typeof r)return e.toStaticHTML(r);if(gt(r))return e.toStaticHTML(r.outerHTML)}return r}if(Le||it(i),t.removed=[],"string"==typeof r&&(qe=!1),qe);else if(r instanceof a)1===(l=(s=ht("\x3c!----\x3e")).ownerDocument.importNode(r,!0)).nodeType&&"BODY"===l.nodeName||"HTML"===l.nodeName?s=l:s.appendChild(l);else{if(!Re&&!De&&!Ae&&-1===r.indexOf("<"))return oe&&Fe?oe.createHTML(r):r;if(!(s=ht(r)))return Re?null:ie}s&&Ie&&dt(s.firstChild);for(var p=ft(qe?r:s);c=p.nextNode();)3===c.nodeType&&c===u||yt(c)||(c.content instanceof o&&kt(c.content),wt(c),u=c);if(u=null,qe)return r;if(Re){if(Pe)for(d=ce.call(s.ownerDocument);s.firstChild;)d.appendChild(s.firstChild);else d=s;return Be&&(d=de.call(n,d,!0)),d}var h=Ae?s.outerHTML:s.innerHTML;return De&&(h=v(h,fe," "),h=v(h,me," ")),oe&&Fe?oe.createHTML(h):h},t.setConfig=function(e){it(e),Le=!0},t.clearConfig=function(){rt=null,Le=!1},t.isValidAttribute=function(e,t,n){rt||it({});var r=nt(e),o=nt(t);return bt(r,o,n)},t.addHook=function(e,t){"function"==typeof t&&(he[e]=he[e]||[],f(he[e],t))},t.removeHook=function(e){he[e]&&h(he[e])},t.removeHooks=function(e){he[e]&&(he[e]=[])},t.removeAllHooks=function(){he={}},t}return K()}()},928:function(e,t,n){"use strict";var r=n(322);e.exports=function(e,t,n){var o,i;if(n=n||0,!r(t))return-1;if(Array.prototype.indexOf)return Array.prototype.indexOf.call(t,e,n);for(i=t.length,o=n;n>=0&&o<i;o+=1)if(t[o]===e)return o;return-1}},690:function(e,t,n){"use strict";var r=n(322),o=n(893),i=n(956);e.exports=function(e,t,n){r(e)?o(e,t,n):i(e,t,n)}},893:function(e){"use strict";e.exports=function(e,t,n){var r=0,o=e.length;for(n=n||null;r<o&&!1!==t.call(n,e[r],r,e);r+=1);}},956:function(e){"use strict";e.exports=function(e,t,n){var r;for(r in n=n||null,e)if(e.hasOwnProperty(r)&&!1===t.call(n,e[r],r,e))break}},354:function(e,t,n){"use strict";var r=n(893);e.exports=function(e){var t;try{t=Array.prototype.slice.call(e)}catch(n){t=[],r(e,(function(e){t.push(e)}))}return t}},755:function(e){"use strict";var t="_feEventKey";e.exports=function(e,n){var r,o=e[t];return o||(o=e[t]={}),(r=o[n])||(r=o[n]=[]),r}},349:function(e,t,n){"use strict";var r=n(758),o=n(690),i=n(755);function s(e,t,n){var r,s=i(e,t);n?(o(s,(function(o,i){return n!==o.handler||(a(e,t,o.wrappedHandler),r=i,!1)})),s.splice(r,1)):(o(s,(function(n){a(e,t,n.wrappedHandler)})),s.splice(0,s.length))}function a(e,t,n){"removeEventListener"in e?e.removeEventListener(t,n):"detachEvent"in e&&e.detachEvent("on"+t,n)}e.exports=function(e,t,n){r(t)?o(t.split(/\s+/g),(function(t){s(e,t,n)})):o(t,(function(t,n){s(e,n,t)}))}},348:function(e,t,n){"use strict";var r=n(758),o=n(690),i=n(755);function s(e,t,n,r){function s(t){n.call(r||e,t||window.event)}"addEventListener"in e?e.addEventListener(t,s):"attachEvent"in e&&e.attachEvent("on"+t,s),function(e,t,n,r){var s=i(e,t),a=!1;o(s,(function(e){return e.handler!==n||(a=!0,!1)})),a||s.push({handler:n,wrappedHandler:r})}(e,t,n,s)}e.exports=function(e,t,n,i){r(t)?o(t.split(/\s+/g),(function(t){s(e,t,n,i)})):o(t,(function(t,r){s(e,r,t,n)}))}},24:function(e,t,n){"use strict";var r=n(322),o=n(929);e.exports=function(e,t){t=(t=r(t)?t.join(" "):t).replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,""),o(e.className.baseVal)?e.className=t:e.className.baseVal=t}},204:function(e,t,n){"use strict";var r=n(690),o=n(928),i=n(902),s=n(24);e.exports=function(e){var t,n=Array.prototype.slice.call(arguments,1),a=e.classList,l=[];a?r(n,(function(t){e.classList.add(t)})):((t=i(e))&&(n=[].concat(t.split(/\s+/),n)),r(n,(function(e){o(e,l)<0&&l.push(e)})),s(e,l))}},522:function(e,t,n){"use strict";var r=n(758),o=n(690);e.exports=function(e,t,n){var i=e.style;r(t)?i[t]=n:o(t,(function(e,t){i[t]=e}))}},902:function(e,t,n){"use strict";var r=n(929);e.exports=function(e){return e&&e.className?r(e.className.baseVal)?e.className:e.className.baseVal:""}},714:function(e,t,n){"use strict";var r=n(928),o=n(902);e.exports=function(e,t){var n;return e.classList?e.classList.contains(t):(n=o(e).split(/\s+/),r(t,n)>-1)}},471:function(e,t,n){"use strict";var r=n(928),o=n(354),i=Element.prototype,s=i.matches||i.webkitMatchesSelector||i.mozMatchesSelector||i.msMatchesSelector||function(e){var t=this.document||this.ownerDocument;return r(this,o(t.querySelectorAll(e)))>-1};e.exports=function(e,t){return s.call(e,t)}},462:function(e,t,n){"use strict";var r=n(893),o=n(928),i=n(902),s=n(24);e.exports=function(e){var t,n,a=Array.prototype.slice.call(arguments,1),l=e.classList;l?r(a,(function(e){l.remove(e)})):(t=i(e).split(/\s+/),n=[],r(t,(function(e){o(e,a)<0&&n.push(e)})),s(e,n))}},969:function(e){"use strict";e.exports=function(e,t){var n,r,o,i,s=Object.prototype.hasOwnProperty;for(o=1,i=arguments.length;o<i;o+=1)for(r in n=arguments[o])s.call(n,r)&&(e[r]=n[r]);return e}},254:function(e,t,n){"use strict";var r=n(956);e.exports=function(e,t){var n=document.createElement("img"),o="";return r(t,(function(e,t){o+="&"+t+"="+e})),o=o.substring(1),n.src=e+"?"+o,n.style.display="none",document.body.appendChild(n),document.body.removeChild(n),n}},391:function(e,t,n){"use strict";var r=n(929),o=n(254);e.exports=function(e,t){var n=location.hostname,i="TOAST UI "+e+" for "+n+": Statistics",s=window.localStorage.getItem(i);(r(window.tui)||!1!==window.tui.usageStatistics)&&(s&&!function(e){return(new Date).getTime()-e>6048e5}(s)||(window.localStorage.setItem(i,(new Date).getTime()),setTimeout((function(){"interactive"!==document.readyState&&"complete"!==document.readyState||o("https://www.google-analytics.com/collect",{v:1,t:"event",tid:t,cid:n,dp:n,dh:e,el:e,ec:"use"})}),1e3)))}},516:function(e){"use strict";e.exports=function(e,t){var n,r;return t=t||0,function(){r=Array.prototype.slice.call(arguments),window.clearTimeout(n),n=window.setTimeout((function(){e.apply(null,r)}),t)}}},423:function(e,t,n){"use strict";var r=n(516);e.exports=function(e,t){var n,o,i,s,a=!0,l=function(t){e.apply(null,t),n=null};function c(){if(s=Array.prototype.slice.call(arguments),a)return l(s),void(a=!1);i=Number(new Date),n=n||i,o(s),i-n>=t&&l(s)}return o=r(l,t=t||0),c.reset=function(){a=!0,n=null},c}},322:function(e){"use strict";e.exports=function(e){return e instanceof Array}},326:function(e){"use strict";e.exports=function(e){return"boolean"==typeof e||e instanceof Boolean}},65:function(e,t,n){"use strict";var r=n(929),o=n(934);e.exports=function(e){return!r(e)&&!o(e)}},404:function(e,t,n){"use strict";var r=n(790);e.exports=function(e){return!r(e)}},294:function(e){"use strict";e.exports=function(e){return e instanceof Function}},934:function(e){"use strict";e.exports=function(e){return null===e}},321:function(e){"use strict";e.exports=function(e){return"number"==typeof e||e instanceof Number}},73:function(e){"use strict";e.exports=function(e){return e===Object(e)}},758:function(e){"use strict";e.exports=function(e){return"string"==typeof e||e instanceof String}},790:function(e,t,n){"use strict";var r=n(65);e.exports=function(e){return r(e)&&!1!==e}},929:function(e){"use strict";e.exports=function(e){return void 0===e}}},t={};function n(r){var o=t[r];if(void 0!==o)return o.exports;var i=t[r]={exports:{}};return e[r].call(i.exports,i,i.exports,n),i.exports}n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,{a:t}),t},n.d=function(e,t){for(var r in t)n.o(t,r)&&!n.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},n.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)};var r={};return function(){"use strict";n.d(r,{default:function(){return vy}});
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var e=function(t,n){return e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n])},e(t,n)};function t(t,n){if("function"!=typeof n&&null!==n)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}var o=function(){return o=Object.assign||function(e){for(var t,n=1,r=arguments.length;n<r;n++)for(var o in t=arguments[n])Object.prototype.hasOwnProperty.call(t,o)&&(e[o]=t[o]);return e},o.apply(this,arguments)};Object.create;function i(e,t,n){if(n||2===arguments.length)for(var r,o=0,i=t.length;o<i;o++)!r&&o in t||(r||(r=Array.prototype.slice.call(t,0,o)),r[o]=t[o]);return e.concat(r||Array.prototype.slice.call(t))}function s(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e}Object.create;function a(e){this.content=e}a.prototype={constructor:a,find:function(e){for(var t=0;t<this.content.length;t+=2)if(this.content[t]===e)return t;return-1},get:function(e){var t=this.find(e);return-1==t?void 0:this.content[t+1]},update:function(e,t,n){var r=n&&n!=e?this.remove(n):this,o=r.find(e),i=r.content.slice();return-1==o?i.push(n||e,t):(i[o+1]=t,n&&(i[o]=n)),new a(i)},remove:function(e){var t=this.find(e);if(-1==t)return this;var n=this.content.slice();return n.splice(t,2),new a(n)},addToStart:function(e,t){return new a([e,t].concat(this.remove(e).content))},addToEnd:function(e,t){var n=this.remove(e).content.slice();return n.push(e,t),new a(n)},addBefore:function(e,t,n){var r=this.remove(t),o=r.content.slice(),i=r.find(e);return o.splice(-1==i?o.length:i,0,t,n),new a(o)},forEach:function(e){for(var t=0;t<this.content.length;t+=2)e(this.content[t],this.content[t+1])},prepend:function(e){return(e=a.from(e)).size?new a(e.content.concat(this.subtract(e).content)):this},append:function(e){return(e=a.from(e)).size?new a(this.subtract(e).content.concat(e.content)):this},subtract:function(e){var t=this;e=a.from(e);for(var n=0;n<e.content.length;n+=2)t=t.remove(e.content[n]);return t},get size(){return this.content.length>>1}},a.from=function(e){if(e instanceof a)return e;var t=[];if(e)for(var n in e)t.push(n,e[n]);return new a(t)};var l=a;function c(e,t,n){for(let r=0;;r++){if(r==e.childCount||r==t.childCount)return e.childCount==t.childCount?null:n;let o=e.child(r),i=t.child(r);if(o!=i){if(!o.sameMarkup(i))return n;if(o.isText&&o.text!=i.text){for(let e=0;o.text[e]==i.text[e];e++)n++;return n}if(o.content.size||i.content.size){let e=c(o.content,i.content,n+1);if(null!=e)return e}n+=o.nodeSize}else n+=o.nodeSize}}function u(e,t,n,r){for(let o=e.childCount,i=t.childCount;;){if(0==o||0==i)return o==i?null:{a:n,b:r};let s=e.child(--o),a=t.child(--i),l=s.nodeSize;if(s!=a){if(!s.sameMarkup(a))return{a:n,b:r};if(s.isText&&s.text!=a.text){let e=0,t=Math.min(s.text.length,a.text.length);for(;e<t&&s.text[s.text.length-e-1]==a.text[a.text.length-e-1];)e++,n--,r--;return{a:n,b:r}}if(s.content.size||a.content.size){let e=u(s.content,a.content,n-1,r-1);if(e)return e}n-=l,r-=l}else n-=l,r-=l}}class d{constructor(e,t){if(this.content=e,this.size=t||0,null==t)for(let t=0;t<e.length;t++)this.size+=e[t].nodeSize}nodesBetween(e,t,n,r=0,o){for(let i=0,s=0;s<t;i++){let a=this.content[i],l=s+a.nodeSize;if(l>e&&!1!==n(a,r+s,o||null,i)&&a.content.size){let o=s+1;a.nodesBetween(Math.max(0,e-o),Math.min(a.content.size,t-o),n,r+o)}s=l}}descendants(e){this.nodesBetween(0,this.size,e)}textBetween(e,t,n,r){let o="",i=!0;return this.nodesBetween(e,t,((s,a)=>{s.isText?(o+=s.text.slice(Math.max(e,a)-a,t-a),i=!n):s.isLeaf?(r?o+="function"==typeof r?r(s):r:s.type.spec.leafText&&(o+=s.type.spec.leafText(s)),i=!n):!i&&s.isBlock&&(o+=n,i=!0)}),0),o}append(e){if(!e.size)return this;if(!this.size)return e;let t=this.lastChild,n=e.firstChild,r=this.content.slice(),o=0;for(t.isText&&t.sameMarkup(n)&&(r[r.length-1]=t.withText(t.text+n.text),o=1);o<e.content.length;o++)r.push(e.content[o]);return new d(r,this.size+e.size)}cut(e,t=this.size){if(0==e&&t==this.size)return this;let n=[],r=0;if(t>e)for(let o=0,i=0;i<t;o++){let s=this.content[o],a=i+s.nodeSize;a>e&&((i<e||a>t)&&(s=s.isText?s.cut(Math.max(0,e-i),Math.min(s.text.length,t-i)):s.cut(Math.max(0,e-i-1),Math.min(s.content.size,t-i-1))),n.push(s),r+=s.nodeSize),i=a}return new d(n,r)}cutByIndex(e,t){return e==t?d.empty:0==e&&t==this.content.length?this:new d(this.content.slice(e,t))}replaceChild(e,t){let n=this.content[e];if(n==t)return this;let r=this.content.slice(),o=this.size+t.nodeSize-n.nodeSize;return r[e]=t,new d(r,o)}addToStart(e){return new d([e].concat(this.content),this.size+e.nodeSize)}addToEnd(e){return new d(this.content.concat(e),this.size+e.nodeSize)}eq(e){if(this.content.length!=e.content.length)return!1;for(let t=0;t<this.content.length;t++)if(!this.content[t].eq(e.content[t]))return!1;return!0}get firstChild(){return this.content.length?this.content[0]:null}get lastChild(){return this.content.length?this.content[this.content.length-1]:null}get childCount(){return this.content.length}child(e){let t=this.content[e];if(!t)throw new RangeError("Index "+e+" out of range for "+this);return t}maybeChild(e){return this.content[e]||null}forEach(e){for(let t=0,n=0;t<this.content.length;t++){let r=this.content[t];e(r,n,t),n+=r.nodeSize}}findDiffStart(e,t=0){return c(this,e,t)}findDiffEnd(e,t=this.size,n=e.size){return u(this,e,t,n)}findIndex(e,t=-1){if(0==e)return h(0,e);if(e==this.size)return h(this.content.length,e);if(e>this.size||e<0)throw new RangeError(`Position ${e} outside of fragment (${this})`);for(let n=0,r=0;;n++){let o=r+this.child(n).nodeSize;if(o>=e)return o==e||t>0?h(n+1,o):h(n,r);r=o}}toString(){return"<"+this.toStringInner()+">"}toStringInner(){return this.content.join(", ")}toJSON(){return this.content.length?this.content.map((e=>e.toJSON())):null}static fromJSON(e,t){if(!t)return d.empty;if(!Array.isArray(t))throw new RangeError("Invalid input for Fragment.fromJSON");return new d(t.map(e.nodeFromJSON))}static fromArray(e){if(!e.length)return d.empty;let t,n=0;for(let r=0;r<e.length;r++){let o=e[r];n+=o.nodeSize,r&&o.isText&&e[r-1].sameMarkup(o)?(t||(t=e.slice(0,r)),t[t.length-1]=o.withText(t[t.length-1].text+o.text)):t&&t.push(o)}return new d(t||e,n)}static from(e){if(!e)return d.empty;if(e instanceof d)return e;if(Array.isArray(e))return this.fromArray(e);if(e.attrs)return new d([e],e.nodeSize);throw new RangeError("Can not convert "+e+" to a Fragment"+(e.nodesBetween?" (looks like multiple versions of prosemirror-model were loaded)":""))}}d.empty=new d([],0);const p={index:0,offset:0};function h(e,t){return p.index=e,p.offset=t,p}function f(e,t){if(e===t)return!0;if(!e||"object"!=typeof e||!t||"object"!=typeof t)return!1;let n=Array.isArray(e);if(Array.isArray(t)!=n)return!1;if(n){if(e.length!=t.length)return!1;for(let n=0;n<e.length;n++)if(!f(e[n],t[n]))return!1}else{for(let n in e)if(!(n in t)||!f(e[n],t[n]))return!1;for(let n in t)if(!(n in e))return!1}return!0}class m{constructor(e,t){this.type=e,this.attrs=t}addToSet(e){let t,n=!1;for(let r=0;r<e.length;r++){let o=e[r];if(this.eq(o))return e;if(this.type.excludes(o.type))t||(t=e.slice(0,r));else{if(o.type.excludes(this.type))return e;!n&&o.type.rank>this.type.rank&&(t||(t=e.slice(0,r)),t.push(this),n=!0),t&&t.push(o)}}return t||(t=e.slice()),n||t.push(this),t}removeFromSet(e){for(let t=0;t<e.length;t++)if(this.eq(e[t]))return e.slice(0,t).concat(e.slice(t+1));return e}isInSet(e){for(let t=0;t<e.length;t++)if(this.eq(e[t]))return!0;return!1}eq(e){return this==e||this.type==e.type&&f(this.attrs,e.attrs)}toJSON(){let e={type:this.type.name};for(let t in this.attrs){e.attrs=this.attrs;break}return e}static fromJSON(e,t){if(!t)throw new RangeError("Invalid input for Mark.fromJSON");let n=e.marks[t.type];if(!n)throw new RangeError(`There is no mark type ${t.type} in this schema`);return n.create(t.attrs)}static sameSet(e,t){if(e==t)return!0;if(e.length!=t.length)return!1;for(let n=0;n<e.length;n++)if(!e[n].eq(t[n]))return!1;return!0}static setFrom(e){if(!e||Array.isArray(e)&&0==e.length)return m.none;if(e instanceof m)return[e];let t=e.slice();return t.sort(((e,t)=>e.type.rank-t.type.rank)),t}}m.none=[];class g extends Error{}class v{constructor(e,t,n){this.content=e,this.openStart=t,this.openEnd=n}get size(){return this.content.size-this.openStart-this.openEnd}insertAt(e,t){let n=b(this.content,e+this.openStart,t);return n&&new v(n,this.openStart,this.openEnd)}removeBetween(e,t){return new v(y(this.content,e+this.openStart,t+this.openStart),this.openStart,this.openEnd)}eq(e){return this.content.eq(e.content)&&this.openStart==e.openStart&&this.openEnd==e.openEnd}toString(){return this.content+"("+this.openStart+","+this.openEnd+")"}toJSON(){if(!this.content.size)return null;let e={content:this.content.toJSON()};return this.openStart>0&&(e.openStart=this.openStart),this.openEnd>0&&(e.openEnd=this.openEnd),e}static fromJSON(e,t){if(!t)return v.empty;let n=t.openStart||0,r=t.openEnd||0;if("number"!=typeof n||"number"!=typeof r)throw new RangeError("Invalid input for Slice.fromJSON");return new v(d.fromJSON(e,t.content),n,r)}static maxOpen(e,t=!0){let n=0,r=0;for(let r=e.firstChild;r&&!r.isLeaf&&(t||!r.type.spec.isolating);r=r.firstChild)n++;for(let n=e.lastChild;n&&!n.isLeaf&&(t||!n.type.spec.isolating);n=n.lastChild)r++;return new v(e,n,r)}}function y(e,t,n){let{index:r,offset:o}=e.findIndex(t),i=e.maybeChild(r),{index:s,offset:a}=e.findIndex(n);if(o==t||i.isText){if(a!=n&&!e.child(s).isText)throw new RangeError("Removing non-flat range");return e.cut(0,t).append(e.cut(n))}if(r!=s)throw new RangeError("Removing non-flat range");return e.replaceChild(r,i.copy(y(i.content,t-o-1,n-o-1)))}function b(e,t,n,r){let{index:o,offset:i}=e.findIndex(t),s=e.maybeChild(o);if(i==t||s.isText)return r&&!r.canReplace(o,o,n)?null:e.cut(0,t).append(n).append(e.cut(t));let a=b(s.content,t-i-1,n);return a&&e.replaceChild(o,s.copy(a))}function w(e,t,n){if(n.openStart>e.depth)throw new g("Inserted content deeper than insertion position");if(e.depth-n.openStart!=t.depth-n.openEnd)throw new g("Inconsistent open depths");return k(e,t,n,0)}function k(e,t,n,r){let o=e.index(r),i=e.node(r);if(o==t.index(r)&&r<e.depth-n.openStart){let s=k(e,t,n,r+1);return i.copy(i.content.replaceChild(o,s))}if(n.content.size){if(n.openStart||n.openEnd||e.depth!=r||t.depth!=r){let{start:o,end:s}=function(e,t){let n=t.depth-e.openStart,r=t.node(n).copy(e.content);for(let e=n-1;e>=0;e--)r=t.node(e).copy(d.from(r));return{start:r.resolveNoCache(e.openStart+n),end:r.resolveNoCache(r.content.size-e.openEnd-n)}}(n,e);return S(i,E(e,o,s,t,r))}{let r=e.parent,o=r.content;return S(r,o.cut(0,e.parentOffset).append(n.content).append(o.cut(t.parentOffset)))}}return S(i,N(e,t,r))}function x(e,t){if(!t.type.compatibleContent(e.type))throw new g("Cannot join "+t.type.name+" onto "+e.type.name)}function C(e,t,n){let r=e.node(n);return x(r,t.node(n)),r}function T(e,t){let n=t.length-1;n>=0&&e.isText&&e.sameMarkup(t[n])?t[n]=e.withText(t[n].text+e.text):t.push(e)}function M(e,t,n,r){let o=(t||e).node(n),i=0,s=t?t.index(n):o.childCount;e&&(i=e.index(n),e.depth>n?i++:e.textOffset&&(T(e.nodeAfter,r),i++));for(let e=i;e<s;e++)T(o.child(e),r);t&&t.depth==n&&t.textOffset&&T(t.nodeBefore,r)}function S(e,t){if(!e.type.validContent(t))throw new g("Invalid content for node "+e.type.name);return e.copy(t)}function E(e,t,n,r,o){let i=e.depth>o&&C(e,t,o+1),s=r.depth>o&&C(n,r,o+1),a=[];return M(null,e,o,a),i&&s&&t.index(o)==n.index(o)?(x(i,s),T(S(i,E(e,t,n,r,o+1)),a)):(i&&T(S(i,N(e,t,o+1)),a),M(t,n,o,a),s&&T(S(s,N(n,r,o+1)),a)),M(r,null,o,a),new d(a)}function N(e,t,n){let r=[];if(M(null,e,n,r),e.depth>n){T(S(C(e,t,n+1),N(e,t,n+1)),r)}return M(t,null,n,r),new d(r)}v.empty=new v(d.empty,0,0);class O{constructor(e,t,n){this.pos=e,this.path=t,this.parentOffset=n,this.depth=t.length/3-1}resolveDepth(e){return null==e?this.depth:e<0?this.depth+e:e}get parent(){return this.node(this.depth)}get doc(){return this.node(0)}node(e){return this.path[3*this.resolveDepth(e)]}index(e){return this.path[3*this.resolveDepth(e)+1]}indexAfter(e){return e=this.resolveDepth(e),this.index(e)+(e!=this.depth||this.textOffset?1:0)}start(e){return 0==(e=this.resolveDepth(e))?0:this.path[3*e-1]+1}end(e){return e=this.resolveDepth(e),this.start(e)+this.node(e).content.size}before(e){if(!(e=this.resolveDepth(e)))throw new RangeError("There is no position before the top-level node");return e==this.depth+1?this.pos:this.path[3*e-1]}after(e){if(!(e=this.resolveDepth(e)))throw new RangeError("There is no position after the top-level node");return e==this.depth+1?this.pos:this.path[3*e-1]+this.path[3*e].nodeSize}get textOffset(){return this.pos-this.path[this.path.length-1]}get nodeAfter(){let e=this.parent,t=this.index(this.depth);if(t==e.childCount)return null;let n=this.pos-this.path[this.path.length-1],r=e.child(t);return n?e.child(t).cut(n):r}get nodeBefore(){let e=this.index(this.depth),t=this.pos-this.path[this.path.length-1];return t?this.parent.child(e).cut(0,t):0==e?null:this.parent.child(e-1)}posAtIndex(e,t){t=this.resolveDepth(t);let n=this.path[3*t],r=0==t?0:this.path[3*t-1]+1;for(let t=0;t<e;t++)r+=n.child(t).nodeSize;return r}marks(){let e=this.parent,t=this.index();if(0==e.content.size)return m.none;if(this.textOffset)return e.child(t).marks;let n=e.maybeChild(t-1),r=e.maybeChild(t);if(!n){let e=n;n=r,r=e}let o=n.marks;for(var i=0;i<o.length;i++)!1!==o[i].type.spec.inclusive||r&&o[i].isInSet(r.marks)||(o=o[i--].removeFromSet(o));return o}marksAcross(e){let t=this.parent.maybeChild(this.index());if(!t||!t.isInline)return null;let n=t.marks,r=e.parent.maybeChild(e.index());for(var o=0;o<n.length;o++)!1!==n[o].type.spec.inclusive||r&&n[o].isInSet(r.marks)||(n=n[o--].removeFromSet(n));return n}sharedDepth(e){for(let t=this.depth;t>0;t--)if(this.start(t)<=e&&this.end(t)>=e)return t;return 0}blockRange(e=this,t){if(e.pos<this.pos)return e.blockRange(this);for(let n=this.depth-(this.parent.inlineContent||this.pos==e.pos?1:0);n>=0;n--)if(e.pos<=this.end(n)&&(!t||t(this.node(n))))return new I(this,e,n);return null}sameParent(e){return this.pos-this.parentOffset==e.pos-e.parentOffset}max(e){return e.pos>this.pos?e:this}min(e){return e.pos<this.pos?e:this}toString(){let e="";for(let t=1;t<=this.depth;t++)e+=(e?"/":"")+this.node(t).type.name+"_"+this.index(t-1);return e+":"+this.parentOffset}static resolve(e,t){if(!(t>=0&&t<=e.content.size))throw new RangeError("Position "+t+" out of range");let n=[],r=0,o=t;for(let t=e;;){let{index:e,offset:i}=t.content.findIndex(o),s=o-i;if(n.push(t,e,r+i),!s)break;if(t=t.child(e),t.isText)break;o=s-1,r+=i+1}return new O(t,n,o)}static resolveCached(e,t){for(let n=0;n<D.length;n++){let r=D[n];if(r.pos==t&&r.doc==e)return r}let n=D[A]=O.resolve(e,t);return A=(A+1)%L,n}}let D=[],A=0,L=12;class I{constructor(e,t,n){this.$from=e,this.$to=t,this.depth=n}get start(){return this.$from.before(this.depth+1)}get end(){return this.$to.after(this.depth+1)}get parent(){return this.$from.node(this.depth)}get startIndex(){return this.$from.index(this.depth)}get endIndex(){return this.$to.indexAfter(this.depth)}}const R=Object.create(null);class P{constructor(e,t,n,r=m.none){this.type=e,this.attrs=t,this.marks=r,this.content=n||d.empty}get nodeSize(){return this.isLeaf?1:2+this.content.size}get childCount(){return this.content.childCount}child(e){return this.content.child(e)}maybeChild(e){return this.content.maybeChild(e)}forEach(e){this.content.forEach(e)}nodesBetween(e,t,n,r=0){this.content.nodesBetween(e,t,n,r,this)}descendants(e){this.nodesBetween(0,this.content.size,e)}get textContent(){return this.isLeaf&&this.type.spec.leafText?this.type.spec.leafText(this):this.textBetween(0,this.content.size,"")}textBetween(e,t,n,r){return this.content.textBetween(e,t,n,r)}get firstChild(){return this.content.firstChild}get lastChild(){return this.content.lastChild}eq(e){return this==e||this.sameMarkup(e)&&this.content.eq(e.content)}sameMarkup(e){return this.hasMarkup(e.type,e.attrs,e.marks)}hasMarkup(e,t,n){return this.type==e&&f(this.attrs,t||e.defaultAttrs||R)&&m.sameSet(this.marks,n||m.none)}copy(e=null){return e==this.content?this:new P(this.type,this.attrs,e,this.marks)}mark(e){return e==this.marks?this:new P(this.type,this.attrs,this.content,e)}cut(e,t=this.content.size){return 0==e&&t==this.content.size?this:this.copy(this.content.cut(e,t))}slice(e,t=this.content.size,n=!1){if(e==t)return v.empty;let r=this.resolve(e),o=this.resolve(t),i=n?0:r.sharedDepth(t),s=r.start(i),a=r.node(i).content.cut(r.pos-s,o.pos-s);return new v(a,r.depth-i,o.depth-i)}replace(e,t,n){return w(this.resolve(e),this.resolve(t),n)}nodeAt(e){for(let t=this;;){let{index:n,offset:r}=t.content.findIndex(e);if(t=t.maybeChild(n),!t)return null;if(r==e||t.isText)return t;e-=r+1}}childAfter(e){let{index:t,offset:n}=this.content.findIndex(e);return{node:this.content.maybeChild(t),index:t,offset:n}}childBefore(e){if(0==e)return{node:null,index:0,offset:0};let{index:t,offset:n}=this.content.findIndex(e);if(n<e)return{node:this.content.child(t),index:t,offset:n};let r=this.content.child(t-1);return{node:r,index:t-1,offset:n-r.nodeSize}}resolve(e){return O.resolveCached(this,e)}resolveNoCache(e){return O.resolve(this,e)}rangeHasMark(e,t,n){let r=!1;return t>e&&this.nodesBetween(e,t,(e=>(n.isInSet(e.marks)&&(r=!0),!r))),r}get isBlock(){return this.type.isBlock}get isTextblock(){return this.type.isTextblock}get inlineContent(){return this.type.inlineContent}get isInline(){return this.type.isInline}get isText(){return this.type.isText}get isLeaf(){return this.type.isLeaf}get isAtom(){return this.type.isAtom}toString(){if(this.type.spec.toDebugString)return this.type.spec.toDebugString(this);let e=this.type.name;return this.content.size&&(e+="("+this.content.toStringInner()+")"),F(this.marks,e)}contentMatchAt(e){let t=this.type.contentMatch.matchFragment(this.content,0,e);if(!t)throw new Error("Called contentMatchAt on a node with invalid content");return t}canReplace(e,t,n=d.empty,r=0,o=n.childCount){let i=this.contentMatchAt(e).matchFragment(n,r,o),s=i&&i.matchFragment(this.content,t);if(!s||!s.validEnd)return!1;for(let e=r;e<o;e++)if(!this.type.allowsMarks(n.child(e).marks))return!1;return!0}canReplaceWith(e,t,n,r){if(r&&!this.type.allowsMarks(r))return!1;let o=this.contentMatchAt(e).matchType(n),i=o&&o.matchFragment(this.content,t);return!!i&&i.validEnd}canAppend(e){return e.content.size?this.canReplace(this.childCount,this.childCount,e.content):this.type.compatibleContent(e.type)}check(){if(!this.type.validContent(this.content))throw new RangeError(`Invalid content for node ${this.type.name}: ${this.content.toString().slice(0,50)}`);let e=m.none;for(let t=0;t<this.marks.length;t++)e=this.marks[t].addToSet(e);if(!m.sameSet(e,this.marks))throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((e=>e.type.name))}`);this.content.forEach((e=>e.check()))}toJSON(){let e={type:this.type.name};for(let t in this.attrs){e.attrs=this.attrs;break}return this.content.size&&(e.content=this.content.toJSON()),this.marks.length&&(e.marks=this.marks.map((e=>e.toJSON()))),e}static fromJSON(e,t){if(!t)throw new RangeError("Invalid input for Node.fromJSON");let n=null;if(t.marks){if(!Array.isArray(t.marks))throw new RangeError("Invalid mark data for Node.fromJSON");n=t.marks.map(e.markFromJSON)}if("text"==t.type){if("string"!=typeof t.text)throw new RangeError("Invalid text node in JSON");return e.text(t.text,n)}let r=d.fromJSON(e,t.content);return e.nodeType(t.type).create(t.attrs,r,n)}}P.prototype.text=void 0;class B extends P{constructor(e,t,n,r){if(super(e,t,null,r),!n)throw new RangeError("Empty text nodes are not allowed");this.text=n}toString(){return this.type.spec.toDebugString?this.type.spec.toDebugString(this):F(this.marks,JSON.stringify(this.text))}get textContent(){return this.text}textBetween(e,t){return this.text.slice(e,t)}get nodeSize(){return this.text.length}mark(e){return e==this.marks?this:new B(this.type,this.attrs,this.text,e)}withText(e){return e==this.text?this:new B(this.type,this.attrs,e,this.marks)}cut(e=0,t=this.text.length){return 0==e&&t==this.text.length?this:this.withText(this.text.slice(e,t))}eq(e){return this.sameMarkup(e)&&this.text==e.text}toJSON(){let e=super.toJSON();return e.text=this.text,e}}function F(e,t){for(let n=e.length-1;n>=0;n--)t=e[n].type.name+"("+t+")";return t}class H{constructor(e){this.validEnd=e,this.next=[],this.wrapCache=[]}static parse(e,t){let n=new z(e,t);if(null==n.next)return H.empty;let r=q(n);n.next&&n.err("Unexpected trailing text");let o=function(e){let t=Object.create(null);return n(W(e,0));function n(r){let o=[];r.forEach((t=>{e[t].forEach((({term:t,to:n})=>{if(!t)return;let r;for(let e=0;e<o.length;e++)o[e][0]==t&&(r=o[e][1]);W(e,n).forEach((e=>{r||o.push([t,r=[]]),-1==r.indexOf(e)&&r.push(e)}))}))}));let i=t[r.join(",")]=new H(r.indexOf(e.length-1)>-1);for(let e=0;e<o.length;e++){let r=o[e][1].sort(U);i.next.push({type:o[e][0],next:t[r.join(",")]||n(r)})}return i}}(function(e){let t=[[]];return o(i(e,0),n()),t;function n(){return t.push([])-1}function r(e,n,r){let o={term:r,to:n};return t[e].push(o),o}function o(e,t){e.forEach((e=>e.to=t))}function i(e,t){if("choice"==e.type)return e.exprs.reduce(((e,n)=>e.concat(i(n,t))),[]);if("seq"!=e.type){if("star"==e.type){let s=n();return r(t,s),o(i(e.expr,s),s),[r(s)]}if("plus"==e.type){let s=n();return o(i(e.expr,t),s),o(i(e.expr,s),s),[r(s)]}if("opt"==e.type)return[r(t)].concat(i(e.expr,t));if("range"==e.type){let s=t;for(let t=0;t<e.min;t++){let t=n();o(i(e.expr,s),t),s=t}if(-1==e.max)o(i(e.expr,s),s);else for(let t=e.min;t<e.max;t++){let t=n();r(s,t),o(i(e.expr,s),t),s=t}return[r(s)]}if("name"==e.type)return[r(t,void 0,e.value)];throw new Error("Unknown expr type")}for(let r=0;;r++){let s=i(e.exprs[r],t);if(r==e.exprs.length-1)return s;o(s,t=n())}}}(r));return function(e,t){for(let n=0,r=[e];n<r.length;n++){let e=r[n],o=!e.validEnd,i=[];for(let t=0;t<e.next.length;t++){let{type:n,next:s}=e.next[t];i.push(n.name),!o||n.isText||n.hasRequiredAttrs()||(o=!1),-1==r.indexOf(s)&&r.push(s)}o&&t.err("Only non-generatable nodes ("+i.join(", ")+") in a required position (see https://prosemirror.net/docs/guide/#generatable)")}}(o,n),o}matchType(e){for(let t=0;t<this.next.length;t++)if(this.next[t].type==e)return this.next[t].next;return null}matchFragment(e,t=0,n=e.childCount){let r=this;for(let o=t;r&&o<n;o++)r=r.matchType(e.child(o).type);return r}get inlineContent(){return this.next.length&&this.next[0].type.isInline}get defaultType(){for(let e=0;e<this.next.length;e++){let{type:t}=this.next[e];if(!t.isText&&!t.hasRequiredAttrs())return t}return null}compatible(e){for(let t=0;t<this.next.length;t++)for(let n=0;n<e.next.length;n++)if(this.next[t].type==e.next[n].type)return!0;return!1}fillBefore(e,t=!1,n=0){let r=[this];return function o(i,s){let a=i.matchFragment(e,n);if(a&&(!t||a.validEnd))return d.from(s.map((e=>e.createAndFill())));for(let e=0;e<i.next.length;e++){let{type:t,next:n}=i.next[e];if(!t.isText&&!t.hasRequiredAttrs()&&-1==r.indexOf(n)){r.push(n);let e=o(n,s.concat(t));if(e)return e}}return null}(this,[])}findWrapping(e){for(let t=0;t<this.wrapCache.length;t+=2)if(this.wrapCache[t]==e)return this.wrapCache[t+1];let t=this.computeWrapping(e);return this.wrapCache.push(e,t),t}computeWrapping(e){let t=Object.create(null),n=[{match:this,type:null,via:null}];for(;n.length;){let r=n.shift(),o=r.match;if(o.matchType(e)){let e=[];for(let t=r;t.type;t=t.via)e.push(t.type);return e.reverse()}for(let e=0;e<o.next.length;e++){let{type:i,next:s}=o.next[e];i.isLeaf||i.hasRequiredAttrs()||i.name in t||r.type&&!s.validEnd||(n.push({match:i.contentMatch,type:i,via:r}),t[i.name]=!0)}}return null}get edgeCount(){return this.next.length}edge(e){if(e>=this.next.length)throw new RangeError(`There's no ${e}th edge in this content match`);return this.next[e]}toString(){let e=[];return function t(n){e.push(n);for(let r=0;r<n.next.length;r++)-1==e.indexOf(n.next[r].next)&&t(n.next[r].next)}(this),e.map(((t,n)=>{let r=n+(t.validEnd?"*":" ")+" ";for(let n=0;n<t.next.length;n++)r+=(n?", ":"")+t.next[n].type.name+"->"+e.indexOf(t.next[n].next);return r})).join("\n")}}H.empty=new H(!0);class z{constructor(e,t){this.string=e,this.nodeTypes=t,this.inline=null,this.pos=0,this.tokens=e.split(/\s*(?=\b|\W|$)/),""==this.tokens[this.tokens.length-1]&&this.tokens.pop(),""==this.tokens[0]&&this.tokens.shift()}get next(){return this.tokens[this.pos]}eat(e){return this.next==e&&(this.pos++||!0)}err(e){throw new SyntaxError(e+" (in content expression '"+this.string+"')")}}function q(e){let t=[];do{t.push(V(e))}while(e.eat("|"));return 1==t.length?t[0]:{type:"choice",exprs:t}}function V(e){let t=[];do{t.push(j(e))}while(e.next&&")"!=e.next&&"|"!=e.next);return 1==t.length?t[0]:{type:"seq",exprs:t}}function j(e){let t=function(e){if(e.eat("(")){let t=q(e);return e.eat(")")||e.err("Missing closing paren"),t}if(!/\W/.test(e.next)){let t=function(e,t){let n=e.nodeTypes,r=n[t];if(r)return[r];let o=[];for(let e in n){let r=n[e];r.groups.indexOf(t)>-1&&o.push(r)}0==o.length&&e.err("No node type or group '"+t+"' found");return o}(e,e.next).map((t=>(null==e.inline?e.inline=t.isInline:e.inline!=t.isInline&&e.err("Mixing inline and block content"),{type:"name",value:t})));return e.pos++,1==t.length?t[0]:{type:"choice",exprs:t}}e.err("Unexpected token '"+e.next+"'")}(e);for(;;)if(e.eat("+"))t={type:"plus",expr:t};else if(e.eat("*"))t={type:"star",expr:t};else if(e.eat("?"))t={type:"opt",expr:t};else{if(!e.eat("{"))break;t=_(e,t)}return t}function $(e){/\D/.test(e.next)&&e.err("Expected number, got '"+e.next+"'");let t=Number(e.next);return e.pos++,t}function _(e,t){let n=$(e),r=n;return e.eat(",")&&(r="}"!=e.next?$(e):-1),e.eat("}")||e.err("Unclosed braced range"),{type:"range",min:n,max:r,expr:t}}function U(e,t){return t-e}function W(e,t){let n=[];return function t(r){let o=e[r];if(1==o.length&&!o[0].term)return t(o[0].to);n.push(r);for(let e=0;e<o.length;e++){let{term:r,to:i}=o[e];r||-1!=n.indexOf(i)||t(i)}}(t),n.sort(U)}function J(e){let t=Object.create(null);for(let n in e){let r=e[n];if(!r.hasDefault)return null;t[n]=r.default}return t}function G(e,t){let n=Object.create(null);for(let r in e){let o=t&&t[r];if(void 0===o){let t=e[r];if(!t.hasDefault)throw new RangeError("No value supplied for attribute "+r);o=t.default}n[r]=o}return n}function K(e){let t=Object.create(null);if(e)for(let n in e)t[n]=new X(e[n]);return t}class Z{constructor(e,t,n){this.name=e,this.schema=t,this.spec=n,this.markSet=null,this.groups=n.group?n.group.split(" "):[],this.attrs=K(n.attrs),this.defaultAttrs=J(this.attrs),this.contentMatch=null,this.inlineContent=null,this.isBlock=!(n.inline||"text"==e),this.isText="text"==e}get isInline(){return!this.isBlock}get isTextblock(){return this.isBlock&&this.inlineContent}get isLeaf(){return this.contentMatch==H.empty}get isAtom(){return this.isLeaf||!!this.spec.atom}get whitespace(){return this.spec.whitespace||(this.spec.code?"pre":"normal")}hasRequiredAttrs(){for(let e in this.attrs)if(this.attrs[e].isRequired)return!0;return!1}compatibleContent(e){return this==e||this.contentMatch.compatible(e.contentMatch)}computeAttrs(e){return!e&&this.defaultAttrs?this.defaultAttrs:G(this.attrs,e)}create(e=null,t,n){if(this.isText)throw new Error("NodeType.create can't construct text nodes");return new P(this,this.computeAttrs(e),d.from(t),m.setFrom(n))}createChecked(e=null,t,n){if(t=d.from(t),!this.validContent(t))throw new RangeError("Invalid content for node "+this.name);return new P(this,this.computeAttrs(e),t,m.setFrom(n))}createAndFill(e=null,t,n){if(e=this.computeAttrs(e),(t=d.from(t)).size){let e=this.contentMatch.fillBefore(t);if(!e)return null;t=e.append(t)}let r=this.contentMatch.matchFragment(t),o=r&&r.fillBefore(d.empty,!0);return o?new P(this,e,t.append(o),m.setFrom(n)):null}validContent(e){let t=this.contentMatch.matchFragment(e);if(!t||!t.validEnd)return!1;for(let t=0;t<e.childCount;t++)if(!this.allowsMarks(e.child(t).marks))return!1;return!0}allowsMarkType(e){return null==this.markSet||this.markSet.indexOf(e)>-1}allowsMarks(e){if(null==this.markSet)return!0;for(let t=0;t<e.length;t++)if(!this.allowsMarkType(e[t].type))return!1;return!0}allowedMarks(e){if(null==this.markSet)return e;let t;for(let n=0;n<e.length;n++)this.allowsMarkType(e[n].type)?t&&t.push(e[n]):t||(t=e.slice(0,n));return t?t.length?t:m.none:e}static compile(e,t){let n=Object.create(null);e.forEach(((e,r)=>n[e]=new Z(e,t,r)));let r=t.spec.topNode||"doc";if(!n[r])throw new RangeError("Schema is missing its top node type ('"+r+"')");if(!n.text)throw new RangeError("Every schema needs a 'text' type");for(let e in n.text.attrs)throw new RangeError("The text node type should not have attributes");return n}}class X{constructor(e){this.hasDefault=Object.prototype.hasOwnProperty.call(e,"default"),this.default=e.default}get isRequired(){return!this.hasDefault}}class Q{constructor(e,t,n,r){this.name=e,this.rank=t,this.schema=n,this.spec=r,this.attrs=K(r.attrs),this.excluded=null;let o=J(this.attrs);this.instance=o?new m(this,o):null}create(e=null){return!e&&this.instance?this.instance:new m(this,G(this.attrs,e))}static compile(e,t){let n=Object.create(null),r=0;return e.forEach(((e,o)=>n[e]=new Q(e,r++,t,o))),n}removeFromSet(e){for(var t=0;t<e.length;t++)e[t].type==this&&(e=e.slice(0,t).concat(e.slice(t+1)),t--);return e}isInSet(e){for(let t=0;t<e.length;t++)if(e[t].type==this)return e[t]}excludes(e){return this.excluded.indexOf(e)>-1}}class Y{constructor(e){this.cached=Object.create(null),this.spec={nodes:l.from(e.nodes),marks:l.from(e.marks||{}),topNode:e.topNode},this.nodes=Z.compile(this.spec.nodes,this),this.marks=Q.compile(this.spec.marks,this);let t=Object.create(null);for(let e in this.nodes){if(e in this.marks)throw new RangeError(e+" can not be both a node and a mark");let n=this.nodes[e],r=n.spec.content||"",o=n.spec.marks;n.contentMatch=t[r]||(t[r]=H.parse(r,this.nodes)),n.inlineContent=n.contentMatch.inlineContent,n.markSet="_"==o?null:o?ee(this,o.split(" ")):""!=o&&n.inlineContent?null:[]}for(let e in this.marks){let t=this.marks[e],n=t.spec.excludes;t.excluded=null==n?[t]:""==n?[]:ee(this,n.split(" "))}this.nodeFromJSON=this.nodeFromJSON.bind(this),this.markFromJSON=this.markFromJSON.bind(this),this.topNodeType=this.nodes[this.spec.topNode||"doc"],this.cached.wrappings=Object.create(null)}node(e,t=null,n,r){if("string"==typeof e)e=this.nodeType(e);else{if(!(e instanceof Z))throw new RangeError("Invalid node type: "+e);if(e.schema!=this)throw new RangeError("Node type from different schema used ("+e.name+")")}return e.createChecked(t,n,r)}text(e,t){let n=this.nodes.text;return new B(n,n.defaultAttrs,e,m.setFrom(t))}mark(e,t){return"string"==typeof e&&(e=this.marks[e]),e.create(t)}nodeFromJSON(e){return P.fromJSON(this,e)}markFromJSON(e){return m.fromJSON(this,e)}nodeType(e){let t=this.nodes[e];if(!t)throw new RangeError("Unknown node type: "+e);return t}}function ee(e,t){let n=[];for(let r=0;r<t.length;r++){let o=t[r],i=e.marks[o],s=i;if(i)n.push(i);else for(let t in e.marks){let r=e.marks[t];("_"==o||r.spec.group&&r.spec.group.split(" ").indexOf(o)>-1)&&n.push(s=r)}if(!s)throw new SyntaxError("Unknown mark type: '"+t[r]+"'")}return n}class te{constructor(e,t){this.schema=e,this.rules=t,this.tags=[],this.styles=[],t.forEach((e=>{e.tag?this.tags.push(e):e.style&&this.styles.push(e)})),this.normalizeLists=!this.tags.some((t=>{if(!/^(ul|ol)\b/.test(t.tag)||!t.node)return!1;let n=e.nodes[t.node];return n.contentMatch.matchType(n)}))}parse(e,t={}){let n=new ae(this,t,!1);return n.addAll(e,t.from,t.to),n.finish()}parseSlice(e,t={}){let n=new ae(this,t,!0);return n.addAll(e,t.from,t.to),v.maxOpen(n.finish())}matchTag(e,t,n){for(let r=n?this.tags.indexOf(n)+1:0;r<this.tags.length;r++){let n=this.tags[r];if(le(e,n.tag)&&(void 0===n.namespace||e.namespaceURI==n.namespace)&&(!n.context||t.matchesContext(n.context))){if(n.getAttrs){let t=n.getAttrs(e);if(!1===t)continue;n.attrs=t||void 0}return n}}}matchStyle(e,t,n,r){for(let o=r?this.styles.indexOf(r)+1:0;o<this.styles.length;o++){let r=this.styles[o],i=r.style;if(!(0!=i.indexOf(e)||r.context&&!n.matchesContext(r.context)||i.length>e.length&&(61!=i.charCodeAt(e.length)||i.slice(e.length+1)!=t))){if(r.getAttrs){let e=r.getAttrs(t);if(!1===e)continue;r.attrs=e||void 0}return r}}}static schemaRules(e){let t=[];function n(e){let n=null==e.priority?50:e.priority,r=0;for(;r<t.length;r++){let e=t[r];if((null==e.priority?50:e.priority)<n)break}t.splice(r,0,e)}for(let t in e.marks){let r=e.marks[t].spec.parseDOM;r&&r.forEach((e=>{n(e=ce(e)),e.mark=t}))}for(let t in e.nodes){let r=e.nodes[t].spec.parseDOM;r&&r.forEach((e=>{n(e=ce(e)),e.node=t}))}return t}static fromSchema(e){return e.cached.domParser||(e.cached.domParser=new te(e,te.schemaRules(e)))}}const ne={address:!0,article:!0,aside:!0,blockquote:!0,canvas:!0,dd:!0,div:!0,dl:!0,fieldset:!0,figcaption:!0,figure:!0,footer:!0,form:!0,h1:!0,h2:!0,h3:!0,h4:!0,h5:!0,h6:!0,header:!0,hgroup:!0,hr:!0,li:!0,noscript:!0,ol:!0,output:!0,p:!0,pre:!0,section:!0,table:!0,tfoot:!0,ul:!0},re={head:!0,noscript:!0,object:!0,script:!0,style:!0,title:!0},oe={ol:!0,ul:!0};function ie(e,t,n){return null!=t?(t?1:0)|("full"===t?2:0):e&&"pre"==e.whitespace?3:-5&n}class se{constructor(e,t,n,r,o,i,s){this.type=e,this.attrs=t,this.marks=n,this.pendingMarks=r,this.solid=o,this.options=s,this.content=[],this.activeMarks=m.none,this.stashMarks=[],this.match=i||(4&s?null:e.contentMatch)}findWrapping(e){if(!this.match){if(!this.type)return[];let t=this.type.contentMatch.fillBefore(d.from(e));if(!t){let t,n=this.type.contentMatch;return(t=n.findWrapping(e.type))?(this.match=n,t):null}this.match=this.type.contentMatch.matchFragment(t)}return this.match.findWrapping(e.type)}finish(e){if(!(1&this.options)){let e,t=this.content[this.content.length-1];if(t&&t.isText&&(e=/[ \t\r\n\u000c]+$/.exec(t.text))){let n=t;t.text.length==e[0].length?this.content.pop():this.content[this.content.length-1]=n.withText(n.text.slice(0,n.text.length-e[0].length))}}let t=d.from(this.content);return!e&&this.match&&(t=t.append(this.match.fillBefore(d.empty,!0))),this.type?this.type.create(this.attrs,t,this.marks):t}popFromStashMark(e){for(let t=this.stashMarks.length-1;t>=0;t--)if(e.eq(this.stashMarks[t]))return this.stashMarks.splice(t,1)[0]}applyPending(e){for(let t=0,n=this.pendingMarks;t<n.length;t++){let r=n[t];(this.type?this.type.allowsMarkType(r.type):ue(r.type,e))&&!r.isInSet(this.activeMarks)&&(this.activeMarks=r.addToSet(this.activeMarks),this.pendingMarks=r.removeFromSet(this.pendingMarks))}}inlineContext(e){return this.type?this.type.inlineContent:this.content.length?this.content[0].isInline:e.parentNode&&!ne.hasOwnProperty(e.parentNode.nodeName.toLowerCase())}}class ae{constructor(e,t,n){this.parser=e,this.options=t,this.isOpen=n,this.open=0;let r,o=t.topNode,i=ie(null,t.preserveWhitespace,0)|(n?4:0);r=o?new se(o.type,o.attrs,m.none,m.none,!0,t.topMatch||o.type.contentMatch,i):new se(n?null:e.schema.topNodeType,null,m.none,m.none,!0,null,i),this.nodes=[r],this.find=t.findPositions,this.needsBlock=!1}get top(){return this.nodes[this.open]}addDOM(e){if(3==e.nodeType)this.addTextNode(e);else if(1==e.nodeType){let t=e.getAttribute("style"),n=t?this.readStyles(function(e){let t,n=/\s*([\w-]+)\s*:\s*([^;]+)/g,r=[];for(;t=n.exec(e);)r.push(t[1],t[2].trim());return r}(t)):null,r=this.top;if(null!=n)for(let e=0;e<n.length;e++)this.addPendingMark(n[e]);if(this.addElement(e),null!=n)for(let e=0;e<n.length;e++)this.removePendingMark(n[e],r)}}addTextNode(e){let t=e.nodeValue,n=this.top;if(2&n.options||n.inlineContext(e)||/[^ \t\r\n\u000c]/.test(t)){if(1&n.options)t=2&n.options?t.replace(/\r\n?/g,"\n"):t.replace(/\r?\n|\r/g," ");else if(t=t.replace(/[ \t\r\n\u000c]+/g," "),/^[ \t\r\n\u000c]/.test(t)&&this.open==this.nodes.length-1){let r=n.content[n.content.length-1],o=e.previousSibling;(!r||o&&"BR"==o.nodeName||r.isText&&/[ \t\r\n\u000c]$/.test(r.text))&&(t=t.slice(1))}t&&this.insertNode(this.parser.schema.text(t)),this.findInText(e)}else this.findInside(e)}addElement(e,t){let n,r=e.nodeName.toLowerCase();oe.hasOwnProperty(r)&&this.parser.normalizeLists&&function(e){for(let t=e.firstChild,n=null;t;t=t.nextSibling){let e=1==t.nodeType?t.nodeName.toLowerCase():null;e&&oe.hasOwnProperty(e)&&n?(n.appendChild(t),t=n):"li"==e?n=t:e&&(n=null)}}(e);let o=this.options.ruleFromNode&&this.options.ruleFromNode(e)||(n=this.parser.matchTag(e,this,t));if(o?o.ignore:re.hasOwnProperty(r))this.findInside(e),this.ignoreFallback(e);else if(!o||o.skip||o.closeParent){o&&o.closeParent?this.open=Math.max(0,this.open-1):o&&o.skip.nodeType&&(e=o.skip);let t,n=this.top,i=this.needsBlock;if(ne.hasOwnProperty(r))t=!0,n.type||(this.needsBlock=!0);else if(!e.firstChild)return void this.leafFallback(e);this.addAll(e),t&&this.sync(n),this.needsBlock=i}else this.addElementByRule(e,o,!1===o.consuming?n:void 0)}leafFallback(e){"BR"==e.nodeName&&this.top.type&&this.top.type.inlineContent&&this.addTextNode(e.ownerDocument.createTextNode("\n"))}ignoreFallback(e){"BR"!=e.nodeName||this.top.type&&this.top.type.inlineContent||this.findPlace(this.parser.schema.text("-"))}readStyles(e){let t=m.none;e:for(let n=0;n<e.length;n+=2)for(let r;;){let o=this.parser.matchStyle(e[n],e[n+1],this,r);if(!o)continue e;if(o.ignore)return null;if(t=this.parser.schema.marks[o.mark].create(o.attrs).addToSet(t),!1!==o.consuming)break;r=o}return t}addElementByRule(e,t,n){let r,o,i;if(t.node)o=this.parser.schema.nodes[t.node],o.isLeaf?this.insertNode(o.create(t.attrs))||this.leafFallback(e):r=this.enter(o,t.attrs||null,t.preserveWhitespace);else{i=this.parser.schema.marks[t.mark].create(t.attrs),this.addPendingMark(i)}let s=this.top;if(o&&o.isLeaf)this.findInside(e);else if(n)this.addElement(e,n);else if(t.getContent)this.findInside(e),t.getContent(e,this.parser.schema).forEach((e=>this.insertNode(e)));else{let n=e;"string"==typeof t.contentElement?n=e.querySelector(t.contentElement):"function"==typeof t.contentElement?n=t.contentElement(e):t.contentElement&&(n=t.contentElement),this.findAround(e,n,!0),this.addAll(n)}r&&this.sync(s)&&this.open--,i&&this.removePendingMark(i,s)}addAll(e,t,n){let r=t||0;for(let o=t?e.childNodes[t]:e.firstChild,i=null==n?null:e.childNodes[n];o!=i;o=o.nextSibling,++r)this.findAtPoint(e,r),this.addDOM(o);this.findAtPoint(e,r)}findPlace(e){let t,n;for(let r=this.open;r>=0;r--){let o=this.nodes[r],i=o.findWrapping(e);if(i&&(!t||t.length>i.length)&&(t=i,n=o,!i.length))break;if(o.solid)break}if(!t)return!1;this.sync(n);for(let e=0;e<t.length;e++)this.enterInner(t[e],null,!1);return!0}insertNode(e){if(e.isInline&&this.needsBlock&&!this.top.type){let e=this.textblockFromContext();e&&this.enterInner(e)}if(this.findPlace(e)){this.closeExtra();let t=this.top;t.applyPending(e.type),t.match&&(t.match=t.match.matchType(e.type));let n=t.activeMarks;for(let r=0;r<e.marks.length;r++)t.type&&!t.type.allowsMarkType(e.marks[r].type)||(n=e.marks[r].addToSet(n));return t.content.push(e.mark(n)),!0}return!1}enter(e,t,n){let r=this.findPlace(e.create(t));return r&&this.enterInner(e,t,!0,n),r}enterInner(e,t=null,n=!1,r){this.closeExtra();let o=this.top;o.applyPending(e),o.match=o.match&&o.match.matchType(e);let i=ie(e,r,o.options);4&o.options&&0==o.content.length&&(i|=4),this.nodes.push(new se(e,t,o.activeMarks,o.pendingMarks,n,null,i)),this.open++}closeExtra(e=!1){let t=this.nodes.length-1;if(t>this.open){for(;t>this.open;t--)this.nodes[t-1].content.push(this.nodes[t].finish(e));this.nodes.length=this.open+1}}finish(){return this.open=0,this.closeExtra(this.isOpen),this.nodes[0].finish(this.isOpen||this.options.topOpen)}sync(e){for(let t=this.open;t>=0;t--)if(this.nodes[t]==e)return this.open=t,!0;return!1}get currentPos(){this.closeExtra();let e=0;for(let t=this.open;t>=0;t--){let n=this.nodes[t].content;for(let t=n.length-1;t>=0;t--)e+=n[t].nodeSize;t&&e++}return e}findAtPoint(e,t){if(this.find)for(let n=0;n<this.find.length;n++)this.find[n].node==e&&this.find[n].offset==t&&(this.find[n].pos=this.currentPos)}findInside(e){if(this.find)for(let t=0;t<this.find.length;t++)null==this.find[t].pos&&1==e.nodeType&&e.contains(this.find[t].node)&&(this.find[t].pos=this.currentPos)}findAround(e,t,n){if(e!=t&&this.find)for(let r=0;r<this.find.length;r++)if(null==this.find[r].pos&&1==e.nodeType&&e.contains(this.find[r].node)){t.compareDocumentPosition(this.find[r].node)&(n?2:4)&&(this.find[r].pos=this.currentPos)}}findInText(e){if(this.find)for(let t=0;t<this.find.length;t++)this.find[t].node==e&&(this.find[t].pos=this.currentPos-(e.nodeValue.length-this.find[t].offset))}matchesContext(e){if(e.indexOf("|")>-1)return e.split(/\s*\|\s*/).some(this.matchesContext,this);let t=e.split("/"),n=this.options.context,r=!(this.isOpen||n&&n.parent.type!=this.nodes[0].type),o=-(n?n.depth+1:0)+(r?0:1),i=(e,s)=>{for(;e>=0;e--){let a=t[e];if(""==a){if(e==t.length-1||0==e)continue;for(;s>=o;s--)if(i(e-1,s))return!0;return!1}{let e=s>0||0==s&&r?this.nodes[s].type:n&&s>=o?n.node(s-o).type:null;if(!e||e.name!=a&&-1==e.groups.indexOf(a))return!1;s--}}return!0};return i(t.length-1,this.open)}textblockFromContext(){let e=this.options.context;if(e)for(let t=e.depth;t>=0;t--){let n=e.node(t).contentMatchAt(e.indexAfter(t)).defaultType;if(n&&n.isTextblock&&n.defaultAttrs)return n}for(let e in this.parser.schema.nodes){let t=this.parser.schema.nodes[e];if(t.isTextblock&&t.defaultAttrs)return t}}addPendingMark(e){let t=function(e,t){for(let n=0;n<t.length;n++)if(e.eq(t[n]))return t[n]}(e,this.top.pendingMarks);t&&this.top.stashMarks.push(t),this.top.pendingMarks=e.addToSet(this.top.pendingMarks)}removePendingMark(e,t){for(let n=this.open;n>=0;n--){let r=this.nodes[n];if(r.pendingMarks.lastIndexOf(e)>-1)r.pendingMarks=e.removeFromSet(r.pendingMarks);else{r.activeMarks=e.removeFromSet(r.activeMarks);let t=r.popFromStashMark(e);t&&r.type&&r.type.allowsMarkType(t.type)&&(r.activeMarks=t.addToSet(r.activeMarks))}if(r==t)break}}}function le(e,t){return(e.matches||e.msMatchesSelector||e.webkitMatchesSelector||e.mozMatchesSelector).call(e,t)}function ce(e){let t={};for(let n in e)t[n]=e[n];return t}function ue(e,t){let n=t.schema.nodes;for(let r in n){let o=n[r];if(!o.allowsMarkType(e))continue;let i=[],s=e=>{i.push(e);for(let n=0;n<e.edgeCount;n++){let{type:r,next:o}=e.edge(n);if(r==t)return!0;if(i.indexOf(o)<0&&s(o))return!0}};if(s(o.contentMatch))return!0}}class de{constructor(e,t){this.nodes=e,this.marks=t}serializeFragment(e,t={},n){n||(n=he(t).createDocumentFragment());let r=n,o=[];return e.forEach((e=>{if(o.length||e.marks.length){let n=0,i=0;for(;n<o.length&&i<e.marks.length;){let t=e.marks[i];if(this.marks[t.type.name]){if(!t.eq(o[n][0])||!1===t.type.spec.spanning)break;n++,i++}else i++}for(;n<o.length;)r=o.pop()[1];for(;i<e.marks.length;){let n=e.marks[i++],s=this.serializeMark(n,e.isInline,t);s&&(o.push([n,r]),r.appendChild(s.dom),r=s.contentDOM||s.dom)}}r.appendChild(this.serializeNodeInner(e,t))})),n}serializeNodeInner(e,t){let{dom:n,contentDOM:r}=de.renderSpec(he(t),this.nodes[e.type.name](e));if(r){if(e.isLeaf)throw new RangeError("Content hole not allowed in a leaf node spec");this.serializeFragment(e.content,t,r)}return n}serializeNode(e,t={}){let n=this.serializeNodeInner(e,t);for(let r=e.marks.length-1;r>=0;r--){let o=this.serializeMark(e.marks[r],e.isInline,t);o&&((o.contentDOM||o.dom).appendChild(n),n=o.dom)}return n}serializeMark(e,t,n={}){let r=this.marks[e.type.name];return r&&de.renderSpec(he(n),r(e,t))}static renderSpec(e,t,n=null){if("string"==typeof t)return{dom:e.createTextNode(t)};if(null!=t.nodeType)return{dom:t};if(t.dom&&null!=t.dom.nodeType)return t;let r,o=t[0],i=o.indexOf(" ");i>0&&(n=o.slice(0,i),o=o.slice(i+1));let s=n?e.createElementNS(n,o):e.createElement(o),a=t[1],l=1;if(a&&"object"==typeof a&&null==a.nodeType&&!Array.isArray(a)){l=2;for(let e in a)if(null!=a[e]){let t=e.indexOf(" ");t>0?s.setAttributeNS(e.slice(0,t),e.slice(t+1),a[e]):s.setAttribute(e,a[e])}}for(let o=l;o<t.length;o++){let i=t[o];if(0===i){if(o<t.length-1||o>l)throw new RangeError("Content hole must be the only child of its parent node");return{dom:s,contentDOM:s}}{let{dom:t,contentDOM:o}=de.renderSpec(e,i,n);if(s.appendChild(t),o){if(r)throw new RangeError("Multiple content holes");r=o}}}return{dom:s,contentDOM:r}}static fromSchema(e){return e.cached.domSerializer||(e.cached.domSerializer=new de(this.nodesFromSchema(e),this.marksFromSchema(e)))}static nodesFromSchema(e){let t=pe(e.nodes);return t.text||(t.text=e=>e.text),t}static marksFromSchema(e){return pe(e.marks)}}function pe(e){let t={};for(let n in e){let r=e[n].spec.toDOM;r&&(t[n]=r)}return t}function he(e){return e.document||window.document}var fe=n(956),me=n.n(fe),ge=n(969),ve=n.n(ge),ye=n(522),be=n.n(ye),we=n(204),ke=n.n(we),xe=n(462),Ce=n.n(xe),Te=n(758),Me=n.n(Te),Se=n(321),Ee=n.n(Se),Ne=n(929),Oe=n.n(Ne),De=n(934),Ae=n.n(De),Le=n(391),Ie=n.n(Le),Re=(/Mac/.test(navigator.platform),/[\u0020]+/g),Pe=/[>(){}[\]+-.!#|]/g,Be=/<([a-zA-Z_][a-zA-Z0-9\-._]*)(\s|[^\\>])*\/?>|<(\/)([a-zA-Z_][a-zA-Z0-9\-._]*)\s*\/?>|<!--[^-]+-->|<([a-zA-Z_][a-zA-Z0-9\-.:/]*)>/g,Fe=/\\[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~\\]/g,He=/[*_~`]/g,ze=/!\[.*\]\(.*\)/g,qe=/[[\]]/g,Ve=/(?:^|[^\\])\\(?!\\)/g,je=new RegExp('[&<>"]',"g");function $e(e){switch(e){case"&":return"&amp;";case"<":return"&lt;";case">":return"&gt;";case'"':return"&quot;";default:return e}}function _e(e){return je.test(e)?e.replace(je,$e):e}function Ue(e,t){return-1!==e.indexOf(t)}var We=["rel","target","hreflang","type"],Je={codeblock:/(^ {4}[^\n]+\n*)+/,thematicBreak:/^ *((\* *){3,}|(- *){3,} *|(_ *){3,}) */,atxHeading:/^(#{1,6}) +[\s\S]+/,seTextheading:/^([^\n]+)\n *(=|-){2,} */,blockquote:/^( *>[^\n]+.*)+/,list:/^ *(\*+|-+|\d+\.) [\s\S]+/,def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? */,link:/!?\[.*\]\(.*\)/,reflink:/!?\[.*\]\s*\[([^\]]*)\]/,verticalBar:/\u007C/,fencedCodeblock:/^((`|~){3,})/};function Ge(e){if(!e)return null;var t={};return We.forEach((function(n){Oe()(e[n])||(t[n]=e[n])})),t}function Ke(e,t){for(var n="",r=0;r<t;r+=1)n+=e;return n}function Ze(e){for(var t=[],n=ze.exec(e);n;)t.push([n.index,n.index+n[0].length]),n=ze.exec(e);return e.replace(qe,(function(e,n){var r=t.some((function(e){return n>e[0]&&n<e[1]}));return r?e:"\\"+e}))}function Xe(e){var t=function(e){return"\\"+e},n=e.replace(Re," ");return Fe.test(n)&&(n=n.replace(Fe,t)),Ve.test(n)&&(n=n.replace(Ve,(function(e){return e+"\\"}))),n=n.replace(He,t),Be.test(n)&&(n=n.replace(Be,t)),function(e){var t=!1;return me()(Je,(function(n){return n.test(e)&&(t=!0),!t})),t}(n)&&(n=n.replace(Pe,t)),n}function Qe(e){return Ae()(e)||Oe()(e)}function Ye(e,t){if(null===e&&e===t)return!0;if("object"!=typeof e||"object"!=typeof t||Qe(e)||Qe(t))return e===t;for(var n in e)if(e[n]!==t[n])return!1;for(var n in t)if(!(n in e))return!1;return!0}function et(e){return e[e.length-1]}function tt(e){return"object"==typeof e&&null!==e}function nt(e,t){var n=o({},e);return e&&t&&Object.keys(t).forEach((function(e){tt(n[e])?Array.isArray(t[e])?n[e]=rt(t[e]):n.hasOwnProperty(e)?n[e]=nt(n[e],t[e]):n[e]=ot(t[e]):n[e]=t[e]})),n}function rt(e){return e.map((function(e){return tt(e)?Array.isArray(e)?rt(e):ot(e):e}))}function ot(e){var t=Object.keys(e);return t.length?t.reduce((function(t,n){return tt(e[n])?t[n]=Array.isArray(e[n])?rt(e[n]):ot(e[n]):t[n]=e[n],t}),{}):e}function it(e,t){return void 0===t&&(t={}),Object.keys(t).forEach((function(n){e.hasOwnProperty(n)&&"object"==typeof e[n]?Array.isArray(t[n])?e[n]=t[n]:it(e[n],t[n]):e[n]=t[n]})),e}function st(e,t){return e>t?[t,e]:[e,t]}const at=Math.pow(2,16);function lt(e,t){return e+t*at}function ct(e){return 65535&e}class ut{constructor(e,t,n){this.pos=e,this.delInfo=t,this.recover=n}get deleted(){return(8&this.delInfo)>0}get deletedBefore(){return(5&this.delInfo)>0}get deletedAfter(){return(6&this.delInfo)>0}get deletedAcross(){return(4&this.delInfo)>0}}class dt{constructor(e,t=!1){if(this.ranges=e,this.inverted=t,!e.length&&dt.empty)return dt.empty}recover(e){let t=0,n=ct(e);if(!this.inverted)for(let e=0;e<n;e++)t+=this.ranges[3*e+2]-this.ranges[3*e+1];return this.ranges[3*n]+t+function(e){return(e-(65535&e))/at}(e)}mapResult(e,t=1){return this._map(e,t,!1)}map(e,t=1){return this._map(e,t,!0)}_map(e,t,n){let r=0,o=this.inverted?2:1,i=this.inverted?1:2;for(let s=0;s<this.ranges.length;s+=3){let a=this.ranges[s]-(this.inverted?r:0);if(a>e)break;let l=this.ranges[s+o],c=this.ranges[s+i],u=a+l;if(e<=u){let o=a+r+((l?e==a?-1:e==u?1:t:t)<0?0:c);if(n)return o;let i=e==(t<0?a:u)?null:lt(s/3,e-a),d=e==a?2:e==u?1:4;return(t<0?e!=a:e!=u)&&(d|=8),new ut(o,d,i)}r+=c-l}return n?e+r:new ut(e+r,0,null)}touches(e,t){let n=0,r=ct(t),o=this.inverted?2:1,i=this.inverted?1:2;for(let t=0;t<this.ranges.length;t+=3){let s=this.ranges[t]-(this.inverted?n:0);if(s>e)break;let a=this.ranges[t+o];if(e<=s+a&&t==3*r)return!0;n+=this.ranges[t+i]-a}return!1}forEach(e){let t=this.inverted?2:1,n=this.inverted?1:2;for(let r=0,o=0;r<this.ranges.length;r+=3){let i=this.ranges[r],s=i-(this.inverted?o:0),a=i+(this.inverted?0:o),l=this.ranges[r+t],c=this.ranges[r+n];e(s,s+l,a,a+c),o+=c-l}}invert(){return new dt(this.ranges,!this.inverted)}toString(){return(this.inverted?"-":"")+JSON.stringify(this.ranges)}static offset(e){return 0==e?dt.empty:new dt(e<0?[0,-e,0]:[0,0,e])}}dt.empty=new dt([]);class pt{constructor(e=[],t,n=0,r=e.length){this.maps=e,this.mirror=t,this.from=n,this.to=r}slice(e=0,t=this.maps.length){return new pt(this.maps,this.mirror,e,t)}copy(){return new pt(this.maps.slice(),this.mirror&&this.mirror.slice(),this.from,this.to)}appendMap(e,t){this.to=this.maps.push(e),null!=t&&this.setMirror(this.maps.length-1,t)}appendMapping(e){for(let t=0,n=this.maps.length;t<e.maps.length;t++){let r=e.getMirror(t);this.appendMap(e.maps[t],null!=r&&r<t?n+r:void 0)}}getMirror(e){if(this.mirror)for(let t=0;t<this.mirror.length;t++)if(this.mirror[t]==e)return this.mirror[t+(t%2?-1:1)]}setMirror(e,t){this.mirror||(this.mirror=[]),this.mirror.push(e,t)}appendMappingInverted(e){for(let t=e.maps.length-1,n=this.maps.length+e.maps.length;t>=0;t--){let r=e.getMirror(t);this.appendMap(e.maps[t].invert(),null!=r&&r>t?n-r-1:void 0)}}invert(){let e=new pt;return e.appendMappingInverted(this),e}map(e,t=1){if(this.mirror)return this._map(e,t,!0);for(let n=this.from;n<this.to;n++)e=this.maps[n].map(e,t);return e}mapResult(e,t=1){return this._map(e,t,!1)}_map(e,t,n){let r=0;for(let n=this.from;n<this.to;n++){let o=this.maps[n].mapResult(e,t);if(null!=o.recover){let t=this.getMirror(n);if(null!=t&&t>n&&t<this.to){n=t,e=this.maps[t].recover(o.recover);continue}}r|=o.delInfo,e=o.pos}return n?e:new ut(e,r,null)}}const ht=Object.create(null);class ft{getMap(){return dt.empty}merge(e){return null}static fromJSON(e,t){if(!t||!t.stepType)throw new RangeError("Invalid input for Step.fromJSON");let n=ht[t.stepType];if(!n)throw new RangeError(`No step type ${t.stepType} defined`);return n.fromJSON(e,t)}static jsonID(e,t){if(e in ht)throw new RangeError("Duplicate use of step JSON ID "+e);return ht[e]=t,t.prototype.jsonID=e,t}}class mt{constructor(e,t){this.doc=e,this.failed=t}static ok(e){return new mt(e,null)}static fail(e){return new mt(null,e)}static fromReplace(e,t,n,r){try{return mt.ok(e.replace(t,n,r))}catch(e){if(e instanceof g)return mt.fail(e.message);throw e}}}function gt(e,t,n){let r=[];for(let o=0;o<e.childCount;o++){let i=e.child(o);i.content.size&&(i=i.copy(gt(i.content,t,i))),i.isInline&&(i=t(i,n,o)),r.push(i)}return d.fromArray(r)}class vt extends ft{constructor(e,t,n){super(),this.from=e,this.to=t,this.mark=n}apply(e){let t=e.slice(this.from,this.to),n=e.resolve(this.from),r=n.node(n.sharedDepth(this.to)),o=new v(gt(t.content,((e,t)=>e.isAtom&&t.type.allowsMarkType(this.mark.type)?e.mark(this.mark.addToSet(e.marks)):e),r),t.openStart,t.openEnd);return mt.fromReplace(e,this.from,this.to,o)}invert(){return new yt(this.from,this.to,this.mark)}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1);return t.deleted&&n.deleted||t.pos>=n.pos?null:new vt(t.pos,n.pos,this.mark)}merge(e){return e instanceof vt&&e.mark.eq(this.mark)&&this.from<=e.to&&this.to>=e.from?new vt(Math.min(this.from,e.from),Math.max(this.to,e.to),this.mark):null}toJSON(){return{stepType:"addMark",mark:this.mark.toJSON(),from:this.from,to:this.to}}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to)throw new RangeError("Invalid input for AddMarkStep.fromJSON");return new vt(t.from,t.to,e.markFromJSON(t.mark))}}ft.jsonID("addMark",vt);class yt extends ft{constructor(e,t,n){super(),this.from=e,this.to=t,this.mark=n}apply(e){let t=e.slice(this.from,this.to),n=new v(gt(t.content,(e=>e.mark(this.mark.removeFromSet(e.marks))),e),t.openStart,t.openEnd);return mt.fromReplace(e,this.from,this.to,n)}invert(){return new vt(this.from,this.to,this.mark)}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1);return t.deleted&&n.deleted||t.pos>=n.pos?null:new yt(t.pos,n.pos,this.mark)}merge(e){return e instanceof yt&&e.mark.eq(this.mark)&&this.from<=e.to&&this.to>=e.from?new yt(Math.min(this.from,e.from),Math.max(this.to,e.to),this.mark):null}toJSON(){return{stepType:"removeMark",mark:this.mark.toJSON(),from:this.from,to:this.to}}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to)throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");return new yt(t.from,t.to,e.markFromJSON(t.mark))}}ft.jsonID("removeMark",yt);class bt extends ft{constructor(e,t,n,r=!1){super(),this.from=e,this.to=t,this.slice=n,this.structure=r}apply(e){return this.structure&&kt(e,this.from,this.to)?mt.fail("Structure replace would overwrite content"):mt.fromReplace(e,this.from,this.to,this.slice)}getMap(){return new dt([this.from,this.to-this.from,this.slice.size])}invert(e){return new bt(this.from,this.from+this.slice.size,e.slice(this.from,this.to))}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1);return t.deletedAcross&&n.deletedAcross?null:new bt(t.pos,Math.max(t.pos,n.pos),this.slice)}merge(e){if(!(e instanceof bt)||e.structure||this.structure)return null;if(this.from+this.slice.size!=e.from||this.slice.openEnd||e.slice.openStart){if(e.to!=this.from||this.slice.openStart||e.slice.openEnd)return null;{let t=this.slice.size+e.slice.size==0?v.empty:new v(e.slice.content.append(this.slice.content),e.slice.openStart,this.slice.openEnd);return new bt(e.from,this.to,t,this.structure)}}{let t=this.slice.size+e.slice.size==0?v.empty:new v(this.slice.content.append(e.slice.content),this.slice.openStart,e.slice.openEnd);return new bt(this.from,this.to+(e.to-e.from),t,this.structure)}}toJSON(){let e={stepType:"replace",from:this.from,to:this.to};return this.slice.size&&(e.slice=this.slice.toJSON()),this.structure&&(e.structure=!0),e}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to)throw new RangeError("Invalid input for ReplaceStep.fromJSON");return new bt(t.from,t.to,v.fromJSON(e,t.slice),!!t.structure)}}ft.jsonID("replace",bt);class wt extends ft{constructor(e,t,n,r,o,i,s=!1){super(),this.from=e,this.to=t,this.gapFrom=n,this.gapTo=r,this.slice=o,this.insert=i,this.structure=s}apply(e){if(this.structure&&(kt(e,this.from,this.gapFrom)||kt(e,this.gapTo,this.to)))return mt.fail("Structure gap-replace would overwrite content");let t=e.slice(this.gapFrom,this.gapTo);if(t.openStart||t.openEnd)return mt.fail("Gap is not a flat range");let n=this.slice.insertAt(this.insert,t.content);return n?mt.fromReplace(e,this.from,this.to,n):mt.fail("Content does not fit in gap")}getMap(){return new dt([this.from,this.gapFrom-this.from,this.insert,this.gapTo,this.to-this.gapTo,this.slice.size-this.insert])}invert(e){let t=this.gapTo-this.gapFrom;return new wt(this.from,this.from+this.slice.size+t,this.from+this.insert,this.from+this.insert+t,e.slice(this.from,this.to).removeBetween(this.gapFrom-this.from,this.gapTo-this.from),this.gapFrom-this.from,this.structure)}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1),r=e.map(this.gapFrom,-1),o=e.map(this.gapTo,1);return t.deletedAcross&&n.deletedAcross||r<t.pos||o>n.pos?null:new wt(t.pos,n.pos,r,o,this.slice,this.insert,this.structure)}toJSON(){let e={stepType:"replaceAround",from:this.from,to:this.to,gapFrom:this.gapFrom,gapTo:this.gapTo,insert:this.insert};return this.slice.size&&(e.slice=this.slice.toJSON()),this.structure&&(e.structure=!0),e}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to||"number"!=typeof t.gapFrom||"number"!=typeof t.gapTo||"number"!=typeof t.insert)throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");return new wt(t.from,t.to,t.gapFrom,t.gapTo,v.fromJSON(e,t.slice),t.insert,!!t.structure)}}function kt(e,t,n){let r=e.resolve(t),o=n-t,i=r.depth;for(;o>0&&i>0&&r.indexAfter(i)==r.node(i).childCount;)i--,o--;if(o>0){let e=r.node(i).maybeChild(r.indexAfter(i));for(;o>0;){if(!e||e.isLeaf)return!0;e=e.firstChild,o--}}return!1}function xt(e,t,n){return(0==t||e.canReplace(t,e.childCount))&&(n==e.childCount||e.canReplace(0,n))}function Ct(e){let t=e.parent.content.cutByIndex(e.startIndex,e.endIndex);for(let n=e.depth;;--n){let r=e.$from.node(n),o=e.$from.index(n),i=e.$to.indexAfter(n);if(n<e.depth&&r.canReplace(o,i,t))return n;if(0==n||r.type.spec.isolating||!xt(r,o,i))break}return null}function Tt(e){return{type:e,attrs:null}}function Mt(e,t,n=1,r){let o=e.resolve(t),i=o.depth-n,s=r&&r[r.length-1]||o.parent;if(i<0||o.parent.type.spec.isolating||!o.parent.canReplace(o.index(),o.parent.childCount)||!s.type.validContent(o.parent.content.cutByIndex(o.index(),o.parent.childCount)))return!1;for(let e=o.depth-1,t=n-2;e>i;e--,t--){let n=o.node(e),i=o.index(e);if(n.type.spec.isolating)return!1;let s=n.content.cutByIndex(i,n.childCount),a=r&&r[t]||n;if(a!=n&&(s=s.replaceChild(0,a.type.create(a.attrs))),!n.canReplace(i+1,n.childCount)||!a.type.validContent(s))return!1}let a=o.indexAfter(i),l=r&&r[0];return o.node(i).canReplaceWith(a,a,l?l.type:o.node(i+1).type)}function St(e,t){let n=e.resolve(t),r=n.index();return Et(n.nodeBefore,n.nodeAfter)&&n.parent.canReplace(r,r+1)}function Et(e,t){return!(!e||!t||e.isLeaf||!e.canAppend(t))}function Nt(e,t,n=t,r=v.empty){if(t==n&&!r.size)return null;let o=e.resolve(t),i=e.resolve(n);return Ot(o,i,r)?new bt(t,n,r):new Dt(o,i,r).fit()}function Ot(e,t,n){return!n.openStart&&!n.openEnd&&e.start()==t.start()&&e.parent.canReplace(e.index(),t.index(),n.content)}ft.jsonID("replaceAround",wt);class Dt{constructor(e,t,n){this.$from=e,this.$to=t,this.unplaced=n,this.frontier=[],this.placed=d.empty;for(let t=0;t<=e.depth;t++){let n=e.node(t);this.frontier.push({type:n.type,match:n.contentMatchAt(e.indexAfter(t))})}for(let t=e.depth;t>0;t--)this.placed=d.from(e.node(t).copy(this.placed))}get depth(){return this.frontier.length-1}fit(){for(;this.unplaced.size;){let e=this.findFittable();e?this.placeNodes(e):this.openMore()||this.dropNode()}let e=this.mustMoveInline(),t=this.placed.size-this.depth-this.$from.depth,n=this.$from,r=this.close(e<0?this.$to:n.doc.resolve(e));if(!r)return null;let o=this.placed,i=n.depth,s=r.depth;for(;i&&s&&1==o.childCount;)o=o.firstChild.content,i--,s--;let a=new v(o,i,s);return e>-1?new wt(n.pos,e,this.$to.pos,this.$to.end(),a,t):a.size||n.pos!=this.$to.pos?new bt(n.pos,r.pos,a):null}findFittable(){for(let e=1;e<=2;e++)for(let t=this.unplaced.openStart;t>=0;t--){let n,r=null;t?(r=It(this.unplaced.content,t-1).firstChild,n=r.content):n=this.unplaced.content;let o=n.firstChild;for(let n=this.depth;n>=0;n--){let i,{type:s,match:a}=this.frontier[n],l=null;if(1==e&&(o?a.matchType(o.type)||(l=a.fillBefore(d.from(o),!1)):r&&s.compatibleContent(r.type)))return{sliceDepth:t,frontierDepth:n,parent:r,inject:l};if(2==e&&o&&(i=a.findWrapping(o.type)))return{sliceDepth:t,frontierDepth:n,parent:r,wrap:i};if(r&&a.matchType(r.type))break}}}openMore(){let{content:e,openStart:t,openEnd:n}=this.unplaced,r=It(e,t);return!(!r.childCount||r.firstChild.isLeaf)&&(this.unplaced=new v(e,t+1,Math.max(n,r.size+t>=e.size-n?t+1:0)),!0)}dropNode(){let{content:e,openStart:t,openEnd:n}=this.unplaced,r=It(e,t);if(r.childCount<=1&&t>0){let o=e.size-t<=t+r.size;this.unplaced=new v(At(e,t-1,1),t-1,o?t-1:n)}else this.unplaced=new v(At(e,t,1),t,n)}placeNodes({sliceDepth:e,frontierDepth:t,parent:n,inject:r,wrap:o}){for(;this.depth>t;)this.closeFrontierNode();if(o)for(let e=0;e<o.length;e++)this.openFrontierNode(o[e]);let i=this.unplaced,s=n?n.content:i.content,a=i.openStart-e,l=0,c=[],{match:u,type:p}=this.frontier[t];if(r){for(let e=0;e<r.childCount;e++)c.push(r.child(e));u=u.matchFragment(r)}let h=s.size+e-(i.content.size-i.openEnd);for(;l<s.childCount;){let e=s.child(l),t=u.matchType(e.type);if(!t)break;l++,(l>1||0==a||e.content.size)&&(u=t,c.push(Rt(e.mark(p.allowedMarks(e.marks)),1==l?a:0,l==s.childCount?h:-1)))}let f=l==s.childCount;f||(h=-1),this.placed=Lt(this.placed,t,d.from(c)),this.frontier[t].match=u,f&&h<0&&n&&n.type==this.frontier[this.depth].type&&this.frontier.length>1&&this.closeFrontierNode();for(let e=0,t=s;e<h;e++){let e=t.lastChild;this.frontier.push({type:e.type,match:e.contentMatchAt(e.childCount)}),t=e.content}this.unplaced=f?0==e?v.empty:new v(At(i.content,e-1,1),e-1,h<0?i.openEnd:e-1):new v(At(i.content,e,l),i.openStart,i.openEnd)}mustMoveInline(){if(!this.$to.parent.isTextblock)return-1;let e,t=this.frontier[this.depth];if(!t.type.isTextblock||!Pt(this.$to,this.$to.depth,t.type,t.match,!1)||this.$to.depth==this.depth&&(e=this.findCloseLevel(this.$to))&&e.depth==this.depth)return-1;let{depth:n}=this.$to,r=this.$to.after(n);for(;n>1&&r==this.$to.end(--n);)++r;return r}findCloseLevel(e){e:for(let t=Math.min(this.depth,e.depth);t>=0;t--){let{match:n,type:r}=this.frontier[t],o=t<e.depth&&e.end(t+1)==e.pos+(e.depth-(t+1)),i=Pt(e,t,r,n,o);if(i){for(let n=t-1;n>=0;n--){let{match:t,type:r}=this.frontier[n],o=Pt(e,n,r,t,!0);if(!o||o.childCount)continue e}return{depth:t,fit:i,move:o?e.doc.resolve(e.after(t+1)):e}}}}close(e){let t=this.findCloseLevel(e);if(!t)return null;for(;this.depth>t.depth;)this.closeFrontierNode();t.fit.childCount&&(this.placed=Lt(this.placed,t.depth,t.fit)),e=t.move;for(let n=t.depth+1;n<=e.depth;n++){let t=e.node(n),r=t.type.contentMatch.fillBefore(t.content,!0,e.index(n));this.openFrontierNode(t.type,t.attrs,r)}return e}openFrontierNode(e,t=null,n){let r=this.frontier[this.depth];r.match=r.match.matchType(e),this.placed=Lt(this.placed,this.depth,d.from(e.create(t,n))),this.frontier.push({type:e,match:e.contentMatch})}closeFrontierNode(){let e=this.frontier.pop().match.fillBefore(d.empty,!0);e.childCount&&(this.placed=Lt(this.placed,this.frontier.length,e))}}function At(e,t,n){return 0==t?e.cutByIndex(n,e.childCount):e.replaceChild(0,e.firstChild.copy(At(e.firstChild.content,t-1,n)))}function Lt(e,t,n){return 0==t?e.append(n):e.replaceChild(e.childCount-1,e.lastChild.copy(Lt(e.lastChild.content,t-1,n)))}function It(e,t){for(let n=0;n<t;n++)e=e.firstChild.content;return e}function Rt(e,t,n){if(t<=0)return e;let r=e.content;return t>1&&(r=r.replaceChild(0,Rt(r.firstChild,t-1,1==r.childCount?n-1:0))),t>0&&(r=e.type.contentMatch.fillBefore(r).append(r),n<=0&&(r=r.append(e.type.contentMatch.matchFragment(r).fillBefore(d.empty,!0)))),e.copy(r)}function Pt(e,t,n,r,o){let i=e.node(t),s=o?e.indexAfter(t):e.index(t);if(s==i.childCount&&!n.compatibleContent(i.type))return null;let a=r.fillBefore(i.content,!0,s);return a&&!function(e,t,n){for(let r=n;r<t.childCount;r++)if(!e.allowsMarks(t.child(r).marks))return!0;return!1}(n,i.content,s)?a:null}function Bt(e){return e.spec.defining||e.spec.definingForContent}function Ft(e,t,n,r,o){if(t<n){let o=e.firstChild;e=e.replaceChild(0,o.copy(Ft(o.content,t+1,n,r,o)))}if(t>r){let t=o.contentMatchAt(0),n=t.fillBefore(e).append(e);e=n.append(t.matchFragment(n).fillBefore(d.empty,!0))}return e}function Ht(e,t){let n=[];for(let r=Math.min(e.depth,t.depth);r>=0;r--){let o=e.start(r);if(o<e.pos-(e.depth-r)||t.end(r)>t.pos+(t.depth-r)||e.node(r).type.spec.isolating||t.node(r).type.spec.isolating)break;(o==t.start(r)||r==e.depth&&r==t.depth&&e.parent.inlineContent&&t.parent.inlineContent&&r&&t.start(r-1)==o-1)&&n.push(r)}return n}let zt=class extends Error{};zt=function e(t){let n=Error.call(this,t);return n.__proto__=e.prototype,n},(zt.prototype=Object.create(Error.prototype)).constructor=zt,zt.prototype.name="TransformError";const qt=Object.create(null);class Vt{constructor(e,t,n){this.$anchor=e,this.$head=t,this.ranges=n||[new jt(e.min(t),e.max(t))]}get anchor(){return this.$anchor.pos}get head(){return this.$head.pos}get from(){return this.$from.pos}get to(){return this.$to.pos}get $from(){return this.ranges[0].$from}get $to(){return this.ranges[0].$to}get empty(){let e=this.ranges;for(let t=0;t<e.length;t++)if(e[t].$from.pos!=e[t].$to.pos)return!1;return!0}content(){return this.$from.doc.slice(this.from,this.to,!0)}replace(e,t=v.empty){let n=t.content.lastChild,r=null;for(let e=0;e<t.openEnd;e++)r=n,n=n.lastChild;let o=e.steps.length,i=this.ranges;for(let s=0;s<i.length;s++){let{$from:a,$to:l}=i[s],c=e.mapping.slice(o);e.replaceRange(c.map(a.pos),c.map(l.pos),s?v.empty:t),0==s&&Qt(e,o,(n?n.isInline:r&&r.isTextblock)?-1:1)}}replaceWith(e,t){let n=e.steps.length,r=this.ranges;for(let o=0;o<r.length;o++){let{$from:i,$to:s}=r[o],a=e.mapping.slice(n),l=a.map(i.pos),c=a.map(s.pos);o?e.deleteRange(l,c):(e.replaceRangeWith(l,c,t),Qt(e,n,t.isInline?-1:1))}}static findFrom(e,t,n=!1){let r=e.parent.inlineContent?new Ut(e):Xt(e.node(0),e.parent,e.pos,e.index(),t,n);if(r)return r;for(let r=e.depth-1;r>=0;r--){let o=t<0?Xt(e.node(0),e.node(r),e.before(r+1),e.index(r),t,n):Xt(e.node(0),e.node(r),e.after(r+1),e.index(r)+1,t,n);if(o)return o}return null}static near(e,t=1){return this.findFrom(e,t)||this.findFrom(e,-t)||new Kt(e.node(0))}static atStart(e){return Xt(e,e,0,0,1)||new Kt(e)}static atEnd(e){return Xt(e,e,e.content.size,e.childCount,-1)||new Kt(e)}static fromJSON(e,t){if(!t||!t.type)throw new RangeError("Invalid input for Selection.fromJSON");let n=qt[t.type];if(!n)throw new RangeError(`No selection type ${t.type} defined`);return n.fromJSON(e,t)}static jsonID(e,t){if(e in qt)throw new RangeError("Duplicate use of selection JSON ID "+e);return qt[e]=t,t.prototype.jsonID=e,t}getBookmark(){return Ut.between(this.$anchor,this.$head).getBookmark()}}Vt.prototype.visible=!0;class jt{constructor(e,t){this.$from=e,this.$to=t}}let $t=!1;function _t(e){$t||e.parent.inlineContent||($t=!0,console.warn("TextSelection endpoint not pointing into a node with inline content ("+e.parent.type.name+")"))}class Ut extends Vt{constructor(e,t=e){_t(e),_t(t),super(e,t)}get $cursor(){return this.$anchor.pos==this.$head.pos?this.$head:null}map(e,t){let n=e.resolve(t.map(this.head));if(!n.parent.inlineContent)return Vt.near(n);let r=e.resolve(t.map(this.anchor));return new Ut(r.parent.inlineContent?r:n,n)}replace(e,t=v.empty){if(super.replace(e,t),t==v.empty){let t=this.$from.marksAcross(this.$to);t&&e.ensureMarks(t)}}eq(e){return e instanceof Ut&&e.anchor==this.anchor&&e.head==this.head}getBookmark(){return new Wt(this.anchor,this.head)}toJSON(){return{type:"text",anchor:this.anchor,head:this.head}}static fromJSON(e,t){if("number"!=typeof t.anchor||"number"!=typeof t.head)throw new RangeError("Invalid input for TextSelection.fromJSON");return new Ut(e.resolve(t.anchor),e.resolve(t.head))}static create(e,t,n=t){let r=e.resolve(t);return new this(r,n==t?r:e.resolve(n))}static between(e,t,n){let r=e.pos-t.pos;if(n&&!r||(n=r>=0?1:-1),!t.parent.inlineContent){let e=Vt.findFrom(t,n,!0)||Vt.findFrom(t,-n,!0);if(!e)return Vt.near(t,n);t=e.$head}return e.parent.inlineContent||(0==r||(e=(Vt.findFrom(e,-n,!0)||Vt.findFrom(e,n,!0)).$anchor).pos<t.pos!=r<0)&&(e=t),new Ut(e,t)}}Vt.jsonID("text",Ut);class Wt{constructor(e,t){this.anchor=e,this.head=t}map(e){return new Wt(e.map(this.anchor),e.map(this.head))}resolve(e){return Ut.between(e.resolve(this.anchor),e.resolve(this.head))}}class Jt extends Vt{constructor(e){let t=e.nodeAfter,n=e.node(0).resolve(e.pos+t.nodeSize);super(e,n),this.node=t}map(e,t){let{deleted:n,pos:r}=t.mapResult(this.anchor),o=e.resolve(r);return n?Vt.near(o):new Jt(o)}content(){return new v(d.from(this.node),0,0)}eq(e){return e instanceof Jt&&e.anchor==this.anchor}toJSON(){return{type:"node",anchor:this.anchor}}getBookmark(){return new Gt(this.anchor)}static fromJSON(e,t){if("number"!=typeof t.anchor)throw new RangeError("Invalid input for NodeSelection.fromJSON");return new Jt(e.resolve(t.anchor))}static create(e,t){return new Jt(e.resolve(t))}static isSelectable(e){return!e.isText&&!1!==e.type.spec.selectable}}Jt.prototype.visible=!1,Vt.jsonID("node",Jt);class Gt{constructor(e){this.anchor=e}map(e){let{deleted:t,pos:n}=e.mapResult(this.anchor);return t?new Wt(n,n):new Gt(n)}resolve(e){let t=e.resolve(this.anchor),n=t.nodeAfter;return n&&Jt.isSelectable(n)?new Jt(t):Vt.near(t)}}class Kt extends Vt{constructor(e){super(e.resolve(0),e.resolve(e.content.size))}replace(e,t=v.empty){if(t==v.empty){e.delete(0,e.doc.content.size);let t=Vt.atStart(e.doc);t.eq(e.selection)||e.setSelection(t)}else super.replace(e,t)}toJSON(){return{type:"all"}}static fromJSON(e){return new Kt(e)}map(e){return new Kt(e)}eq(e){return e instanceof Kt}getBookmark(){return Zt}}Vt.jsonID("all",Kt);const Zt={map(){return this},resolve:e=>new Kt(e)};function Xt(e,t,n,r,o,i=!1){if(t.inlineContent)return Ut.create(e,n);for(let s=r-(o>0?0:1);o>0?s<t.childCount:s>=0;s+=o){let r=t.child(s);if(r.isAtom){if(!i&&Jt.isSelectable(r))return Jt.create(e,n-(o<0?r.nodeSize:0))}else{let t=Xt(e,r,n+o,o<0?r.childCount:0,o,i);if(t)return t}n+=r.nodeSize*o}return null}function Qt(e,t,n){let r=e.steps.length-1;if(r<t)return;let o,i=e.steps[r];(i instanceof bt||i instanceof wt)&&(e.mapping.maps[r].forEach(((e,t,n,r)=>{null==o&&(o=r)})),e.setSelection(Vt.near(e.doc.resolve(o),n)))}class Yt extends class{constructor(e){this.doc=e,this.steps=[],this.docs=[],this.mapping=new pt}get before(){return this.docs.length?this.docs[0]:this.doc}step(e){let t=this.maybeStep(e);if(t.failed)throw new zt(t.failed);return this}maybeStep(e){let t=e.apply(this.doc);return t.failed||this.addStep(e,t.doc),t}get docChanged(){return this.steps.length>0}addStep(e,t){this.docs.push(this.doc),this.steps.push(e),this.mapping.appendMap(e.getMap()),this.doc=t}replace(e,t=e,n=v.empty){let r=Nt(this.doc,e,t,n);return r&&this.step(r),this}replaceWith(e,t,n){return this.replace(e,t,new v(d.from(n),0,0))}delete(e,t){return this.replace(e,t,v.empty)}insert(e,t){return this.replaceWith(e,e,t)}replaceRange(e,t,n){return function(e,t,n,r){if(!r.size)return e.deleteRange(t,n);let o=e.doc.resolve(t),i=e.doc.resolve(n);if(Ot(o,i,r))return e.step(new bt(t,n,r));let s=Ht(o,e.doc.resolve(n));0==s[s.length-1]&&s.pop();let a=-(o.depth+1);s.unshift(a);for(let e=o.depth,t=o.pos-1;e>0;e--,t--){let n=o.node(e).type.spec;if(n.defining||n.definingAsContext||n.isolating)break;s.indexOf(e)>-1?a=e:o.before(e)==t&&s.splice(1,0,-e)}let l=s.indexOf(a),c=[],u=r.openStart;for(let e=r.content,t=0;;t++){let n=e.firstChild;if(c.push(n),t==r.openStart)break;e=n.content}for(let e=u-1;e>=0;e--){let t=c[e].type,n=Bt(t);if(n&&o.node(l).type!=t)u=e;else if(n||!t.isTextblock)break}for(let t=r.openStart;t>=0;t--){let a=(t+u+1)%(r.openStart+1),d=c[a];if(d)for(let t=0;t<s.length;t++){let c=s[(t+l)%s.length],u=!0;c<0&&(u=!1,c=-c);let p=o.node(c-1),h=o.index(c-1);if(p.canReplaceWith(h,h,d.type,d.marks))return e.replace(o.before(c),u?i.after(c):n,new v(Ft(r.content,0,r.openStart,a),a,r.openEnd))}}let d=e.steps.length;for(let a=s.length-1;a>=0&&(e.replace(t,n,r),!(e.steps.length>d));a--){let e=s[a];e<0||(t=o.before(e),n=i.after(e))}}(this,e,t,n),this}replaceRangeWith(e,t,n){return function(e,t,n,r){if(!r.isInline&&t==n&&e.doc.resolve(t).parent.content.size){let o=function(e,t,n){let r=e.resolve(t);if(r.parent.canReplaceWith(r.index(),r.index(),n))return t;if(0==r.parentOffset)for(let e=r.depth-1;e>=0;e--){let t=r.index(e);if(r.node(e).canReplaceWith(t,t,n))return r.before(e+1);if(t>0)return null}if(r.parentOffset==r.parent.content.size)for(let e=r.depth-1;e>=0;e--){let t=r.indexAfter(e);if(r.node(e).canReplaceWith(t,t,n))return r.after(e+1);if(t<r.node(e).childCount)return null}return null}(e.doc,t,r.type);null!=o&&(t=n=o)}e.replaceRange(t,n,new v(d.from(r),0,0))}(this,e,t,n),this}deleteRange(e,t){return function(e,t,n){let r=e.doc.resolve(t),o=e.doc.resolve(n),i=Ht(r,o);for(let t=0;t<i.length;t++){let n=i[t],s=t==i.length-1;if(s&&0==n||r.node(n).type.contentMatch.validEnd)return e.delete(r.start(n),o.end(n));if(n>0&&(s||r.node(n-1).canReplace(r.index(n-1),o.indexAfter(n-1))))return e.delete(r.before(n),o.after(n))}for(let i=1;i<=r.depth&&i<=o.depth;i++)if(t-r.start(i)==r.depth-i&&n>r.end(i)&&o.end(i)-n!=o.depth-i)return e.delete(r.before(i),n);e.delete(t,n)}(this,e,t),this}lift(e,t){return function(e,t,n){let{$from:r,$to:o,depth:i}=t,s=r.before(i+1),a=o.after(i+1),l=s,c=a,u=d.empty,p=0;for(let e=i,t=!1;e>n;e--)t||r.index(e)>0?(t=!0,u=d.from(r.node(e).copy(u)),p++):l--;let h=d.empty,f=0;for(let e=i,t=!1;e>n;e--)t||o.after(e+1)<o.end(e)?(t=!0,h=d.from(o.node(e).copy(h)),f++):c++;e.step(new wt(l,c,s,a,new v(u.append(h),p,f),u.size-p,!0))}(this,e,t),this}join(e,t=1){return function(e,t,n){let r=new bt(t-n,t+n,v.empty,!0);e.step(r)}(this,e,t),this}wrap(e,t){return function(e,t,n){let r=d.empty;for(let e=n.length-1;e>=0;e--){if(r.size){let t=n[e].type.contentMatch.matchFragment(r);if(!t||!t.validEnd)throw new RangeError("Wrapper type given to Transform.wrap does not form valid content of its parent wrapper")}r=d.from(n[e].type.create(n[e].attrs,r))}let o=t.start,i=t.end;e.step(new wt(o,i,o,i,new v(r,0,0),n.length,!0))}(this,e,t),this}setBlockType(e,t=e,n,r=null){return function(e,t,n,r,o){if(!r.isTextblock)throw new RangeError("Type given to setBlockType should be a textblock");let i=e.steps.length;e.doc.nodesBetween(t,n,((t,n)=>{if(t.isTextblock&&!t.hasMarkup(r,o)&&function(e,t,n){let r=e.resolve(t),o=r.index();return r.parent.canReplaceWith(o,o+1,n)}(e.doc,e.mapping.slice(i).map(n),r)){e.clearIncompatible(e.mapping.slice(i).map(n,1),r);let s=e.mapping.slice(i),a=s.map(n,1),l=s.map(n+t.nodeSize,1);return e.step(new wt(a,l,a+1,l-1,new v(d.from(r.create(o,null,t.marks)),0,0),1,!0)),!1}}))}(this,e,t,n,r),this}setNodeMarkup(e,t,n=null,r=[]){return function(e,t,n,r,o){let i=e.doc.nodeAt(t);if(!i)throw new RangeError("No node at given position");n||(n=i.type);let s=n.create(r,null,o||i.marks);if(i.isLeaf)return e.replaceWith(t,t+i.nodeSize,s);if(!n.validContent(i.content))throw new RangeError("Invalid content for node type "+n.name);e.step(new wt(t,t+i.nodeSize,t+1,t+i.nodeSize-1,new v(d.from(s),0,0),1,!0))}(this,e,t,n,r),this}split(e,t=1,n){return function(e,t,n=1,r){let o=e.doc.resolve(t),i=d.empty,s=d.empty;for(let e=o.depth,t=o.depth-n,a=n-1;e>t;e--,a--){i=d.from(o.node(e).copy(i));let t=r&&r[a];s=d.from(t?t.type.create(t.attrs,s):o.node(e).copy(s))}e.step(new bt(t,t,new v(i.append(s),n,n),!0))}(this,e,t,n),this}addMark(e,t,n){return function(e,t,n,r){let o,i,s=[],a=[];e.doc.nodesBetween(t,n,((e,l,c)=>{if(!e.isInline)return;let u=e.marks;if(!r.isInSet(u)&&c.type.allowsMarkType(r.type)){let c=Math.max(l,t),d=Math.min(l+e.nodeSize,n),p=r.addToSet(u);for(let e=0;e<u.length;e++)u[e].isInSet(p)||(o&&o.to==c&&o.mark.eq(u[e])?o.to=d:s.push(o=new yt(c,d,u[e])));i&&i.to==c?i.to=d:a.push(i=new vt(c,d,r))}})),s.forEach((t=>e.step(t))),a.forEach((t=>e.step(t)))}(this,e,t,n),this}removeMark(e,t,n){return function(e,t,n,r){let o=[],i=0;e.doc.nodesBetween(t,n,((e,s)=>{if(!e.isInline)return;i++;let a=null;if(r instanceof Q){let t,n=e.marks;for(;t=r.isInSet(n);)(a||(a=[])).push(t),n=t.removeFromSet(n)}else r?r.isInSet(e.marks)&&(a=[r]):a=e.marks;if(a&&a.length){let r=Math.min(s+e.nodeSize,n);for(let e=0;e<a.length;e++){let n,l=a[e];for(let e=0;e<o.length;e++){let t=o[e];t.step==i-1&&l.eq(o[e].style)&&(n=t)}n?(n.to=r,n.step=i):o.push({style:l,from:Math.max(s,t),to:r,step:i})}}})),o.forEach((t=>e.step(new yt(t.from,t.to,t.style))))}(this,e,t,n),this}clearIncompatible(e,t,n){return function(e,t,n,r=n.contentMatch){let o=e.doc.nodeAt(t),i=[],s=t+1;for(let t=0;t<o.childCount;t++){let a=o.child(t),l=s+a.nodeSize,c=r.matchType(a.type);if(c){r=c;for(let t=0;t<a.marks.length;t++)n.allowsMarkType(a.marks[t].type)||e.step(new yt(s,l,a.marks[t]))}else i.push(new bt(s,l,v.empty));s=l}if(!r.validEnd){let t=r.fillBefore(d.empty,!0);e.replace(s,s,new v(t,0,0))}for(let t=i.length-1;t>=0;t--)e.step(i[t])}(this,e,t,n),this}}{constructor(e){super(e.doc),this.curSelectionFor=0,this.updated=0,this.meta=Object.create(null),this.time=Date.now(),this.curSelection=e.selection,this.storedMarks=e.storedMarks}get selection(){return this.curSelectionFor<this.steps.length&&(this.curSelection=this.curSelection.map(this.doc,this.mapping.slice(this.curSelectionFor)),this.curSelectionFor=this.steps.length),this.curSelection}setSelection(e){if(e.$from.doc!=this.doc)throw new RangeError("Selection passed to setSelection must point at the current document");return this.curSelection=e,this.curSelectionFor=this.steps.length,this.updated=-3&(1|this.updated),this.storedMarks=null,this}get selectionSet(){return(1&this.updated)>0}setStoredMarks(e){return this.storedMarks=e,this.updated|=2,this}ensureMarks(e){return m.sameSet(this.storedMarks||this.selection.$from.marks(),e)||this.setStoredMarks(e),this}addStoredMark(e){return this.ensureMarks(e.addToSet(this.storedMarks||this.selection.$head.marks()))}removeStoredMark(e){return this.ensureMarks(e.removeFromSet(this.storedMarks||this.selection.$head.marks()))}get storedMarksSet(){return(2&this.updated)>0}addStep(e,t){super.addStep(e,t),this.updated=-3&this.updated,this.storedMarks=null}setTime(e){return this.time=e,this}replaceSelection(e){return this.selection.replace(this,e),this}replaceSelectionWith(e,t=!0){let n=this.selection;return t&&(e=e.mark(this.storedMarks||(n.empty?n.$from.marks():n.$from.marksAcross(n.$to)||m.none))),n.replaceWith(this,e),this}deleteSelection(){return this.selection.replace(this),this}insertText(e,t,n){let r=this.doc.type.schema;if(null==t)return e?this.replaceSelectionWith(r.text(e),!0):this.deleteSelection();{if(null==n&&(n=t),n=null==n?t:n,!e)return this.deleteRange(t,n);let o=this.storedMarks;if(!o){let e=this.doc.resolve(t);o=n==t?e.marks():e.marksAcross(this.doc.resolve(n))}return this.replaceRangeWith(t,n,r.text(e,o)),this.selection.empty||this.setSelection(Vt.near(this.selection.$to)),this}}setMeta(e,t){return this.meta["string"==typeof e?e:e.key]=t,this}getMeta(e){return this.meta["string"==typeof e?e:e.key]}get isGeneric(){for(let e in this.meta)return!1;return!0}scrollIntoView(){return this.updated|=4,this}get scrolledIntoView(){return(4&this.updated)>0}}function en(e,t){return t&&e?e.bind(t):e}class tn{constructor(e,t,n){this.name=e,this.init=en(t.init,n),this.apply=en(t.apply,n)}}const nn=[new tn("doc",{init:e=>e.doc||e.schema.topNodeType.createAndFill(),apply:e=>e.doc}),new tn("selection",{init:(e,t)=>e.selection||Vt.atStart(t.doc),apply:e=>e.selection}),new tn("storedMarks",{init:e=>e.storedMarks||null,apply:(e,t,n,r)=>r.selection.$cursor?e.storedMarks:null}),new tn("scrollToSelection",{init:()=>0,apply:(e,t)=>e.scrolledIntoView?t+1:t})];class rn{constructor(e,t){this.schema=e,this.plugins=[],this.pluginsByKey=Object.create(null),this.fields=nn.slice(),t&&t.forEach((e=>{if(this.pluginsByKey[e.key])throw new RangeError("Adding different instances of a keyed plugin ("+e.key+")");this.plugins.push(e),this.pluginsByKey[e.key]=e,e.spec.state&&this.fields.push(new tn(e.key,e.spec.state,e))}))}}class on{constructor(e){this.config=e}get schema(){return this.config.schema}get plugins(){return this.config.plugins}apply(e){return this.applyTransaction(e).state}filterTransaction(e,t=-1){for(let n=0;n<this.config.plugins.length;n++)if(n!=t){let t=this.config.plugins[n];if(t.spec.filterTransaction&&!t.spec.filterTransaction.call(t,e,this))return!1}return!0}applyTransaction(e){if(!this.filterTransaction(e))return{state:this,transactions:[]};let t=[e],n=this.applyInner(e),r=null;for(;;){let o=!1;for(let i=0;i<this.config.plugins.length;i++){let s=this.config.plugins[i];if(s.spec.appendTransaction){let a=r?r[i].n:0,l=r?r[i].state:this,c=a<t.length&&s.spec.appendTransaction.call(s,a?t.slice(a):t,l,n);if(c&&n.filterTransaction(c,i)){if(c.setMeta("appendedTransaction",e),!r){r=[];for(let e=0;e<this.config.plugins.length;e++)r.push(e<i?{state:n,n:t.length}:{state:this,n:0})}t.push(c),n=n.applyInner(c),o=!0}r&&(r[i]={state:n,n:t.length})}}if(!o)return{state:n,transactions:t}}}applyInner(e){if(!e.before.eq(this.doc))throw new RangeError("Applying a mismatched transaction");let t=new on(this.config),n=this.config.fields;for(let r=0;r<n.length;r++){let o=n[r];t[o.name]=o.apply(e,this[o.name],this,t)}return t}get tr(){return new Yt(this)}static create(e){let t=new rn(e.doc?e.doc.type.schema:e.schema,e.plugins),n=new on(t);for(let r=0;r<t.fields.length;r++)n[t.fields[r].name]=t.fields[r].init(e,n);return n}reconfigure(e){let t=new rn(this.schema,e.plugins),n=t.fields,r=new on(t);for(let t=0;t<n.length;t++){let o=n[t].name;r[o]=this.hasOwnProperty(o)?this[o]:n[t].init(e,r)}return r}toJSON(e){let t={doc:this.doc.toJSON(),selection:this.selection.toJSON()};if(this.storedMarks&&(t.storedMarks=this.storedMarks.map((e=>e.toJSON()))),e&&"object"==typeof e)for(let n in e){if("doc"==n||"selection"==n)throw new RangeError("The JSON fields `doc` and `selection` are reserved");let r=e[n],o=r.spec.state;o&&o.toJSON&&(t[n]=o.toJSON.call(r,this[r.key]))}return t}static fromJSON(e,t,n){if(!t)throw new RangeError("Invalid input for EditorState.fromJSON");if(!e.schema)throw new RangeError("Required config field 'schema' missing");let r=new rn(e.schema,e.plugins),o=new on(r);return r.fields.forEach((r=>{if("doc"==r.name)o.doc=P.fromJSON(e.schema,t.doc);else if("selection"==r.name)o.selection=Vt.fromJSON(o.doc,t.selection);else if("storedMarks"==r.name)t.storedMarks&&(o.storedMarks=t.storedMarks.map(e.schema.markFromJSON));else{if(n)for(let i in n){let s=n[i],a=s.spec.state;if(s.key==r.name&&a&&a.fromJSON&&Object.prototype.hasOwnProperty.call(t,i))return void(o[r.name]=a.fromJSON.call(s,e,t[i],o))}o[r.name]=r.init(e,o)}})),o}}function sn(e,t,n){for(let r in e){let o=e[r];o instanceof Function?o=o.bind(t):"handleDOMEvents"==r&&(o=sn(o,t,{})),n[r]=o}return n}class an{constructor(e){this.spec=e,this.props={},e.props&&sn(e.props,this,this.props),this.key=e.key?e.key.key:cn("plugin")}getState(e){return e[this.key]}}const ln=Object.create(null);function cn(e){return e in ln?e+"$"+ ++ln[e]:(ln[e]=0,e+"$")}class un{constructor(e="key"){this.key=cn(e)}get(e){return e.config.pluginsByKey[this.key]}getState(e){return e[this.key]}}const dn="undefined"!=typeof navigator?navigator:null,pn="undefined"!=typeof document?document:null,hn=dn&&dn.userAgent||"",fn=/Edge\/(\d+)/.exec(hn),mn=/MSIE \d/.exec(hn),gn=/Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(hn),vn=!!(mn||gn||fn),yn=mn?document.documentMode:gn?+gn[1]:fn?+fn[1]:0,bn=!vn&&/gecko\/(\d+)/i.test(hn);bn&&(/Firefox\/(\d+)/.exec(hn)||[0,0])[1];const wn=!vn&&/Chrome\/(\d+)/.exec(hn),kn=!!wn,xn=wn?+wn[1]:0,Cn=!vn&&!!dn&&/Apple Computer/.test(dn.vendor),Tn=Cn&&(/Mobile\/\w+/.test(hn)||!!dn&&dn.maxTouchPoints>2),Mn=Tn||!!dn&&/Mac/.test(dn.platform),Sn=/Android \d/.test(hn),En=!!pn&&"webkitFontSmoothing"in pn.documentElement.style,Nn=En?+(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent)||[0,0])[1]:0,On=function(e){for(var t=0;;t++)if(!(e=e.previousSibling))return t},Dn=function(e){let t=e.assignedSlot||e.parentNode;return t&&11==t.nodeType?t.host:t};let An=null;const Ln=function(e,t,n){let r=An||(An=document.createRange());return r.setEnd(e,null==n?e.nodeValue.length:n),r.setStart(e,t||0),r},In=function(e,t,n,r){return n&&(Pn(e,t,n,r,-1)||Pn(e,t,n,r,1))},Rn=/^(img|br|input|textarea|hr)$/i;function Pn(e,t,n,r,o){for(;;){if(e==n&&t==r)return!0;if(t==(o<0?0:Bn(e))){let n=e.parentNode;if(!n||1!=n.nodeType||Fn(e)||Rn.test(e.nodeName)||"false"==e.contentEditable)return!1;t=On(e)+(o<0?0:1),e=n}else{if(1!=e.nodeType)return!1;if("false"==(e=e.childNodes[t+(o<0?-1:0)]).contentEditable)return!1;t=o<0?Bn(e):0}}}function Bn(e){return 3==e.nodeType?e.nodeValue.length:e.childNodes.length}function Fn(e){let t;for(let n=e;n&&!(t=n.pmViewDesc);n=n.parentNode);return t&&t.node&&t.node.isBlock&&(t.dom==e||t.contentDOM==e)}const Hn=function(e){let t=e.isCollapsed;return t&&kn&&e.rangeCount&&!e.getRangeAt(0).collapsed&&(t=!1),t};function zn(e,t){let n=document.createEvent("Event");return n.initEvent("keydown",!0,!0),n.keyCode=e,n.key=n.code=t,n}function qn(e){return{left:0,right:e.documentElement.clientWidth,top:0,bottom:e.documentElement.clientHeight}}function Vn(e,t){return"number"==typeof e?e:e[t]}function jn(e){let t=e.getBoundingClientRect(),n=t.width/e.offsetWidth||1,r=t.height/e.offsetHeight||1;return{left:t.left,right:t.left+e.clientWidth*n,top:t.top,bottom:t.top+e.clientHeight*r}}function $n(e,t,n){let r=e.someProp("scrollThreshold")||0,o=e.someProp("scrollMargin")||5,i=e.dom.ownerDocument;for(let s=n||e.dom;s;s=Dn(s)){if(1!=s.nodeType)continue;let e=s,n=e==i.body,a=n?qn(i):jn(e),l=0,c=0;if(t.top<a.top+Vn(r,"top")?c=-(a.top-t.top+Vn(o,"top")):t.bottom>a.bottom-Vn(r,"bottom")&&(c=t.bottom-a.bottom+Vn(o,"bottom")),t.left<a.left+Vn(r,"left")?l=-(a.left-t.left+Vn(o,"left")):t.right>a.right-Vn(r,"right")&&(l=t.right-a.right+Vn(o,"right")),l||c)if(n)i.defaultView.scrollBy(l,c);else{let n=e.scrollLeft,r=e.scrollTop;c&&(e.scrollTop+=c),l&&(e.scrollLeft+=l);let o=e.scrollLeft-n,i=e.scrollTop-r;t={left:t.left-o,top:t.top-i,right:t.right-o,bottom:t.bottom-i}}if(n)break}}function _n(e){let t=[],n=e.ownerDocument;for(let r=e;r&&(t.push({dom:r,top:r.scrollTop,left:r.scrollLeft}),e!=n);r=Dn(r));return t}function Un(e,t){for(let n=0;n<e.length;n++){let{dom:r,top:o,left:i}=e[n];r.scrollTop!=o+t&&(r.scrollTop=o+t),r.scrollLeft!=i&&(r.scrollLeft=i)}}let Wn=null;function Jn(e,t){let n,r,o=2e8,i=0,s=t.top,a=t.top;for(let l=e.firstChild,c=0;l;l=l.nextSibling,c++){let e;if(1==l.nodeType)e=l.getClientRects();else{if(3!=l.nodeType)continue;e=Ln(l).getClientRects()}for(let u=0;u<e.length;u++){let d=e[u];if(d.top<=s&&d.bottom>=a){s=Math.max(d.bottom,s),a=Math.min(d.top,a);let e=d.left>t.left?d.left-t.left:d.right<t.left?t.left-d.right:0;if(e<o){n=l,o=e,r=e&&3==n.nodeType?{left:d.right<t.left?d.right:d.left,top:t.top}:t,1==l.nodeType&&e&&(i=c+(t.left>=(d.left+d.right)/2?1:0));continue}}!n&&(t.left>=d.right&&t.top>=d.top||t.left>=d.left&&t.top>=d.bottom)&&(i=c+1)}}return n&&3==n.nodeType?function(e,t){let n=e.nodeValue.length,r=document.createRange();for(let o=0;o<n;o++){r.setEnd(e,o+1),r.setStart(e,o);let n=Xn(r,1);if(n.top!=n.bottom&&Gn(t,n))return{node:e,offset:o+(t.left>=(n.left+n.right)/2?1:0)}}return{node:e,offset:0}}(n,r):!n||o&&1==n.nodeType?{node:e,offset:i}:Jn(n,r)}function Gn(e,t){return e.left>=t.left-1&&e.left<=t.right+1&&e.top>=t.top-1&&e.top<=t.bottom+1}function Kn(e,t,n){let r=e.childNodes.length;if(r&&n.top<n.bottom)for(let o=Math.max(0,Math.min(r-1,Math.floor(r*(t.top-n.top)/(n.bottom-n.top))-2)),i=o;;){let n=e.childNodes[i];if(1==n.nodeType){let e=n.getClientRects();for(let r=0;r<e.length;r++){let o=e[r];if(Gn(t,o))return Kn(n,t,o)}}if((i=(i+1)%r)==o)break}return e}function Zn(e,t){let n,r=e.dom.ownerDocument,o=0;if(r.caretPositionFromPoint)try{let e=r.caretPositionFromPoint(t.left,t.top);e&&({offsetNode:n,offset:o}=e)}catch(e){}if(!n&&r.caretRangeFromPoint){let e=r.caretRangeFromPoint(t.left,t.top);e&&({startContainer:n,startOffset:o}=e)}let i,s=(e.root.elementFromPoint?e.root:r).elementFromPoint(t.left,t.top);if(!s||!e.dom.contains(1!=s.nodeType?s.parentNode:s)){let n=e.dom.getBoundingClientRect();if(!Gn(t,n))return null;if(s=Kn(e.dom,t,n),!s)return null}if(Cn)for(let e=s;n&&e;e=Dn(e))e.draggable&&(n=void 0);if(s=function(e,t){let n=e.parentNode;return n&&/^li$/i.test(n.nodeName)&&t.left<e.getBoundingClientRect().left?n:e}(s,t),n){if(bn&&1==n.nodeType&&(o=Math.min(o,n.childNodes.length),o<n.childNodes.length)){let e,r=n.childNodes[o];"IMG"==r.nodeName&&(e=r.getBoundingClientRect()).right<=t.left&&e.bottom>t.top&&o++}n==e.dom&&o==n.childNodes.length-1&&1==n.lastChild.nodeType&&t.top>n.lastChild.getBoundingClientRect().bottom?i=e.state.doc.content.size:0!=o&&1==n.nodeType&&"BR"==n.childNodes[o-1].nodeName||(i=function(e,t,n,r){let o=-1;for(let n=t;n!=e.dom;){let t=e.docView.nearestDesc(n,!0);if(!t)return null;if(t.node.isBlock&&t.parent){let e=t.dom.getBoundingClientRect();if(e.left>r.left||e.top>r.top)o=t.posBefore;else{if(!(e.right<r.left||e.bottom<r.top))break;o=t.posAfter}}n=t.dom.parentNode}return o>-1?o:e.docView.posFromDOM(t,n,1)}(e,n,o,t))}null==i&&(i=function(e,t,n){let{node:r,offset:o}=Jn(t,n),i=-1;if(1==r.nodeType&&!r.firstChild){let e=r.getBoundingClientRect();i=e.left!=e.right&&n.left>(e.left+e.right)/2?1:-1}return e.docView.posFromDOM(r,o,i)}(e,s,t));let a=e.docView.nearestDesc(s,!0);return{pos:i,inside:a?a.posAtStart-a.border:-1}}function Xn(e,t){let n=e.getClientRects();return n.length?n[t<0?0:n.length-1]:e.getBoundingClientRect()}const Qn=/[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;function Yn(e,t,n){let{node:r,offset:o,atom:i}=e.docView.domFromPos(t,n<0?-1:1),s=En||bn;if(3==r.nodeType){if(!s||!Qn.test(r.nodeValue)&&(n<0?o:o!=r.nodeValue.length)){let e=o,t=o,i=n<0?1:-1;return n<0&&!o?(t++,i=-1):n>=0&&o==r.nodeValue.length?(e--,i=1):n<0?e--:t++,er(Xn(Ln(r,e,t),i),i<0)}{let e=Xn(Ln(r,o,o),n);if(bn&&o&&/\s/.test(r.nodeValue[o-1])&&o<r.nodeValue.length){let t=Xn(Ln(r,o-1,o-1),-1);if(t.top==e.top){let n=Xn(Ln(r,o,o+1),-1);if(n.top!=e.top)return er(n,n.left<t.left)}}return e}}if(!e.state.doc.resolve(t-(i||0)).parent.inlineContent){if(null==i&&o&&(n<0||o==Bn(r))){let e=r.childNodes[o-1];if(1==e.nodeType)return tr(e.getBoundingClientRect(),!1)}if(null==i&&o<Bn(r)){let e=r.childNodes[o];if(1==e.nodeType)return tr(e.getBoundingClientRect(),!0)}return tr(r.getBoundingClientRect(),n>=0)}if(null==i&&o&&(n<0||o==Bn(r))){let e=r.childNodes[o-1],t=3==e.nodeType?Ln(e,Bn(e)-(s?0:1)):1!=e.nodeType||"BR"==e.nodeName&&e.nextSibling?null:e;if(t)return er(Xn(t,1),!1)}if(null==i&&o<Bn(r)){let e=r.childNodes[o];for(;e.pmViewDesc&&e.pmViewDesc.ignoreForCoords;)e=e.nextSibling;let t=e?3==e.nodeType?Ln(e,0,s?0:1):1==e.nodeType?e:null:null;if(t)return er(Xn(t,-1),!0)}return er(Xn(3==r.nodeType?Ln(r):r,-n),n>=0)}function er(e,t){if(0==e.width)return e;let n=t?e.left:e.right;return{top:e.top,bottom:e.bottom,left:n,right:n}}function tr(e,t){if(0==e.height)return e;let n=t?e.top:e.bottom;return{top:n,bottom:n,left:e.left,right:e.right}}function nr(e,t,n){let r=e.state,o=e.root.activeElement;r!=t&&e.updateState(t),o!=e.dom&&e.focus();try{return n()}finally{r!=t&&e.updateState(r),o!=e.dom&&o&&o.focus()}}const rr=/[\u0590-\u08ac]/;let or=null,ir=null,sr=!1;function ar(e,t,n){return or==t&&ir==n?sr:(or=t,ir=n,sr="up"==n||"down"==n?function(e,t,n){let r=t.selection,o="up"==n?r.$from:r.$to;return nr(e,t,(()=>{let{node:t}=e.docView.domFromPos(o.pos,"up"==n?-1:1);for(;;){let n=e.docView.nearestDesc(t,!0);if(!n)break;if(n.node.isBlock){t=n.dom;break}t=n.dom.parentNode}let r=Yn(e,o.pos,1);for(let e=t.firstChild;e;e=e.nextSibling){let t;if(1==e.nodeType)t=e.getClientRects();else{if(3!=e.nodeType)continue;t=Ln(e,0,e.nodeValue.length).getClientRects()}for(let e=0;e<t.length;e++){let o=t[e];if(o.bottom>o.top+1&&("up"==n?r.top-o.top>2*(o.bottom-r.top):o.bottom-r.bottom>2*(r.bottom-o.top)))return!1}}return!0}))}(e,t,n):function(e,t,n){let{$head:r}=t.selection;if(!r.parent.isTextblock)return!1;let o=r.parentOffset,i=!o,s=o==r.parent.content.size,a=e.domSelection();return rr.test(r.parent.textContent)&&a.modify?nr(e,t,(()=>{let t=a.getRangeAt(0),o=a.focusNode,i=a.focusOffset,s=a.caretBidiLevel;a.modify("move",n,"character");let l=!(r.depth?e.docView.domAfterPos(r.before()):e.dom).contains(1==a.focusNode.nodeType?a.focusNode:a.focusNode.parentNode)||o==a.focusNode&&i==a.focusOffset;return a.removeAllRanges(),a.addRange(t),null!=s&&(a.caretBidiLevel=s),l})):"left"==n||"backward"==n?i:s}(e,t,n))}class lr{constructor(e,t,n,r){this.parent=e,this.children=t,this.dom=n,this.contentDOM=r,this.dirty=0,n.pmViewDesc=this}matchesWidget(e){return!1}matchesMark(e){return!1}matchesNode(e,t,n){return!1}matchesHack(e){return!1}parseRule(){return null}stopEvent(e){return!1}get size(){let e=0;for(let t=0;t<this.children.length;t++)e+=this.children[t].size;return e}get border(){return 0}destroy(){this.parent=void 0,this.dom.pmViewDesc==this&&(this.dom.pmViewDesc=void 0);for(let e=0;e<this.children.length;e++)this.children[e].destroy()}posBeforeChild(e){for(let t=0,n=this.posAtStart;;t++){let r=this.children[t];if(r==e)return n;n+=r.size}}get posBefore(){return this.parent.posBeforeChild(this)}get posAtStart(){return this.parent?this.parent.posBeforeChild(this)+this.border:0}get posAfter(){return this.posBefore+this.size}get posAtEnd(){return this.posAtStart+this.size-2*this.border}localPosFromDOM(e,t,n){if(this.contentDOM&&this.contentDOM.contains(1==e.nodeType?e:e.parentNode)){if(n<0){let n,r;if(e==this.contentDOM)n=e.childNodes[t-1];else{for(;e.parentNode!=this.contentDOM;)e=e.parentNode;n=e.previousSibling}for(;n&&(!(r=n.pmViewDesc)||r.parent!=this);)n=n.previousSibling;return n?this.posBeforeChild(r)+r.size:this.posAtStart}{let n,r;if(e==this.contentDOM)n=e.childNodes[t];else{for(;e.parentNode!=this.contentDOM;)e=e.parentNode;n=e.nextSibling}for(;n&&(!(r=n.pmViewDesc)||r.parent!=this);)n=n.nextSibling;return n?this.posBeforeChild(r):this.posAtEnd}}let r;if(e==this.dom&&this.contentDOM)r=t>On(this.contentDOM);else if(this.contentDOM&&this.contentDOM!=this.dom&&this.dom.contains(this.contentDOM))r=2&e.compareDocumentPosition(this.contentDOM);else if(this.dom.firstChild){if(0==t)for(let t=e;;t=t.parentNode){if(t==this.dom){r=!1;break}if(t.previousSibling)break}if(null==r&&t==e.childNodes.length)for(let t=e;;t=t.parentNode){if(t==this.dom){r=!0;break}if(t.nextSibling)break}}return(null==r?n>0:r)?this.posAtEnd:this.posAtStart}nearestDesc(e,t=!1){for(let n=!0,r=e;r;r=r.parentNode){let o,i=this.getDesc(r);if(i&&(!t||i.node)){if(!n||!(o=i.nodeDOM)||(1==o.nodeType?o.contains(1==e.nodeType?e:e.parentNode):o==e))return i;n=!1}}}getDesc(e){let t=e.pmViewDesc;for(let e=t;e;e=e.parent)if(e==this)return t}posFromDOM(e,t,n){for(let r=e;r;r=r.parentNode){let o=this.getDesc(r);if(o)return o.localPosFromDOM(e,t,n)}return-1}descAt(e){for(let t=0,n=0;t<this.children.length;t++){let r=this.children[t],o=n+r.size;if(n==e&&o!=n){for(;!r.border&&r.children.length;)r=r.children[0];return r}if(e<o)return r.descAt(e-n-r.border);n=o}}domFromPos(e,t){if(!this.contentDOM)return{node:this.dom,offset:0,atom:e+1};let n,r=0,o=0;for(let t=0;r<this.children.length;r++){let n=this.children[r],i=t+n.size;if(i>e||n instanceof mr){o=e-t;break}t=i}if(o)return this.children[r].domFromPos(o-this.children[r].border,t);for(;r&&!(n=this.children[r-1]).size&&n instanceof cr&&n.side>=0;r--);if(t<=0){let e,n=!0;for(;e=r?this.children[r-1]:null,e&&e.dom.parentNode!=this.contentDOM;r--,n=!1);return e&&t&&n&&!e.border&&!e.domAtom?e.domFromPos(e.size,t):{node:this.contentDOM,offset:e?On(e.dom)+1:0}}{let e,n=!0;for(;e=r<this.children.length?this.children[r]:null,e&&e.dom.parentNode!=this.contentDOM;r++,n=!1);return e&&n&&!e.border&&!e.domAtom?e.domFromPos(0,t):{node:this.contentDOM,offset:e?On(e.dom):this.contentDOM.childNodes.length}}}parseRange(e,t,n=0){if(0==this.children.length)return{node:this.contentDOM,from:e,to:t,fromOffset:0,toOffset:this.contentDOM.childNodes.length};let r=-1,o=-1;for(let i=n,s=0;;s++){let n=this.children[s],a=i+n.size;if(-1==r&&e<=a){let o=i+n.border;if(e>=o&&t<=a-n.border&&n.node&&n.contentDOM&&this.contentDOM.contains(n.contentDOM))return n.parseRange(e,t,o);e=i;for(let t=s;t>0;t--){let n=this.children[t-1];if(n.size&&n.dom.parentNode==this.contentDOM&&!n.emptyChildAt(1)){r=On(n.dom)+1;break}e-=n.size}-1==r&&(r=0)}if(r>-1&&(a>t||s==this.children.length-1)){t=a;for(let e=s+1;e<this.children.length;e++){let n=this.children[e];if(n.size&&n.dom.parentNode==this.contentDOM&&!n.emptyChildAt(-1)){o=On(n.dom);break}t+=n.size}-1==o&&(o=this.contentDOM.childNodes.length);break}i=a}return{node:this.contentDOM,from:e,to:t,fromOffset:r,toOffset:o}}emptyChildAt(e){if(this.border||!this.contentDOM||!this.children.length)return!1;let t=this.children[e<0?0:this.children.length-1];return 0==t.size||t.emptyChildAt(e)}domAfterPos(e){let{node:t,offset:n}=this.domFromPos(e,0);if(1!=t.nodeType||n==t.childNodes.length)throw new RangeError("No node after pos "+e);return t.childNodes[n]}setSelection(e,t,n,r=!1){let o=Math.min(e,t),i=Math.max(e,t);for(let s=0,a=0;s<this.children.length;s++){let l=this.children[s],c=a+l.size;if(o>a&&i<c)return l.setSelection(e-a-l.border,t-a-l.border,n,r);a=c}let s=this.domFromPos(e,e?-1:1),a=t==e?s:this.domFromPos(t,t?-1:1),l=n.getSelection(),c=!1;if((bn||Cn)&&e==t){let{node:e,offset:t}=s;if(3==e.nodeType){if(c=!(!t||"\n"!=e.nodeValue[t-1]),c&&t==e.nodeValue.length)for(let t,n=e;n;n=n.parentNode){if(t=n.nextSibling){"BR"==t.nodeName&&(s=a={node:t.parentNode,offset:On(t)+1});break}let e=n.pmViewDesc;if(e&&e.node&&e.node.isBlock)break}}else{let n=e.childNodes[t-1];c=n&&("BR"==n.nodeName||"false"==n.contentEditable)}}if(bn&&l.focusNode&&l.focusNode!=a.node&&1==l.focusNode.nodeType){let e=l.focusNode.childNodes[l.focusOffset];e&&"false"==e.contentEditable&&(r=!0)}if(!(r||c&&Cn)&&In(s.node,s.offset,l.anchorNode,l.anchorOffset)&&In(a.node,a.offset,l.focusNode,l.focusOffset))return;let u=!1;if((l.extend||e==t)&&!c){l.collapse(s.node,s.offset);try{e!=t&&l.extend(a.node,a.offset),u=!0}catch(e){if(!(e instanceof DOMException))throw e}}if(!u){if(e>t){let e=s;s=a,a=e}let n=document.createRange();n.setEnd(a.node,a.offset),n.setStart(s.node,s.offset),l.removeAllRanges(),l.addRange(n)}}ignoreMutation(e){return!this.contentDOM&&"selection"!=e.type}get contentLost(){return this.contentDOM&&this.contentDOM!=this.dom&&!this.dom.contains(this.contentDOM)}markDirty(e,t){for(let n=0,r=0;r<this.children.length;r++){let o=this.children[r],i=n+o.size;if(n==i?e<=i&&t>=n:e<i&&t>n){let r=n+o.border,s=i-o.border;if(e>=r&&t<=s)return this.dirty=e==n||t==i?2:1,void(e!=r||t!=s||!o.contentLost&&o.dom.parentNode==this.contentDOM?o.markDirty(e-r,t-r):o.dirty=3);o.dirty=o.dom!=o.contentDOM||o.dom.parentNode!=this.contentDOM||o.children.length?3:2}n=i}this.dirty=2}markParentsDirty(){let e=1;for(let t=this.parent;t;t=t.parent,e++){let n=1==e?2:1;t.dirty<n&&(t.dirty=n)}}get domAtom(){return!1}get ignoreForCoords(){return!1}}class cr extends lr{constructor(e,t,n,r){let o,i=t.type.toDOM;if("function"==typeof i&&(i=i(n,(()=>o?o.parent?o.parent.posBeforeChild(o):void 0:r))),!t.type.spec.raw){if(1!=i.nodeType){let e=document.createElement("span");e.appendChild(i),i=e}i.contentEditable="false",i.classList.add("ProseMirror-widget")}super(e,[],i,null),this.widget=t,this.widget=t,o=this}matchesWidget(e){return 0==this.dirty&&e.type.eq(this.widget.type)}parseRule(){return{ignore:!0}}stopEvent(e){let t=this.widget.spec.stopEvent;return!!t&&t(e)}ignoreMutation(e){return"selection"!=e.type||this.widget.spec.ignoreSelection}destroy(){this.widget.type.destroy(this.dom),super.destroy()}get domAtom(){return!0}get side(){return this.widget.type.side}}class ur extends lr{constructor(e,t,n,r){super(e,[],t,null),this.textDOM=n,this.text=r}get size(){return this.text.length}localPosFromDOM(e,t){return e!=this.textDOM?this.posAtStart+(t?this.size:0):this.posAtStart+t}domFromPos(e){return{node:this.textDOM,offset:e}}ignoreMutation(e){return"characterData"===e.type&&e.target.nodeValue==e.oldValue}}class dr extends lr{constructor(e,t,n,r){super(e,[],n,r),this.mark=t}static create(e,t,n,r){let o=r.nodeViews[t.type.name],i=o&&o(t,r,n);return i&&i.dom||(i=de.renderSpec(document,t.type.spec.toDOM(t,n))),new dr(e,t,i.dom,i.contentDOM||i.dom)}parseRule(){return 3&this.dirty||this.mark.type.spec.reparseInView?null:{mark:this.mark.type.name,attrs:this.mark.attrs,contentElement:this.contentDOM||void 0}}matchesMark(e){return 3!=this.dirty&&this.mark.eq(e)}markDirty(e,t){if(super.markDirty(e,t),0!=this.dirty){let e=this.parent;for(;!e.node;)e=e.parent;e.dirty<this.dirty&&(e.dirty=this.dirty),this.dirty=0}}slice(e,t,n){let r=dr.create(this.parent,this.mark,!0,n),o=this.children,i=this.size;t<i&&(o=Nr(o,t,i,n)),e>0&&(o=Nr(o,0,e,n));for(let e=0;e<o.length;e++)o[e].parent=r;return r.children=o,r}}class pr extends lr{constructor(e,t,n,r,o,i,s,a,l){super(e,[],o,i),this.node=t,this.outerDeco=n,this.innerDeco=r,this.nodeDOM=s,i&&this.updateChildren(a,l)}static create(e,t,n,r,o,i){let s,a=o.nodeViews[t.type.name],l=a&&a(t,o,(()=>s?s.parent?s.parent.posBeforeChild(s):void 0:i),n,r),c=l&&l.dom,u=l&&l.contentDOM;if(t.isText)if(c){if(3!=c.nodeType)throw new RangeError("Text must be rendered as a DOM text node")}else c=document.createTextNode(t.text);else c||({dom:c,contentDOM:u}=de.renderSpec(document,t.type.spec.toDOM(t)));u||t.isText||"BR"==c.nodeName||(c.hasAttribute("contenteditable")||(c.contentEditable="false"),t.type.spec.draggable&&(c.draggable=!0));let d=c;return c=Cr(c,n,t),l?s=new gr(e,t,n,r,c,u||null,d,l,o,i+1):t.isText?new fr(e,t,n,r,c,d,o):new pr(e,t,n,r,c,u||null,d,o,i+1)}parseRule(){if(this.node.type.spec.reparseInView)return null;let e={node:this.node.type.name,attrs:this.node.attrs};if("pre"==this.node.type.whitespace&&(e.preserveWhitespace="full"),this.contentDOM)if(this.contentLost){for(let t=this.children.length-1;t>=0;t--){let n=this.children[t];if(this.dom.contains(n.dom.parentNode)){e.contentElement=n.dom.parentNode;break}}e.contentElement||(e.getContent=()=>d.empty)}else e.contentElement=this.contentDOM;else e.getContent=()=>this.node.content;return e}matchesNode(e,t,n){return 0==this.dirty&&e.eq(this.node)&&Tr(t,this.outerDeco)&&n.eq(this.innerDeco)}get size(){return this.node.nodeSize}get border(){return this.node.isLeaf?0:1}updateChildren(e,t){let n=this.node.inlineContent,r=t,o=e.composing?this.localCompositionInfo(e,t):null,i=o&&o.pos>-1?o:null,s=o&&o.pos<0,a=new Sr(this,i&&i.node);!function(e,t,n,r){let o=t.locals(e),i=0;if(0==o.length){for(let n=0;n<e.childCount;n++){let s=e.child(n);r(s,o,t.forChild(i,s),n),i+=s.nodeSize}return}let s=0,a=[],l=null;for(let c=0;;){if(s<o.length&&o[s].to==i){let e,t=o[s++];for(;s<o.length&&o[s].to==i;)(e||(e=[t])).push(o[s++]);if(e){e.sort(Er);for(let t=0;t<e.length;t++)n(e[t],c,!!l)}else n(t,c,!!l)}let u,d;if(l)d=-1,u=l,l=null;else{if(!(c<e.childCount))break;d=c,u=e.child(c++)}for(let e=0;e<a.length;e++)a[e].to<=i&&a.splice(e--,1);for(;s<o.length&&o[s].from<=i&&o[s].to>i;)a.push(o[s++]);let p=i+u.nodeSize;if(u.isText){let e=p;s<o.length&&o[s].from<e&&(e=o[s].from);for(let t=0;t<a.length;t++)a[t].to<e&&(e=a[t].to);e<p&&(l=u.cut(e-i),u=u.cut(0,e-i),p=e,d=-1)}r(u,u.isInline&&!u.isLeaf?a.filter((e=>!e.inline)):a.slice(),t.forChild(i,u),d),i=p}}(this.node,this.innerDeco,((t,o,i)=>{t.spec.marks?a.syncToMarks(t.spec.marks,n,e):t.type.side>=0&&!i&&a.syncToMarks(o==this.node.childCount?m.none:this.node.child(o).marks,n,e),a.placeWidget(t,e,r)}),((t,i,l,c)=>{let u;a.syncToMarks(t.marks,n,e),a.findNodeMatch(t,i,l,c)||s&&e.state.selection.from>r&&e.state.selection.to<r+t.nodeSize&&(u=a.findIndexWithChild(o.node))>-1&&a.updateNodeAt(t,i,l,u,e)||a.updateNextNode(t,i,l,e,c)||a.addNode(t,i,l,e,r),r+=t.nodeSize})),a.syncToMarks([],n,e),this.node.isTextblock&&a.addTextblockHacks(),a.destroyRest(),(a.changed||2==this.dirty)&&(i&&this.protectLocalComposition(e,i),vr(this.contentDOM,this.children,e),Tn&&function(e){if("UL"==e.nodeName||"OL"==e.nodeName){let t=e.style.cssText;e.style.cssText=t+"; list-style: square !important",window.getComputedStyle(e).listStyle,e.style.cssText=t}}(this.dom))}localCompositionInfo(e,t){let{from:n,to:r}=e.state.selection;if(!(e.state.selection instanceof Ut)||n<t||r>t+this.node.content.size)return null;let o=e.domSelection(),i=function(e,t){for(;;){if(3==e.nodeType)return e;if(1==e.nodeType&&t>0){if(e.childNodes.length>t&&3==e.childNodes[t].nodeType)return e.childNodes[t];t=Bn(e=e.childNodes[t-1])}else{if(!(1==e.nodeType&&t<e.childNodes.length))return null;e=e.childNodes[t],t=0}}}(o.focusNode,o.focusOffset);if(!i||!this.dom.contains(i.parentNode))return null;if(this.node.inlineContent){let e=i.nodeValue,o=function(e,t,n,r){for(let o=0,i=0;o<e.childCount&&i<=r;){let s=e.child(o++),a=i;if(i+=s.nodeSize,!s.isText)continue;let l=s.text;for(;o<e.childCount;){let t=e.child(o++);if(i+=t.nodeSize,!t.isText)break;l+=t.text}if(i>=n){let e=a<r?l.lastIndexOf(t,r-a-1):-1;if(e>=0&&e+t.length+a>=n)return a+e;if(n==r&&l.length>=r+t.length-a&&l.slice(r-a,r-a+t.length)==t)return r}}return-1}(this.node.content,e,n-t,r-t);return o<0?null:{node:i,pos:o,text:e}}return{node:i,pos:-1,text:""}}protectLocalComposition(e,{node:t,pos:n,text:r}){if(this.getDesc(t))return;let o=t;for(;o.parentNode!=this.contentDOM;o=o.parentNode){for(;o.previousSibling;)o.parentNode.removeChild(o.previousSibling);for(;o.nextSibling;)o.parentNode.removeChild(o.nextSibling);o.pmViewDesc&&(o.pmViewDesc=void 0)}let i=new ur(this,o,t,r);e.input.compositionNodes.push(i),this.children=Nr(this.children,n,n+r.length,e,i)}update(e,t,n,r){return!(3==this.dirty||!e.sameMarkup(this.node))&&(this.updateInner(e,t,n,r),!0)}updateInner(e,t,n,r){this.updateOuterDeco(t),this.node=e,this.innerDeco=n,this.contentDOM&&this.updateChildren(r,this.posAtStart),this.dirty=0}updateOuterDeco(e){if(Tr(e,this.outerDeco))return;let t=1!=this.nodeDOM.nodeType,n=this.dom;this.dom=kr(this.dom,this.nodeDOM,wr(this.outerDeco,this.node,t),wr(e,this.node,t)),this.dom!=n&&(n.pmViewDesc=void 0,this.dom.pmViewDesc=this),this.outerDeco=e}selectNode(){1==this.nodeDOM.nodeType&&this.nodeDOM.classList.add("ProseMirror-selectednode"),!this.contentDOM&&this.node.type.spec.draggable||(this.dom.draggable=!0)}deselectNode(){1==this.nodeDOM.nodeType&&this.nodeDOM.classList.remove("ProseMirror-selectednode"),!this.contentDOM&&this.node.type.spec.draggable||this.dom.removeAttribute("draggable")}get domAtom(){return this.node.isAtom}}function hr(e,t,n,r,o){return Cr(r,t,e),new pr(void 0,e,t,n,r,r,r,o,0)}class fr extends pr{constructor(e,t,n,r,o,i,s){super(e,t,n,r,o,null,i,s,0)}parseRule(){let e=this.nodeDOM.parentNode;for(;e&&e!=this.dom&&!e.pmIsDeco;)e=e.parentNode;return{skip:e||!0}}update(e,t,n,r){return!(3==this.dirty||0!=this.dirty&&!this.inParent()||!e.sameMarkup(this.node))&&(this.updateOuterDeco(t),0==this.dirty&&e.text==this.node.text||e.text==this.nodeDOM.nodeValue||(this.nodeDOM.nodeValue=e.text,r.trackWrites==this.nodeDOM&&(r.trackWrites=null)),this.node=e,this.dirty=0,!0)}inParent(){let e=this.parent.contentDOM;for(let t=this.nodeDOM;t;t=t.parentNode)if(t==e)return!0;return!1}domFromPos(e){return{node:this.nodeDOM,offset:e}}localPosFromDOM(e,t,n){return e==this.nodeDOM?this.posAtStart+Math.min(t,this.node.text.length):super.localPosFromDOM(e,t,n)}ignoreMutation(e){return"characterData"!=e.type&&"selection"!=e.type}slice(e,t,n){let r=this.node.cut(e,t),o=document.createTextNode(r.text);return new fr(this.parent,r,this.outerDeco,this.innerDeco,o,o,n)}markDirty(e,t){super.markDirty(e,t),this.dom==this.nodeDOM||0!=e&&t!=this.nodeDOM.nodeValue.length||(this.dirty=3)}get domAtom(){return!1}}class mr extends lr{parseRule(){return{ignore:!0}}matchesHack(e){return 0==this.dirty&&this.dom.nodeName==e}get domAtom(){return!0}get ignoreForCoords(){return"IMG"==this.dom.nodeName}}class gr extends pr{constructor(e,t,n,r,o,i,s,a,l,c){super(e,t,n,r,o,i,s,l,c),this.spec=a}update(e,t,n,r){if(3==this.dirty)return!1;if(this.spec.update){let o=this.spec.update(e,t,n);return o&&this.updateInner(e,t,n,r),o}return!(!this.contentDOM&&!e.isLeaf)&&super.update(e,t,n,r)}selectNode(){this.spec.selectNode?this.spec.selectNode():super.selectNode()}deselectNode(){this.spec.deselectNode?this.spec.deselectNode():super.deselectNode()}setSelection(e,t,n,r){this.spec.setSelection?this.spec.setSelection(e,t,n):super.setSelection(e,t,n,r)}destroy(){this.spec.destroy&&this.spec.destroy(),super.destroy()}stopEvent(e){return!!this.spec.stopEvent&&this.spec.stopEvent(e)}ignoreMutation(e){return this.spec.ignoreMutation?this.spec.ignoreMutation(e):super.ignoreMutation(e)}}function vr(e,t,n){let r=e.firstChild,o=!1;for(let i=0;i<t.length;i++){let s=t[i],a=s.dom;if(a.parentNode==e){for(;a!=r;)r=Mr(r),o=!0;r=r.nextSibling}else o=!0,e.insertBefore(a,r);if(s instanceof dr){let t=r?r.previousSibling:e.lastChild;vr(s.contentDOM,s.children,n),r=t?t.nextSibling:e.firstChild}}for(;r;)r=Mr(r),o=!0;o&&n.trackWrites==e&&(n.trackWrites=null)}const yr=function(e){e&&(this.nodeName=e)};yr.prototype=Object.create(null);const br=[new yr];function wr(e,t,n){if(0==e.length)return br;let r=n?br[0]:new yr,o=[r];for(let i=0;i<e.length;i++){let s=e[i].type.attrs;if(s){s.nodeName&&o.push(r=new yr(s.nodeName));for(let e in s){let i=s[e];null!=i&&(n&&1==o.length&&o.push(r=new yr(t.isInline?"span":"div")),"class"==e?r.class=(r.class?r.class+" ":"")+i:"style"==e?r.style=(r.style?r.style+";":"")+i:"nodeName"!=e&&(r[e]=i))}}}return o}function kr(e,t,n,r){if(n==br&&r==br)return t;let o=t;for(let t=0;t<r.length;t++){let i=r[t],s=n[t];if(t){let t;s&&s.nodeName==i.nodeName&&o!=e&&(t=o.parentNode)&&t.nodeName.toLowerCase()==i.nodeName||(t=document.createElement(i.nodeName),t.pmIsDeco=!0,t.appendChild(o),s=br[0]),o=t}xr(o,s||br[0],i)}return o}function xr(e,t,n){for(let r in t)"class"==r||"style"==r||"nodeName"==r||r in n||e.removeAttribute(r);for(let r in n)"class"!=r&&"style"!=r&&"nodeName"!=r&&n[r]!=t[r]&&e.setAttribute(r,n[r]);if(t.class!=n.class){let r=t.class?t.class.split(" ").filter(Boolean):[],o=n.class?n.class.split(" ").filter(Boolean):[];for(let t=0;t<r.length;t++)-1==o.indexOf(r[t])&&e.classList.remove(r[t]);for(let t=0;t<o.length;t++)-1==r.indexOf(o[t])&&e.classList.add(o[t]);0==e.classList.length&&e.removeAttribute("class")}if(t.style!=n.style){if(t.style){let n,r=/\s*([\w\-\xa1-\uffff]+)\s*:(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|\(.*?\)|[^;])*/g;for(;n=r.exec(t.style);)e.style.removeProperty(n[1])}n.style&&(e.style.cssText+=n.style)}}function Cr(e,t,n){return kr(e,e,br,wr(t,n,1!=e.nodeType))}function Tr(e,t){if(e.length!=t.length)return!1;for(let n=0;n<e.length;n++)if(!e[n].type.eq(t[n].type))return!1;return!0}function Mr(e){let t=e.nextSibling;return e.parentNode.removeChild(e),t}class Sr{constructor(e,t){this.lock=t,this.index=0,this.stack=[],this.changed=!1,this.top=e,this.preMatch=function(e,t){let n=t,r=n.children.length,o=e.childCount,i=new Map,s=[];e:for(;o>0;){let a;for(;;)if(r){let e=n.children[r-1];if(!(e instanceof dr)){a=e,r--;break}n=e,r=e.children.length}else{if(n==t)break e;r=n.parent.children.indexOf(n),n=n.parent}let l=a.node;if(l){if(l!=e.child(o-1))break;--o,i.set(a,o),s.push(a)}}return{index:o,matched:i,matches:s.reverse()}}(e.node.content,e)}destroyBetween(e,t){if(e!=t){for(let n=e;n<t;n++)this.top.children[n].destroy();this.top.children.splice(e,t-e),this.changed=!0}}destroyRest(){this.destroyBetween(this.index,this.top.children.length)}syncToMarks(e,t,n){let r=0,o=this.stack.length>>1,i=Math.min(o,e.length);for(;r<i&&(r==o-1?this.top:this.stack[r+1<<1]).matchesMark(e[r])&&!1!==e[r].type.spec.spanning;)r++;for(;r<o;)this.destroyRest(),this.top.dirty=0,this.index=this.stack.pop(),this.top=this.stack.pop(),o--;for(;o<e.length;){this.stack.push(this.top,this.index+1);let r=-1;for(let t=this.index;t<Math.min(this.index+3,this.top.children.length);t++)if(this.top.children[t].matchesMark(e[o])){r=t;break}if(r>-1)r>this.index&&(this.changed=!0,this.destroyBetween(this.index,r)),this.top=this.top.children[this.index];else{let r=dr.create(this.top,e[o],t,n);this.top.children.splice(this.index,0,r),this.top=r,this.changed=!0}this.index=0,o++}}findNodeMatch(e,t,n,r){let o,i=-1;if(r>=this.preMatch.index&&(o=this.preMatch.matches[r-this.preMatch.index]).parent==this.top&&o.matchesNode(e,t,n))i=this.top.children.indexOf(o,this.index);else for(let r=this.index,o=Math.min(this.top.children.length,r+5);r<o;r++){let o=this.top.children[r];if(o.matchesNode(e,t,n)&&!this.preMatch.matched.has(o)){i=r;break}}return!(i<0)&&(this.destroyBetween(this.index,i),this.index++,!0)}updateNodeAt(e,t,n,r,o){let i=this.top.children[r];return 3==i.dirty&&i.dom==i.contentDOM&&(i.dirty=2),!!i.update(e,t,n,o)&&(this.destroyBetween(this.index,r),this.index++,!0)}findIndexWithChild(e){for(;;){let t=e.parentNode;if(!t)return-1;if(t==this.top.contentDOM){let t=e.pmViewDesc;if(t)for(let e=this.index;e<this.top.children.length;e++)if(this.top.children[e]==t)return e;return-1}e=t}}updateNextNode(e,t,n,r,o){for(let i=this.index;i<this.top.children.length;i++){let s=this.top.children[i];if(s instanceof pr){let a=this.preMatch.matched.get(s);if(null!=a&&a!=o)return!1;let l=s.dom;if(!(this.lock&&(l==this.lock||1==l.nodeType&&l.contains(this.lock.parentNode))&&!(e.isText&&s.node&&s.node.isText&&s.nodeDOM.nodeValue==e.text&&3!=s.dirty&&Tr(t,s.outerDeco)))&&s.update(e,t,n,r))return this.destroyBetween(this.index,i),s.dom!=l&&(this.changed=!0),this.index++,!0;break}}return!1}addNode(e,t,n,r,o){this.top.children.splice(this.index++,0,pr.create(this.top,e,t,n,r,o)),this.changed=!0}placeWidget(e,t,n){let r=this.index<this.top.children.length?this.top.children[this.index]:null;if(!r||!r.matchesWidget(e)||e!=r.widget&&r.widget.type.toDOM.parentNode){let r=new cr(this.top,e,t,n);this.top.children.splice(this.index++,0,r),this.changed=!0}else this.index++}addTextblockHacks(){let e=this.top.children[this.index-1],t=this.top;for(;e instanceof dr;)t=e,e=t.children[t.children.length-1];e&&e instanceof fr&&!/\n$/.test(e.node.text)||((Cn||kn)&&e&&"false"==e.dom.contentEditable&&this.addHackNode("IMG",t),this.addHackNode("BR",this.top))}addHackNode(e,t){if(t==this.top&&this.index<t.children.length&&t.children[this.index].matchesHack(e))this.index++;else{let n=document.createElement(e);"IMG"==e&&(n.className="ProseMirror-separator",n.alt=""),"BR"==e&&(n.className="ProseMirror-trailingBreak");let r=new mr(this.top,[],n,null);t!=this.top?t.children.push(r):t.children.splice(this.index++,0,r),this.changed=!0}}}function Er(e,t){return e.type.side-t.type.side}function Nr(e,t,n,r,o){let i=[];for(let s=0,a=0;s<e.length;s++){let l=e[s],c=a,u=a+=l.size;c>=n||u<=t?i.push(l):(c<t&&i.push(l.slice(0,t-c,r)),o&&(i.push(o),o=void 0),u>n&&i.push(l.slice(n-c,l.size,r)))}return i}function Or(e,t=null){let n=e.domSelection(),r=e.state.doc;if(!n.focusNode)return null;let o=e.docView.nearestDesc(n.focusNode),i=o&&0==o.size,s=e.docView.posFromDOM(n.focusNode,n.focusOffset,1);if(s<0)return null;let a,l,c=r.resolve(s);if(Hn(n)){for(a=c;o&&!o.node;)o=o.parent;let e=o.node;if(o&&e.isAtom&&Jt.isSelectable(e)&&o.parent&&(!e.isInline||!function(e,t,n){for(let r=0==t,o=t==Bn(e);r||o;){if(e==n)return!0;let t=On(e);if(!(e=e.parentNode))return!1;r=r&&0==t,o=o&&t==Bn(e)}}(n.focusNode,n.focusOffset,o.dom))){let e=o.posBefore;l=new Jt(s==e?c:r.resolve(e))}}else{let t=e.docView.posFromDOM(n.anchorNode,n.anchorOffset,1);if(t<0)return null;a=r.resolve(t)}if(!l){l=Hr(e,a,c,"pointer"==t||e.state.selection.head<c.pos&&!i?1:-1)}return l}function Dr(e){return e.editable?e.hasFocus():qr(e)&&document.activeElement&&document.activeElement.contains(e.dom)}function Ar(e,t=!1){let n=e.state.selection;if(Br(e,n),Dr(e)){if(!t&&e.input.mouseDown&&e.input.mouseDown.allowDefault&&kn){let t=e.domSelection(),n=e.domObserver.currentSelection;if(t.anchorNode&&n.anchorNode&&In(t.anchorNode,t.anchorOffset,n.anchorNode,n.anchorOffset))return e.input.mouseDown.delayedSelectionSync=!0,void e.domObserver.setCurSelection()}if(e.domObserver.disconnectSelection(),e.cursorWrapper)!function(e){let t=e.domSelection(),n=document.createRange(),r=e.cursorWrapper.dom,o="IMG"==r.nodeName;o?n.setEnd(r.parentNode,On(r)+1):n.setEnd(r,0);n.collapse(!1),t.removeAllRanges(),t.addRange(n),!o&&!e.state.selection.visible&&vn&&yn<=11&&(r.disabled=!0,r.disabled=!1)}(e);else{let r,o,{anchor:i,head:s}=n;!Lr||n instanceof Ut||(n.$from.parent.inlineContent||(r=Ir(e,n.from)),n.empty||n.$from.parent.inlineContent||(o=Ir(e,n.to))),e.docView.setSelection(i,s,e.root,t),Lr&&(r&&Pr(r),o&&Pr(o)),n.visible?e.dom.classList.remove("ProseMirror-hideselection"):(e.dom.classList.add("ProseMirror-hideselection"),"onselectionchange"in document&&function(e){let t=e.dom.ownerDocument;t.removeEventListener("selectionchange",e.input.hideSelectionGuard);let n=e.domSelection(),r=n.anchorNode,o=n.anchorOffset;t.addEventListener("selectionchange",e.input.hideSelectionGuard=()=>{n.anchorNode==r&&n.anchorOffset==o||(t.removeEventListener("selectionchange",e.input.hideSelectionGuard),setTimeout((()=>{Dr(e)&&!e.state.selection.visible||e.dom.classList.remove("ProseMirror-hideselection")}),20))})}(e))}e.domObserver.setCurSelection(),e.domObserver.connectSelection()}}const Lr=Cn||kn&&xn<63;function Ir(e,t){let{node:n,offset:r}=e.docView.domFromPos(t,0),o=r<n.childNodes.length?n.childNodes[r]:null,i=r?n.childNodes[r-1]:null;if(Cn&&o&&"false"==o.contentEditable)return Rr(o);if(!(o&&"false"!=o.contentEditable||i&&"false"!=i.contentEditable)){if(o)return Rr(o);if(i)return Rr(i)}}function Rr(e){return e.contentEditable="true",Cn&&e.draggable&&(e.draggable=!1,e.wasDraggable=!0),e}function Pr(e){e.contentEditable="false",e.wasDraggable&&(e.draggable=!0,e.wasDraggable=null)}function Br(e,t){if(t instanceof Jt){let n=e.docView.descAt(t.from);n!=e.lastSelectedViewDesc&&(Fr(e),n&&n.selectNode(),e.lastSelectedViewDesc=n)}else Fr(e)}function Fr(e){e.lastSelectedViewDesc&&(e.lastSelectedViewDesc.parent&&e.lastSelectedViewDesc.deselectNode(),e.lastSelectedViewDesc=void 0)}function Hr(e,t,n,r){return e.someProp("createSelectionBetween",(r=>r(e,t,n)))||Ut.between(t,n,r)}function zr(e){return(!e.editable||e.root.activeElement==e.dom)&&qr(e)}function qr(e){let t=e.domSelection();if(!t.anchorNode)return!1;try{return e.dom.contains(3==t.anchorNode.nodeType?t.anchorNode.parentNode:t.anchorNode)&&(e.editable||e.dom.contains(3==t.focusNode.nodeType?t.focusNode.parentNode:t.focusNode))}catch(e){return!1}}function Vr(e,t){let{$anchor:n,$head:r}=e.selection,o=t>0?n.max(r):n.min(r),i=o.parent.inlineContent?o.depth?e.doc.resolve(t>0?o.after():o.before()):null:o;return i&&Vt.findFrom(i,t)}function jr(e,t){return e.dispatch(e.state.tr.setSelection(t).scrollIntoView()),!0}function $r(e,t,n){let r=e.state.selection;if(!(r instanceof Ut)){if(r instanceof Jt&&r.node.isInline)return jr(e,new Ut(t>0?r.$to:r.$from));{let n=Vr(e.state,t);return!!n&&jr(e,n)}}if(!r.empty||n.indexOf("s")>-1)return!1;if(e.endOfTextblock(t>0?"right":"left")){let n=Vr(e.state,t);return!!(n&&n instanceof Jt)&&jr(e,n)}if(!(Mn&&n.indexOf("m")>-1)){let n,o=r.$head,i=o.textOffset?null:t<0?o.nodeBefore:o.nodeAfter;if(!i||i.isText)return!1;let s=t<0?o.pos-i.nodeSize:o.pos;return!!(i.isAtom||(n=e.docView.descAt(s))&&!n.contentDOM)&&(Jt.isSelectable(i)?jr(e,new Jt(t<0?e.state.doc.resolve(o.pos-i.nodeSize):o)):!!En&&jr(e,new Ut(e.state.doc.resolve(t<0?s:s+i.nodeSize))))}}function _r(e){return 3==e.nodeType?e.nodeValue.length:e.childNodes.length}function Ur(e){let t=e.pmViewDesc;return t&&0==t.size&&(e.nextSibling||"BR"!=e.nodeName)}function Wr(e){let t=e.domSelection(),n=t.focusNode,r=t.focusOffset;if(!n)return;let o,i,s=!1;for(bn&&1==n.nodeType&&r<_r(n)&&Ur(n.childNodes[r])&&(s=!0);;)if(r>0){if(1!=n.nodeType)break;{let e=n.childNodes[r-1];if(Ur(e))o=n,i=--r;else{if(3!=e.nodeType)break;n=e,r=n.nodeValue.length}}}else{if(Gr(n))break;{let t=n.previousSibling;for(;t&&Ur(t);)o=n.parentNode,i=On(t),t=t.previousSibling;if(t)n=t,r=_r(n);else{if(n=n.parentNode,n==e.dom)break;r=0}}}s?Kr(e,t,n,r):o&&Kr(e,t,o,i)}function Jr(e){let t=e.domSelection(),n=t.focusNode,r=t.focusOffset;if(!n)return;let o,i,s=_r(n);for(;;)if(r<s){if(1!=n.nodeType)break;if(!Ur(n.childNodes[r]))break;o=n,i=++r}else{if(Gr(n))break;{let t=n.nextSibling;for(;t&&Ur(t);)o=t.parentNode,i=On(t)+1,t=t.nextSibling;if(t)n=t,r=0,s=_r(n);else{if(n=n.parentNode,n==e.dom)break;r=s=0}}}o&&Kr(e,t,o,i)}function Gr(e){let t=e.pmViewDesc;return t&&t.node&&t.node.isBlock}function Kr(e,t,n,r){if(Hn(t)){let e=document.createRange();e.setEnd(n,r),e.setStart(n,r),t.removeAllRanges(),t.addRange(e)}else t.extend&&t.extend(n,r);e.domObserver.setCurSelection();let{state:o}=e;setTimeout((()=>{e.state==o&&Ar(e)}),50)}function Zr(e,t,n){let r=e.state.selection;if(r instanceof Ut&&!r.empty||n.indexOf("s")>-1)return!1;if(Mn&&n.indexOf("m")>-1)return!1;let{$from:o,$to:i}=r;if(!o.parent.inlineContent||e.endOfTextblock(t<0?"up":"down")){let n=Vr(e.state,t);if(n&&n instanceof Jt)return jr(e,n)}if(!o.parent.inlineContent){let n=t<0?o:i,s=r instanceof Kt?Vt.near(n,t):Vt.findFrom(n,t);return!!s&&jr(e,s)}return!1}function Xr(e,t){if(!(e.state.selection instanceof Ut))return!0;let{$head:n,$anchor:r,empty:o}=e.state.selection;if(!n.sameParent(r))return!0;if(!o)return!1;if(e.endOfTextblock(t>0?"forward":"backward"))return!0;let i=!n.textOffset&&(t<0?n.nodeBefore:n.nodeAfter);if(i&&!i.isText){let r=e.state.tr;return t<0?r.delete(n.pos-i.nodeSize,n.pos):r.delete(n.pos,n.pos+i.nodeSize),e.dispatch(r),!0}return!1}function Qr(e,t,n){e.domObserver.stop(),t.contentEditable=n,e.domObserver.start()}function Yr(e,t){let n=t.keyCode,r=function(e){let t="";return e.ctrlKey&&(t+="c"),e.metaKey&&(t+="m"),e.altKey&&(t+="a"),e.shiftKey&&(t+="s"),t}(t);return 8==n||Mn&&72==n&&"c"==r?Xr(e,-1)||Wr(e):46==n||Mn&&68==n&&"c"==r?Xr(e,1)||Jr(e):13==n||27==n||(37==n||Mn&&66==n&&"c"==r?$r(e,-1,r)||Wr(e):39==n||Mn&&70==n&&"c"==r?$r(e,1,r)||Jr(e):38==n||Mn&&80==n&&"c"==r?Zr(e,-1,r)||Wr(e):40==n||Mn&&78==n&&"c"==r?function(e){if(!Cn||e.state.selection.$head.parentOffset>0)return!1;let{focusNode:t,focusOffset:n}=e.domSelection();if(t&&1==t.nodeType&&0==n&&t.firstChild&&"false"==t.firstChild.contentEditable){let n=t.firstChild;Qr(e,n,"true"),setTimeout((()=>Qr(e,n,"false")),20)}return!1}(e)||Zr(e,1,r)||Jr(e):r==(Mn?"m":"c")&&(66==n||73==n||89==n||90==n))}function eo(e,t){let n=[],{content:r,openStart:o,openEnd:i}=t;for(;o>1&&i>1&&1==r.childCount&&1==r.firstChild.childCount;){o--,i--;let e=r.firstChild;n.push(e.type.name,e.attrs!=e.type.defaultAttrs?e.attrs:null),r=e.content}let s=e.someProp("clipboardSerializer")||de.fromSchema(e.state.schema),a=uo(),l=a.createElement("div");l.appendChild(s.serializeFragment(r,{document:a}));let c,u=l.firstChild,d=0;for(;u&&1==u.nodeType&&(c=lo[u.nodeName.toLowerCase()]);){for(let e=c.length-1;e>=0;e--){let t=a.createElement(c[e]);for(;l.firstChild;)t.appendChild(l.firstChild);l.appendChild(t),d++}u=l.firstChild}return u&&1==u.nodeType&&u.setAttribute("data-pm-slice",`${o} ${i}${d?` -${d}`:""} ${JSON.stringify(n)}`),{dom:l,text:e.someProp("clipboardTextSerializer",(e=>e(t)))||t.content.textBetween(0,t.content.size,"\n\n")}}function to(e,t,n,r,o){let i,s,a=o.parent.type.spec.code;if(!n&&!t)return null;let l=t&&(r||a||!n);if(l){if(e.someProp("transformPastedText",(e=>{t=e(t,a||r)})),a)return t?new v(d.from(e.state.schema.text(t.replace(/\r\n?/g,"\n"))),0,0):v.empty;let n=e.someProp("clipboardTextParser",(e=>e(t,o,r)));if(n)s=n;else{let n=o.marks(),{schema:r}=e.state,s=de.fromSchema(r);i=document.createElement("div"),t.split(/(?:\r\n?|\n)+/).forEach((e=>{let t=i.appendChild(document.createElement("p"));e&&t.appendChild(s.serializeNode(r.text(e,n)))}))}}else e.someProp("transformPastedHTML",(e=>{n=e(n)})),i=function(e){let t=/^(\s*<meta [^>]*>)*/.exec(e);t&&(e=e.slice(t[0].length));let n,r=uo().createElement("div"),o=/<([a-z][^>\s]+)/i.exec(e);(n=o&&lo[o[1].toLowerCase()])&&(e=n.map((e=>"<"+e+">")).join("")+e+n.map((e=>"</"+e+">")).reverse().join(""));if(r.innerHTML=e,n)for(let e=0;e<n.length;e++)r=r.querySelector(n[e])||r;return r}(n),En&&function(e){let t=e.querySelectorAll(kn?"span:not([class]):not([style])":"span.Apple-converted-space");for(let n=0;n<t.length;n++){let r=t[n];1==r.childNodes.length&&" "==r.textContent&&r.parentNode&&r.parentNode.replaceChild(e.ownerDocument.createTextNode(" "),r)}}(i);let c=i&&i.querySelector("[data-pm-slice]"),u=c&&/^(\d+) (\d+)(?: -(\d+))? (.*)/.exec(c.getAttribute("data-pm-slice")||"");if(u&&u[3])for(let e=+u[3];e>0&&i.firstChild;e--)i=i.firstChild;if(!s){let t=e.someProp("clipboardParser")||e.someProp("domParser")||te.fromSchema(e.state.schema);s=t.parseSlice(i,{preserveWhitespace:!(!l&&!u),context:o,ruleFromNode:e=>"BR"!=e.nodeName||e.nextSibling||!e.parentNode||no.test(e.parentNode.nodeName)?null:{ignore:!0}})}if(u)s=function(e,t){if(!e.size)return e;let n,r=e.content.firstChild.type.schema;try{n=JSON.parse(t)}catch(t){return e}let{content:o,openStart:i,openEnd:s}=e;for(let e=n.length-2;e>=0;e-=2){let t=r.nodes[n[e]];if(!t||t.hasRequiredAttrs())break;o=d.from(t.create(n[e+1],o)),i++,s++}return new v(o,i,s)}(ao(s,+u[1],+u[2]),u[4]);else if(s=v.maxOpen(function(e,t){if(e.childCount<2)return e;for(let n=t.depth;n>=0;n--){let r,o=t.node(n).contentMatchAt(t.index(n)),i=[];if(e.forEach((e=>{if(!i)return;let t,n=o.findWrapping(e.type);if(!n)return i=null;if(t=i.length&&r.length&&oo(n,r,e,i[i.length-1],0))i[i.length-1]=t;else{i.length&&(i[i.length-1]=io(i[i.length-1],r.length));let t=ro(e,n);i.push(t),o=o.matchType(t.type),r=n}})),i)return d.from(i)}return e}(s.content,o),!0),s.openStart||s.openEnd){let e=0,t=0;for(let t=s.content.firstChild;e<s.openStart&&!t.type.spec.isolating;e++,t=t.firstChild);for(let e=s.content.lastChild;t<s.openEnd&&!e.type.spec.isolating;t++,e=e.lastChild);s=ao(s,e,t)}return e.someProp("transformPasted",(e=>{s=e(s)})),s}const no=/^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var)$/i;function ro(e,t,n=0){for(let r=t.length-1;r>=n;r--)e=t[r].create(null,d.from(e));return e}function oo(e,t,n,r,o){if(o<e.length&&o<t.length&&e[o]==t[o]){let i=oo(e,t,n,r.lastChild,o+1);if(i)return r.copy(r.content.replaceChild(r.childCount-1,i));if(r.contentMatchAt(r.childCount).matchType(o==e.length-1?n.type:e[o+1]))return r.copy(r.content.append(d.from(ro(n,e,o+1))))}}function io(e,t){if(0==t)return e;let n=e.content.replaceChild(e.childCount-1,io(e.lastChild,t-1)),r=e.contentMatchAt(e.childCount).fillBefore(d.empty,!0);return e.copy(n.append(r))}function so(e,t,n,r,o,i){let s=t<0?e.firstChild:e.lastChild,a=s.content;return o<r-1&&(a=so(a,t,n,r,o+1,i)),o>=n&&(a=t<0?s.contentMatchAt(0).fillBefore(a,e.childCount>1||i<=o).append(a):a.append(s.contentMatchAt(s.childCount).fillBefore(d.empty,!0))),e.replaceChild(t<0?0:e.childCount-1,s.copy(a))}function ao(e,t,n){return t<e.openStart&&(e=new v(so(e.content,-1,t,e.openStart,0,e.openEnd),t,e.openEnd)),n<e.openEnd&&(e=new v(so(e.content,1,n,e.openEnd,0,0),e.openStart,n)),e}const lo={thead:["table"],tbody:["table"],tfoot:["table"],caption:["table"],colgroup:["table"],col:["table","colgroup"],tr:["table","tbody"],td:["table","tbody","tr"],th:["table","tbody","tr"]};let co=null;function uo(){return co||(co=document.implementation.createHTMLDocument("title"))}const po={};let ho={};class fo{constructor(){this.shiftKey=!1,this.mouseDown=null,this.lastKeyCode=null,this.lastKeyCodeTime=0,this.lastClick={time:0,x:0,y:0,type:""},this.lastSelectionOrigin=null,this.lastSelectionTime=0,this.lastIOSEnter=0,this.lastIOSEnterFallbackTimeout=-1,this.lastAndroidDelete=0,this.composing=!1,this.composingTimeout=-1,this.compositionNodes=[],this.compositionEndedAt=-2e8,this.domChangeCount=0,this.eventHandlers=Object.create(null),this.hideSelectionGuard=null}}function mo(e,t){e.input.lastSelectionOrigin=t,e.input.lastSelectionTime=Date.now()}function go(e){e.someProp("handleDOMEvents",(t=>{for(let n in t)e.input.eventHandlers[n]||e.dom.addEventListener(n,e.input.eventHandlers[n]=t=>vo(e,t))}))}function vo(e,t){return e.someProp("handleDOMEvents",(n=>{let r=n[t.type];return!!r&&(r(e,t)||t.defaultPrevented)}))}function yo(e,t){if(!t.bubbles)return!0;if(t.defaultPrevented)return!1;for(let n=t.target;n!=e.dom;n=n.parentNode)if(!n||11==n.nodeType||n.pmViewDesc&&n.pmViewDesc.stopEvent(t))return!1;return!0}function bo(e){return{left:e.clientX,top:e.clientY}}function wo(e,t,n,r,o){if(-1==r)return!1;let i=e.state.doc.resolve(r);for(let r=i.depth+1;r>0;r--)if(e.someProp(t,(t=>r>i.depth?t(e,n,i.nodeAfter,i.before(r),o,!0):t(e,n,i.node(r),i.before(r),o,!1))))return!0;return!1}function ko(e,t,n){e.focused||e.focus();let r=e.state.tr.setSelection(t);"pointer"==n&&r.setMeta("pointer",!0),e.dispatch(r)}function xo(e,t,n,r,o){return wo(e,"handleClickOn",t,n,r)||e.someProp("handleClick",(n=>n(e,t,r)))||(o?function(e,t){if(-1==t)return!1;let n,r,o=e.state.selection;o instanceof Jt&&(n=o.node);let i=e.state.doc.resolve(t);for(let e=i.depth+1;e>0;e--){let t=e>i.depth?i.nodeAfter:i.node(e);if(Jt.isSelectable(t)){r=n&&o.$from.depth>0&&e>=o.$from.depth&&i.before(o.$from.depth+1)==o.$from.pos?i.before(o.$from.depth):i.before(e);break}}return null!=r&&(ko(e,Jt.create(e.state.doc,r),"pointer"),!0)}(e,n):function(e,t){if(-1==t)return!1;let n=e.state.doc.resolve(t),r=n.nodeAfter;return!!(r&&r.isAtom&&Jt.isSelectable(r))&&(ko(e,new Jt(n),"pointer"),!0)}(e,n))}function Co(e,t,n,r){return wo(e,"handleDoubleClickOn",t,n,r)||e.someProp("handleDoubleClick",(n=>n(e,t,r)))}function To(e,t,n,r){return wo(e,"handleTripleClickOn",t,n,r)||e.someProp("handleTripleClick",(n=>n(e,t,r)))||function(e,t,n){if(0!=n.button)return!1;let r=e.state.doc;if(-1==t)return!!r.inlineContent&&(ko(e,Ut.create(r,0,r.content.size),"pointer"),!0);let o=r.resolve(t);for(let t=o.depth+1;t>0;t--){let n=t>o.depth?o.nodeAfter:o.node(t),i=o.before(t);if(n.inlineContent)ko(e,Ut.create(r,i+1,i+1+n.content.size),"pointer");else{if(!Jt.isSelectable(n))continue;ko(e,Jt.create(r,i),"pointer")}return!0}}(e,n,r)}function Mo(e){return Lo(e)}ho.keydown=(e,t)=>{let n=t;if(e.input.shiftKey=16==n.keyCode||n.shiftKey,!No(e,n)&&(e.input.lastKeyCode=n.keyCode,e.input.lastKeyCodeTime=Date.now(),!Sn||!kn||13!=n.keyCode))if(229!=n.keyCode&&e.domObserver.forceFlush(),!Tn||13!=n.keyCode||n.ctrlKey||n.altKey||n.metaKey)e.someProp("handleKeyDown",(t=>t(e,n)))||Yr(e,n)?n.preventDefault():mo(e,"key");else{let t=Date.now();e.input.lastIOSEnter=t,e.input.lastIOSEnterFallbackTimeout=setTimeout((()=>{e.input.lastIOSEnter==t&&(e.someProp("handleKeyDown",(t=>t(e,zn(13,"Enter")))),e.input.lastIOSEnter=0)}),200)}},ho.keyup=(e,t)=>{16==t.keyCode&&(e.input.shiftKey=!1)},ho.keypress=(e,t)=>{let n=t;if(No(e,n)||!n.charCode||n.ctrlKey&&!n.altKey||Mn&&n.metaKey)return;if(e.someProp("handleKeyPress",(t=>t(e,n))))return void n.preventDefault();let r=e.state.selection;if(!(r instanceof Ut&&r.$from.sameParent(r.$to))){let t=String.fromCharCode(n.charCode);e.someProp("handleTextInput",(n=>n(e,r.$from.pos,r.$to.pos,t)))||e.dispatch(e.state.tr.insertText(t).scrollIntoView()),n.preventDefault()}};const So=Mn?"metaKey":"ctrlKey";po.mousedown=(e,t)=>{let n=t;e.input.shiftKey=n.shiftKey;let r=Mo(e),o=Date.now(),i="singleClick";o-e.input.lastClick.time<500&&function(e,t){let n=t.x-e.clientX,r=t.y-e.clientY;return n*n+r*r<100}(n,e.input.lastClick)&&!n[So]&&("singleClick"==e.input.lastClick.type?i="doubleClick":"doubleClick"==e.input.lastClick.type&&(i="tripleClick")),e.input.lastClick={time:o,x:n.clientX,y:n.clientY,type:i};let s=e.posAtCoords(bo(n));s&&("singleClick"==i?(e.input.mouseDown&&e.input.mouseDown.done(),e.input.mouseDown=new Eo(e,s,n,!!r)):("doubleClick"==i?Co:To)(e,s.pos,s.inside,n)?n.preventDefault():mo(e,"pointer"))};class Eo{constructor(e,t,n,r){let o,i;if(this.view=e,this.pos=t,this.event=n,this.flushed=r,this.delayedSelectionSync=!1,this.mightDrag=null,this.startDoc=e.state.doc,this.selectNode=!!n[So],this.allowDefault=n.shiftKey,t.inside>-1)o=e.state.doc.nodeAt(t.inside),i=t.inside;else{let n=e.state.doc.resolve(t.pos);o=n.parent,i=n.depth?n.before():0}const s=r?null:n.target,a=s?e.docView.nearestDesc(s,!0):null;this.target=a?a.dom:null;let{selection:l}=e.state;(0==n.button&&o.type.spec.draggable&&!1!==o.type.spec.selectable||l instanceof Jt&&l.from<=i&&l.to>i)&&(this.mightDrag={node:o,pos:i,addAttr:!(!this.target||this.target.draggable),setUneditable:!(!this.target||!bn||this.target.hasAttribute("contentEditable"))}),this.target&&this.mightDrag&&(this.mightDrag.addAttr||this.mightDrag.setUneditable)&&(this.view.domObserver.stop(),this.mightDrag.addAttr&&(this.target.draggable=!0),this.mightDrag.setUneditable&&setTimeout((()=>{this.view.input.mouseDown==this&&this.target.setAttribute("contentEditable","false")}),20),this.view.domObserver.start()),e.root.addEventListener("mouseup",this.up=this.up.bind(this)),e.root.addEventListener("mousemove",this.move=this.move.bind(this)),mo(e,"pointer")}done(){this.view.root.removeEventListener("mouseup",this.up),this.view.root.removeEventListener("mousemove",this.move),this.mightDrag&&this.target&&(this.view.domObserver.stop(),this.mightDrag.addAttr&&this.target.removeAttribute("draggable"),this.mightDrag.setUneditable&&this.target.removeAttribute("contentEditable"),this.view.domObserver.start()),this.delayedSelectionSync&&setTimeout((()=>Ar(this.view))),this.view.input.mouseDown=null}up(e){if(this.done(),!this.view.dom.contains(e.target))return;let t=this.pos;this.view.state.doc!=this.startDoc&&(t=this.view.posAtCoords(bo(e))),this.allowDefault||!t?mo(this.view,"pointer"):xo(this.view,t.pos,t.inside,e,this.selectNode)?e.preventDefault():0==e.button&&(this.flushed||Cn&&this.mightDrag&&!this.mightDrag.node.isAtom||kn&&!(this.view.state.selection instanceof Ut)&&Math.min(Math.abs(t.pos-this.view.state.selection.from),Math.abs(t.pos-this.view.state.selection.to))<=2)?(ko(this.view,Vt.near(this.view.state.doc.resolve(t.pos)),"pointer"),e.preventDefault()):mo(this.view,"pointer")}move(e){!this.allowDefault&&(Math.abs(this.event.x-e.clientX)>4||Math.abs(this.event.y-e.clientY)>4)&&(this.allowDefault=!0),mo(this.view,"pointer"),0==e.buttons&&this.done()}}function No(e,t){return!!e.composing||!!(Cn&&Math.abs(t.timeStamp-e.input.compositionEndedAt)<500)&&(e.input.compositionEndedAt=-2e8,!0)}po.touchdown=e=>{Mo(e),mo(e,"pointer")},po.contextmenu=e=>Mo(e);const Oo=Sn?5e3:-1;function Do(e,t){clearTimeout(e.input.composingTimeout),t>-1&&(e.input.composingTimeout=setTimeout((()=>Lo(e)),t))}function Ao(e){for(e.composing&&(e.input.composing=!1,e.input.compositionEndedAt=function(){let e=document.createEvent("Event");return e.initEvent("event",!0,!0),e.timeStamp}());e.input.compositionNodes.length>0;)e.input.compositionNodes.pop().markParentsDirty()}function Lo(e,t=!1){if(!(Sn&&e.domObserver.flushingSoon>=0)){if(e.domObserver.forceFlush(),Ao(e),t||e.docView&&e.docView.dirty){let t=Or(e);return t&&!t.eq(e.state.selection)?e.dispatch(e.state.tr.setSelection(t)):e.updateState(e.state),!0}return!1}}ho.compositionstart=ho.compositionupdate=e=>{if(!e.composing){e.domObserver.flush();let{state:t}=e,n=t.selection.$from;if(t.selection.empty&&(t.storedMarks||!n.textOffset&&n.parentOffset&&n.nodeBefore.marks.some((e=>!1===e.type.spec.inclusive))))e.markCursor=e.state.storedMarks||n.marks(),Lo(e,!0),e.markCursor=null;else if(Lo(e),bn&&t.selection.empty&&n.parentOffset&&!n.textOffset&&n.nodeBefore.marks.length){let t=e.domSelection();for(let e=t.focusNode,n=t.focusOffset;e&&1==e.nodeType&&0!=n;){let r=n<0?e.lastChild:e.childNodes[n-1];if(!r)break;if(3==r.nodeType){t.collapse(r,r.nodeValue.length);break}e=r,n=-1}}e.input.composing=!0}Do(e,Oo)},ho.compositionend=(e,t)=>{e.composing&&(e.input.composing=!1,e.input.compositionEndedAt=t.timeStamp,Do(e,20))};const Io=vn&&yn<15||Tn&&Nn<604;function Ro(e,t,n,r){let o=to(e,t,n,e.input.shiftKey,e.state.selection.$from);if(e.someProp("handlePaste",(t=>t(e,r,o||v.empty))))return!0;if(!o)return!1;let i=function(e){return 0==e.openStart&&0==e.openEnd&&1==e.content.childCount?e.content.firstChild:null}(o),s=i?e.state.tr.replaceSelectionWith(i,e.input.shiftKey):e.state.tr.replaceSelection(o);return e.dispatch(s.scrollIntoView().setMeta("paste",!0).setMeta("uiEvent","paste")),!0}po.copy=ho.cut=(e,t)=>{let n=t,r=e.state.selection,o="cut"==n.type;if(r.empty)return;let i=Io?null:n.clipboardData,s=r.content(),{dom:a,text:l}=eo(e,s);i?(n.preventDefault(),i.clearData(),i.setData("text/html",a.innerHTML),i.setData("text/plain",l)):function(e,t){if(!e.dom.parentNode)return;let n=e.dom.parentNode.appendChild(document.createElement("div"));n.appendChild(t),n.style.cssText="position: fixed; left: -10000px; top: 10px";let r=getSelection(),o=document.createRange();o.selectNodeContents(t),e.dom.blur(),r.removeAllRanges(),r.addRange(o),setTimeout((()=>{n.parentNode&&n.parentNode.removeChild(n),e.focus()}),50)}(e,a),o&&e.dispatch(e.state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent","cut"))},ho.paste=(e,t)=>{let n=t;if(e.composing&&!Sn)return;let r=Io?null:n.clipboardData;r&&Ro(e,r.getData("text/plain"),r.getData("text/html"),n)?n.preventDefault():function(e,t){if(!e.dom.parentNode)return;let n=e.input.shiftKey||e.state.selection.$from.parent.type.spec.code,r=e.dom.parentNode.appendChild(document.createElement(n?"textarea":"div"));n||(r.contentEditable="true"),r.style.cssText="position: fixed; left: -10000px; top: 10px",r.focus(),setTimeout((()=>{e.focus(),r.parentNode&&r.parentNode.removeChild(r),n?Ro(e,r.value,null,t):Ro(e,r.textContent,r.innerHTML,t)}),50)}(e,n)};class Po{constructor(e,t){this.slice=e,this.move=t}}const Bo=Mn?"altKey":"ctrlKey";po.dragstart=(e,t)=>{let n=t,r=e.input.mouseDown;if(r&&r.done(),!n.dataTransfer)return;let o=e.state.selection,i=o.empty?null:e.posAtCoords(bo(n));if(i&&i.pos>=o.from&&i.pos<=(o instanceof Jt?o.to-1:o.to));else if(r&&r.mightDrag)e.dispatch(e.state.tr.setSelection(Jt.create(e.state.doc,r.mightDrag.pos)));else if(n.target&&1==n.target.nodeType){let t=e.docView.nearestDesc(n.target,!0);t&&t.node.type.spec.draggable&&t!=e.docView&&e.dispatch(e.state.tr.setSelection(Jt.create(e.state.doc,t.posBefore)))}let s=e.state.selection.content(),{dom:a,text:l}=eo(e,s);n.dataTransfer.clearData(),n.dataTransfer.setData(Io?"Text":"text/html",a.innerHTML),n.dataTransfer.effectAllowed="copyMove",Io||n.dataTransfer.setData("text/plain",l),e.dragging=new Po(s,!n[Bo])},po.dragend=e=>{let t=e.dragging;window.setTimeout((()=>{e.dragging==t&&(e.dragging=null)}),50)},ho.dragover=ho.dragenter=(e,t)=>t.preventDefault(),ho.drop=(e,t)=>{let n=t,r=e.dragging;if(e.dragging=null,!n.dataTransfer)return;let o=e.posAtCoords(bo(n));if(!o)return;let i=e.state.doc.resolve(o.pos);if(!i)return;let s=r&&r.slice;s?e.someProp("transformPasted",(e=>{s=e(s)})):s=to(e,n.dataTransfer.getData(Io?"Text":"text/plain"),Io?null:n.dataTransfer.getData("text/html"),!1,i);let a=!(!r||n[Bo]);if(e.someProp("handleDrop",(t=>t(e,n,s||v.empty,a))))return void n.preventDefault();if(!s)return;n.preventDefault();let l=s?function(e,t,n){let r=e.resolve(t);if(!n.content.size)return t;let o=n.content;for(let e=0;e<n.openStart;e++)o=o.firstChild.content;for(let e=1;e<=(0==n.openStart&&n.size?2:1);e++)for(let t=r.depth;t>=0;t--){let n=t==r.depth?0:r.pos<=(r.start(t+1)+r.end(t+1))/2?-1:1,i=r.index(t)+(n>0?1:0),s=r.node(t),a=!1;if(1==e)a=s.canReplace(i,i,o);else{let e=s.contentMatchAt(i).findWrapping(o.firstChild.type);a=e&&s.canReplaceWith(i,i,e[0])}if(a)return 0==n?r.pos:n<0?r.before(t+1):r.after(t+1)}return null}(e.state.doc,i.pos,s):i.pos;null==l&&(l=i.pos);let c=e.state.tr;a&&c.deleteSelection();let u=c.mapping.map(l),d=0==s.openStart&&0==s.openEnd&&1==s.content.childCount,p=c.doc;if(d?c.replaceRangeWith(u,u,s.content.firstChild):c.replaceRange(u,u,s),c.doc.eq(p))return;let h=c.doc.resolve(u);if(d&&Jt.isSelectable(s.content.firstChild)&&h.nodeAfter&&h.nodeAfter.sameMarkup(s.content.firstChild))c.setSelection(new Jt(h));else{let t=c.mapping.map(l);c.mapping.maps[c.mapping.maps.length-1].forEach(((e,n,r,o)=>t=o)),c.setSelection(Hr(e,h,c.doc.resolve(t)))}e.focus(),e.dispatch(c.setMeta("uiEvent","drop"))},po.focus=e=>{e.focused||(e.domObserver.stop(),e.dom.classList.add("ProseMirror-focused"),e.domObserver.start(),e.focused=!0,setTimeout((()=>{e.docView&&e.hasFocus()&&!e.domObserver.currentSelection.eq(e.domSelection())&&Ar(e)}),20))},po.blur=(e,t)=>{let n=t;e.focused&&(e.domObserver.stop(),e.dom.classList.remove("ProseMirror-focused"),e.domObserver.start(),n.relatedTarget&&e.dom.contains(n.relatedTarget)&&e.domObserver.currentSelection.clear(),e.focused=!1)},po.beforeinput=(e,t)=>{if(kn&&Sn&&"deleteContentBackward"==t.inputType){e.domObserver.flushSoon();let{domChangeCount:t}=e.input;setTimeout((()=>{if(e.input.domChangeCount!=t)return;if(e.dom.blur(),e.focus(),e.someProp("handleKeyDown",(t=>t(e,zn(8,"Backspace")))))return;let{$cursor:n}=e.state.selection;n&&n.pos>0&&e.dispatch(e.state.tr.delete(n.pos-1,n.pos).scrollIntoView())}),50)}};for(let e in ho)po[e]=ho[e];function Fo(e,t){if(e==t)return!0;for(let n in e)if(e[n]!==t[n])return!1;for(let n in t)if(!(n in e))return!1;return!0}class Ho{constructor(e,t){this.toDOM=e,this.spec=t||$o,this.side=this.spec.side||0}map(e,t,n,r){let{pos:o,deleted:i}=e.mapResult(t.from+r,this.side<0?-1:1);return i?null:new Vo(o-n,o-n,this)}valid(){return!0}eq(e){return this==e||e instanceof Ho&&(this.spec.key&&this.spec.key==e.spec.key||this.toDOM==e.toDOM&&Fo(this.spec,e.spec))}destroy(e){this.spec.destroy&&this.spec.destroy(e)}}class zo{constructor(e,t){this.attrs=e,this.spec=t||$o}map(e,t,n,r){let o=e.map(t.from+r,this.spec.inclusiveStart?-1:1)-n,i=e.map(t.to+r,this.spec.inclusiveEnd?1:-1)-n;return o>=i?null:new Vo(o,i,this)}valid(e,t){return t.from<t.to}eq(e){return this==e||e instanceof zo&&Fo(this.attrs,e.attrs)&&Fo(this.spec,e.spec)}static is(e){return e.type instanceof zo}destroy(){}}class qo{constructor(e,t){this.attrs=e,this.spec=t||$o}map(e,t,n,r){let o=e.mapResult(t.from+r,1);if(o.deleted)return null;let i=e.mapResult(t.to+r,-1);return i.deleted||i.pos<=o.pos?null:new Vo(o.pos-n,i.pos-n,this)}valid(e,t){let n,{index:r,offset:o}=e.content.findIndex(t.from);return o==t.from&&!(n=e.child(r)).isText&&o+n.nodeSize==t.to}eq(e){return this==e||e instanceof qo&&Fo(this.attrs,e.attrs)&&Fo(this.spec,e.spec)}destroy(){}}class Vo{constructor(e,t,n){this.from=e,this.to=t,this.type=n}copy(e,t){return new Vo(e,t,this.type)}eq(e,t=0){return this.type.eq(e.type)&&this.from+t==e.from&&this.to+t==e.to}map(e,t,n){return this.type.map(e,this,t,n)}static widget(e,t,n){return new Vo(e,e,new Ho(t,n))}static inline(e,t,n,r){return new Vo(e,t,new zo(n,r))}static node(e,t,n,r){return new Vo(e,t,new qo(n,r))}get spec(){return this.type.spec}get inline(){return this.type instanceof zo}}const jo=[],$o={};class _o{constructor(e,t){this.local=e.length?e:jo,this.children=t.length?t:jo}static create(e,t){return t.length?Zo(t,e,0,$o):Uo}find(e,t,n){let r=[];return this.findInner(null==e?0:e,null==t?1e9:t,r,0,n),r}findInner(e,t,n,r,o){for(let i=0;i<this.local.length;i++){let s=this.local[i];s.from<=t&&s.to>=e&&(!o||o(s.spec))&&n.push(s.copy(s.from+r,s.to+r))}for(let i=0;i<this.children.length;i+=3)if(this.children[i]<t&&this.children[i+1]>e){let s=this.children[i]+1;this.children[i+2].findInner(e-s,t-s,n,r+s,o)}}map(e,t,n){return this==Uo||0==e.maps.length?this:this.mapInner(e,t,0,0,n||$o)}mapInner(e,t,n,r,o){let i;for(let s=0;s<this.local.length;s++){let a=this.local[s].map(e,n,r);a&&a.type.valid(t,a)?(i||(i=[])).push(a):o.onRemove&&o.onRemove(this.local[s].spec)}return this.children.length?function(e,t,n,r,o,i,s){let a=e.slice(),l=(e,t,n,r)=>{for(let s=0;s<a.length;s+=3){let l,c=a[s+1];if(c<0||e>c+i)continue;let u=a[s]+i;t>=u?a[s+1]=e<=u?-2:-1:n>=o&&(l=r-n-(t-e))&&(a[s]+=l,a[s+1]+=l)}};for(let e=0;e<n.maps.length;e++)n.maps[e].forEach(l);let c=!1;for(let t=0;t<a.length;t+=3)if(a[t+1]<0){if(-2==a[t+1]){c=!0,a[t+1]=-1;continue}let l=n.map(e[t]+i),u=l-o;if(u<0||u>=r.content.size){c=!0;continue}let d=n.map(e[t+1]+i,-1)-o,{index:p,offset:h}=r.content.findIndex(u),f=r.maybeChild(p);if(f&&h==u&&h+f.nodeSize==d){let r=a[t+2].mapInner(n,f,l+1,e[t]+i+1,s);r!=Uo?(a[t]=u,a[t+1]=d,a[t+2]=r):(a[t+1]=-2,c=!0)}else c=!0}if(c){let l=function(e,t,n,r,o,i,s){function a(e,t){for(let i=0;i<e.local.length;i++){let a=e.local[i].map(r,o,t);a?n.push(a):s.onRemove&&s.onRemove(e.local[i].spec)}for(let n=0;n<e.children.length;n+=3)a(e.children[n+2],e.children[n]+t+1)}for(let n=0;n<e.length;n+=3)-1==e[n+1]&&a(e[n+2],t[n]+i+1);return n}(a,e,t,n,o,i,s),c=Zo(l,r,0,s);t=c.local;for(let e=0;e<a.length;e+=3)a[e+1]<0&&(a.splice(e,3),e-=3);for(let e=0,t=0;e<c.children.length;e+=3){let n=c.children[e];for(;t<a.length&&a[t]<n;)t+=3;a.splice(t,0,c.children[e],c.children[e+1],c.children[e+2])}}return new _o(t.sort(Xo),a)}(this.children,i||[],e,t,n,r,o):i?new _o(i.sort(Xo),jo):Uo}add(e,t){return t.length?this==Uo?_o.create(e,t):this.addInner(e,t,0):this}addInner(e,t,n){let r,o=0;e.forEach(((e,i)=>{let s,a=i+n;if(s=Go(t,e,a)){for(r||(r=this.children.slice());o<r.length&&r[o]<i;)o+=3;r[o]==i?r[o+2]=r[o+2].addInner(e,s,a+1):r.splice(o,0,i,i+e.nodeSize,Zo(s,e,a+1,$o)),o+=3}}));let i=Jo(o?Ko(t):t,-n);for(let t=0;t<i.length;t++)i[t].type.valid(e,i[t])||i.splice(t--,1);return new _o(i.length?this.local.concat(i).sort(Xo):this.local,r||this.children)}remove(e){return 0==e.length||this==Uo?this:this.removeInner(e,0)}removeInner(e,t){let n=this.children,r=this.local;for(let r=0;r<n.length;r+=3){let o,i=n[r]+t,s=n[r+1]+t;for(let t,n=0;n<e.length;n++)(t=e[n])&&t.from>i&&t.to<s&&(e[n]=null,(o||(o=[])).push(t));if(!o)continue;n==this.children&&(n=this.children.slice());let a=n[r+2].removeInner(o,i+1);a!=Uo?n[r+2]=a:(n.splice(r,3),r-=3)}if(r.length)for(let n,o=0;o<e.length;o++)if(n=e[o])for(let e=0;e<r.length;e++)r[e].eq(n,t)&&(r==this.local&&(r=this.local.slice()),r.splice(e--,1));return n==this.children&&r==this.local?this:r.length||n.length?new _o(r,n):Uo}forChild(e,t){if(this==Uo)return this;if(t.isLeaf)return _o.empty;let n,r;for(let t=0;t<this.children.length;t+=3)if(this.children[t]>=e){this.children[t]==e&&(n=this.children[t+2]);break}let o=e+1,i=o+t.content.size;for(let e=0;e<this.local.length;e++){let t=this.local[e];if(t.from<i&&t.to>o&&t.type instanceof zo){let e=Math.max(o,t.from)-o,n=Math.min(i,t.to)-o;e<n&&(r||(r=[])).push(t.copy(e,n))}}if(r){let e=new _o(r.sort(Xo),jo);return n?new Wo([e,n]):e}return n||Uo}eq(e){if(this==e)return!0;if(!(e instanceof _o)||this.local.length!=e.local.length||this.children.length!=e.children.length)return!1;for(let t=0;t<this.local.length;t++)if(!this.local[t].eq(e.local[t]))return!1;for(let t=0;t<this.children.length;t+=3)if(this.children[t]!=e.children[t]||this.children[t+1]!=e.children[t+1]||!this.children[t+2].eq(e.children[t+2]))return!1;return!0}locals(e){return Qo(this.localsInner(e))}localsInner(e){if(this==Uo)return jo;if(e.inlineContent||!this.local.some(zo.is))return this.local;let t=[];for(let e=0;e<this.local.length;e++)this.local[e].type instanceof zo||t.push(this.local[e]);return t}}_o.empty=new _o([],[]),_o.removeOverlap=Qo;const Uo=_o.empty;class Wo{constructor(e){this.members=e}map(e,t){const n=this.members.map((n=>n.map(e,t,$o)));return Wo.from(n)}forChild(e,t){if(t.isLeaf)return _o.empty;let n=[];for(let r=0;r<this.members.length;r++){let o=this.members[r].forChild(e,t);o!=Uo&&(o instanceof Wo?n=n.concat(o.members):n.push(o))}return Wo.from(n)}eq(e){if(!(e instanceof Wo)||e.members.length!=this.members.length)return!1;for(let t=0;t<this.members.length;t++)if(!this.members[t].eq(e.members[t]))return!1;return!0}locals(e){let t,n=!0;for(let r=0;r<this.members.length;r++){let o=this.members[r].localsInner(e);if(o.length)if(t){n&&(t=t.slice(),n=!1);for(let e=0;e<o.length;e++)t.push(o[e])}else t=o}return t?Qo(n?t:t.sort(Xo)):jo}static from(e){switch(e.length){case 0:return Uo;case 1:return e[0];default:return new Wo(e)}}}function Jo(e,t){if(!t||!e.length)return e;let n=[];for(let r=0;r<e.length;r++){let o=e[r];n.push(new Vo(o.from+t,o.to+t,o.type))}return n}function Go(e,t,n){if(t.isLeaf)return null;let r=n+t.nodeSize,o=null;for(let t,i=0;i<e.length;i++)(t=e[i])&&t.from>n&&t.to<r&&((o||(o=[])).push(t),e[i]=null);return o}function Ko(e){let t=[];for(let n=0;n<e.length;n++)null!=e[n]&&t.push(e[n]);return t}function Zo(e,t,n,r){let o=[],i=!1;t.forEach(((t,s)=>{let a=Go(e,t,s+n);if(a){i=!0;let e=Zo(a,t,n+s+1,r);e!=Uo&&o.push(s,s+t.nodeSize,e)}}));let s=Jo(i?Ko(e):e,-n).sort(Xo);for(let e=0;e<s.length;e++)s[e].type.valid(t,s[e])||(r.onRemove&&r.onRemove(s[e].spec),s.splice(e--,1));return s.length||o.length?new _o(s,o):Uo}function Xo(e,t){return e.from-t.from||e.to-t.to}function Qo(e){let t=e;for(let n=0;n<t.length-1;n++){let r=t[n];if(r.from!=r.to)for(let o=n+1;o<t.length;o++){let i=t[o];if(i.from!=r.from){i.from<r.to&&(t==e&&(t=e.slice()),t[n]=r.copy(r.from,i.from),Yo(t,o,r.copy(i.from,r.to)));break}i.to!=r.to&&(t==e&&(t=e.slice()),t[o]=i.copy(i.from,r.to),Yo(t,o+1,i.copy(r.to,i.to)))}}return t}function Yo(e,t,n){for(;t<e.length&&Xo(n,e[t])>0;)t++;e.splice(t,0,n)}function ei(e){let t=[];return e.someProp("decorations",(n=>{let r=n(e.state);r&&r!=Uo&&t.push(r)})),e.cursorWrapper&&t.push(_o.create(e.state.doc,[e.cursorWrapper.deco])),Wo.from(t)}const ti={childList:!0,characterData:!0,characterDataOldValue:!0,attributes:!0,attributeOldValue:!0,subtree:!0},ni=vn&&yn<=11;class ri{constructor(){this.anchorNode=null,this.anchorOffset=0,this.focusNode=null,this.focusOffset=0}set(e){this.anchorNode=e.anchorNode,this.anchorOffset=e.anchorOffset,this.focusNode=e.focusNode,this.focusOffset=e.focusOffset}clear(){this.anchorNode=this.focusNode=null}eq(e){return e.anchorNode==this.anchorNode&&e.anchorOffset==this.anchorOffset&&e.focusNode==this.focusNode&&e.focusOffset==this.focusOffset}}class oi{constructor(e,t){this.view=e,this.handleDOMChange=t,this.queue=[],this.flushingSoon=-1,this.observer=null,this.currentSelection=new ri,this.onCharData=null,this.suppressingSelectionUpdates=!1,this.observer=window.MutationObserver&&new window.MutationObserver((e=>{for(let t=0;t<e.length;t++)this.queue.push(e[t]);vn&&yn<=11&&e.some((e=>"childList"==e.type&&e.removedNodes.length||"characterData"==e.type&&e.oldValue.length>e.target.nodeValue.length))?this.flushSoon():this.flush()})),ni&&(this.onCharData=e=>{this.queue.push({target:e.target,type:"characterData",oldValue:e.prevValue}),this.flushSoon()}),this.onSelectionChange=this.onSelectionChange.bind(this)}flushSoon(){this.flushingSoon<0&&(this.flushingSoon=window.setTimeout((()=>{this.flushingSoon=-1,this.flush()}),20))}forceFlush(){this.flushingSoon>-1&&(window.clearTimeout(this.flushingSoon),this.flushingSoon=-1,this.flush())}start(){this.observer&&(this.observer.takeRecords(),this.observer.observe(this.view.dom,ti)),this.onCharData&&this.view.dom.addEventListener("DOMCharacterDataModified",this.onCharData),this.connectSelection()}stop(){if(this.observer){let e=this.observer.takeRecords();if(e.length){for(let t=0;t<e.length;t++)this.queue.push(e[t]);window.setTimeout((()=>this.flush()),20)}this.observer.disconnect()}this.onCharData&&this.view.dom.removeEventListener("DOMCharacterDataModified",this.onCharData),this.disconnectSelection()}connectSelection(){this.view.dom.ownerDocument.addEventListener("selectionchange",this.onSelectionChange)}disconnectSelection(){this.view.dom.ownerDocument.removeEventListener("selectionchange",this.onSelectionChange)}suppressSelectionUpdates(){this.suppressingSelectionUpdates=!0,setTimeout((()=>this.suppressingSelectionUpdates=!1),50)}onSelectionChange(){if(zr(this.view)){if(this.suppressingSelectionUpdates)return Ar(this.view);if(vn&&yn<=11&&!this.view.state.selection.empty){let e=this.view.domSelection();if(e.focusNode&&In(e.focusNode,e.focusOffset,e.anchorNode,e.anchorOffset))return this.flushSoon()}this.flush()}}setCurSelection(){this.currentSelection.set(this.view.domSelection())}ignoreSelectionChange(e){if(0==e.rangeCount)return!0;let t=e.getRangeAt(0).commonAncestorContainer,n=this.view.docView.nearestDesc(t);return n&&n.ignoreMutation({type:"selection",target:3==t.nodeType?t.parentNode:t})?(this.setCurSelection(),!0):void 0}flush(){if(!this.view.docView||this.flushingSoon>-1)return;let e=this.observer?this.observer.takeRecords():[];this.queue.length&&(e=this.queue.concat(e),this.queue.length=0);let t=this.view.domSelection(),n=!this.suppressingSelectionUpdates&&!this.currentSelection.eq(t)&&zr(this.view)&&!this.ignoreSelectionChange(t),r=-1,o=-1,i=!1,s=[];if(this.view.editable)for(let t=0;t<e.length;t++){let n=this.registerMutation(e[t],s);n&&(r=r<0?n.from:Math.min(n.from,r),o=o<0?n.to:Math.max(n.to,o),n.typeOver&&(i=!0))}if(bn&&s.length>1){let e=s.filter((e=>"BR"==e.nodeName));if(2==e.length){let t=e[0],n=e[1];t.parentNode&&t.parentNode.parentNode==n.parentNode?n.remove():t.remove()}}(r>-1||n)&&(r>-1&&(this.view.docView.markDirty(r,o),function(e){if(ii)return;ii=!0,"normal"==getComputedStyle(e.dom).whiteSpace&&console.warn("ProseMirror expects the CSS white-space property to be set, preferably to 'pre-wrap'. It is recommended to load style/prosemirror.css from the prosemirror-view package.")}(this.view)),this.handleDOMChange(r,o,i,s),this.view.docView&&this.view.docView.dirty?this.view.updateState(this.view.state):this.currentSelection.eq(t)||Ar(this.view),this.currentSelection.set(t))}registerMutation(e,t){if(t.indexOf(e.target)>-1)return null;let n=this.view.docView.nearestDesc(e.target);if("attributes"==e.type&&(n==this.view.docView||"contenteditable"==e.attributeName||"style"==e.attributeName&&!e.oldValue&&!e.target.getAttribute("style")))return null;if(!n||n.ignoreMutation(e))return null;if("childList"==e.type){for(let n=0;n<e.addedNodes.length;n++)t.push(e.addedNodes[n]);if(n.contentDOM&&n.contentDOM!=n.dom&&!n.contentDOM.contains(e.target))return{from:n.posBefore,to:n.posAfter};let r=e.previousSibling,o=e.nextSibling;if(vn&&yn<=11&&e.addedNodes.length)for(let t=0;t<e.addedNodes.length;t++){let{previousSibling:n,nextSibling:i}=e.addedNodes[t];(!n||Array.prototype.indexOf.call(e.addedNodes,n)<0)&&(r=n),(!i||Array.prototype.indexOf.call(e.addedNodes,i)<0)&&(o=i)}let i=r&&r.parentNode==e.target?On(r)+1:0,s=n.localPosFromDOM(e.target,i,-1),a=o&&o.parentNode==e.target?On(o):e.target.childNodes.length;return{from:s,to:n.localPosFromDOM(e.target,a,1)}}return"attributes"==e.type?{from:n.posAtStart-n.border,to:n.posAtEnd+n.border}:{from:n.posAtStart,to:n.posAtEnd,typeOver:e.target.nodeValue==e.oldValue}}}let ii=!1;function si(e){let t=e.pmViewDesc;if(t)return t.parseRule();if("BR"==e.nodeName&&e.parentNode){if(Cn&&/^(ul|ol)$/i.test(e.parentNode.nodeName)){let e=document.createElement("div");return e.appendChild(document.createElement("li")),{skip:e}}if(e.parentNode.lastChild==e||Cn&&/^(tr|table)$/i.test(e.parentNode.nodeName))return{ignore:!0}}else if("IMG"==e.nodeName&&e.getAttribute("mark-placeholder"))return{ignore:!0};return null}function ai(e,t,n,r,o){if(t<0){let t=e.input.lastSelectionTime>Date.now()-50?e.input.lastSelectionOrigin:null,n=Or(e,t);if(n&&!e.state.selection.eq(n)){let r=e.state.tr.setSelection(n);"pointer"==t?r.setMeta("pointer",!0):"key"==t&&r.scrollIntoView(),e.dispatch(r)}return}let i=e.state.doc.resolve(t),s=i.sharedDepth(n);t=i.before(s+1),n=e.state.doc.resolve(n).after(s+1);let a=e.state.selection,l=function(e,t,n){let r,{node:o,fromOffset:i,toOffset:s,from:a,to:l}=e.docView.parseRange(t,n),c=e.domSelection(),u=c.anchorNode;if(u&&e.dom.contains(1==u.nodeType?u:u.parentNode)&&(r=[{node:u,offset:c.anchorOffset}],Hn(c)||r.push({node:c.focusNode,offset:c.focusOffset})),kn&&8===e.input.lastKeyCode)for(let e=s;e>i;e--){let t=o.childNodes[e-1],n=t.pmViewDesc;if("BR"==t.nodeName&&!n){s=e;break}if(!n||n.size)break}let d=e.state.doc,p=e.someProp("domParser")||te.fromSchema(e.state.schema),h=d.resolve(a),f=null,m=p.parse(o,{topNode:h.parent,topMatch:h.parent.contentMatchAt(h.index()),topOpen:!0,from:i,to:s,preserveWhitespace:"pre"!=h.parent.type.whitespace||"full",findPositions:r,ruleFromNode:si,context:h});if(r&&null!=r[0].pos){let e=r[0].pos,t=r[1]&&r[1].pos;null==t&&(t=e),f={anchor:e+a,head:t+a}}return{doc:m,sel:f,from:a,to:l}}(e,t,n);if(kn&&e.cursorWrapper&&l.sel&&l.sel.anchor==e.cursorWrapper.deco.from&&l.sel.head==l.sel.anchor){let t=e.cursorWrapper.deco.type.toDOM.nextSibling,n=t&&t.nodeValue?t.nodeValue.length:1;l.sel={anchor:l.sel.anchor+n,head:l.sel.anchor+n}}let c,u,p=e.state.doc,h=p.slice(l.from,l.to);8===e.input.lastKeyCode&&Date.now()-100<e.input.lastKeyCodeTime?(c=e.state.selection.to,u="end"):(c=e.state.selection.from,u="start"),e.input.lastKeyCode=null;let f=function(e,t,n,r,o){let i=e.findDiffStart(t,n);if(null==i)return null;let{a:s,b:a}=e.findDiffEnd(t,n+e.size,n+t.size);if("end"==o){r-=s+Math.max(0,i-Math.min(s,a))-i}if(s<i&&e.size<t.size){i-=r<=i&&r>=s?i-r:0,a=i+(a-s),s=i}else if(a<i){i-=r<=i&&r>=a?i-r:0,s=i+(s-a),a=i}return{start:i,endA:s,endB:a}}(h.content,l.doc.content,l.from,c,u);if((Tn&&e.input.lastIOSEnter>Date.now()-225||Sn)&&o.some((e=>"DIV"==e.nodeName||"P"==e.nodeName))&&(!f||f.endA>=f.endB)&&e.someProp("handleKeyDown",(t=>t(e,zn(13,"Enter")))))return void(e.input.lastIOSEnter=0);if(!f){if(!(r&&a instanceof Ut&&!a.empty&&a.$head.sameParent(a.$anchor))||e.composing||l.sel&&l.sel.anchor!=l.sel.head){if(l.sel){let t=li(e,e.state.doc,l.sel);t&&!t.eq(e.state.selection)&&e.dispatch(e.state.tr.setSelection(t))}return}f={start:a.from,endA:a.to,endB:a.to}}e.input.domChangeCount++,e.state.selection.from<e.state.selection.to&&f.start==f.endB&&e.state.selection instanceof Ut&&(f.start>e.state.selection.from&&f.start<=e.state.selection.from+2&&e.state.selection.from>=l.from?f.start=e.state.selection.from:f.endA<e.state.selection.to&&f.endA>=e.state.selection.to-2&&e.state.selection.to<=l.to&&(f.endB+=e.state.selection.to-f.endA,f.endA=e.state.selection.to)),vn&&yn<=11&&f.endB==f.start+1&&f.endA==f.start&&f.start>l.from&&"  "==l.doc.textBetween(f.start-l.from-1,f.start-l.from+1)&&(f.start--,f.endA--,f.endB--);let m,g=l.doc.resolveNoCache(f.start-l.from),v=l.doc.resolveNoCache(f.endB-l.from),y=p.resolve(f.start),b=g.sameParent(v)&&g.parent.inlineContent&&y.end()>=f.endA;if((Tn&&e.input.lastIOSEnter>Date.now()-225&&(!b||o.some((e=>"DIV"==e.nodeName||"P"==e.nodeName)))||!b&&g.pos<l.doc.content.size&&(m=Vt.findFrom(l.doc.resolve(g.pos+1),1,!0))&&m.head==v.pos)&&e.someProp("handleKeyDown",(t=>t(e,zn(13,"Enter")))))return void(e.input.lastIOSEnter=0);if(e.state.selection.anchor>f.start&&function(e,t,n,r,o){if(!r.parent.isTextblock||n-t<=o.pos-r.pos||ci(r,!0,!1)<o.pos)return!1;let i=e.resolve(t);if(i.parentOffset<i.parent.content.size||!i.parent.isTextblock)return!1;let s=e.resolve(ci(i,!0,!0));return!(!s.parent.isTextblock||s.pos>n||ci(s,!0,!1)<n)&&r.parent.content.cut(r.parentOffset).eq(s.parent.content)}(p,f.start,f.endA,g,v)&&e.someProp("handleKeyDown",(t=>t(e,zn(8,"Backspace")))))return void(Sn&&kn&&e.domObserver.suppressSelectionUpdates());kn&&Sn&&f.endB==f.start&&(e.input.lastAndroidDelete=Date.now()),Sn&&!b&&g.start()!=v.start()&&0==v.parentOffset&&g.depth==v.depth&&l.sel&&l.sel.anchor==l.sel.head&&l.sel.head==f.endA&&(f.endB-=2,v=l.doc.resolveNoCache(f.endB-l.from),setTimeout((()=>{e.someProp("handleKeyDown",(function(t){return t(e,zn(13,"Enter"))}))}),20));let w,k,x,C=f.start,T=f.endA;if(b)if(g.pos==v.pos)vn&&yn<=11&&0==g.parentOffset&&(e.domObserver.suppressSelectionUpdates(),setTimeout((()=>Ar(e)),20)),w=e.state.tr.delete(C,T),k=p.resolve(f.start).marksAcross(p.resolve(f.endA));else if(f.endA==f.endB&&(x=function(e,t){let n,r,o,i=e.firstChild.marks,s=t.firstChild.marks,a=i,l=s;for(let e=0;e<s.length;e++)a=s[e].removeFromSet(a);for(let e=0;e<i.length;e++)l=i[e].removeFromSet(l);if(1==a.length&&0==l.length)r=a[0],n="add",o=e=>e.mark(r.addToSet(e.marks));else{if(0!=a.length||1!=l.length)return null;r=l[0],n="remove",o=e=>e.mark(r.removeFromSet(e.marks))}let c=[];for(let e=0;e<t.childCount;e++)c.push(o(t.child(e)));if(d.from(c).eq(e))return{mark:r,type:n}}(g.parent.content.cut(g.parentOffset,v.parentOffset),y.parent.content.cut(y.parentOffset,f.endA-y.start()))))w=e.state.tr,"add"==x.type?w.addMark(C,T,x.mark):w.removeMark(C,T,x.mark);else if(g.parent.child(g.index()).isText&&g.index()==v.index()-(v.textOffset?0:1)){let t=g.parent.textBetween(g.parentOffset,v.parentOffset);if(e.someProp("handleTextInput",(n=>n(e,C,T,t))))return;w=e.state.tr.insertText(t,C,T)}if(w||(w=e.state.tr.replace(C,T,l.doc.slice(f.start-l.from,f.endB-l.from))),l.sel){let t=li(e,w.doc,l.sel);t&&!(kn&&Sn&&e.composing&&t.empty&&(f.start!=f.endB||e.input.lastAndroidDelete<Date.now()-100)&&(t.head==C||t.head==w.mapping.map(T)-1)||vn&&t.empty&&t.head==C)&&w.setSelection(t)}k&&w.ensureMarks(k),e.dispatch(w.scrollIntoView())}function li(e,t,n){return Math.max(n.anchor,n.head)>t.content.size?null:Hr(e,t.resolve(n.anchor),t.resolve(n.head))}function ci(e,t,n){let r=e.depth,o=t?e.end():e.pos;for(;r>0&&(t||e.indexAfter(r)==e.node(r).childCount);)r--,o++,t=!1;if(n){let t=e.node(r).maybeChild(e.indexAfter(r));for(;t&&!t.isLeaf;)t=t.firstChild,o++}return o}class ui{constructor(e,t){this._root=null,this.focused=!1,this.trackWrites=null,this.mounted=!1,this.markCursor=null,this.cursorWrapper=null,this.lastSelectedViewDesc=void 0,this.input=new fo,this.prevDirectPlugins=[],this.pluginViews=[],this.dragging=null,this._props=t,this.state=t.state,this.directPlugins=t.plugins||[],this.directPlugins.forEach(mi),this.dispatch=this.dispatch.bind(this),this.dom=e&&e.mount||document.createElement("div"),e&&(e.appendChild?e.appendChild(this.dom):"function"==typeof e?e(this.dom):e.mount&&(this.mounted=!0)),this.editable=hi(this),pi(this),this.nodeViews=fi(this),this.docView=hr(this.state.doc,di(this),ei(this),this.dom,this),this.domObserver=new oi(this,((e,t,n,r)=>ai(this,e,t,n,r))),this.domObserver.start(),function(e){for(let t in po){let n=po[t];e.dom.addEventListener(t,e.input.eventHandlers[t]=t=>{!yo(e,t)||vo(e,t)||!e.editable&&t.type in ho||n(e,t)})}Cn&&e.dom.addEventListener("input",(()=>null)),go(e)}(this),this.updatePluginViews()}get composing(){return this.input.composing}get props(){if(this._props.state!=this.state){let e=this._props;this._props={};for(let t in e)this._props[t]=e[t];this._props.state=this.state}return this._props}update(e){e.handleDOMEvents!=this._props.handleDOMEvents&&go(this),this._props=e,e.plugins&&(e.plugins.forEach(mi),this.directPlugins=e.plugins),this.updateStateInner(e.state,!0)}setProps(e){let t={};for(let e in this._props)t[e]=this._props[e];t.state=this.state;for(let n in e)t[n]=e[n];this.update(t)}updateState(e){this.updateStateInner(e,this.state.plugins!=e.plugins)}updateStateInner(e,t){let n=this.state,r=!1,o=!1;if(e.storedMarks&&this.composing&&(Ao(this),o=!0),this.state=e,t){let e=fi(this);(function(e,t){let n=0,r=0;for(let r in e){if(e[r]!=t[r])return!0;n++}for(let e in t)r++;return n!=r})(e,this.nodeViews)&&(this.nodeViews=e,r=!0),go(this)}this.editable=hi(this),pi(this);let i=ei(this),s=di(this),a=t?"reset":e.scrollToSelection>n.scrollToSelection?"to selection":"preserve",l=r||!this.docView.matchesNode(e.doc,s,i);!l&&e.selection.eq(n.selection)||(o=!0);let c="preserve"==a&&o&&null==this.dom.style.overflowAnchor&&function(e){let t,n,r=e.dom.getBoundingClientRect(),o=Math.max(0,r.top);for(let i=(r.left+r.right)/2,s=o+1;s<Math.min(innerHeight,r.bottom);s+=5){let r=e.root.elementFromPoint(i,s);if(!r||r==e.dom||!e.dom.contains(r))continue;let a=r.getBoundingClientRect();if(a.top>=o-20){t=r,n=a.top;break}}return{refDOM:t,refTop:n,stack:_n(e.dom)}}(this);if(o){this.domObserver.stop();let t=l&&(vn||kn)&&!this.composing&&!n.selection.empty&&!e.selection.empty&&function(e,t){let n=Math.min(e.$anchor.sharedDepth(e.head),t.$anchor.sharedDepth(t.head));return e.$anchor.start(n)!=t.$anchor.start(n)}(n.selection,e.selection);if(l){let n=kn?this.trackWrites=this.domSelection().focusNode:null;!r&&this.docView.update(e.doc,s,i,this)||(this.docView.updateOuterDeco([]),this.docView.destroy(),this.docView=hr(e.doc,s,i,this.dom,this)),n&&!this.trackWrites&&(t=!0)}t||!(this.input.mouseDown&&this.domObserver.currentSelection.eq(this.domSelection())&&function(e){let t=e.docView.domFromPos(e.state.selection.anchor,0),n=e.domSelection();return In(t.node,t.offset,n.anchorNode,n.anchorOffset)}(this))?Ar(this,t):(Br(this,e.selection),this.domObserver.setCurSelection()),this.domObserver.start()}if(this.updatePluginViews(n),"reset"==a)this.dom.scrollTop=0;else if("to selection"==a){let t=this.domSelection().focusNode;if(this.someProp("handleScrollToSelection",(e=>e(this))));else if(e.selection instanceof Jt){let n=this.docView.domAfterPos(e.selection.from);1==n.nodeType&&$n(this,n.getBoundingClientRect(),t)}else $n(this,this.coordsAtPos(e.selection.head,1),t)}else c&&function({refDOM:e,refTop:t,stack:n}){let r=e?e.getBoundingClientRect().top:0;Un(n,0==r?0:r-t)}(c)}destroyPluginViews(){let e;for(;e=this.pluginViews.pop();)e.destroy&&e.destroy()}updatePluginViews(e){if(e&&e.plugins==this.state.plugins&&this.directPlugins==this.prevDirectPlugins)for(let t=0;t<this.pluginViews.length;t++){let n=this.pluginViews[t];n.update&&n.update(this,e)}else{this.prevDirectPlugins=this.directPlugins,this.destroyPluginViews();for(let e=0;e<this.directPlugins.length;e++){let t=this.directPlugins[e];t.spec.view&&this.pluginViews.push(t.spec.view(this))}for(let e=0;e<this.state.plugins.length;e++){let t=this.state.plugins[e];t.spec.view&&this.pluginViews.push(t.spec.view(this))}}}someProp(e,t){let n,r=this._props&&this._props[e];if(null!=r&&(n=t?t(r):r))return n;for(let r=0;r<this.directPlugins.length;r++){let o=this.directPlugins[r].props[e];if(null!=o&&(n=t?t(o):o))return n}let o=this.state.plugins;if(o)for(let r=0;r<o.length;r++){let i=o[r].props[e];if(null!=i&&(n=t?t(i):i))return n}}hasFocus(){return this.root.activeElement==this.dom}focus(){this.domObserver.stop(),this.editable&&function(e){if(e.setActive)return e.setActive();if(Wn)return e.focus(Wn);let t=_n(e);e.focus(null==Wn?{get preventScroll(){return Wn={preventScroll:!0},!0}}:void 0),Wn||(Wn=!1,Un(t,0))}(this.dom),Ar(this),this.domObserver.start()}get root(){let e=this._root;if(null==e)for(let e=this.dom.parentNode;e;e=e.parentNode)if(9==e.nodeType||11==e.nodeType&&e.host)return e.getSelection||(Object.getPrototypeOf(e).getSelection=()=>e.ownerDocument.getSelection()),this._root=e;return e||document}posAtCoords(e){return Zn(this,e)}coordsAtPos(e,t=1){return Yn(this,e,t)}domAtPos(e,t=0){return this.docView.domFromPos(e,t)}nodeDOM(e){let t=this.docView.descAt(e);return t?t.nodeDOM:null}posAtDOM(e,t,n=-1){let r=this.docView.posFromDOM(e,t,n);if(null==r)throw new RangeError("DOM position not inside the editor");return r}endOfTextblock(e,t){return ar(this,t||this.state,e)}destroy(){this.docView&&(!function(e){e.domObserver.stop();for(let t in e.input.eventHandlers)e.dom.removeEventListener(t,e.input.eventHandlers[t]);clearTimeout(e.input.composingTimeout),clearTimeout(e.input.lastIOSEnterFallbackTimeout)}(this),this.destroyPluginViews(),this.mounted?(this.docView.update(this.state.doc,[],ei(this),this),this.dom.textContent=""):this.dom.parentNode&&this.dom.parentNode.removeChild(this.dom),this.docView.destroy(),this.docView=null)}get isDestroyed(){return null==this.docView}dispatchEvent(e){return function(e,t){vo(e,t)||!po[t.type]||!e.editable&&t.type in ho||po[t.type](e,t)}(this,e)}dispatch(e){let t=this._props.dispatchTransaction;t?t.call(this,e):this.updateState(this.state.apply(e))}domSelection(){return this.root.getSelection()}}function di(e){let t=Object.create(null);return t.class="ProseMirror",t.contenteditable=String(e.editable),t.translate="no",e.someProp("attributes",(n=>{if("function"==typeof n&&(n=n(e.state)),n)for(let e in n)"class"==e&&(t.class+=" "+n[e]),"style"==e?t.style=(t.style?t.style+";":"")+n[e]:t[e]||"contenteditable"==e||"nodeName"==e||(t[e]=String(n[e]))})),[Vo.node(0,e.state.doc.content.size,t)]}function pi(e){if(e.markCursor){let t=document.createElement("img");t.className="ProseMirror-separator",t.setAttribute("mark-placeholder","true"),t.setAttribute("alt",""),e.cursorWrapper={dom:t,deco:Vo.widget(e.state.selection.head,t,{raw:!0,marks:e.markCursor})}}else e.cursorWrapper=null}function hi(e){return!e.someProp("editable",(t=>!1===t(e.state)))}function fi(e){let t=Object.create(null);function n(e){for(let n in e)Object.prototype.hasOwnProperty.call(t,n)||(t[n]=e[n])}return e.someProp("nodeViews",n),e.someProp("markViews",n),t}function mi(e){if(e.spec.state||e.spec.filterTransaction||e.spec.appendTransaction)throw new RangeError("Plugins passed directly to the view must not have a state component")}for(var gi=n(354),vi=n.n(gi),yi={8:"Backspace",9:"Tab",10:"Enter",12:"NumLock",13:"Enter",16:"Shift",17:"Control",18:"Alt",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",44:"PrintScreen",45:"Insert",46:"Delete",59:";",61:"=",91:"Meta",92:"Meta",106:"*",107:"+",108:",",109:"-",110:".",111:"/",144:"NumLock",145:"ScrollLock",160:"Shift",161:"Shift",162:"Control",163:"Control",164:"Alt",165:"Alt",173:"-",186:";",187:"=",188:",",189:"-",190:".",191:"/",192:"`",219:"[",220:"\\",221:"]",222:"'",229:"q"},bi={48:")",49:"!",50:"@",51:"#",52:"$",53:"%",54:"^",55:"&",56:"*",57:"(",59:":",61:"+",173:"_",186:":",187:"+",188:"<",189:"_",190:">",191:"?",192:"~",219:"{",220:"|",221:"}",222:'"',229:"Q"},wi="undefined"!=typeof navigator&&/Chrome\/(\d+)/.exec(navigator.userAgent),ki="undefined"!=typeof navigator&&/Apple Computer/.test(navigator.vendor),xi="undefined"!=typeof navigator&&/Gecko\/\d+/.test(navigator.userAgent),Ci="undefined"!=typeof navigator&&/Mac/.test(navigator.platform),Ti="undefined"!=typeof navigator&&/MSIE \d|Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent),Mi=wi&&(Ci||+wi[1]<57)||xi&&Ci,Si=0;Si<10;Si++)yi[48+Si]=yi[96+Si]=String(Si);for(Si=1;Si<=24;Si++)yi[Si+111]="F"+Si;for(Si=65;Si<=90;Si++)yi[Si]=String.fromCharCode(Si+32),bi[Si]=String.fromCharCode(Si);for(var Ei in yi)bi.hasOwnProperty(Ei)||(bi[Ei]=yi[Ei]);const Ni="undefined"!=typeof navigator&&/Mac|iP(hone|[oa]d)/.test(navigator.platform);function Oi(e){let t,n,r,o,i=e.split(/-(?!$)/),s=i[i.length-1];"Space"==s&&(s=" ");for(let e=0;e<i.length-1;e++){let s=i[e];if(/^(cmd|meta|m)$/i.test(s))o=!0;else if(/^a(lt)?$/i.test(s))t=!0;else if(/^(c|ctrl|control)$/i.test(s))n=!0;else if(/^s(hift)?$/i.test(s))r=!0;else{if(!/^mod$/i.test(s))throw new Error("Unrecognized modifier name: "+s);Ni?o=!0:n=!0}}return t&&(s="Alt-"+s),n&&(s="Ctrl-"+s),o&&(s="Meta-"+s),r&&(s="Shift-"+s),s}function Di(e,t,n){return t.altKey&&(e="Alt-"+e),t.ctrlKey&&(e="Ctrl-"+e),t.metaKey&&(e="Meta-"+e),!1!==n&&t.shiftKey&&(e="Shift-"+e),e}function Ai(e){return new an({props:{handleKeyDown:Li(e)}})}function Li(e){let t=function(e){let t=Object.create(null);for(let n in e)t[Oi(n)]=e[n];return t}(e);return function(e,n){let r,o=function(e){var t=!(Mi&&(e.ctrlKey||e.altKey||e.metaKey)||(ki||Ti)&&e.shiftKey&&e.key&&1==e.key.length)&&e.key||(e.shiftKey?bi:yi)[e.keyCode]||e.key||"Unidentified";return"Esc"==t&&(t="Escape"),"Del"==t&&(t="Delete"),"Left"==t&&(t="ArrowLeft"),"Up"==t&&(t="ArrowUp"),"Right"==t&&(t="ArrowRight"),"Down"==t&&(t="ArrowDown"),t}(n),i=1==o.length&&" "!=o,s=t[Di(o,n,!i)];if(s&&s(e.state,e.dispatch,e))return!0;if(i&&(n.shiftKey||n.altKey||n.metaKey||o.charCodeAt(0)>127)&&(r=yi[n.keyCode])&&r!=o){let o=t[Di(r,n,!0)];if(o&&o(e.state,e.dispatch,e))return!0}else if(i&&n.shiftKey){let r=t[Di(o,n,!0)];if(r&&r(e.state,e.dispatch,e))return!0}return!1}}const Ii=(e,t)=>!e.selection.empty&&(t&&t(e.tr.deleteSelection().scrollIntoView()),!0);function Ri(e,t,n=!1){for(let r=e;r;r="start"==t?r.firstChild:r.lastChild){if(r.isTextblock)return!0;if(n&&1!=r.childCount)return!1}return!1}function Pi(e){if(!e.parent.type.spec.isolating)for(let t=e.depth-1;t>=0;t--){if(e.index(t)>0)return e.doc.resolve(e.before(t+1));if(e.node(t).type.spec.isolating)break}return null}const Bi=(e,t,n)=>{let{$cursor:r}=e.selection;if(!r||(n?!n.endOfTextblock("forward",e):r.parentOffset<r.parent.content.size))return!1;let o=Fi(r);if(!o)return!1;let i=o.nodeAfter;if($i(e,o,t))return!0;if(0==r.parent.content.size&&(Ri(i,"start")||Jt.isSelectable(i))){let n=Nt(e.doc,r.before(),r.after(),v.empty);if(n&&n.slice.size<n.to-n.from){if(t){let r=e.tr.step(n);r.setSelection(Ri(i,"start")?Vt.findFrom(r.doc.resolve(r.mapping.map(o.pos)),1):Jt.create(r.doc,r.mapping.map(o.pos))),t(r.scrollIntoView())}return!0}}return!(!i.isAtom||o.depth!=r.depth-1)&&(t&&t(e.tr.delete(o.pos,o.pos+i.nodeSize).scrollIntoView()),!0)};function Fi(e){if(!e.parent.type.spec.isolating)for(let t=e.depth-1;t>=0;t--){let n=e.node(t);if(e.index(t)+1<n.childCount)return e.doc.resolve(e.after(t+1));if(n.type.spec.isolating)break}return null}const Hi=(e,t)=>{let{$head:n,$anchor:r}=e.selection;return!(!n.parent.type.spec.code||!n.sameParent(r))&&(t&&t(e.tr.insertText("\n").scrollIntoView()),!0)};function zi(e){for(let t=0;t<e.edgeCount;t++){let{type:n}=e.edge(t);if(n.isTextblock&&!n.hasRequiredAttrs())return n}return null}const qi=(e,t)=>{let{$head:n,$anchor:r}=e.selection;if(!n.parent.type.spec.code||!n.sameParent(r))return!1;let o=n.node(-1),i=n.indexAfter(-1),s=zi(o.contentMatchAt(i));if(!s||!o.canReplaceWith(i,i,s))return!1;if(t){let r=n.after(),o=e.tr.replaceWith(r,r,s.createAndFill());o.setSelection(Vt.near(o.doc.resolve(r),1)),t(o.scrollIntoView())}return!0},Vi=(e,t)=>{let{$from:n,$to:r}=e.selection;if(e.selection instanceof Jt&&e.selection.node.isBlock)return!(!n.parentOffset||!Mt(e.doc,n.pos))&&(t&&t(e.tr.split(n.pos).scrollIntoView()),!0);if(!n.parent.isBlock)return!1;if(t){let o=r.parentOffset==r.parent.content.size,i=e.tr;(e.selection instanceof Ut||e.selection instanceof Kt)&&i.deleteSelection();let s=0==n.depth?null:zi(n.node(-1).contentMatchAt(n.indexAfter(-1))),a=o&&s?[{type:s}]:void 0,l=Mt(i.doc,i.mapping.map(n.pos),1,a);if(a||l||!Mt(i.doc,i.mapping.map(n.pos),1,s?[{type:s}]:void 0)||(s&&(a=[{type:s}]),l=!0),l&&(i.split(i.mapping.map(n.pos),1,a),!o&&!n.parentOffset&&n.parent.type!=s)){let e=i.mapping.map(n.before()),t=i.doc.resolve(e);s&&n.node(-1).canReplaceWith(t.index(),t.index()+1,s)&&i.setNodeMarkup(i.mapping.map(n.before()),s)}t(i.scrollIntoView())}return!0},ji=(e,t)=>(t&&t(e.tr.setSelection(new Kt(e.doc))),!0);function $i(e,t,n){let r,o,i=t.nodeBefore,s=t.nodeAfter;if(i.type.spec.isolating||s.type.spec.isolating)return!1;if(function(e,t,n){let r=t.nodeBefore,o=t.nodeAfter,i=t.index();return!(!(r&&o&&r.type.compatibleContent(o.type))||(!r.content.size&&t.parent.canReplace(i-1,i)?(n&&n(e.tr.delete(t.pos-r.nodeSize,t.pos).scrollIntoView()),0):!t.parent.canReplace(i,i+1)||!o.isTextblock&&!St(e.doc,t.pos)||(n&&n(e.tr.clearIncompatible(t.pos,r.type,r.contentMatchAt(r.childCount)).join(t.pos).scrollIntoView()),0)))}(e,t,n))return!0;let a=t.parent.canReplace(t.index(),t.index()+1);if(a&&(r=(o=i.contentMatchAt(i.childCount)).findWrapping(s.type))&&o.matchType(r[0]||s.type).validEnd){if(n){let o=t.pos+s.nodeSize,a=d.empty;for(let e=r.length-1;e>=0;e--)a=d.from(r[e].create(null,a));a=d.from(i.copy(a));let l=e.tr.step(new wt(t.pos-1,o,t.pos,o,new v(a,1,0),r.length,!0)),c=o+2*r.length;St(l.doc,c)&&l.join(c),n(l.scrollIntoView())}return!0}let l=Vt.findFrom(t,1),c=l&&l.$from.blockRange(l.$to),u=c&&Ct(c);if(null!=u&&u>=t.depth)return n&&n(e.tr.lift(c,u).scrollIntoView()),!0;if(a&&Ri(s,"start",!0)&&Ri(i,"end")){let r=i,o=[];for(;o.push(r),!r.isTextblock;)r=r.lastChild;let a=s,l=1;for(;!a.isTextblock;a=a.firstChild)l++;if(r.canReplace(r.childCount,r.childCount,a.content)){if(n){let r=d.empty;for(let e=o.length-1;e>=0;e--)r=d.from(o[e].copy(r));n(e.tr.step(new wt(t.pos-o.length,t.pos+s.nodeSize,t.pos+l,t.pos+s.nodeSize-l,new v(r,o.length,0),0,!0)).scrollIntoView())}return!0}}return!1}function _i(e){return function(t,n){let r=t.selection,o=e<0?r.$from:r.$to,i=o.depth;for(;o.node(i).isInline;){if(!i)return!1;i--}return!!o.node(i).isTextblock&&(n&&n(t.tr.setSelection(Ut.create(t.doc,e<0?o.start(i):o.end(i)))),!0)}}const Ui=_i(-1),Wi=_i(1);function Ji(e,t=null){return function(n,r){let{$from:o,$to:i}=n.selection,s=o.blockRange(i),a=s&&function(e,t,n=null,r=e){let o=function(e,t){let{parent:n,startIndex:r,endIndex:o}=e,i=n.contentMatchAt(r).findWrapping(t);if(!i)return null;let s=i.length?i[0]:t;return n.canReplaceWith(r,o,s)?i:null}(e,t),i=o&&function(e,t){let{parent:n,startIndex:r,endIndex:o}=e,i=n.child(r),s=t.contentMatch.findWrapping(i.type);if(!s)return null;let a=(s.length?s[s.length-1]:t).contentMatch;for(let e=r;a&&e<o;e++)a=a.matchType(n.child(e).type);return a&&a.validEnd?s:null}(r,t);return i?o.map(Tt).concat({type:t,attrs:n}).concat(i.map(Tt)):null}(s,e,t);return!!a&&(r&&r(n.tr.wrap(s,a).scrollIntoView()),!0)}}function Gi(e,t=null){return function(n,r){let{from:o,to:i}=n.selection,s=!1;return n.doc.nodesBetween(o,i,((r,o)=>{if(s)return!1;if(r.isTextblock&&!r.hasMarkup(e,t))if(r.type==e)s=!0;else{let t=n.doc.resolve(o),r=t.index();s=t.parent.canReplaceWith(r,r+1,e)}})),!!s&&(r&&r(n.tr.setBlockType(o,i,e,t).scrollIntoView()),!0)}}function Ki(e,t=null){return function(n,r){let{empty:o,$cursor:i,ranges:s}=n.selection;if(o&&!i||!function(e,t,n){for(let r=0;r<t.length;r++){let{$from:o,$to:i}=t[r],s=0==o.depth&&e.type.allowsMarkType(n);if(e.nodesBetween(o.pos,i.pos,(e=>{if(s)return!1;s=e.inlineContent&&e.type.allowsMarkType(n)})),s)return!0}return!1}(n.doc,s,e))return!1;if(r)if(i)e.isInSet(n.storedMarks||i.marks())?r(n.tr.removeStoredMark(e)):r(n.tr.addStoredMark(e.create(t)));else{let o=!1,i=n.tr;for(let t=0;!o&&t<s.length;t++){let{$from:r,$to:i}=s[t];o=n.doc.rangeHasMark(r.pos,i.pos,e)}for(let n=0;n<s.length;n++){let{$from:r,$to:a}=s[n];if(o)i.removeMark(r.pos,a.pos,e);else{let n=r.pos,o=a.pos,s=r.nodeAfter,l=a.nodeBefore,c=s&&s.isText?/^\s*/.exec(s.text)[0].length:0,u=l&&l.isText?/\s*$/.exec(l.text)[0].length:0;n+c<o&&(n+=c,o-=u),i.addMark(n,o,e.create(t))}}r(i.scrollIntoView())}return!0}}function Zi(...e){return function(t,n,r){for(let o=0;o<e.length;o++)if(e[o](t,n,r))return!0;return!1}}let Xi=Zi(Ii,((e,t,n)=>{let{$cursor:r}=e.selection;if(!r||(n?!n.endOfTextblock("backward",e):r.parentOffset>0))return!1;let o=Pi(r);if(!o){let n=r.blockRange(),o=n&&Ct(n);return null!=o&&(t&&t(e.tr.lift(n,o).scrollIntoView()),!0)}let i=o.nodeBefore;if(!i.type.spec.isolating&&$i(e,o,t))return!0;if(0==r.parent.content.size&&(Ri(i,"end")||Jt.isSelectable(i))){let n=Nt(e.doc,r.before(),r.after(),v.empty);if(n&&n.slice.size<n.to-n.from){if(t){let r=e.tr.step(n);r.setSelection(Ri(i,"end")?Vt.findFrom(r.doc.resolve(r.mapping.map(o.pos,-1)),-1):Jt.create(r.doc,o.pos-i.nodeSize)),t(r.scrollIntoView())}return!0}}return!(!i.isAtom||o.depth!=r.depth-1)&&(t&&t(e.tr.delete(o.pos-i.nodeSize,o.pos).scrollIntoView()),!0)}),((e,t,n)=>{let{$head:r,empty:o}=e.selection,i=r;if(!o)return!1;if(r.parent.isTextblock){if(n?!n.endOfTextblock("backward",e):r.parentOffset>0)return!1;i=Pi(r)}let s=i&&i.nodeBefore;return!(!s||!Jt.isSelectable(s))&&(t&&t(e.tr.setSelection(Jt.create(e.doc,i.pos-s.nodeSize)).scrollIntoView()),!0)})),Qi=Zi(Ii,Bi,((e,t,n)=>{let{$head:r,empty:o}=e.selection,i=r;if(!o)return!1;if(r.parent.isTextblock){if(n?!n.endOfTextblock("forward",e):r.parentOffset<r.parent.content.size)return!1;i=Fi(r)}let s=i&&i.nodeAfter;return!(!s||!Jt.isSelectable(s))&&(t&&t(e.tr.setSelection(Jt.create(e.doc,i.pos)).scrollIntoView()),!0)}));const Yi={Enter:Zi(Hi,((e,t)=>{let n=e.selection,{$from:r,$to:o}=n;if(n instanceof Kt||r.parent.inlineContent||o.parent.inlineContent)return!1;let i=zi(o.parent.contentMatchAt(o.indexAfter()));if(!i||!i.isTextblock)return!1;if(t){let n=(!r.parentOffset&&o.index()<o.parent.childCount?r:o).pos,s=e.tr.insert(n,i.createAndFill());s.setSelection(Ut.create(s.doc,n+1)),t(s.scrollIntoView())}return!0}),((e,t)=>{let{$cursor:n}=e.selection;if(!n||n.parent.content.size)return!1;if(n.depth>1&&n.after()!=n.end(-1)){let r=n.before();if(Mt(e.doc,r))return t&&t(e.tr.split(r).scrollIntoView()),!0}let r=n.blockRange(),o=r&&Ct(r);return null!=o&&(t&&t(e.tr.lift(r,o).scrollIntoView()),!0)}),Vi),"Mod-Enter":qi,Backspace:Xi,"Mod-Backspace":Xi,"Shift-Backspace":Xi,Delete:Qi,"Mod-Delete":Qi,"Mod-a":ji},es={"Ctrl-h":Yi.Backspace,"Alt-Backspace":Yi["Mod-Backspace"],"Ctrl-d":Yi.Delete,"Ctrl-Alt-Backspace":Yi["Mod-Delete"],"Alt-Delete":Yi["Mod-Delete"],"Alt-d":Yi["Mod-Delete"],"Ctrl-a":Ui,"Ctrl-e":Wi};for(let e in Yi)es[e]=Yi[e];const ts=("undefined"!=typeof navigator?/Mac|iP(hone|[oa]d)/.test(navigator.platform):!("undefined"==typeof os||!os.platform)&&"darwin"==os.platform())?es:Yi;class ns{constructor(e,t){var n;this.match=e,this.match=e,this.handler="string"==typeof t?(n=t,function(e,t,r,o){let i=n;if(t[1]){let e=t[0].lastIndexOf(t[1]);i+=t[0].slice(e+t[1].length);let n=(r+=e)-o;n>0&&(i=t[0].slice(e-n,e)+i,r=o)}return e.tr.insertText(i,r,o)}):t}}function rs({rules:e}){let t=new an({state:{init:()=>null,apply(e,t){let n=e.getMeta(this);return n||(e.selectionSet||e.docChanged?null:t)}},props:{handleTextInput:(n,r,o,i)=>is(n,r,o,i,e,t),handleDOMEvents:{compositionend:n=>{setTimeout((()=>{let{$cursor:r}=n.state.selection;r&&is(n,r.pos,r.pos,"",e,t)}))}}},isInputRules:!0});return t}function is(e,t,n,r,o,i){if(e.composing)return!1;let s=e.state,a=s.doc.resolve(t);if(a.parent.type.spec.code)return!1;let l=a.parent.textBetween(Math.max(0,a.parentOffset-500),a.parentOffset,null,"")+r;for(let a=0;a<o.length;a++){let c=o[a].match.exec(l),u=c&&o[a].handler(s,c,t-(c[0].length-r.length),n);if(u)return e.dispatch(u.setMeta(i,{transform:u,from:t,to:n,text:r})),!0}return!1}const ss=(e,t)=>{let n=e.plugins;for(let r=0;r<n.length;r++){let o,i=n[r];if(i.spec.isInputRules&&(o=i.getState(e))){if(t){let n=e.tr,r=o.transform;for(let e=r.steps.length-1;e>=0;e--)n.step(r.steps[e].invert(r.docs[e]));if(o.text){let t=n.doc.resolve(o.from).marks();n.replaceWith(o.from,o.to,e.schema.text(o.text,t))}else n.delete(o.from,o.to);t(n)}return!0}}return!1};new ns(/--$/,"—"),new ns(/\.\.\.$/,"…"),new ns(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/,"“"),new ns(/"$/,"”"),new ns(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/,"‘"),new ns(/'$/,"’");var as=200,ls=function(){};ls.prototype.append=function(e){return e.length?(e=ls.from(e),!this.length&&e||e.length<as&&this.leafAppend(e)||this.length<as&&e.leafPrepend(this)||this.appendInner(e)):this},ls.prototype.prepend=function(e){return e.length?ls.from(e).append(this):this},ls.prototype.appendInner=function(e){return new us(this,e)},ls.prototype.slice=function(e,t){return void 0===e&&(e=0),void 0===t&&(t=this.length),e>=t?ls.empty:this.sliceInner(Math.max(0,e),Math.min(this.length,t))},ls.prototype.get=function(e){if(!(e<0||e>=this.length))return this.getInner(e)},ls.prototype.forEach=function(e,t,n){void 0===t&&(t=0),void 0===n&&(n=this.length),t<=n?this.forEachInner(e,t,n,0):this.forEachInvertedInner(e,t,n,0)},ls.prototype.map=function(e,t,n){void 0===t&&(t=0),void 0===n&&(n=this.length);var r=[];return this.forEach((function(t,n){return r.push(e(t,n))}),t,n),r},ls.from=function(e){return e instanceof ls?e:e&&e.length?new cs(e):ls.empty};var cs=function(e){function t(t){e.call(this),this.values=t}e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t;var n={length:{configurable:!0},depth:{configurable:!0}};return t.prototype.flatten=function(){return this.values},t.prototype.sliceInner=function(e,n){return 0==e&&n==this.length?this:new t(this.values.slice(e,n))},t.prototype.getInner=function(e){return this.values[e]},t.prototype.forEachInner=function(e,t,n,r){for(var o=t;o<n;o++)if(!1===e(this.values[o],r+o))return!1},t.prototype.forEachInvertedInner=function(e,t,n,r){for(var o=t-1;o>=n;o--)if(!1===e(this.values[o],r+o))return!1},t.prototype.leafAppend=function(e){if(this.length+e.length<=as)return new t(this.values.concat(e.flatten()))},t.prototype.leafPrepend=function(e){if(this.length+e.length<=as)return new t(e.flatten().concat(this.values))},n.length.get=function(){return this.values.length},n.depth.get=function(){return 0},Object.defineProperties(t.prototype,n),t}(ls);ls.empty=new cs([]);var us=function(e){function t(t,n){e.call(this),this.left=t,this.right=n,this.length=t.length+n.length,this.depth=Math.max(t.depth,n.depth)+1}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype.flatten=function(){return this.left.flatten().concat(this.right.flatten())},t.prototype.getInner=function(e){return e<this.left.length?this.left.get(e):this.right.get(e-this.left.length)},t.prototype.forEachInner=function(e,t,n,r){var o=this.left.length;return!(t<o&&!1===this.left.forEachInner(e,t,Math.min(n,o),r))&&(!(n>o&&!1===this.right.forEachInner(e,Math.max(t-o,0),Math.min(this.length,n)-o,r+o))&&void 0)},t.prototype.forEachInvertedInner=function(e,t,n,r){var o=this.left.length;return!(t>o&&!1===this.right.forEachInvertedInner(e,t-o,Math.max(n,o)-o,r+o))&&(!(n<o&&!1===this.left.forEachInvertedInner(e,Math.min(t,o),n,r))&&void 0)},t.prototype.sliceInner=function(e,t){if(0==e&&t==this.length)return this;var n=this.left.length;return t<=n?this.left.slice(e,t):e>=n?this.right.slice(e-n,t-n):this.left.slice(e,n).append(this.right.slice(0,t-n))},t.prototype.leafAppend=function(e){var n=this.right.leafAppend(e);if(n)return new t(this.left,n)},t.prototype.leafPrepend=function(e){var n=this.left.leafPrepend(e);if(n)return new t(n,this.right)},t.prototype.appendInner=function(e){return this.left.depth>=Math.max(this.right.depth,e.depth)+1?new t(this.left,new t(this.right,e)):new t(this,e)},t}(ls),ds=ls;class ps{constructor(e,t){this.items=e,this.eventCount=t}popEvent(e,t){if(0==this.eventCount)return null;let n,r,o=this.items.length;for(;;o--){if(this.items.get(o-1).selection){--o;break}}t&&(n=this.remapping(o,this.items.length),r=n.maps.length);let i,s,a=e.tr,l=[],c=[];return this.items.forEach(((e,t)=>{if(!e.step)return n||(n=this.remapping(o,t+1),r=n.maps.length),r--,void c.push(e);if(n){c.push(new hs(e.map));let t,o=e.step.map(n.slice(r));o&&a.maybeStep(o).doc&&(t=a.mapping.maps[a.mapping.maps.length-1],l.push(new hs(t,void 0,void 0,l.length+c.length))),r--,t&&n.appendMap(t,r)}else a.maybeStep(e.step);return e.selection?(i=n?e.selection.map(n.slice(r)):e.selection,s=new ps(this.items.slice(0,o).append(c.reverse().concat(l)),this.eventCount-1),!1):void 0}),this.items.length,0),{remaining:s,transform:a,selection:i}}addTransform(e,t,n,r){let o=[],i=this.eventCount,s=this.items,a=!r&&s.length?s.get(s.length-1):null;for(let n=0;n<e.steps.length;n++){let l,c=e.steps[n].invert(e.docs[n]),u=new hs(e.mapping.maps[n],c,t);(l=a&&a.merge(u))&&(u=l,n?o.pop():s=s.slice(0,s.length-1)),o.push(u),t&&(i++,t=void 0),r||(a=u)}let l=i-n.depth;return l>ms&&(s=function(e,t){let n;return e.forEach(((e,r)=>{if(e.selection&&0==t--)return n=r,!1})),e.slice(n)}(s,l),i-=l),new ps(s.append(o),i)}remapping(e,t){let n=new pt;return this.items.forEach(((t,r)=>{let o=null!=t.mirrorOffset&&r-t.mirrorOffset>=e?n.maps.length-t.mirrorOffset:void 0;n.appendMap(t.map,o)}),e,t),n}addMaps(e){return 0==this.eventCount?this:new ps(this.items.append(e.map((e=>new hs(e)))),this.eventCount)}rebased(e,t){if(!this.eventCount)return this;let n=[],r=Math.max(0,this.items.length-t),o=e.mapping,i=e.steps.length,s=this.eventCount;this.items.forEach((e=>{e.selection&&s--}),r);let a=t;this.items.forEach((t=>{let r=o.getMirror(--a);if(null==r)return;i=Math.min(i,r);let l=o.maps[r];if(t.step){let i=e.steps[r].invert(e.docs[r]),c=t.selection&&t.selection.map(o.slice(a+1,r));c&&s++,n.push(new hs(l,i,c))}else n.push(new hs(l))}),r);let l=[];for(let e=t;e<i;e++)l.push(new hs(o.maps[e]));let c=this.items.slice(0,r).append(l).append(n),u=new ps(c,s);return u.emptyItemCount()>500&&(u=u.compress(this.items.length-n.length)),u}emptyItemCount(){let e=0;return this.items.forEach((t=>{t.step||e++})),e}compress(e=this.items.length){let t=this.remapping(0,e),n=t.maps.length,r=[],o=0;return this.items.forEach(((i,s)=>{if(s>=e)r.push(i),i.selection&&o++;else if(i.step){let e=i.step.map(t.slice(n)),s=e&&e.getMap();if(n--,s&&t.appendMap(s,n),e){let a=i.selection&&i.selection.map(t.slice(n));a&&o++;let l,c=new hs(s.invert(),e,a),u=r.length-1;(l=r.length&&r[u].merge(c))?r[u]=l:r.push(c)}}else i.map&&n--}),this.items.length,0),new ps(ds.from(r.reverse()),o)}}ps.empty=new ps(ds.empty,0);class hs{constructor(e,t,n,r){this.map=e,this.step=t,this.selection=n,this.mirrorOffset=r}merge(e){if(this.step&&e.step&&!e.selection){let t=e.step.merge(this.step);if(t)return new hs(t.getMap().invert(),t,this.selection)}}}class fs{constructor(e,t,n,r){this.done=e,this.undone=t,this.prevRanges=n,this.prevTime=r}}const ms=20;function gs(e){let t=[];return e.forEach(((e,n,r,o)=>t.push(r,o))),t}function vs(e,t){if(!e)return null;let n=[];for(let r=0;r<e.length;r+=2){let o=t.map(e[r],1),i=t.map(e[r+1],-1);o<=i&&n.push(o,i)}return n}function ys(e,t,n,r){let o=ks(t),i=xs.get(t).spec.config,s=(r?e.undone:e.done).popEvent(t,o);if(!s)return;let a=s.selection.resolve(s.transform.doc),l=(r?e.done:e.undone).addTransform(s.transform,t.selection.getBookmark(),i,o),c=new fs(r?l:s.remaining,r?s.remaining:l,null,0);n(s.transform.setSelection(a).setMeta(xs,{redo:r,historyState:c}).scrollIntoView())}let bs=!1,ws=null;function ks(e){let t=e.plugins;if(ws!=t){bs=!1,ws=t;for(let e=0;e<t.length;e++)if(t[e].spec.historyPreserveItems){bs=!0;break}}return bs}const xs=new un("history"),Cs=new un("closeHistory");function Ts(e={}){return e={depth:e.depth||100,newGroupDelay:e.newGroupDelay||500},new an({key:xs,state:{init:()=>new fs(ps.empty,ps.empty,null,0),apply:(t,n,r)=>function(e,t,n,r){let o,i=n.getMeta(xs);if(i)return i.historyState;n.getMeta(Cs)&&(e=new fs(e.done,e.undone,null,0));let s=n.getMeta("appendedTransaction");if(0==n.steps.length)return e;if(s&&s.getMeta(xs))return s.getMeta(xs).redo?new fs(e.done.addTransform(n,void 0,r,ks(t)),e.undone,gs(n.mapping.maps[n.steps.length-1]),e.prevTime):new fs(e.done,e.undone.addTransform(n,void 0,r,ks(t)),null,e.prevTime);if(!1===n.getMeta("addToHistory")||s&&!1===s.getMeta("addToHistory"))return(o=n.getMeta("rebased"))?new fs(e.done.rebased(n,o),e.undone.rebased(n,o),vs(e.prevRanges,n.mapping),e.prevTime):new fs(e.done.addMaps(n.mapping.maps),e.undone.addMaps(n.mapping.maps),vs(e.prevRanges,n.mapping),e.prevTime);{let o=0==e.prevTime||!s&&(e.prevTime<(n.time||0)-r.newGroupDelay||!function(e,t){if(!t)return!1;if(!e.docChanged)return!0;let n=!1;return e.mapping.maps[0].forEach(((e,r)=>{for(let o=0;o<t.length;o+=2)e<=t[o+1]&&r>=t[o]&&(n=!0)})),n}(n,e.prevRanges)),i=s?vs(e.prevRanges,n.mapping):gs(n.mapping.maps[n.steps.length-1]);return new fs(e.done.addTransform(n,o?t.selection.getBookmark():void 0,r,ks(t)),ps.empty,i,n.time)}}(n,r,t,e)},config:e,props:{handleDOMEvents:{beforeinput(e,t){let n=t.inputType,r="historyUndo"==n?Ms:"historyRedo"==n?Ss:null;return!!r&&(t.preventDefault(),r(e.state,e.dispatch))}}}})}const Ms=(e,t)=>{let n=xs.getState(e);return!(!n||0==n.done.eventCount)&&(t&&ys(n,e,t,!1),!0)},Ss=(e,t)=>{let n=xs.getState(e);return!(!n||0==n.undone.eventCount)&&(t&&ys(n,e,t,!0),!0)};function Es(e,t){var n=e.nodes.paragraph;return t?n.create(null,Me()(t)?e.text(t):t):n.createAndFill()}function Ns(e,t,n){return e.text(t,n)}function Os(e,t,n){void 0===n&&(n=t);var r=e.doc.content.size,o=r>0?r-1:1;return Ut.create(e.doc,Math.min(t,o),Math.min(n,o))}function Ds(e,t,n){var r=t.pos;return e.replaceWith(r,r,Es(n)),e.setSelection(Os(e,r+1))}function As(e){for(var t=e.state,n=e.from,r=e.startIndex,o=e.endIndex,i=e.createText,s=t.tr,a=t.doc,l=t.schema,c=r;c<=o;c+=1){var u=a.child(c),p=u.nodeSize,h=u.textContent,f=u.content,m=i(h),g=m?Ns(l,m):d.empty,v=s.mapping.map(n),y=v+f.size;s.replaceWith(v,y,g),n+=p}return s}function Ls(e,t,n,r){var o=n.length;e.split(t).delete(t-o,t).insert(e.mapping.map(t),r).setSelection(Os(e,e.mapping.map(t)-o))}function Is(e){return e.sourcepos[0][0]}function Rs(e){return e.sourcepos[1][0]}function Ps(e){return e.sourcepos[0][1]}function Bs(e){return e.sourcepos[1][1]}function Fs(e){var t=e.type;return"strike"===t||"strong"===t||"emph"===t||"code"===t||"link"===t||"image"===t}function Hs(e){return e&&("item"===e.type||"list"===e.type)}function zs(e){return Hs(e)&&"ordered"===e.listData.type}function qs(e){return Hs(e)&&"ordered"!==e.listData.type}function Vs(e){return e&&("tableCell"===e.type||"tableDelimCell"===e.type)}function js(e,t,n){for(void 0===n&&(n=!0),e=n?e:e.parent;e&&"document"!==e.type;){if(t(e))return e;e=e.parent}return null}function $s(e,t){return[e[0],e[1]+t]}function _s(e,t){return[e[0],t]}function Us(e){var t=e.firstChild.literal;switch(e.type){case"emph":return"*"+t+"*";case"strong":return"**"+t+"**";case"strike":return"~~"+t+"~~";case"code":return"`"+t+"`";case"link":case"image":var n=e,r=n.destination,o=n.title;return("link"===e.type?"":"!")+"["+t+"]("+r+(o?' "'+o+'"':"")+")";default:return null}}function Ws(e){switch(e.type){case"document":case"blockQuote":case"list":case"item":case"paragraph":case"heading":case"emph":case"strong":case"strike":case"link":case"image":case"table":case"tableHead":case"tableBody":case"tableRow":case"tableCell":case"tableDelimRow":case"customInline":return!0;default:return!1}}function Js(e){for(var t=[],n=e.walker(),r=null;r=n.next();){var o=r.node;"text"===o.type&&t.push(o.literal)}return t.join("")}var Gs=[],Ks={},Zs=/\$\$widget\d+\s/;function Xs(e){var t=e.search(Zs);if(-1!==t){var n=e.substring(t).replace(Zs,"").replace("$$","");e=e.substring(0,t),e+=Xs(n)}return e}function Qs(e,t){return"$$"+e+" "+t+"$$"}function Ys(e,t){var n=Ks[e],r=n.rule,o=n.toDOM,i=Xs(t).match(r);return i&&(t=i[0]),o(t)}function ea(){return Gs}function ta(e){(Gs=e).forEach((function(e,t){Ks["widget"+t]=e}))}function na(e,t,n,r){return e.concat(ra(t,n,r))}function ra(e,t,n){void 0===n&&(n=0);var r=[],o=(Gs[n]||{}).rule,i=n+1;if(e=Xs(e),o&&o.test(e)){for(var s=void 0;-1!==(s=e.search(o));){var a=e.substring(0,s);a&&(r=na(r,a,t,i));var l=(e=e.substring(s)).match(o)[0],c="widget"+n;r.push(t.nodes.widget.create({info:c},t.text(Qs(c,l)))),e=e.substring(l.length)}e&&(r=na(r,e,t,i))}else e&&(r=n<Gs.length-1?na(r,e,t,i):[t.text(e)]);return r}function oa(e){for(var t,n="",r=e.walker();t=r.next();){var o=t.node;t.entering&&(o!==e&&"text"!==o.type?(n+=Us(o),r.resumeAt(e,!1),r.next()):"text"===o.type&&(n+=o.literal))}return n}function ia(){return{deleteSelection:function(){return Ii},selectAll:function(){return ji},undo:function(){return Ms},redo:function(){return Ss}}}var sa=n(322),aa=n.n(sa),la=n(714),ca=n.n(la),ua=n(471),da=n.n(ua),pa="[A-Za-z][A-Za-z0-9-]*",ha="(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)",fa="<("+pa+")("+ha+")*\\s*/?>",ma="(?:"+fa+"|</([A-Za-z][A-Za-z0-9-]*)\\s*[>])",ga=new RegExp("^"+ma,"i"),va=/<br\s*\/*>/i,ya=/<! ---->|<!--(?:-?[^>-])(?:-?[^-])*-->/,ba="</p><p>";function wa(e,t,n){var r=parseInt(e.left,10),o=parseInt(e.top,10),i=parseInt(e.width,10)+parseInt(e.paddingLeft,10)+parseInt(e.paddingRight,10),s=parseInt(e.height,10)+parseInt(e.paddingTop,10)+parseInt(e.paddingBottom,10);return t>=r&&t<=r+i&&n>=o&&n<=o+s}var ka="toastui-editor-";function xa(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var n=[],r=0,o=e;r<o.length;r++){var i=o[r],s=void 0;(s=Array.isArray(i)?i[0]?i[1]:null:i)&&n.push(""+ka+s)}return n.join(" ")}function Ca(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return e.map((function(e){return ka+"md-"+e})).join(" ")}function Ta(e){return e&&e.nodeType===Node.ELEMENT_NODE}function Ma(e){e.parentNode&&e.parentNode.removeChild(e)}function Sa(e,t,n){Oe()(n)&&(n=!ca()(e,t)),(n?ke():Ce())(e,t)}function Ea(e,t){var n=document.createElement("div");Me()(e)?n.innerHTML=e:n.appendChild(e);var r=n.firstChild;return t&&t.appendChild(r),r}function Na(e){var t=window.getComputedStyle(e);return["margin-left","margin-right"].reduce((function(e,n){return e+parseInt(t.getPropertyValue(n),10)}),0)+e.offsetWidth}function Oa(e,t){var n;for(n=Me()(t)?function(e){return da()(e,t)}:function(e){return e===t};e&&e!==document;){if(Ta(e)&&n(e))return e;e=e.parentNode}return null}function Da(e,t){for(var n=0,r=0;e&&e!==t;){if(n+=e.offsetTop,r+=e.offsetLeft,e.offsetParent===t.offsetParent)break;e=e.offsetParent}return{offsetTop:n,offsetLeft:r}}function Aa(e,t){Object.keys(e).forEach((function(n){Qe(e[n])?t.removeAttribute(n):t.setAttribute(n,e[n])}))}function La(e){var t=e;return t=(t=t.replace(/<img class="ProseMirror-separator" alt="">/g,"")).replace(/ class="ProseMirror-trailingBreak"/g,"")}var Ia=new un("widget"),Ra=function(){function e(e,t){var n=this;this.popup=null,this.removeWidget=function(){n.popup&&(n.rootEl.removeChild(n.popup),n.popup=null)},this.rootEl=e.dom.parentElement,this.eventEmitter=t,this.eventEmitter.listen("blur",this.removeWidget),this.eventEmitter.listen("loadUI",(function(){n.rootEl=Oa(e.dom.parentElement,"."+xa("defaultUI"))})),this.eventEmitter.listen("removePopupWidget",this.removeWidget)}return e.prototype.update=function(e){var t=Ia.getState(e.state);if(this.removeWidget(),t){var n=t.node,r=t.style,o=e.coordsAtPos(t.pos),i=o.top,s=o.left,a=o.bottom-i,l=this.rootEl.getBoundingClientRect(),c=i-l.top;be()(n,{opacity:"0"}),this.rootEl.appendChild(n),be()(n,{position:"absolute",left:s-l.left+5+"px",top:("bottom"===r?c+a-5:c-a)+"px",opacity:"1"}),this.popup=n,e.focus()}},e.prototype.destroy=function(){this.eventEmitter.removeEventHandler("blur",this.removeWidget)},e}();function Pa(e){return new an({key:Ia,state:{init:function(){return null},apply:function(e){return e.getMeta("widget")}},view:function(t){return new Ra(t,e)}})}var Ba=n(893),Fa=n.n(Ba);function Ha(e,t,n){e.emit("addImageBlobHook",t,(function(n,r){e.emit("command","addImage",{imageUrl:n,altText:r||t.name||"image"})}),n)}function za(e){var t=vi()(e).filter((function(e){return-1!==e.type.indexOf("image")}));if(1===t.length){var n=t[0];if(n)return n.getAsFile()}return null}function qa(e){var t=e.eventEmitter;return new an({props:{handleDOMEvents:{drop:function(e,n){var r,o=null===(r=n.dataTransfer)||void 0===r?void 0:r.files;return o&&Fa()(o,(function(e){return-1===e.type.indexOf("image")||(n.preventDefault(),n.stopPropagation(),Ha(t,e,n.type),!1)})),!0}}}})}var Va=function(){function e(){}return Object.defineProperty(e.prototype,"type",{get:function(){return"node"},enumerable:!1,configurable:!0}),e.prototype.setContext=function(e){this.context=e},e}();function ja(e){var t=document.createElement("span"),n=Ys(e.attrs.info,e.textContent);return t.className="tui-widget",t.appendChild(n),{dom:t}}function $a(e){return"widget"===e.type.name}var _a=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"widget"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{info:{default:null}},group:"inline",inline:!0,content:"text*",selectable:!1,atom:!0,toDOM:function(){return["span",{class:"tui-widget"},0]},parseDOM:[{tag:"span.tui-widget",getAttrs:function(e){return{info:e.textContent.match(/\$\$(widget\d+)/)[1]}}}]}},enumerable:!1,configurable:!0}),n}(Va),Ua=function(){function e(e){this.timer=null,this.el=document.createElement("div"),this.el.className="toastui-editor",this.eventEmitter=e,this.placeholder={text:""}}return e.prototype.createState=function(){return on.create({schema:this.schema,plugins:this.createPlugins()})},e.prototype.initEvent=function(){var e=this,t=e.eventEmitter,n=e.view,r=e.editorType;n.dom.addEventListener("focus",(function(){return t.emit("focus",r)})),n.dom.addEventListener("blur",(function(){return t.emit("blur",r)}))},e.prototype.emitChangeEvent=function(e){this.eventEmitter.emit("caretChange",this.editorType),e.docChanged&&this.eventEmitter.emit("change",this.editorType)},Object.defineProperty(e.prototype,"defaultPlugins",{get:function(){var e,t=this.createInputRules(),n=i(i([],this.keymaps),[Ai(o({"Shift-Enter":ts.Enter},ts)),Ts(),(e=this.placeholder,new an({props:{decorations:function(t){var n=t.doc;if(e.text&&1===n.childCount&&n.firstChild.isTextblock&&0===n.firstChild.content.size){var r=document.createElement("span");return ke()(r,"placeholder"),e.className&&ke()(r,e.className),r.textContent=e.text,_o.create(n,[Vo.widget(1,r)])}return null}}})),Pa(this.eventEmitter),qa(this.context)]);return t?n.concat(t):n},enumerable:!1,configurable:!0}),e.prototype.createInputRules=function(){var e=ea().map((function(e){var t=e.rule;return new ns(t,(function(e,n,r,o){var i=e.schema,s=e.tr,a=e.doc,l=n.input.match(new RegExp(t,"g")),c=a.resolve(r),u=c.parent,d=0;if($a(u)&&(u=c.node(c.depth-1)),u.forEach((function(e){return $a(e)&&(d+=1)})),l.length>d){var p=et(l),h=ra(p,i);return s.replaceWith(o-p.length+1,o,h)}return null}))}));return e.length?rs({rules:e}):null},e.prototype.clearTimer=function(){this.timer&&(clearTimeout(this.timer),this.timer=null)},e.prototype.createSchema=function(){return new Y({nodes:this.specs.nodes,marks:this.specs.marks})},e.prototype.createKeymaps=function(e){var t=ia(),n=t.undo,r=t.redo,o=this.specs.keymaps(e),i={"Mod-z":n(),"Shift-Mod-z":r()};return e?o.concat(Ai(i)):o},e.prototype.createCommands=function(){return this.specs.commands(this.view)},e.prototype.createPluginProps=function(){var e=this;return this.extraPlugins.map((function(t){return t(e.eventEmitter)}))},e.prototype.focus=function(){var e=this;this.clearTimer(),this.timer=setTimeout((function(){e.view.focus(),e.view.dispatch(e.view.state.tr.scrollIntoView())}))},e.prototype.blur=function(){this.view.dom.blur()},e.prototype.destroy=function(){var e=this;this.clearTimer(),this.view.destroy(),Object.keys(this).forEach((function(t){delete e[t]}))},e.prototype.moveCursorToStart=function(e){var t=this.view.state.tr;this.view.dispatch(t.setSelection(Os(t,1)).scrollIntoView()),e&&this.focus()},e.prototype.moveCursorToEnd=function(e){var t=this.view.state.tr;this.view.dispatch(t.setSelection(Os(t,t.doc.content.size-1)).scrollIntoView()),e&&this.focus()},e.prototype.setScrollTop=function(e){this.view.dom.scrollTop=e},e.prototype.getScrollTop=function(){return this.view.dom.scrollTop},e.prototype.setPlaceholder=function(e){this.placeholder.text=e,this.view.dispatch(this.view.state.tr.scrollIntoView())},e.prototype.setHeight=function(e){be()(this.el,{height:e+"px"})},e.prototype.setMinHeight=function(e){be()(this.el,{minHeight:e+"px"})},e.prototype.getElement=function(){return this.el},e}(),Wa=Ua,Ja=n(294),Ga=n.n(Ja),Ka=["Enter","Shift-Enter","Mod-Enter","Tab","Shift-Tab","Delete","Backspace","Mod-Delete","Mod-Backspace","ArrowUp","ArrowDown","ArrowLeft","ArrowRight","Mod-d","Mod-D","Alt-ArrowUp","Alt-ArrowDown"];function Za(e,t,n){return e.focus(),t(n)(e.state,e.dispatch,e)}var Xa=function(){function e(e){this.specs=e}return Object.defineProperty(e.prototype,"nodes",{get:function(){return this.specs.filter((function(e){return"node"===e.type})).reduce((function(e,t){var n,r=t.name,i=t.schema;return o(o({},e),((n={})[r]=i,n))}),{})},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"marks",{get:function(){return this.specs.filter((function(e){return"mark"===e.type})).reduce((function(e,t){var n,r=t.name,i=t.schema;return o(o({},e),((n={})[r]=i,n))}),{})},enumerable:!1,configurable:!0}),e.prototype.commands=function(e,t){var n=this.specs.filter((function(e){return e.commands})).reduce((function(t,n){var r={},i=n.commands();return Ga()(i)?r[n.name]=function(t){return Za(e,i,t)}:Object.keys(i).forEach((function(t){r[t]=function(n){return Za(e,i[t],n)}})),o(o({},t),r)}),{}),r=ia();return Object.keys(r).forEach((function(t){n[t]=function(n){return Za(e,r[t],n)}})),t&&Object.keys(t).forEach((function(r){n[r]=function(n){return Za(e,t[r],n)}})),n},e.prototype.keymaps=function(e){return this.specs.filter((function(e){return e.keymaps})).map((function(e){return e.keymaps()})).map((function(t){return e||Object.keys(t).forEach((function(e){Ue(Ka,e)||delete t[e]})),Ai(t)}))},e.prototype.setContext=function(e){this.specs.forEach((function(t){t.setContext(e)}))},e}(),Qa=Xa;function Ya(e){var t=e.from,n=e.to;return e instanceof Kt?[t+1,n-1]:[t,n]}function el(e){return e.index(0)+1}function tl(e,t,n){void 0===n&&(n=1);var r=0;return e.forEach((function(e,o){$a(e)&&o+2<t&&(r+=2*n)})),r}function nl(e,t,n){void 0===n&&(n=t);var r=t===n,o=e.resolve(t),i=el(o),s=i,a=o.start(1),l=a;if(!r){var c=e.resolve(n===e.content.size?n-1:n);l=c.start(1),s=el(c),c.pos===e.content.size&&(n=e.content.size-2)}var u=Math.max(t-a+1,1),d=Math.max(n-l+1,1);return[[i,u+tl(e.child(i-1),u,-1)],[s,d+tl(e.child(s-1),d,-1)]]}function rl(e,t){for(var n=[],r=0,o=0;r<t;r+=1){var i=e.child(r);n[r]=o,o+=i.nodeSize}return n}function ol(e,t,n){var r=rl(e,n[0]),o=t[0]-1,i=n[0]-1,s=e.child(o),a=e.child(i),l=r[o],c=r[i];return l+=t[1]+tl(s,t[1]-1),c+=n[1]+tl(a,n[1]-1),[l,Math.min(c,e.content.size)]}function il(e){var t=e.$from,n=e.$to,r=e.from,o=e.to,i=t.doc;return e instanceof Kt&&(t=i.resolve(r+1),n=i.resolve(o-1)),0===t.depth&&(n=t=i.resolve(r-1)),{startFromOffset:t.start(1),endFromOffset:n.start(1),startToOffset:t.end(1),endToOffset:n.end(1),startIndex:t.index(0),endIndex:n.index(0),from:t.pos,to:n.pos}}function sl(e,t){for(var n=1,r=1,o=0,i=0;o<e.childCount;o+=1){var s=e.child(o).nodeSize;if(n=i+1,r=i+s-1,o===t)break;i+=s}return{startOffset:n,endOffset:r}}var al="heading",ll="link",cl="code",ul="meta",dl="delimiter",pl="markedText",hl={strong:2,emph:1,strike:2};function fl(e,t,n,r){return{start:e,end:t,spec:{type:n,attrs:r}}}function ml(e,t,n){var r=e.type,o=$s(t,hl[r]),i=$s(n,-hl[r]);return[fl(o,i,r),fl(t,o,dl),fl(i,n,dl)]}function gl(e,t,n,r){return[fl(e,t,ll),fl(_s(e,n[1]+1),_s(t,r),ll,{desc:!0}),fl(_s(t,r+2),$s(t,-1),ll,{url:!0})]}function vl(e,t,n,r){var i={start:t,end:n,spec:{attrs:{className:r+"-line-background",codeStart:t[0],codeEnd:n[0]}},lineBackground:!0};return"item"!==e.type&&"blockQuote"!==e.type?[o(o({},i),{end:t,spec:{attrs:{className:r+"-line-background start"}}}),o(o({},i),{start:[Math.min(t[0]+1,n[0]),t[1]]})]:null}function yl(e,t){for(var n=[];e;){var r=e.type;"paragraph"!==r&&"codeBlock"!==r||n.push(fl([Is(e),Ps(e)-1],[Rs(e),Bs(e)+1],t)),e=e.next}return n}var bl={heading:function(e,t,n){var r=e.level,o=e.headingType,i=[fl(t,n,al,{level:r})];return"atx"===o?i.push(fl(t,$s(t,r),dl)):i.push(fl(_s(n,0),n,al,{seText:!0})),i},strong:ml,emph:ml,strike:ml,link:function(e,t,n){var r=e.lastChild,o=e.extendedAutolink,i=r?Bs(r)+1:2;return o?[fl(t,n,ll,{desc:!0})]:gl(t,n,t,i)},image:function(e,t,n){var r=e.lastChild,o=r?Bs(r)+1:3,s=$s(t,1);return i([fl(t,s,ul)],gl(t,n,s,o))},code:function(e,t,n){var r=e.tickCount,o=$s(t,r),i=$s(n,-r);return[fl(t,n,cl),fl(t,o,cl,{start:!0}),fl(o,i,cl,{marked:!0}),fl(i,n,cl,{end:!0})]},codeBlock:function(e,t,n,r){var o=e.fenceOffset,i=e.fenceLength,s=e.fenceChar,a=e.info,l=e.infoPadding,c=e.parent,u=o+i,d=[fl(_s(t,1),n,"codeBlock")];s&&d.push(fl(t,$s(t,u),dl)),a&&d.push(fl($s(t,i),$s(t,i+l+a.length),ul)),new RegExp("^(\\s{0,4})("+s+"{"+i+",})").test(r)&&d.push(fl(_s(n,1),n,dl));var p=vl(c,t,n,"code-block");return p?d.concat(p):d},blockQuote:function(e,t,n){var r=e.parent&&"blockQuote"!==e.parent.type?[fl(t,n,"blockQuote")]:[];if(e.firstChild){var o=[];"paragraph"===e.firstChild.type?o=function(e){for(var t=[];e;)t.push(fl([Is(e),Ps(e)],[Rs(e),Bs(e)+1],pl)),e=e.next;return t}(e.firstChild.firstChild):"list"===e.firstChild.type&&(o=yl(e.firstChild,pl)),r=i(i([],r),o)}return r},item:function(e,t){var n=e.listData,r=n.padding,s=n.task,a=function(e){for(var t=0;e.parent.parent&&"item"===e.parent.parent.type;)e=e.parent.parent,t+=1;return["listItem",o(o({},[{odd:!0},{even:!0}][t%2]),{listStyle:!0})]}(e),l=[fl.apply(void 0,i([t,$s(t,r)],a))];return s&&(l.push(fl($s(t,r),$s(t,r+3),"taskDelimiter")),l.push(fl($s(t,r+1),$s(t,r+2),ul))),l.concat(yl(e.firstChild,pl))},customBlock:function(e,t,n){var r=e,o=r.offset,i=r.syntaxLength,s=r.info,a=r.parent,l=o+i,c=[fl(_s(t,1),n,"customBlock")];c.push(fl(t,$s(t,l),dl)),s&&c.push(fl($s(t,l),$s(t,i+s.length),ul)),c.push(fl(_s(n,1),n,dl));var u=vl(a,t,n,"custom-block");return u?c.concat(u):c}},wl={thematicBreak:"thematicBreak",table:"table",tableCell:"tableCell",htmlInline:"html"};function kl(e,t,n,r){var o=e.type;return Ga()(bl[o])?bl[o](e,t,n,r):wl[o]?[fl(t,n,wl[o])]:null}var xl={};function Cl(e){var t=e.schema,n=e.toastMark;return new an({appendTransaction:function(e,r,o){var i=e[0],s=o.tr;if(i.docChanged){var a=[];i.getMeta("editResult").forEach((function(e){var t=e.nodes,r=e.removedNodeRange;if(t.length){a=a.concat(function(e,t){var n=e.doc,r=t[0].sourcepos[0],o=et(t).sourcepos[1],i=[r[0],r[1]],s=[o[0],o[1]+1],a=[];return function(e,t,n){var r=[];xl={};for(var o=t[0]-1;o<n[0];o+=1){var i=e.child(o),s=i.attrs.codeEnd,a=i.attrs.codeStart;if(a&&s&&!Ue(r,a)){r.push(a),s=Math.min(s,e.childCount);for(var l=a-1,c=n[0],u=l;u<c;u+=1)xl[u]=!0}}}(n,r,o),a.push({start:i,end:s}),a}(s,t));for(var o=0,i=t;o<i.length;o++)for(var l=i[o].walker(),c=l.next();c;){var u=c.node;c.entering&&(a=a.concat(Ml(u,n))),c=l.next()}}else if(r)for(var d=s.doc.childCount-1,p=r.line,h=p[0],f=p[1],m=Math.min(h,d),g=Math.min(f,d),v=m;v<=g;v+=1)xl[v]=!0})),function(e,t,n){var r=e.doc,o=t.nodes.paragraph,i=rl(r,r.childCount);n.forEach((function(n){var s=n.start,a=n.end,l=n.spec,c=n.lineBackground,u=Math.min(s[0],r.childCount)-1,d=Math.min(a[0],r.childCount)-1,p=r.child(u),h=r.child(d),f=i[u],m=i[d];(f+=s[1]+tl(p,s[1]-1),m+=a[1]+tl(h,a[1]-1),l)?c?function(e,t,n,r,o){void 0===o&&(o={});for(var i=r.startIndex,s=r.endIndex,a=r.from,l=r.to,c=!1,u=i;u<=s;u+=1)delete xl[u],c=Tl(t,u,o);c&&e.setBlockType(a,l,n,o)}(e,r,o,{from:f,to:m,startIndex:u,endIndex:d},l.attrs):e.addMark(f,m,t.mark(l.type,l.attrs)):e.removeMark(f,m)})),function(e,t,n){Object.keys(xl).forEach((function(r){var o=Number(r),i=Math.min(Number(r)+1,e.doc.childCount-1),s=t[o],a=t[i]-1;o===i&&(a+=2),e.setBlockType(s,a,n)}))}(e,i,o)}(s,t,a)}return s.setMeta("widget",i.getMeta("widget"))}})}function Tl(e,t,n){return Object.keys(n).some((function(r){return n[r]!==e.child(t).attrs[r]}))}function Ml(e,t){var n=t.getLineTexts(),r=[Is(e),Ps(e)],o=[Rs(e),Bs(e)+1],i=kl(e,r,o,n[o[0]-1]);return null!=i?i:[]}var Sl=["taskList","orderedList","bulletList","table","strong","emph","strike","heading","thematicBreak","blockQuote","code","codeBlock","indent","outdent"];function El(e){var t={indent:{active:!1,disabled:!0},outdent:{active:!1,disabled:!0}},n=!0;return function(e,t,n){for(void 0===n&&(n=!0),e=n?e:e.parent;e&&"document"!==e.type;)t(e),e=e.parent}(e,(function(e){var r=function(e){var t=e.type;return Hs(e)?e.listData.task?"taskList":"ordered"===e.listData.type?"orderedList":"bulletList":-1!==t.indexOf("table")?"table":Ue(Sl,t)?t:null}(e);r&&("bulletList"===r||"orderedList"===r?n&&(t[r]={active:!0},t.indent.disabled=!1,t.outdent.disabled=!1,n=!1):t[r]={active:!0})})),t}function Nl(e){var t=e.toastMark,n=e.eventEmitter;return new an({view:function(){return{update:function(e,r){var o=e.state,i=o.doc,s=o.selection;if(!(r&&r.doc.eq(i)&&r.selection.eq(s))){var a=s.from,l=o.doc.resolve(a).start(),c=a-l;a===l&&(c+=1);var u=[o.doc.content.findIndex(a).index+1,c],d=t.findNodeAtPosition(u),p=El(d);n.emit("changeToolbarState",{cursorPos:u,mdNode:d,toolbarState:p}),n.emit("setFocusedNode",d)}}}}})}var Ol=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"doc"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"block+"}},enumerable:!1,configurable:!0}),n}(Va),Dl=function(){function e(){}return Object.defineProperty(e.prototype,"type",{get:function(){return"mark"},enumerable:!1,configurable:!0}),e.prototype.setContext=function(e){this.context=e},e}(),Al=Dl;function Ll(e,t){return Il(e,t-1)}function Il(e,t){return e.child(t).textContent}var Rl=/^\s*> ?/,Pl=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"blockQuote"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("block-quote")},0]}}},enumerable:!1,configurable:!0}),n.prototype.createBlockQuoteText=function(e,t){return t?e.replace(Rl,"").trim():"> "+e.trim()},n.prototype.extendBlockQuote=function(){var e=this;return function(t,n){var r=t.selection,o=t.doc,i=t.tr,s=t.schema,a=il(r),l=a.endFromOffset,c=a.endToOffset,u=a.endIndex,d=a.to,p=Il(o,u);if(Rl.test(p)&&d>l&&r.empty){if(!p.replace(Rl,"").trim())i.deleteRange(l,c).split(i.mapping.map(c));else{var h=p.slice(d-l).trim();Ls(i,c,h,Ns(s,e.createBlockQuoteText(h)))}return n(i),!0}return!1}},n.prototype.commands=function(){var e=this;return function(){return function(t,n){var r=t.selection,o=t.doc,i=il(r),s=i.startFromOffset,a=i.endToOffset,l=i.startIndex,c=i.endIndex,u=Rl.test(Il(o,l)),d=As({state:t,startIndex:l,endIndex:c,from:s,createText:function(t){return e.createBlockQuoteText(t,u)}});return n(d.setSelection(Os(d,d.mapping.map(a)))),!0}}},n.prototype.keymaps=function(){var e=this.commands()();return{"alt-q":e,"alt-Q":e,Enter:this.extendBlockQuote()}},n}(Al),Bl=/(^\s*)([-*+] |[\d]+\. )/,Fl=/(^\s*)([\d])+\.( \[[ xX]])? /,Hl=/^(\s*)((\d+)([.)]\s(?:\[(?:x|\s)\]\s)?))(.*)/,zl=/(^\s*)([-*+]|[\d]+\.)( \[[ xX]])? /,ql=/^(\s*)([-*+]+(\s(?:\[(?:x|\s)\]\s)?))(.*)/,Vl=/(^\s*)([-*+] |[\d]+\. )(\[[ xX]] )/,jl=/(^\s*)([-*+])( \[[ xX]]) /;function $l(e){return Fl.test(e)?"ordered":"bullet"}function _l(e){for(var t=0;e&&"document"!==e.type;)"list"===e.type&&(t+=1),e=e.parent;return t}function Ul(e,t,n,r){for(var o=e.getLineTexts().length,i=[],s=t;r?s<o:s>1;){s=r?s+1:s-1;var a=e.findFirstNodeAtLine(s),l=_l(a);if(l===n)i.push({line:s,depth:n,mdNode:a});else if(l<n)break}return i}function Wl(e,t,n,r){void 0===r&&(r=0);var o=Number.MAX_VALUE,i=0,s=t.map((function(t,s){var a=t.line;o=Math.min(a-1,o),i=Math.max(a-1,i);var l=Ll(e,a);return l="bullet"===n?function(e){if(!Bl.test(e))return"* "+e;var t=$l(e);return"bullet"===t&&zl.test(e)?e=e.replace(jl,"$1$2 "):"ordered"===t&&(e=e.replace(Fl,"$1* ")),e}(l):function(e,t){if(!Bl.test(e))return t+". "+e;var n=$l(e);if("bullet"===n||"ordered"===n&&zl.test(e))e=e.replace(zl,"$1"+t+". ");else if("ordered"===n){var r=Hl.exec(e)[3];Number(r)!==t&&(e=e.replace(Fl,"$1"+t+". "))}return e}(l,s+1+r),{text:l,line:a}}));return{changedResults:s,firstIndex:o,lastIndex:i}}function Jl(e,t){var n,r,o,i,s,a,l,c=(r=(n=t).toastMark,o=n.mdNode,i=n.line,s=_l(o),a=Ul(r,i,s,!1).reverse(),l=Ul(r,i,s,!0),a.concat([{line:i,depth:s,mdNode:o}]).concat(l));return Wl(t.doc,c,e)}var Gl={bullet:function(e){return Jl("bullet",e)},ordered:function(e){return Jl("ordered",e)},task:function(e){var t=e.mdNode,n=e.doc,r=e.line,o=Ll(n,r);return t.listData.task?o=o.replace(Vl,"$1$2"):Hs(t)&&(o=o.replace(Bl,"$1$2[ ] ")),{changedResults:[{text:o,line:r}]}}},Kl={bullet:function(e){var t=e.doc,n=e.line;return{changedResults:[{text:"* "+Ll(t,n),line:n}]}},ordered:function(e){for(var t=e.toastMark,n=e.doc,r=e.line,o=e.startLine,i=Ll(n,r),s=1,a=o,l=0,c=o-1;c>0;c-=1){var u=t.findFirstNodeAtLine(c),d=Ll(n,c)&&!!js(u,(function(e){return Hs(e)})),p=Hl.exec(Ll(n,c));if(!p&&!d)break;if(p||!d){var h=p,f=h[1],m=h[3];if(!f){s=Number(m),a=c;break}}else l+=1}return{changedResults:[{text:s+r-a-l+". "+i,line:r}]}},task:function(e){var t=e.doc,n=e.line;return{changedResults:[{text:"* [ ] "+Ll(t,n),line:n}]}}},Zl={bullet:function(e){var t=e.line,n=Ll(e.doc,t),r=ql.exec(n);return{listSyntax:""+r[1]+r[2]}},ordered:function(e){var t=e.toastMark,n=e.line,r=e.mdNode,i=e.doc,s=_l(r),a=Ll(i,n),l=Hl.exec(a),c=l[1],u=l[3],d=l[4],p=Number(u)+1,h=""+c+p+d,f=Ul(t,n,s,!0).filter((function(e){var t=Hl.exec(Ll(i,e.line));return t&&t[1].length===c.length&&!!js(e.mdNode,(function(e){return zs(e)}))}));return o({listSyntax:h},Wl(i,f,"ordered",p))}};function Xl(e,t,n,r,o){for(var i=[],s=Ll(e,n),a=Hl.exec(s);a;){var l=a[1],c=a[4],u=a[5],d=l.length;if(d===o)i.push(Ns(t,""+l+r+c+u)),r+=1,n+=1;else if(d>o){var p=Xl(e,t,n,1,d);n=p.line,i=i.concat(p.nodes)}if(d<o||n>e.childCount)break;s=Ll(e,n),a=Hl.exec(s)}return{nodes:i,line:n}}var Ql=/(^\s{1,4})(.*)/;function Yl(e,t,n){return e<t||Bl.test(n)||Rl.test(n)}function ec(e,t,n){var r=n.$from;0===r.depth&&(r=e.resolve(r.pos-1));var o=r.node(1),i=r.start(1),s=o.content.size;return o.rangeHasMark(0,s,t.marks.table)&&r.pos-i!==s&&r.pos!==i}function tc(e,t){var n=t.from,r=t.to;if("indent"===t.type){n+=4,r+=4*(t.lineLen+1)}else{var o=t.spaceLenList;n-=o[0];for(var i=0;i<o.length;i+=1)r-=o[i]}return Os(e,n,r)}var nc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"paragraph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"inline*",attrs:{className:{default:null},codeStart:{default:null},codeEnd:{default:null}},selectable:!1,group:"block",parseDOM:[{tag:"div"}],toDOM:function(e){var t=e.attrs;return t.className?["div",{class:Ca(t.className)},0]:["div",0]}}},enumerable:!1,configurable:!0}),n.prototype.reorderList=function(e,t){for(var n=this.context,r=n.view,o=n.toastMark,i=n.schema,s=r.state,a=s.tr,l=s.selection,c=s.doc,u=o.findFirstNodeAtLine(e),d=u;u&&!qs(u)&&"document"!==u.parent.type;)if(zs(u=u.parent)){d=u;break}d&&(e=d.sourcepos[0][0]);var p=Hl.exec(Ll(c,e)),h=p[1],f=p[3],m=h.length,g=Xl(c,i,e,Number(f),m),v=g.line,y=g.nodes;t=Math.max(t,v-1);for(var b=sl(c,e-1).startOffset,w=e-1;w<=t-1;w+=1){var k=c.child(w),x=k.nodeSize,C=k.content,T=a.mapping.map(b),M=T+C.size;a.replaceWith(T,M,y[w-e+1]),b+=x}var S=Os(a,l.from,l.to);r.dispatch(a.setSelection(S))},n.prototype.indent=function(e){var t=this;return void 0===e&&(e=!1),function(){return function(n,r){var o=n.schema,i=n.selection,s=n.doc,a=il(i),l=a.from,c=a.to,u=a.startFromOffset,d=a.startIndex,p=a.endIndex;if(e&&ec(s,o,i))return!1;var h=Il(s,d);if(e&&Yl(l,c,h)||!e&&Bl.test(h)){var f=As({state:n,from:u,startIndex:d,endIndex:p,createText:function(e){return"    "+e}}),m={type:"indent",from:l,to:c,lineLen:p-d};r(f.setSelection(tc(f,m))),Hl.test(h)&&t.reorderList(d+1,p+1)}else e&&r(n.tr.insert(c,Ns(o,"    ")));return!0}}},n.prototype.outdent=function(e){var t=this;return void 0===e&&(e=!1),function(){return function(n,r){var o=n.selection,i=n.doc,s=n.schema,a=il(o),l=a.from,c=a.to,u=a.startFromOffset,d=a.startIndex,p=a.endIndex;if(e&&ec(i,s,o))return!1;var h=Il(i,d);if(e&&Yl(l,c,h)||!e&&Bl.test(h)){var f=[],m=As({state:n,from:u,startIndex:d,endIndex:p,createText:function(e){var t=Ql.exec(e);return f.push(t?t[1].length:0),e.replace(Ql,"$2")}}),g={type:"outdent",from:l,to:c,spaceLenList:f};r(m.setSelection(tc(m,g))),Hl.test(h)&&t.reorderList(d+1,p+1)}else if(e){var v=h.slice(0,c-u),y=v.replace(/\s{1,4}$/,""),b=c-(v.length-y.length);r(n.tr.delete(b,c))}return!0}}},n.prototype.deleteLines=function(){var e=this;return function(t,n){var r=e.context.view,o=il(t.selection),i=o.startFromOffset,s=o.endToOffset;return Zi((function(){return n(t.tr.deleteRange(i,s)),!0}),Bi)(t,n,r)}},n.prototype.moveDown=function(){return function(e,t){var n=e.doc,r=e.tr,o=e.selection,i=e.schema,s=il(o),a=s.startFromOffset,l=s.endToOffset,c=s.endIndex;if(c<n.content.childCount-1){var u=n.child(c+1),d=u.nodeSize,p=u.textContent;return r.delete(l,l+d).split(a).insert(r.mapping.map(a)-2,Ns(i,p)),t(r),!0}return!1}},n.prototype.moveUp=function(){return function(e,t){var n=e.tr,r=e.doc,o=e.selection,i=e.schema,s=il(o),a=s.startFromOffset,l=s.endToOffset,c=s.startIndex;if(c>0){var u=r.child(c-1),d=u.nodeSize,p=u.textContent;return n.delete(a-d,a).split(n.mapping.map(l)).insert(n.mapping.map(l),Ns(i,p)),t(n),!0}return!1}},n.prototype.commands=function(){return{indent:this.indent(),outdent:this.outdent()}},n.prototype.keymaps=function(){return{Tab:this.indent(!0)(),"Shift-Tab":this.outdent(!0)(),"Mod-d":this.deleteLines(),"Mod-D":this.deleteLines(),"Alt-ArrowUp":this.moveUp(),"Alt-ArrowDown":this.moveDown()}},n}(Va),rc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"text"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{group:"inline"}},enumerable:!1,configurable:!0}),n}(Va),oc=/^#{1,6}\s/,ic=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"heading"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{level:{default:1},seText:{default:!1}},toDOM:function(e){var t=e.attrs,n="heading|heading"+t.level;return t.seText&&(n+="|delimiter|setext"),["span",{class:Ca.apply(void 0,n.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.createHeadingText=function(e,t,n){for(var r=t.replace(n,"").trim(),o="";e>0;)o+="#",e-=1;return o+" "+r},n.prototype.commands=function(){var e=this;return function(t){return function(n,r){var o=t.level,i=il(n.selection),s=i.startFromOffset,a=i.endToOffset,l=As({state:n,from:s,startIndex:i.startIndex,endIndex:i.endIndex,createText:function(t){var n=t.match(oc),r=n?n[0]:"";return e.createHeadingText(o,t,r)}});return r(l.setSelection(Os(l,l.mapping.map(a)))),!0}}},n}(Al),sc="```",ac=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"codeBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("code-block")},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){var n=e.selection,r=e.schema,o=e.tr,i=il(n),s=i.startFromOffset,a=i.endToOffset,l=Ns(r,sc);return o.insert(s,l).split(s+sc.length),o.split(o.mapping.map(a)).insert(o.mapping.map(a),l),t(o.setSelection(Os(o,o.mapping.map(a)-(sc.length+2)))),!0}}},n.prototype.keepIndentation=function(){var e=this;return function(t,n){var r=t.selection,o=t.tr,i=t.doc,s=t.schema,a=e.context.toastMark,l=il(r),c=l.startFromOffset,u=l.endToOffset,d=l.endIndex,p=l.from,h=l.to,f=Il(i,d);if(p===h&&f.trim()){var m=f.match(/^\s+/);if(function(e){return e&&"codeBlock"===e.type}(a.findFirstNodeAtLine(d+1))&&m){var g=m[0],v=f.slice(h-c);return Ls(o,u,v,Ns(s,g+v)),n(o),!0}}return!1}},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-p":e,"Shift-Mod-P":e,Enter:this.keepIndentation()}},n}(Al),lc=/\||\s/g;function cc(e,t){for(var n="|",r=0;r<e;r+=1)n+=t?" --- |":"  |";return n}var uc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"table"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("table")},0]}}},enumerable:!1,configurable:!0}),n.prototype.extendTable=function(){var e=this;return function(t,n){var r=t.selection,o=t.doc,i=t.tr,s=t.schema;if(!r.empty)return!1;var a=il(r),l=a.endFromOffset,c=a.endToOffset,u=a.endIndex,d=a.to,p=Il(o,u),h=[u+1,d-l+1],f=js(e.context.toastMark.findNodeAtPosition(h),(function(e){return Vs(e)&&("tableDelimRow"===e.parent.type||"tableBody"===e.parent.parent.type)}));if(f){var m=!p.replace(lc,"").trim(),g=cc(f.parent.parent.parent.columns.length);return m?i.deleteRange(l,c).split(i.mapping.map(c)):i.split(c).insert(i.mapping.map(c),Ns(s,g)).setSelection(Os(i,i.mapping.map(c)-2)),n(i),!0}return!1}},n.prototype.moveTableCell=function(e){var t=this;return function(n,r){var o=n.selection,i=n.tr,s=il(o),a=s.endFromOffset,l=[s.endIndex+1,s.to-a],c=js(t.context.toastMark.findNodeAtPosition(l),(function(e){return Vs(e)}));if(c){var u=c.parent,d=function(e){return e?{type:"next",parentType:"tableHead",childType:"firstChild"}:{type:"prev",parentType:"tableBody",childType:"lastChild"}}(e),p=d.type,h=d.parentType,f=d.childType,m=Bs(c);if(c[p])m=Bs(c[p])-1;else{var g=u[p]||u.parent.type!==h?u[p]:u.parent[p][f];if("next"===p)m+=(g?Bs(g[f]):0)+2;else"prev"===p&&(m=g?-4:0)}return r(i.setSelection(Os(i,a+m))),!0}return!1}},n.prototype.addTable=function(){return function(e){return function(t,n){var r=t.selection,o=t.tr,s=t.schema,a=e,l=a.columnCount,c=a.rowCount,u=il(r).endToOffset,d=function(e){return[cc(e),cc(e,!0)]}(l),p=function(e,t){for(var n=[],r=0;r<t;r+=1)n.push(cc(e));return n}(l,c-1);return i(i([],d),p).forEach((function(e){o.split(o.mapping.map(u)).insert(o.mapping.map(u),Ns(s,e))})),n(o.setSelection(Os(o,u+4))),!0}}},n.prototype.commands=function(){return{addTable:this.addTable()}},n.prototype.keymaps=function(){return{Enter:this.extendTable(),Tab:this.moveTableCell(!0),"Shift-Tab":this.moveTableCell(!1)}},n}(Al),dc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"thematicBreak"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("thematic-break")},0]}}},enumerable:!1,configurable:!0}),n.prototype.hr=function(){return function(){return function(e,t){var n=e.selection,r=e.schema,o=e.tr,i=il(n),s=i.from,a=i.to,l=i.endToOffset,c=Ns(r,"***");return o.split(s).replaceWith(o.mapping.map(s),o.mapping.map(a),c).split(o.mapping.map(a)).setSelection(Os(o,o.mapping.map(l))),t(o),!0}}},n.prototype.commands=function(){return{hr:this.hr()}},n.prototype.keymaps=function(){var e=this.hr()();return{"Mod-l":e,"Mod-L":e}},n}(Al);function pc(e,t){var n=e.type;return t<=e.sourcepos[0][0]&&("codeBlock"===n||"heading"===n||n.match("table"))}var hc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"listItem"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{odd:{default:!1},even:{default:!1},listStyle:{default:!1}},toDOM:function(e){var t=e.attrs,n=t.odd,r=t.even,o="list-item";return t.listStyle&&(o+="|list-item-style"),n&&(o+="|list-item-odd"),r&&(o+="|list-item-even"),["span",{class:Ca.apply(void 0,o.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.extendList=function(){var e=this;return function(t,n){var r=t.selection,o=t.doc,i=t.schema,s=t.tr,a=e.context.toastMark,l=il(r),c=l.to,u=l.startFromOffset,d=l.endFromOffset,p=l.endIndex,h=l.endToOffset,f=Il(o,p);if(!Bl.test(f)||r.from===u||!r.empty)return!1;if(!f.replace(zl,"").trim())s.deleteRange(d,h).split(s.mapping.map(h));else{var m=$l(f),g=a.findFirstNodeAtLine(p+1),v=f.slice(c-d),y={toastMark:a,mdNode:g,doc:o,line:p+1},b=Zl[m](y),w=b.listSyntax,k=b.changedResults;if(null==k?void 0:k.length){s.split(c),k.unshift({text:w+v,line:p+1}),e.changeToListPerLine(s,k,{from:c,startLine:k[0].line,endLine:et(k).line});var x=s.mapping.map(h)-v.length;s.setSelection(Os(s,x))}else{Ls(s,h,v,Ns(i,w+v))}}return n(s),!0}},n.prototype.toList=function(e){var t=this;return function(){return function(n,r){for(var o=n.doc,i=n.tr,s=n.selection,a=t.context.toastMark,l=il(s),c=l.startIndex+1,u=l.endIndex+1,d=l.endToOffset,p=[],h=c;h<=u;h+=1){var f=a.findFirstNodeAtLine(h);if(f&&pc(f,h))break;if(-1===p.indexOf(h)){var m={toastMark:a,mdNode:f,doc:o,line:h,startLine:c},g=(Hs(f)?Gl[e](m):Kl[e](m)).changedResults,v=t.changeToListPerLine(i,g,{from:sl(o,g[0].line-1).startOffset,startLine:g[0].line,endLine:et(g).line,indexDiff:1});d=Math.max(v,d),g&&(p=p.concat(g.map((function(e){return e.line}))))}}return r(i.setSelection(Os(i,i.mapping.map(d)))),!0}}},n.prototype.changeToListPerLine=function(e,t,n){for(var r=n.from,o=n.startLine,i=n.endLine,s=n.indexDiff,a=void 0===s?0:s,l=0,c=function(n){var o=e.doc.child(n),i=o.nodeSize,s=o.content,c=e.mapping.map(r),d=c+s.size,p=t.filter((function(e){return e.line-a===n}))[0];p&&(e.replaceWith(c,d,Ns(u.context.schema,p.text)),l=Math.max(l,r+s.size)),r+=i},u=this,d=o-a;d<=i-a;d+=1)c(d);return l},n.prototype.toggleTask=function(){var e=this;return function(t,n){for(var r=t.selection,o=t.tr,i=t.doc,s=t.schema,a=e.context.toastMark,l=il(r),c=l.startIndex,u=l.endIndex,d=null,p=c;p<=u;p+=1){var h=a.findFirstNodeAtLine(p+1);if(Hs(h)&&h.listData.task){var f=h.listData,m=f.checked,g=f.padding,v=m?" ":"x",y=h.sourcepos[0],b=sl(i,y[0]-1).startOffset;b+=y[1]+g,d=o.replaceWith(b,b+1,s.text(v))}}return!!d&&(n(d),!0)}},n.prototype.commands=function(){return{bulletList:this.toList("bullet"),orderedList:this.toList("ordered"),taskList:this.toList("task")}},n.prototype.keymaps=function(){var e=this.toList("bullet")(),t=this.toList("ordered")(),n=this.toList("task")(),r=this.toggleTask();return{"Mod-u":e,"Mod-U":e,"Mod-o":t,"Mod-O":t,"alt-t":n,"alt-T":n,"Shift-Ctrl-x":r,"Shift-Ctrl-X":r,Enter:this.extendList()}},n}(Al);function fc(e,t){return function(){return function(n,r){var o=n.tr,i=n.selection,s=Ga()(e)?e:function(t){return e.test(t)},a=t.length,l=o.doc,c=Ya(i),u=c[0],d=c[1],p=Math.max(u-a,1),h=Math.min(d+a,l.content.size-1),f=i.content(),m=f.content.textBetween(0,f.content.size,"\n"),g=l.textBetween(p,u,"\n"),v=l.textBetween(d,h,"\n");if(m=""+g+m+v,g&&v&&s(m))o.delete(h-a,h).delete(p,p+a);else{o.insertText(t,d).insertText(t,u);var y=i.empty?Os(o,u+a):Os(o,u+a,d+a);o.setSelection(y)}return r(o),!0}}}var mc=/^(\*{2}|_{2}).*([\s\S]*)\1$/m,gc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strong"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("strong")},0]}}},enumerable:!1,configurable:!0}),n.prototype.bold=function(){return fc(mc,"**")},n.prototype.commands=function(){return{bold:this.bold()}},n.prototype.keymaps=function(){var e=this.bold()();return{"Mod-b":e,"Mod-B":e}},n}(Al),vc=/^(~{2}).*([\s\S]*)\1$/m,yc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strike"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("strike")},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return fc(vc,"~~")},n.prototype.keymaps=function(){var e=this.commands()();return{"Mod-s":e,"Mod-S":e}},n}(Al),bc=/^(\*|_).*([\s\S]*)\1$/m,wc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"emph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("emph")},0]}}},enumerable:!1,configurable:!0}),n.prototype.italic=function(){return fc(bc,"*")},n.prototype.commands=function(){return{italic:this.italic()}},n.prototype.keymaps=function(){var e=this.italic()();return{"Mod-i":e,"Mod-I":e}},n}(Al),kc=/^(`).*([\s\S]*)\1$/m,xc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"code"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{start:{default:!1},end:{default:!1},marked:{default:!1}},toDOM:function(e){var t=e.attrs,n="code";return t.start&&(n+="|delimiter|start"),t.end&&(n+="|delimiter|end"),t.marked&&(n+="|marked-text"),["span",{class:Ca.apply(void 0,n.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return fc(kc,"`")},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-c":e,"Shift-Mod-C":e}},n}(Al),Cc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"link"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{url:{default:!1},desc:{default:!1}},toDOM:function(e){var t=e.attrs,n="link";return t.url&&(n+="|link-url|marked-text"),t.desc&&(n+="|link-desc|marked-text"),["span",{class:Ca.apply(void 0,n.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.addLinkOrImage=function(e){return function(t){return function(n,r){var o=n.selection,i=n.tr,s=n.schema,a=Ya(o),l=a[0],c=a[1],u=t,d=u.linkText,p=u.altText,h=u.linkUrl,f=u.imageUrl,m=d,g=h,v="";return"image"===e&&(m=p,g=f,v="!"),v+="["+(m=Ze(m))+"]("+g+")",r(i.replaceWith(l,c,Ns(s,v))),!0}}},n.prototype.commands=function(){return{addImage:this.addLinkOrImage("image"),addLink:this.addLinkOrImage("link")}},n}(Al),Tc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"taskDelimiter"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("delimiter","list-item")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Mc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"delimiter"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("delimiter")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Sc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"meta"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("meta")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Ec=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"markedText"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("marked-text")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Nc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableCell"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("table-cell")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Oc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"html"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("html")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Dc="$$",Ac=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"customBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("custom-block")},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(e){return function(t,n){var r=t.selection,o=t.schema,i=t.tr,s=il(r),a=s.startFromOffset,l=s.endToOffset;if(!(null==e?void 0:e.info))return!1;var c="$$"+e.info,u=Ns(o,c),d=Ns(o,Dc);return i.insert(a,u).split(a+c.length),i.split(i.mapping.map(l)).insert(i.mapping.map(l),d),n(i.setSelection(Os(i,i.mapping.map(l)-(Dc.length+2)))),!0}}},n}(Al),Lc=/x|backspace/i,Ic=/^\[(\s*)(x?)(\s*)\](?:\s+)/i;var Rc="cut",Pc=/\r\n|\n|\r/,Bc=function(e){function n(t,n){var r=e.call(this,t)||this,i=n.toastMark,s=n.useCommandShortcut,a=void 0===s||s,l=n.mdPlugins,c=void 0===l?[]:l;return r.editorType="markdown",r.el.classList.add("md-mode"),r.toastMark=i,r.extraPlugins=c,r.specs=r.createSpecs(),r.schema=r.createSchema(),r.context=r.createContext(),r.keymaps=r.createKeymaps(a),r.view=r.createView(),r.commands=r.createCommands(),r.specs.setContext(o(o({},r.context),{view:r.view})),r.createClipboard(),r.eventEmitter.listen("changePreviewTabWrite",(function(e){return r.toggleActive(!0,e)})),r.eventEmitter.listen("changePreviewTabPreview",(function(){return r.toggleActive(!1)})),r.initEvent(),r}return t(n,e),n.prototype.toggleActive=function(e,t){Sa(this.el,"active",e),e?t||this.focus():this.blur()},n.prototype.createClipboard=function(){var e=this;this.clipboard=document.createElement("textarea"),this.clipboard.className=xa("pseudo-clipboard"),this.clipboard.addEventListener("paste",(function(t){var n=t.clipboardData||window.clipboardData,r=n&&n.items;if(r){var o=vi()(r).some((function(e){return"string"===e.kind&&"text/rtf"===e.type}));if(!o){var i=za(r);i&&(t.preventDefault(),Ha(e.eventEmitter,i,t.type))}}})),this.clipboard.addEventListener("input",(function(t){var n=t.target.value;e.replaceSelection(n),t.preventDefault(),t.target.value=""})),this.el.insertBefore(this.clipboard,this.view.dom)},n.prototype.createContext=function(){return{toastMark:this.toastMark,schema:this.schema,eventEmitter:this.eventEmitter}},n.prototype.createSpecs=function(){return new Qa([new Ol,new nc,new _a,new rc,new ic,new Pl,new ac,new Ac,new uc,new Nc,new dc,new hc,new gc,new yc,new wc,new xc,new Cc,new Mc,new Tc,new Ec,new Sc,new Oc])},n.prototype.createPlugins=function(){return i([Cl(this.context),Nl(this.context),(e=this.context,t=e.schema,n=e.toastMark,new an({props:{handleDOMEvents:{keyup:function(e,r){var o,i=e.state,s=i.doc,a=i.tr,l=i.selection;if(l.empty&&Lc.test(r.key)){var c=il(l),u=c.startIndex,d=c.startFromOffset,p=[u+1,c.from-d+1],h=js(n.findNodeAtPosition(p),(function(e){var t;return"paragraph"===e.type&&"item"===(null===(t=e.parent)||void 0===t?void 0:t.type)}));if(null===(o=null==h?void 0:h.firstChild)||void 0===o?void 0:o.literal){var f=h.firstChild,m=f.literal.match(Ic);if(m){var g=f.sourcepos[0],v=m[1],y=m[2],b=m[3],w=v.length+b.length,k=sl(s,g[0]-1).startOffset,x=g[1]+k;if(y){var C=w?w+1:0;a.replaceWith(x,C+x,t.text(y)),e.dispatch(a)}else w||(a.insertText(" ",x),e.dispatch(a))}}}return!1}}}}))],this.createPluginProps()).concat(this.defaultPlugins);var e,t,n},n.prototype.createView=function(){var e=this;return new ui(this.el,{state:this.createState(),dispatchTransaction:function(t){e.updateMarkdown(t);var n=e.view.state.applyTransaction(t).state;e.view.updateState(n),e.emitChangeEvent(t)},handleKeyDown:function(t,n){return(n.metaKey||n.ctrlKey)&&"V"===n.key.toUpperCase()&&e.clipboard.focus(),e.eventEmitter.emit("keydown",e.editorType,n),!1},handleDOMEvents:{copy:function(t,n){return e.captureCopy(n)},cut:function(t,n){return e.captureCopy(n,Rc)},scroll:function(){return e.eventEmitter.emit("scroll","editor"),!0},keyup:function(t,n){return e.eventEmitter.emit("keyup",e.editorType,n),!1}},nodeViews:{widget:ja}})},n.prototype.createCommands=function(){return this.specs.commands(this.view)},n.prototype.captureCopy=function(e,t){e.preventDefault();var n=this.view.state,r=n.selection,o=n.tr;if(r.empty)return!0;var i=this.getChanged(r.content());return e.clipboardData?e.clipboardData.setData("text/plain",i):window.clipboardData.setData("Text",i),t===Rc&&this.view.dispatch(o.deleteSelection().scrollIntoView().setMeta("uiEvent",Rc)),!0},n.prototype.updateMarkdown=function(e){var t=this;e.docChanged&&e.steps.forEach((function(n,r){if(n.slice&&!(n instanceof wt)){var o=e.docs[r],i=[n.from,n.to],s=nl(o,i[0],i[1]),a=s[0],l=s[1],c=t.getChanged(n.slice);a[0]===l[0]&&a[1]===l[1]&&""===c&&(c="\n");var u=t.toastMark.editMarkdown(a,l,c);t.eventEmitter.emit("updatePreview",u),e.setMeta("editResult",u).scrollIntoView()}}))},n.prototype.getChanged=function(e){var t="",n=e.content.size;return e.content.nodesBetween(0,n,(function(e,r){e.isText?t+=e.text.slice(Math.max(0,r)-r,n-r):e.isBlock&&r>0&&(t+="\n")})),t},n.prototype.setSelection=function(e,t){void 0===t&&(t=e);var n=this.view.state.tr,r=ol(n.doc,e,t),o=r[0],i=r[1];this.view.dispatch(n.setSelection(Os(n,o,i)).scrollIntoView())},n.prototype.replaceSelection=function(e,t,n){var r,o=this.view.state,i=o.tr,s=o.schema,a=o.doc,l=e.split(Pc).map((function(e){return Es(s,ra(e,s))})),c=new v(d.from(l),1,1);if(this.focus(),t&&n){var u=ol(a,t,n),p=u[0],h=u[1];r=i.replaceRange(p,h,c)}else r=i.replaceSelection(c);this.view.dispatch(r.scrollIntoView())},n.prototype.deleteSelection=function(e,t){var n,r=this.view.state,o=r.tr,i=r.doc;if(e&&t){var s=ol(i,e,t),a=s[0],l=s[1];n=o.deleteRange(a,l)}else n=o.deleteSelection();this.view.dispatch(n.scrollIntoView())},n.prototype.getSelectedText=function(e,t){var n=this.view.state,r=n.doc,o=n.selection,i=o.from,s=o.to;if(e&&t){var a=ol(r,e,t);i=a[0],s=a[1]}return r.textBetween(i,s,"\n")},n.prototype.getSelection=function(){var e=this.view.state.selection,t=e.from,n=e.to;return nl(this.view.state.tr.doc,t,n)},n.prototype.setMarkdown=function(e,t){void 0===t&&(t=!0);var n=e.split(Pc),r=this.view.state,o=r.tr,i=r.doc,s=r.schema,a=n.map((function(e){return Es(s,ra(e,s))}));this.view.dispatch(o.replaceWith(0,i.content.size,a)),t&&this.moveCursorToEnd(!0)},n.prototype.addWidget=function(e,t,n){var r=this.view.state,o=r.tr,i=r.doc,s=r.selection,a=n?ol(i,n,n)[0]:s.to;this.view.dispatch(o.setMeta("widget",{pos:a,node:e,style:t}))},n.prototype.replaceWithWidget=function(e,t,n){var r=this.view.state,o=r.tr,i=r.schema,s=ol(r.doc,e,t),a=ra(n,i);this.view.dispatch(o.replaceWith(s[0],s[1],a))},n.prototype.getRangeInfoOfNode=function(e){var t=this.view.state,n=t.doc,r=t.selection,o=e||nl(n,r.from)[0],i=this.toastMark.findNodeAtPosition(o);return"text"===i.type&&"paragraph"!==i.parent.type&&(i=i.parent),i.sourcepos[1][1]+=1,{range:i.sourcepos,type:i.type}},n.prototype.getMarkdown=function(){return this.toastMark.getLineTexts().map((function(e){return Xs(e)})).join("\n")},n.prototype.getToastMark=function(){return this.toastMark},n}(Wa),Fc=Bc,Hc=n(349),zc=n.n(Hc),qc=n(348),Vc=n.n(qc),jc=function(e,t){return jc=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n])},jc(e,t)};function $c(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");function n(){this.constructor=e}jc(e,t),e.prototype=null===t?Object.create(t):(n.prototype=t.prototype,new n)}var _c=function(){return _c=Object.assign||function(e){for(var t,n=1,r=arguments.length;n<r;n++)for(var o in t=arguments[n])Object.prototype.hasOwnProperty.call(t,o)&&(e[o]=t[o]);return e},_c.apply(this,arguments)};function Uc(e,t,n){if(n||2===arguments.length)for(var r,o=0,i=t.length;o<i;o++)!r&&o in t||(r||(r=Array.prototype.slice.call(t,0,o)),r[o]=t[o]);return e.concat(r||Array.prototype.slice.call(t))}var Wc="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:void 0!==n.g?n.g:"undefined"!=typeof self?self:{},Jc={};function Gc(e,t,n){var r,o,i,s,a,l="";for("string"!=typeof t&&(n=t,t=Gc.defaultChars),void 0===n&&(n=!0),a=function(e){var t,n,r=Jc[e];if(r)return r;for(r=Jc[e]=[],t=0;t<128;t++)n=String.fromCharCode(t),/^[0-9a-z]$/i.test(n)?r.push(n):r.push("%"+("0"+t.toString(16).toUpperCase()).slice(-2));for(t=0;t<e.length;t++)r[e.charCodeAt(t)]=e[t];return r}(t),r=0,o=e.length;r<o;r++)if(i=e.charCodeAt(r),n&&37===i&&r+2<o&&/^[0-9a-f]{2}$/i.test(e.slice(r+1,r+3)))l+=e.slice(r,r+3),r+=2;else if(i<128)l+=a[i];else if(i>=55296&&i<=57343){if(i>=55296&&i<=56319&&r+1<o&&(s=e.charCodeAt(r+1))>=56320&&s<=57343){l+=encodeURIComponent(e[r]+e[r+1]),r++;continue}l+="%EF%BF%BD"}else l+=encodeURIComponent(e[r]);return l}Gc.defaultChars=";/?:@&=+$,-_.!~*'()#",Gc.componentChars="-_.!~*'()";var Kc=Gc,Zc={},Xc={},Qc={Aacute:"Á",aacute:"á",Abreve:"Ă",abreve:"ă",ac:"∾",acd:"∿",acE:"∾̳",Acirc:"Â",acirc:"â",acute:"´",Acy:"А",acy:"а",AElig:"Æ",aelig:"æ",af:"⁡",Afr:"𝔄",afr:"𝔞",Agrave:"À",agrave:"à",alefsym:"ℵ",aleph:"ℵ",Alpha:"Α",alpha:"α",Amacr:"Ā",amacr:"ā",amalg:"⨿",amp:"&",AMP:"&",andand:"⩕",And:"⩓",and:"∧",andd:"⩜",andslope:"⩘",andv:"⩚",ang:"∠",ange:"⦤",angle:"∠",angmsdaa:"⦨",angmsdab:"⦩",angmsdac:"⦪",angmsdad:"⦫",angmsdae:"⦬",angmsdaf:"⦭",angmsdag:"⦮",angmsdah:"⦯",angmsd:"∡",angrt:"∟",angrtvb:"⊾",angrtvbd:"⦝",angsph:"∢",angst:"Å",angzarr:"⍼",Aogon:"Ą",aogon:"ą",Aopf:"𝔸",aopf:"𝕒",apacir:"⩯",ap:"≈",apE:"⩰",ape:"≊",apid:"≋",apos:"'",ApplyFunction:"⁡",approx:"≈",approxeq:"≊",Aring:"Å",aring:"å",Ascr:"𝒜",ascr:"𝒶",Assign:"≔",ast:"*",asymp:"≈",asympeq:"≍",Atilde:"Ã",atilde:"ã",Auml:"Ä",auml:"ä",awconint:"∳",awint:"⨑",backcong:"≌",backepsilon:"϶",backprime:"‵",backsim:"∽",backsimeq:"⋍",Backslash:"∖",Barv:"⫧",barvee:"⊽",barwed:"⌅",Barwed:"⌆",barwedge:"⌅",bbrk:"⎵",bbrktbrk:"⎶",bcong:"≌",Bcy:"Б",bcy:"б",bdquo:"„",becaus:"∵",because:"∵",Because:"∵",bemptyv:"⦰",bepsi:"϶",bernou:"ℬ",Bernoullis:"ℬ",Beta:"Β",beta:"β",beth:"ℶ",between:"≬",Bfr:"𝔅",bfr:"𝔟",bigcap:"⋂",bigcirc:"◯",bigcup:"⋃",bigodot:"⨀",bigoplus:"⨁",bigotimes:"⨂",bigsqcup:"⨆",bigstar:"★",bigtriangledown:"▽",bigtriangleup:"△",biguplus:"⨄",bigvee:"⋁",bigwedge:"⋀",bkarow:"⤍",blacklozenge:"⧫",blacksquare:"▪",blacktriangle:"▴",blacktriangledown:"▾",blacktriangleleft:"◂",blacktriangleright:"▸",blank:"␣",blk12:"▒",blk14:"░",blk34:"▓",block:"█",bne:"=⃥",bnequiv:"≡⃥",bNot:"⫭",bnot:"⌐",Bopf:"𝔹",bopf:"𝕓",bot:"⊥",bottom:"⊥",bowtie:"⋈",boxbox:"⧉",boxdl:"┐",boxdL:"╕",boxDl:"╖",boxDL:"╗",boxdr:"┌",boxdR:"╒",boxDr:"╓",boxDR:"╔",boxh:"─",boxH:"═",boxhd:"┬",boxHd:"╤",boxhD:"╥",boxHD:"╦",boxhu:"┴",boxHu:"╧",boxhU:"╨",boxHU:"╩",boxminus:"⊟",boxplus:"⊞",boxtimes:"⊠",boxul:"┘",boxuL:"╛",boxUl:"╜",boxUL:"╝",boxur:"└",boxuR:"╘",boxUr:"╙",boxUR:"╚",boxv:"│",boxV:"║",boxvh:"┼",boxvH:"╪",boxVh:"╫",boxVH:"╬",boxvl:"┤",boxvL:"╡",boxVl:"╢",boxVL:"╣",boxvr:"├",boxvR:"╞",boxVr:"╟",boxVR:"╠",bprime:"‵",breve:"˘",Breve:"˘",brvbar:"¦",bscr:"𝒷",Bscr:"ℬ",bsemi:"⁏",bsim:"∽",bsime:"⋍",bsolb:"⧅",bsol:"\\",bsolhsub:"⟈",bull:"•",bullet:"•",bump:"≎",bumpE:"⪮",bumpe:"≏",Bumpeq:"≎",bumpeq:"≏",Cacute:"Ć",cacute:"ć",capand:"⩄",capbrcup:"⩉",capcap:"⩋",cap:"∩",Cap:"⋒",capcup:"⩇",capdot:"⩀",CapitalDifferentialD:"ⅅ",caps:"∩︀",caret:"⁁",caron:"ˇ",Cayleys:"ℭ",ccaps:"⩍",Ccaron:"Č",ccaron:"č",Ccedil:"Ç",ccedil:"ç",Ccirc:"Ĉ",ccirc:"ĉ",Cconint:"∰",ccups:"⩌",ccupssm:"⩐",Cdot:"Ċ",cdot:"ċ",cedil:"¸",Cedilla:"¸",cemptyv:"⦲",cent:"¢",centerdot:"·",CenterDot:"·",cfr:"𝔠",Cfr:"ℭ",CHcy:"Ч",chcy:"ч",check:"✓",checkmark:"✓",Chi:"Χ",chi:"χ",circ:"ˆ",circeq:"≗",circlearrowleft:"↺",circlearrowright:"↻",circledast:"⊛",circledcirc:"⊚",circleddash:"⊝",CircleDot:"⊙",circledR:"®",circledS:"Ⓢ",CircleMinus:"⊖",CirclePlus:"⊕",CircleTimes:"⊗",cir:"○",cirE:"⧃",cire:"≗",cirfnint:"⨐",cirmid:"⫯",cirscir:"⧂",ClockwiseContourIntegral:"∲",CloseCurlyDoubleQuote:"”",CloseCurlyQuote:"’",clubs:"♣",clubsuit:"♣",colon:":",Colon:"∷",Colone:"⩴",colone:"≔",coloneq:"≔",comma:",",commat:"@",comp:"∁",compfn:"∘",complement:"∁",complexes:"ℂ",cong:"≅",congdot:"⩭",Congruent:"≡",conint:"∮",Conint:"∯",ContourIntegral:"∮",copf:"𝕔",Copf:"ℂ",coprod:"∐",Coproduct:"∐",copy:"©",COPY:"©",copysr:"℗",CounterClockwiseContourIntegral:"∳",crarr:"↵",cross:"✗",Cross:"⨯",Cscr:"𝒞",cscr:"𝒸",csub:"⫏",csube:"⫑",csup:"⫐",csupe:"⫒",ctdot:"⋯",cudarrl:"⤸",cudarrr:"⤵",cuepr:"⋞",cuesc:"⋟",cularr:"↶",cularrp:"⤽",cupbrcap:"⩈",cupcap:"⩆",CupCap:"≍",cup:"∪",Cup:"⋓",cupcup:"⩊",cupdot:"⊍",cupor:"⩅",cups:"∪︀",curarr:"↷",curarrm:"⤼",curlyeqprec:"⋞",curlyeqsucc:"⋟",curlyvee:"⋎",curlywedge:"⋏",curren:"¤",curvearrowleft:"↶",curvearrowright:"↷",cuvee:"⋎",cuwed:"⋏",cwconint:"∲",cwint:"∱",cylcty:"⌭",dagger:"†",Dagger:"‡",daleth:"ℸ",darr:"↓",Darr:"↡",dArr:"⇓",dash:"‐",Dashv:"⫤",dashv:"⊣",dbkarow:"⤏",dblac:"˝",Dcaron:"Ď",dcaron:"ď",Dcy:"Д",dcy:"д",ddagger:"‡",ddarr:"⇊",DD:"ⅅ",dd:"ⅆ",DDotrahd:"⤑",ddotseq:"⩷",deg:"°",Del:"∇",Delta:"Δ",delta:"δ",demptyv:"⦱",dfisht:"⥿",Dfr:"𝔇",dfr:"𝔡",dHar:"⥥",dharl:"⇃",dharr:"⇂",DiacriticalAcute:"´",DiacriticalDot:"˙",DiacriticalDoubleAcute:"˝",DiacriticalGrave:"`",DiacriticalTilde:"˜",diam:"⋄",diamond:"⋄",Diamond:"⋄",diamondsuit:"♦",diams:"♦",die:"¨",DifferentialD:"ⅆ",digamma:"ϝ",disin:"⋲",div:"÷",divide:"÷",divideontimes:"⋇",divonx:"⋇",DJcy:"Ђ",djcy:"ђ",dlcorn:"⌞",dlcrop:"⌍",dollar:"$",Dopf:"𝔻",dopf:"𝕕",Dot:"¨",dot:"˙",DotDot:"⃜",doteq:"≐",doteqdot:"≑",DotEqual:"≐",dotminus:"∸",dotplus:"∔",dotsquare:"⊡",doublebarwedge:"⌆",DoubleContourIntegral:"∯",DoubleDot:"¨",DoubleDownArrow:"⇓",DoubleLeftArrow:"⇐",DoubleLeftRightArrow:"⇔",DoubleLeftTee:"⫤",DoubleLongLeftArrow:"⟸",DoubleLongLeftRightArrow:"⟺",DoubleLongRightArrow:"⟹",DoubleRightArrow:"⇒",DoubleRightTee:"⊨",DoubleUpArrow:"⇑",DoubleUpDownArrow:"⇕",DoubleVerticalBar:"∥",DownArrowBar:"⤓",downarrow:"↓",DownArrow:"↓",Downarrow:"⇓",DownArrowUpArrow:"⇵",DownBreve:"̑",downdownarrows:"⇊",downharpoonleft:"⇃",downharpoonright:"⇂",DownLeftRightVector:"⥐",DownLeftTeeVector:"⥞",DownLeftVectorBar:"⥖",DownLeftVector:"↽",DownRightTeeVector:"⥟",DownRightVectorBar:"⥗",DownRightVector:"⇁",DownTeeArrow:"↧",DownTee:"⊤",drbkarow:"⤐",drcorn:"⌟",drcrop:"⌌",Dscr:"𝒟",dscr:"𝒹",DScy:"Ѕ",dscy:"ѕ",dsol:"⧶",Dstrok:"Đ",dstrok:"đ",dtdot:"⋱",dtri:"▿",dtrif:"▾",duarr:"⇵",duhar:"⥯",dwangle:"⦦",DZcy:"Џ",dzcy:"џ",dzigrarr:"⟿",Eacute:"É",eacute:"é",easter:"⩮",Ecaron:"Ě",ecaron:"ě",Ecirc:"Ê",ecirc:"ê",ecir:"≖",ecolon:"≕",Ecy:"Э",ecy:"э",eDDot:"⩷",Edot:"Ė",edot:"ė",eDot:"≑",ee:"ⅇ",efDot:"≒",Efr:"𝔈",efr:"𝔢",eg:"⪚",Egrave:"È",egrave:"è",egs:"⪖",egsdot:"⪘",el:"⪙",Element:"∈",elinters:"⏧",ell:"ℓ",els:"⪕",elsdot:"⪗",Emacr:"Ē",emacr:"ē",empty:"∅",emptyset:"∅",EmptySmallSquare:"◻",emptyv:"∅",EmptyVerySmallSquare:"▫",emsp13:" ",emsp14:" ",emsp:" ",ENG:"Ŋ",eng:"ŋ",ensp:" ",Eogon:"Ę",eogon:"ę",Eopf:"𝔼",eopf:"𝕖",epar:"⋕",eparsl:"⧣",eplus:"⩱",epsi:"ε",Epsilon:"Ε",epsilon:"ε",epsiv:"ϵ",eqcirc:"≖",eqcolon:"≕",eqsim:"≂",eqslantgtr:"⪖",eqslantless:"⪕",Equal:"⩵",equals:"=",EqualTilde:"≂",equest:"≟",Equilibrium:"⇌",equiv:"≡",equivDD:"⩸",eqvparsl:"⧥",erarr:"⥱",erDot:"≓",escr:"ℯ",Escr:"ℰ",esdot:"≐",Esim:"⩳",esim:"≂",Eta:"Η",eta:"η",ETH:"Ð",eth:"ð",Euml:"Ë",euml:"ë",euro:"€",excl:"!",exist:"∃",Exists:"∃",expectation:"ℰ",exponentiale:"ⅇ",ExponentialE:"ⅇ",fallingdotseq:"≒",Fcy:"Ф",fcy:"ф",female:"♀",ffilig:"ffi",fflig:"ff",ffllig:"ffl",Ffr:"𝔉",ffr:"𝔣",filig:"fi",FilledSmallSquare:"◼",FilledVerySmallSquare:"▪",fjlig:"fj",flat:"♭",fllig:"fl",fltns:"▱",fnof:"ƒ",Fopf:"𝔽",fopf:"𝕗",forall:"∀",ForAll:"∀",fork:"⋔",forkv:"⫙",Fouriertrf:"ℱ",fpartint:"⨍",frac12:"½",frac13:"⅓",frac14:"¼",frac15:"⅕",frac16:"⅙",frac18:"⅛",frac23:"⅔",frac25:"⅖",frac34:"¾",frac35:"⅗",frac38:"⅜",frac45:"⅘",frac56:"⅚",frac58:"⅝",frac78:"⅞",frasl:"⁄",frown:"⌢",fscr:"𝒻",Fscr:"ℱ",gacute:"ǵ",Gamma:"Γ",gamma:"γ",Gammad:"Ϝ",gammad:"ϝ",gap:"⪆",Gbreve:"Ğ",gbreve:"ğ",Gcedil:"Ģ",Gcirc:"Ĝ",gcirc:"ĝ",Gcy:"Г",gcy:"г",Gdot:"Ġ",gdot:"ġ",ge:"≥",gE:"≧",gEl:"⪌",gel:"⋛",geq:"≥",geqq:"≧",geqslant:"⩾",gescc:"⪩",ges:"⩾",gesdot:"⪀",gesdoto:"⪂",gesdotol:"⪄",gesl:"⋛︀",gesles:"⪔",Gfr:"𝔊",gfr:"𝔤",gg:"≫",Gg:"⋙",ggg:"⋙",gimel:"ℷ",GJcy:"Ѓ",gjcy:"ѓ",gla:"⪥",gl:"≷",glE:"⪒",glj:"⪤",gnap:"⪊",gnapprox:"⪊",gne:"⪈",gnE:"≩",gneq:"⪈",gneqq:"≩",gnsim:"⋧",Gopf:"𝔾",gopf:"𝕘",grave:"`",GreaterEqual:"≥",GreaterEqualLess:"⋛",GreaterFullEqual:"≧",GreaterGreater:"⪢",GreaterLess:"≷",GreaterSlantEqual:"⩾",GreaterTilde:"≳",Gscr:"𝒢",gscr:"ℊ",gsim:"≳",gsime:"⪎",gsiml:"⪐",gtcc:"⪧",gtcir:"⩺",gt:">",GT:">",Gt:"≫",gtdot:"⋗",gtlPar:"⦕",gtquest:"⩼",gtrapprox:"⪆",gtrarr:"⥸",gtrdot:"⋗",gtreqless:"⋛",gtreqqless:"⪌",gtrless:"≷",gtrsim:"≳",gvertneqq:"≩︀",gvnE:"≩︀",Hacek:"ˇ",hairsp:" ",half:"½",hamilt:"ℋ",HARDcy:"Ъ",hardcy:"ъ",harrcir:"⥈",harr:"↔",hArr:"⇔",harrw:"↭",Hat:"^",hbar:"ℏ",Hcirc:"Ĥ",hcirc:"ĥ",hearts:"♥",heartsuit:"♥",hellip:"…",hercon:"⊹",hfr:"𝔥",Hfr:"ℌ",HilbertSpace:"ℋ",hksearow:"⤥",hkswarow:"⤦",hoarr:"⇿",homtht:"∻",hookleftarrow:"↩",hookrightarrow:"↪",hopf:"𝕙",Hopf:"ℍ",horbar:"―",HorizontalLine:"─",hscr:"𝒽",Hscr:"ℋ",hslash:"ℏ",Hstrok:"Ħ",hstrok:"ħ",HumpDownHump:"≎",HumpEqual:"≏",hybull:"⁃",hyphen:"‐",Iacute:"Í",iacute:"í",ic:"⁣",Icirc:"Î",icirc:"î",Icy:"И",icy:"и",Idot:"İ",IEcy:"Е",iecy:"е",iexcl:"¡",iff:"⇔",ifr:"𝔦",Ifr:"ℑ",Igrave:"Ì",igrave:"ì",ii:"ⅈ",iiiint:"⨌",iiint:"∭",iinfin:"⧜",iiota:"℩",IJlig:"IJ",ijlig:"ij",Imacr:"Ī",imacr:"ī",image:"ℑ",ImaginaryI:"ⅈ",imagline:"ℐ",imagpart:"ℑ",imath:"ı",Im:"ℑ",imof:"⊷",imped:"Ƶ",Implies:"⇒",incare:"℅",in:"∈",infin:"∞",infintie:"⧝",inodot:"ı",intcal:"⊺",int:"∫",Int:"∬",integers:"ℤ",Integral:"∫",intercal:"⊺",Intersection:"⋂",intlarhk:"⨗",intprod:"⨼",InvisibleComma:"⁣",InvisibleTimes:"⁢",IOcy:"Ё",iocy:"ё",Iogon:"Į",iogon:"į",Iopf:"𝕀",iopf:"𝕚",Iota:"Ι",iota:"ι",iprod:"⨼",iquest:"¿",iscr:"𝒾",Iscr:"ℐ",isin:"∈",isindot:"⋵",isinE:"⋹",isins:"⋴",isinsv:"⋳",isinv:"∈",it:"⁢",Itilde:"Ĩ",itilde:"ĩ",Iukcy:"І",iukcy:"і",Iuml:"Ï",iuml:"ï",Jcirc:"Ĵ",jcirc:"ĵ",Jcy:"Й",jcy:"й",Jfr:"𝔍",jfr:"𝔧",jmath:"ȷ",Jopf:"𝕁",jopf:"𝕛",Jscr:"𝒥",jscr:"𝒿",Jsercy:"Ј",jsercy:"ј",Jukcy:"Є",jukcy:"є",Kappa:"Κ",kappa:"κ",kappav:"ϰ",Kcedil:"Ķ",kcedil:"ķ",Kcy:"К",kcy:"к",Kfr:"𝔎",kfr:"𝔨",kgreen:"ĸ",KHcy:"Х",khcy:"х",KJcy:"Ќ",kjcy:"ќ",Kopf:"𝕂",kopf:"𝕜",Kscr:"𝒦",kscr:"𝓀",lAarr:"⇚",Lacute:"Ĺ",lacute:"ĺ",laemptyv:"⦴",lagran:"ℒ",Lambda:"Λ",lambda:"λ",lang:"⟨",Lang:"⟪",langd:"⦑",langle:"⟨",lap:"⪅",Laplacetrf:"ℒ",laquo:"«",larrb:"⇤",larrbfs:"⤟",larr:"←",Larr:"↞",lArr:"⇐",larrfs:"⤝",larrhk:"↩",larrlp:"↫",larrpl:"⤹",larrsim:"⥳",larrtl:"↢",latail:"⤙",lAtail:"⤛",lat:"⪫",late:"⪭",lates:"⪭︀",lbarr:"⤌",lBarr:"⤎",lbbrk:"❲",lbrace:"{",lbrack:"[",lbrke:"⦋",lbrksld:"⦏",lbrkslu:"⦍",Lcaron:"Ľ",lcaron:"ľ",Lcedil:"Ļ",lcedil:"ļ",lceil:"⌈",lcub:"{",Lcy:"Л",lcy:"л",ldca:"⤶",ldquo:"“",ldquor:"„",ldrdhar:"⥧",ldrushar:"⥋",ldsh:"↲",le:"≤",lE:"≦",LeftAngleBracket:"⟨",LeftArrowBar:"⇤",leftarrow:"←",LeftArrow:"←",Leftarrow:"⇐",LeftArrowRightArrow:"⇆",leftarrowtail:"↢",LeftCeiling:"⌈",LeftDoubleBracket:"⟦",LeftDownTeeVector:"⥡",LeftDownVectorBar:"⥙",LeftDownVector:"⇃",LeftFloor:"⌊",leftharpoondown:"↽",leftharpoonup:"↼",leftleftarrows:"⇇",leftrightarrow:"↔",LeftRightArrow:"↔",Leftrightarrow:"⇔",leftrightarrows:"⇆",leftrightharpoons:"⇋",leftrightsquigarrow:"↭",LeftRightVector:"⥎",LeftTeeArrow:"↤",LeftTee:"⊣",LeftTeeVector:"⥚",leftthreetimes:"⋋",LeftTriangleBar:"⧏",LeftTriangle:"⊲",LeftTriangleEqual:"⊴",LeftUpDownVector:"⥑",LeftUpTeeVector:"⥠",LeftUpVectorBar:"⥘",LeftUpVector:"↿",LeftVectorBar:"⥒",LeftVector:"↼",lEg:"⪋",leg:"⋚",leq:"≤",leqq:"≦",leqslant:"⩽",lescc:"⪨",les:"⩽",lesdot:"⩿",lesdoto:"⪁",lesdotor:"⪃",lesg:"⋚︀",lesges:"⪓",lessapprox:"⪅",lessdot:"⋖",lesseqgtr:"⋚",lesseqqgtr:"⪋",LessEqualGreater:"⋚",LessFullEqual:"≦",LessGreater:"≶",lessgtr:"≶",LessLess:"⪡",lesssim:"≲",LessSlantEqual:"⩽",LessTilde:"≲",lfisht:"⥼",lfloor:"⌊",Lfr:"𝔏",lfr:"𝔩",lg:"≶",lgE:"⪑",lHar:"⥢",lhard:"↽",lharu:"↼",lharul:"⥪",lhblk:"▄",LJcy:"Љ",ljcy:"љ",llarr:"⇇",ll:"≪",Ll:"⋘",llcorner:"⌞",Lleftarrow:"⇚",llhard:"⥫",lltri:"◺",Lmidot:"Ŀ",lmidot:"ŀ",lmoustache:"⎰",lmoust:"⎰",lnap:"⪉",lnapprox:"⪉",lne:"⪇",lnE:"≨",lneq:"⪇",lneqq:"≨",lnsim:"⋦",loang:"⟬",loarr:"⇽",lobrk:"⟦",longleftarrow:"⟵",LongLeftArrow:"⟵",Longleftarrow:"⟸",longleftrightarrow:"⟷",LongLeftRightArrow:"⟷",Longleftrightarrow:"⟺",longmapsto:"⟼",longrightarrow:"⟶",LongRightArrow:"⟶",Longrightarrow:"⟹",looparrowleft:"↫",looparrowright:"↬",lopar:"⦅",Lopf:"𝕃",lopf:"𝕝",loplus:"⨭",lotimes:"⨴",lowast:"∗",lowbar:"_",LowerLeftArrow:"↙",LowerRightArrow:"↘",loz:"◊",lozenge:"◊",lozf:"⧫",lpar:"(",lparlt:"⦓",lrarr:"⇆",lrcorner:"⌟",lrhar:"⇋",lrhard:"⥭",lrm:"‎",lrtri:"⊿",lsaquo:"‹",lscr:"𝓁",Lscr:"ℒ",lsh:"↰",Lsh:"↰",lsim:"≲",lsime:"⪍",lsimg:"⪏",lsqb:"[",lsquo:"‘",lsquor:"‚",Lstrok:"Ł",lstrok:"ł",ltcc:"⪦",ltcir:"⩹",lt:"<",LT:"<",Lt:"≪",ltdot:"⋖",lthree:"⋋",ltimes:"⋉",ltlarr:"⥶",ltquest:"⩻",ltri:"◃",ltrie:"⊴",ltrif:"◂",ltrPar:"⦖",lurdshar:"⥊",luruhar:"⥦",lvertneqq:"≨︀",lvnE:"≨︀",macr:"¯",male:"♂",malt:"✠",maltese:"✠",Map:"⤅",map:"↦",mapsto:"↦",mapstodown:"↧",mapstoleft:"↤",mapstoup:"↥",marker:"▮",mcomma:"⨩",Mcy:"М",mcy:"м",mdash:"—",mDDot:"∺",measuredangle:"∡",MediumSpace:" ",Mellintrf:"ℳ",Mfr:"𝔐",mfr:"𝔪",mho:"℧",micro:"µ",midast:"*",midcir:"⫰",mid:"∣",middot:"·",minusb:"⊟",minus:"−",minusd:"∸",minusdu:"⨪",MinusPlus:"∓",mlcp:"⫛",mldr:"…",mnplus:"∓",models:"⊧",Mopf:"𝕄",mopf:"𝕞",mp:"∓",mscr:"𝓂",Mscr:"ℳ",mstpos:"∾",Mu:"Μ",mu:"μ",multimap:"⊸",mumap:"⊸",nabla:"∇",Nacute:"Ń",nacute:"ń",nang:"∠⃒",nap:"≉",napE:"⩰̸",napid:"≋̸",napos:"ʼn",napprox:"≉",natural:"♮",naturals:"ℕ",natur:"♮",nbsp:" ",nbump:"≎̸",nbumpe:"≏̸",ncap:"⩃",Ncaron:"Ň",ncaron:"ň",Ncedil:"Ņ",ncedil:"ņ",ncong:"≇",ncongdot:"⩭̸",ncup:"⩂",Ncy:"Н",ncy:"н",ndash:"–",nearhk:"⤤",nearr:"↗",neArr:"⇗",nearrow:"↗",ne:"≠",nedot:"≐̸",NegativeMediumSpace:"​",NegativeThickSpace:"​",NegativeThinSpace:"​",NegativeVeryThinSpace:"​",nequiv:"≢",nesear:"⤨",nesim:"≂̸",NestedGreaterGreater:"≫",NestedLessLess:"≪",NewLine:"\n",nexist:"∄",nexists:"∄",Nfr:"𝔑",nfr:"𝔫",ngE:"≧̸",nge:"≱",ngeq:"≱",ngeqq:"≧̸",ngeqslant:"⩾̸",nges:"⩾̸",nGg:"⋙̸",ngsim:"≵",nGt:"≫⃒",ngt:"≯",ngtr:"≯",nGtv:"≫̸",nharr:"↮",nhArr:"⇎",nhpar:"⫲",ni:"∋",nis:"⋼",nisd:"⋺",niv:"∋",NJcy:"Њ",njcy:"њ",nlarr:"↚",nlArr:"⇍",nldr:"‥",nlE:"≦̸",nle:"≰",nleftarrow:"↚",nLeftarrow:"⇍",nleftrightarrow:"↮",nLeftrightarrow:"⇎",nleq:"≰",nleqq:"≦̸",nleqslant:"⩽̸",nles:"⩽̸",nless:"≮",nLl:"⋘̸",nlsim:"≴",nLt:"≪⃒",nlt:"≮",nltri:"⋪",nltrie:"⋬",nLtv:"≪̸",nmid:"∤",NoBreak:"⁠",NonBreakingSpace:" ",nopf:"𝕟",Nopf:"ℕ",Not:"⫬",not:"¬",NotCongruent:"≢",NotCupCap:"≭",NotDoubleVerticalBar:"∦",NotElement:"∉",NotEqual:"≠",NotEqualTilde:"≂̸",NotExists:"∄",NotGreater:"≯",NotGreaterEqual:"≱",NotGreaterFullEqual:"≧̸",NotGreaterGreater:"≫̸",NotGreaterLess:"≹",NotGreaterSlantEqual:"⩾̸",NotGreaterTilde:"≵",NotHumpDownHump:"≎̸",NotHumpEqual:"≏̸",notin:"∉",notindot:"⋵̸",notinE:"⋹̸",notinva:"∉",notinvb:"⋷",notinvc:"⋶",NotLeftTriangleBar:"⧏̸",NotLeftTriangle:"⋪",NotLeftTriangleEqual:"⋬",NotLess:"≮",NotLessEqual:"≰",NotLessGreater:"≸",NotLessLess:"≪̸",NotLessSlantEqual:"⩽̸",NotLessTilde:"≴",NotNestedGreaterGreater:"⪢̸",NotNestedLessLess:"⪡̸",notni:"∌",notniva:"∌",notnivb:"⋾",notnivc:"⋽",NotPrecedes:"⊀",NotPrecedesEqual:"⪯̸",NotPrecedesSlantEqual:"⋠",NotReverseElement:"∌",NotRightTriangleBar:"⧐̸",NotRightTriangle:"⋫",NotRightTriangleEqual:"⋭",NotSquareSubset:"⊏̸",NotSquareSubsetEqual:"⋢",NotSquareSuperset:"⊐̸",NotSquareSupersetEqual:"⋣",NotSubset:"⊂⃒",NotSubsetEqual:"⊈",NotSucceeds:"⊁",NotSucceedsEqual:"⪰̸",NotSucceedsSlantEqual:"⋡",NotSucceedsTilde:"≿̸",NotSuperset:"⊃⃒",NotSupersetEqual:"⊉",NotTilde:"≁",NotTildeEqual:"≄",NotTildeFullEqual:"≇",NotTildeTilde:"≉",NotVerticalBar:"∤",nparallel:"∦",npar:"∦",nparsl:"⫽⃥",npart:"∂̸",npolint:"⨔",npr:"⊀",nprcue:"⋠",nprec:"⊀",npreceq:"⪯̸",npre:"⪯̸",nrarrc:"⤳̸",nrarr:"↛",nrArr:"⇏",nrarrw:"↝̸",nrightarrow:"↛",nRightarrow:"⇏",nrtri:"⋫",nrtrie:"⋭",nsc:"⊁",nsccue:"⋡",nsce:"⪰̸",Nscr:"𝒩",nscr:"𝓃",nshortmid:"∤",nshortparallel:"∦",nsim:"≁",nsime:"≄",nsimeq:"≄",nsmid:"∤",nspar:"∦",nsqsube:"⋢",nsqsupe:"⋣",nsub:"⊄",nsubE:"⫅̸",nsube:"⊈",nsubset:"⊂⃒",nsubseteq:"⊈",nsubseteqq:"⫅̸",nsucc:"⊁",nsucceq:"⪰̸",nsup:"⊅",nsupE:"⫆̸",nsupe:"⊉",nsupset:"⊃⃒",nsupseteq:"⊉",nsupseteqq:"⫆̸",ntgl:"≹",Ntilde:"Ñ",ntilde:"ñ",ntlg:"≸",ntriangleleft:"⋪",ntrianglelefteq:"⋬",ntriangleright:"⋫",ntrianglerighteq:"⋭",Nu:"Ν",nu:"ν",num:"#",numero:"№",numsp:" ",nvap:"≍⃒",nvdash:"⊬",nvDash:"⊭",nVdash:"⊮",nVDash:"⊯",nvge:"≥⃒",nvgt:">⃒",nvHarr:"⤄",nvinfin:"⧞",nvlArr:"⤂",nvle:"≤⃒",nvlt:"<⃒",nvltrie:"⊴⃒",nvrArr:"⤃",nvrtrie:"⊵⃒",nvsim:"∼⃒",nwarhk:"⤣",nwarr:"↖",nwArr:"⇖",nwarrow:"↖",nwnear:"⤧",Oacute:"Ó",oacute:"ó",oast:"⊛",Ocirc:"Ô",ocirc:"ô",ocir:"⊚",Ocy:"О",ocy:"о",odash:"⊝",Odblac:"Ő",odblac:"ő",odiv:"⨸",odot:"⊙",odsold:"⦼",OElig:"Œ",oelig:"œ",ofcir:"⦿",Ofr:"𝔒",ofr:"𝔬",ogon:"˛",Ograve:"Ò",ograve:"ò",ogt:"⧁",ohbar:"⦵",ohm:"Ω",oint:"∮",olarr:"↺",olcir:"⦾",olcross:"⦻",oline:"‾",olt:"⧀",Omacr:"Ō",omacr:"ō",Omega:"Ω",omega:"ω",Omicron:"Ο",omicron:"ο",omid:"⦶",ominus:"⊖",Oopf:"𝕆",oopf:"𝕠",opar:"⦷",OpenCurlyDoubleQuote:"“",OpenCurlyQuote:"‘",operp:"⦹",oplus:"⊕",orarr:"↻",Or:"⩔",or:"∨",ord:"⩝",order:"ℴ",orderof:"ℴ",ordf:"ª",ordm:"º",origof:"⊶",oror:"⩖",orslope:"⩗",orv:"⩛",oS:"Ⓢ",Oscr:"𝒪",oscr:"ℴ",Oslash:"Ø",oslash:"ø",osol:"⊘",Otilde:"Õ",otilde:"õ",otimesas:"⨶",Otimes:"⨷",otimes:"⊗",Ouml:"Ö",ouml:"ö",ovbar:"⌽",OverBar:"‾",OverBrace:"⏞",OverBracket:"⎴",OverParenthesis:"⏜",para:"¶",parallel:"∥",par:"∥",parsim:"⫳",parsl:"⫽",part:"∂",PartialD:"∂",Pcy:"П",pcy:"п",percnt:"%",period:".",permil:"‰",perp:"⊥",pertenk:"‱",Pfr:"𝔓",pfr:"𝔭",Phi:"Φ",phi:"φ",phiv:"ϕ",phmmat:"ℳ",phone:"☎",Pi:"Π",pi:"π",pitchfork:"⋔",piv:"ϖ",planck:"ℏ",planckh:"ℎ",plankv:"ℏ",plusacir:"⨣",plusb:"⊞",pluscir:"⨢",plus:"+",plusdo:"∔",plusdu:"⨥",pluse:"⩲",PlusMinus:"±",plusmn:"±",plussim:"⨦",plustwo:"⨧",pm:"±",Poincareplane:"ℌ",pointint:"⨕",popf:"𝕡",Popf:"ℙ",pound:"£",prap:"⪷",Pr:"⪻",pr:"≺",prcue:"≼",precapprox:"⪷",prec:"≺",preccurlyeq:"≼",Precedes:"≺",PrecedesEqual:"⪯",PrecedesSlantEqual:"≼",PrecedesTilde:"≾",preceq:"⪯",precnapprox:"⪹",precneqq:"⪵",precnsim:"⋨",pre:"⪯",prE:"⪳",precsim:"≾",prime:"′",Prime:"″",primes:"ℙ",prnap:"⪹",prnE:"⪵",prnsim:"⋨",prod:"∏",Product:"∏",profalar:"⌮",profline:"⌒",profsurf:"⌓",prop:"∝",Proportional:"∝",Proportion:"∷",propto:"∝",prsim:"≾",prurel:"⊰",Pscr:"𝒫",pscr:"𝓅",Psi:"Ψ",psi:"ψ",puncsp:" ",Qfr:"𝔔",qfr:"𝔮",qint:"⨌",qopf:"𝕢",Qopf:"ℚ",qprime:"⁗",Qscr:"𝒬",qscr:"𝓆",quaternions:"ℍ",quatint:"⨖",quest:"?",questeq:"≟",quot:'"',QUOT:'"',rAarr:"⇛",race:"∽̱",Racute:"Ŕ",racute:"ŕ",radic:"√",raemptyv:"⦳",rang:"⟩",Rang:"⟫",rangd:"⦒",range:"⦥",rangle:"⟩",raquo:"»",rarrap:"⥵",rarrb:"⇥",rarrbfs:"⤠",rarrc:"⤳",rarr:"→",Rarr:"↠",rArr:"⇒",rarrfs:"⤞",rarrhk:"↪",rarrlp:"↬",rarrpl:"⥅",rarrsim:"⥴",Rarrtl:"⤖",rarrtl:"↣",rarrw:"↝",ratail:"⤚",rAtail:"⤜",ratio:"∶",rationals:"ℚ",rbarr:"⤍",rBarr:"⤏",RBarr:"⤐",rbbrk:"❳",rbrace:"}",rbrack:"]",rbrke:"⦌",rbrksld:"⦎",rbrkslu:"⦐",Rcaron:"Ř",rcaron:"ř",Rcedil:"Ŗ",rcedil:"ŗ",rceil:"⌉",rcub:"}",Rcy:"Р",rcy:"р",rdca:"⤷",rdldhar:"⥩",rdquo:"”",rdquor:"”",rdsh:"↳",real:"ℜ",realine:"ℛ",realpart:"ℜ",reals:"ℝ",Re:"ℜ",rect:"▭",reg:"®",REG:"®",ReverseElement:"∋",ReverseEquilibrium:"⇋",ReverseUpEquilibrium:"⥯",rfisht:"⥽",rfloor:"⌋",rfr:"𝔯",Rfr:"ℜ",rHar:"⥤",rhard:"⇁",rharu:"⇀",rharul:"⥬",Rho:"Ρ",rho:"ρ",rhov:"ϱ",RightAngleBracket:"⟩",RightArrowBar:"⇥",rightarrow:"→",RightArrow:"→",Rightarrow:"⇒",RightArrowLeftArrow:"⇄",rightarrowtail:"↣",RightCeiling:"⌉",RightDoubleBracket:"⟧",RightDownTeeVector:"⥝",RightDownVectorBar:"⥕",RightDownVector:"⇂",RightFloor:"⌋",rightharpoondown:"⇁",rightharpoonup:"⇀",rightleftarrows:"⇄",rightleftharpoons:"⇌",rightrightarrows:"⇉",rightsquigarrow:"↝",RightTeeArrow:"↦",RightTee:"⊢",RightTeeVector:"⥛",rightthreetimes:"⋌",RightTriangleBar:"⧐",RightTriangle:"⊳",RightTriangleEqual:"⊵",RightUpDownVector:"⥏",RightUpTeeVector:"⥜",RightUpVectorBar:"⥔",RightUpVector:"↾",RightVectorBar:"⥓",RightVector:"⇀",ring:"˚",risingdotseq:"≓",rlarr:"⇄",rlhar:"⇌",rlm:"‏",rmoustache:"⎱",rmoust:"⎱",rnmid:"⫮",roang:"⟭",roarr:"⇾",robrk:"⟧",ropar:"⦆",ropf:"𝕣",Ropf:"ℝ",roplus:"⨮",rotimes:"⨵",RoundImplies:"⥰",rpar:")",rpargt:"⦔",rppolint:"⨒",rrarr:"⇉",Rrightarrow:"⇛",rsaquo:"›",rscr:"𝓇",Rscr:"ℛ",rsh:"↱",Rsh:"↱",rsqb:"]",rsquo:"’",rsquor:"’",rthree:"⋌",rtimes:"⋊",rtri:"▹",rtrie:"⊵",rtrif:"▸",rtriltri:"⧎",RuleDelayed:"⧴",ruluhar:"⥨",rx:"℞",Sacute:"Ś",sacute:"ś",sbquo:"‚",scap:"⪸",Scaron:"Š",scaron:"š",Sc:"⪼",sc:"≻",sccue:"≽",sce:"⪰",scE:"⪴",Scedil:"Ş",scedil:"ş",Scirc:"Ŝ",scirc:"ŝ",scnap:"⪺",scnE:"⪶",scnsim:"⋩",scpolint:"⨓",scsim:"≿",Scy:"С",scy:"с",sdotb:"⊡",sdot:"⋅",sdote:"⩦",searhk:"⤥",searr:"↘",seArr:"⇘",searrow:"↘",sect:"§",semi:";",seswar:"⤩",setminus:"∖",setmn:"∖",sext:"✶",Sfr:"𝔖",sfr:"𝔰",sfrown:"⌢",sharp:"♯",SHCHcy:"Щ",shchcy:"щ",SHcy:"Ш",shcy:"ш",ShortDownArrow:"↓",ShortLeftArrow:"←",shortmid:"∣",shortparallel:"∥",ShortRightArrow:"→",ShortUpArrow:"↑",shy:"­",Sigma:"Σ",sigma:"σ",sigmaf:"ς",sigmav:"ς",sim:"∼",simdot:"⩪",sime:"≃",simeq:"≃",simg:"⪞",simgE:"⪠",siml:"⪝",simlE:"⪟",simne:"≆",simplus:"⨤",simrarr:"⥲",slarr:"←",SmallCircle:"∘",smallsetminus:"∖",smashp:"⨳",smeparsl:"⧤",smid:"∣",smile:"⌣",smt:"⪪",smte:"⪬",smtes:"⪬︀",SOFTcy:"Ь",softcy:"ь",solbar:"⌿",solb:"⧄",sol:"/",Sopf:"𝕊",sopf:"𝕤",spades:"♠",spadesuit:"♠",spar:"∥",sqcap:"⊓",sqcaps:"⊓︀",sqcup:"⊔",sqcups:"⊔︀",Sqrt:"√",sqsub:"⊏",sqsube:"⊑",sqsubset:"⊏",sqsubseteq:"⊑",sqsup:"⊐",sqsupe:"⊒",sqsupset:"⊐",sqsupseteq:"⊒",square:"□",Square:"□",SquareIntersection:"⊓",SquareSubset:"⊏",SquareSubsetEqual:"⊑",SquareSuperset:"⊐",SquareSupersetEqual:"⊒",SquareUnion:"⊔",squarf:"▪",squ:"□",squf:"▪",srarr:"→",Sscr:"𝒮",sscr:"𝓈",ssetmn:"∖",ssmile:"⌣",sstarf:"⋆",Star:"⋆",star:"☆",starf:"★",straightepsilon:"ϵ",straightphi:"ϕ",strns:"¯",sub:"⊂",Sub:"⋐",subdot:"⪽",subE:"⫅",sube:"⊆",subedot:"⫃",submult:"⫁",subnE:"⫋",subne:"⊊",subplus:"⪿",subrarr:"⥹",subset:"⊂",Subset:"⋐",subseteq:"⊆",subseteqq:"⫅",SubsetEqual:"⊆",subsetneq:"⊊",subsetneqq:"⫋",subsim:"⫇",subsub:"⫕",subsup:"⫓",succapprox:"⪸",succ:"≻",succcurlyeq:"≽",Succeeds:"≻",SucceedsEqual:"⪰",SucceedsSlantEqual:"≽",SucceedsTilde:"≿",succeq:"⪰",succnapprox:"⪺",succneqq:"⪶",succnsim:"⋩",succsim:"≿",SuchThat:"∋",sum:"∑",Sum:"∑",sung:"♪",sup1:"¹",sup2:"²",sup3:"³",sup:"⊃",Sup:"⋑",supdot:"⪾",supdsub:"⫘",supE:"⫆",supe:"⊇",supedot:"⫄",Superset:"⊃",SupersetEqual:"⊇",suphsol:"⟉",suphsub:"⫗",suplarr:"⥻",supmult:"⫂",supnE:"⫌",supne:"⊋",supplus:"⫀",supset:"⊃",Supset:"⋑",supseteq:"⊇",supseteqq:"⫆",supsetneq:"⊋",supsetneqq:"⫌",supsim:"⫈",supsub:"⫔",supsup:"⫖",swarhk:"⤦",swarr:"↙",swArr:"⇙",swarrow:"↙",swnwar:"⤪",szlig:"ß",Tab:"\t",target:"⌖",Tau:"Τ",tau:"τ",tbrk:"⎴",Tcaron:"Ť",tcaron:"ť",Tcedil:"Ţ",tcedil:"ţ",Tcy:"Т",tcy:"т",tdot:"⃛",telrec:"⌕",Tfr:"𝔗",tfr:"𝔱",there4:"∴",therefore:"∴",Therefore:"∴",Theta:"Θ",theta:"θ",thetasym:"ϑ",thetav:"ϑ",thickapprox:"≈",thicksim:"∼",ThickSpace:"  ",ThinSpace:" ",thinsp:" ",thkap:"≈",thksim:"∼",THORN:"Þ",thorn:"þ",tilde:"˜",Tilde:"∼",TildeEqual:"≃",TildeFullEqual:"≅",TildeTilde:"≈",timesbar:"⨱",timesb:"⊠",times:"×",timesd:"⨰",tint:"∭",toea:"⤨",topbot:"⌶",topcir:"⫱",top:"⊤",Topf:"𝕋",topf:"𝕥",topfork:"⫚",tosa:"⤩",tprime:"‴",trade:"™",TRADE:"™",triangle:"▵",triangledown:"▿",triangleleft:"◃",trianglelefteq:"⊴",triangleq:"≜",triangleright:"▹",trianglerighteq:"⊵",tridot:"◬",trie:"≜",triminus:"⨺",TripleDot:"⃛",triplus:"⨹",trisb:"⧍",tritime:"⨻",trpezium:"⏢",Tscr:"𝒯",tscr:"𝓉",TScy:"Ц",tscy:"ц",TSHcy:"Ћ",tshcy:"ћ",Tstrok:"Ŧ",tstrok:"ŧ",twixt:"≬",twoheadleftarrow:"↞",twoheadrightarrow:"↠",Uacute:"Ú",uacute:"ú",uarr:"↑",Uarr:"↟",uArr:"⇑",Uarrocir:"⥉",Ubrcy:"Ў",ubrcy:"ў",Ubreve:"Ŭ",ubreve:"ŭ",Ucirc:"Û",ucirc:"û",Ucy:"У",ucy:"у",udarr:"⇅",Udblac:"Ű",udblac:"ű",udhar:"⥮",ufisht:"⥾",Ufr:"𝔘",ufr:"𝔲",Ugrave:"Ù",ugrave:"ù",uHar:"⥣",uharl:"↿",uharr:"↾",uhblk:"▀",ulcorn:"⌜",ulcorner:"⌜",ulcrop:"⌏",ultri:"◸",Umacr:"Ū",umacr:"ū",uml:"¨",UnderBar:"_",UnderBrace:"⏟",UnderBracket:"⎵",UnderParenthesis:"⏝",Union:"⋃",UnionPlus:"⊎",Uogon:"Ų",uogon:"ų",Uopf:"𝕌",uopf:"𝕦",UpArrowBar:"⤒",uparrow:"↑",UpArrow:"↑",Uparrow:"⇑",UpArrowDownArrow:"⇅",updownarrow:"↕",UpDownArrow:"↕",Updownarrow:"⇕",UpEquilibrium:"⥮",upharpoonleft:"↿",upharpoonright:"↾",uplus:"⊎",UpperLeftArrow:"↖",UpperRightArrow:"↗",upsi:"υ",Upsi:"ϒ",upsih:"ϒ",Upsilon:"Υ",upsilon:"υ",UpTeeArrow:"↥",UpTee:"⊥",upuparrows:"⇈",urcorn:"⌝",urcorner:"⌝",urcrop:"⌎",Uring:"Ů",uring:"ů",urtri:"◹",Uscr:"𝒰",uscr:"𝓊",utdot:"⋰",Utilde:"Ũ",utilde:"ũ",utri:"▵",utrif:"▴",uuarr:"⇈",Uuml:"Ü",uuml:"ü",uwangle:"⦧",vangrt:"⦜",varepsilon:"ϵ",varkappa:"ϰ",varnothing:"∅",varphi:"ϕ",varpi:"ϖ",varpropto:"∝",varr:"↕",vArr:"⇕",varrho:"ϱ",varsigma:"ς",varsubsetneq:"⊊︀",varsubsetneqq:"⫋︀",varsupsetneq:"⊋︀",varsupsetneqq:"⫌︀",vartheta:"ϑ",vartriangleleft:"⊲",vartriangleright:"⊳",vBar:"⫨",Vbar:"⫫",vBarv:"⫩",Vcy:"В",vcy:"в",vdash:"⊢",vDash:"⊨",Vdash:"⊩",VDash:"⊫",Vdashl:"⫦",veebar:"⊻",vee:"∨",Vee:"⋁",veeeq:"≚",vellip:"⋮",verbar:"|",Verbar:"‖",vert:"|",Vert:"‖",VerticalBar:"∣",VerticalLine:"|",VerticalSeparator:"❘",VerticalTilde:"≀",VeryThinSpace:" ",Vfr:"𝔙",vfr:"𝔳",vltri:"⊲",vnsub:"⊂⃒",vnsup:"⊃⃒",Vopf:"𝕍",vopf:"𝕧",vprop:"∝",vrtri:"⊳",Vscr:"𝒱",vscr:"𝓋",vsubnE:"⫋︀",vsubne:"⊊︀",vsupnE:"⫌︀",vsupne:"⊋︀",Vvdash:"⊪",vzigzag:"⦚",Wcirc:"Ŵ",wcirc:"ŵ",wedbar:"⩟",wedge:"∧",Wedge:"⋀",wedgeq:"≙",weierp:"℘",Wfr:"𝔚",wfr:"𝔴",Wopf:"𝕎",wopf:"𝕨",wp:"℘",wr:"≀",wreath:"≀",Wscr:"𝒲",wscr:"𝓌",xcap:"⋂",xcirc:"◯",xcup:"⋃",xdtri:"▽",Xfr:"𝔛",xfr:"𝔵",xharr:"⟷",xhArr:"⟺",Xi:"Ξ",xi:"ξ",xlarr:"⟵",xlArr:"⟸",xmap:"⟼",xnis:"⋻",xodot:"⨀",Xopf:"𝕏",xopf:"𝕩",xoplus:"⨁",xotime:"⨂",xrarr:"⟶",xrArr:"⟹",Xscr:"𝒳",xscr:"𝓍",xsqcup:"⨆",xuplus:"⨄",xutri:"△",xvee:"⋁",xwedge:"⋀",Yacute:"Ý",yacute:"ý",YAcy:"Я",yacy:"я",Ycirc:"Ŷ",ycirc:"ŷ",Ycy:"Ы",ycy:"ы",yen:"¥",Yfr:"𝔜",yfr:"𝔶",YIcy:"Ї",yicy:"ї",Yopf:"𝕐",yopf:"𝕪",Yscr:"𝒴",yscr:"𝓎",YUcy:"Ю",yucy:"ю",yuml:"ÿ",Yuml:"Ÿ",Zacute:"Ź",zacute:"ź",Zcaron:"Ž",zcaron:"ž",Zcy:"З",zcy:"з",Zdot:"Ż",zdot:"ż",zeetrf:"ℨ",ZeroWidthSpace:"​",Zeta:"Ζ",zeta:"ζ",zfr:"𝔷",Zfr:"ℨ",ZHcy:"Ж",zhcy:"ж",zigrarr:"⇝",zopf:"𝕫",Zopf:"ℤ",Zscr:"𝒵",zscr:"𝓏",zwj:"‍",zwnj:"‌"},Yc={Aacute:"Á",aacute:"á",Acirc:"Â",acirc:"â",acute:"´",AElig:"Æ",aelig:"æ",Agrave:"À",agrave:"à",amp:"&",AMP:"&",Aring:"Å",aring:"å",Atilde:"Ã",atilde:"ã",Auml:"Ä",auml:"ä",brvbar:"¦",Ccedil:"Ç",ccedil:"ç",cedil:"¸",cent:"¢",copy:"©",COPY:"©",curren:"¤",deg:"°",divide:"÷",Eacute:"É",eacute:"é",Ecirc:"Ê",ecirc:"ê",Egrave:"È",egrave:"è",ETH:"Ð",eth:"ð",Euml:"Ë",euml:"ë",frac12:"½",frac14:"¼",frac34:"¾",gt:">",GT:">",Iacute:"Í",iacute:"í",Icirc:"Î",icirc:"î",iexcl:"¡",Igrave:"Ì",igrave:"ì",iquest:"¿",Iuml:"Ï",iuml:"ï",laquo:"«",lt:"<",LT:"<",macr:"¯",micro:"µ",middot:"·",nbsp:" ",not:"¬",Ntilde:"Ñ",ntilde:"ñ",Oacute:"Ó",oacute:"ó",Ocirc:"Ô",ocirc:"ô",Ograve:"Ò",ograve:"ò",ordf:"ª",ordm:"º",Oslash:"Ø",oslash:"ø",Otilde:"Õ",otilde:"õ",Ouml:"Ö",ouml:"ö",para:"¶",plusmn:"±",pound:"£",quot:'"',QUOT:'"',raquo:"»",reg:"®",REG:"®",sect:"§",shy:"­",sup1:"¹",sup2:"²",sup3:"³",szlig:"ß",THORN:"Þ",thorn:"þ",times:"×",Uacute:"Ú",uacute:"ú",Ucirc:"Û",ucirc:"û",Ugrave:"Ù",ugrave:"ù",uml:"¨",Uuml:"Ü",uuml:"ü",Yacute:"Ý",yacute:"ý",yen:"¥",yuml:"ÿ"},eu={amp:"&",apos:"'",gt:">",lt:"<",quot:'"'},tu={},nu=Wc&&Wc.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(tu,"__esModule",{value:!0});var ru=nu({0:65533,128:8364,130:8218,131:402,132:8222,133:8230,134:8224,135:8225,136:710,137:8240,138:352,139:8249,140:338,142:381,145:8216,146:8217,147:8220,148:8221,149:8226,150:8211,151:8212,152:732,153:8482,154:353,155:8250,156:339,158:382,159:376}),ou=String.fromCodePoint||function(e){var t="";return e>65535&&(e-=65536,t+=String.fromCharCode(e>>>10&1023|55296),e=56320|1023&e),t+=String.fromCharCode(e)};tu.default=function(e){return e>=55296&&e<=57343||e>1114111?"�":(e in ru.default&&(e=ru.default[e]),ou(e))};var iu=Wc&&Wc.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(Xc,"__esModule",{value:!0}),Xc.decodeHTML=Xc.decodeHTMLStrict=Xc.decodeXML=void 0;var su=iu(Qc),au=iu(Yc),lu=iu(eu),cu=iu(tu),uu=/&(?:[a-zA-Z0-9]+|#[xX][\da-fA-F]+|#\d+);/g;function du(e){var t=hu(e);return function(e){return String(e).replace(uu,t)}}Xc.decodeXML=du(lu.default),Xc.decodeHTMLStrict=du(su.default);var pu=function(e,t){return e<t?1:-1};function hu(e){return function(t){if("#"===t.charAt(1)){var n=t.charAt(2);return"X"===n||"x"===n?cu.default(parseInt(t.substr(3),16)):cu.default(parseInt(t.substr(2),10))}return e[t.slice(1,-1)]||t}}Xc.decodeHTML=function(){for(var e=Object.keys(au.default).sort(pu),t=Object.keys(su.default).sort(pu),n=0,r=0;n<t.length;n++)e[r]===t[n]?(t[n]+=";?",r++):t[n]+=";";var o=new RegExp("&(?:"+t.join("|")+"|#[xX][\\da-fA-F]+;?|#\\d+;?)","g"),i=hu(su.default);function s(e){return";"!==e.substr(-1)&&(e+=";"),i(e)}return function(e){return String(e).replace(o,s)}}();var fu={},mu=Wc&&Wc.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(fu,"__esModule",{value:!0}),fu.escapeUTF8=fu.escape=fu.encodeNonAsciiHTML=fu.encodeHTML=fu.encodeXML=void 0;var gu=xu(mu(eu).default),vu=Cu(gu);fu.encodeXML=Nu(gu);var yu,bu,wu=xu(mu(Qc).default),ku=Cu(wu);function xu(e){return Object.keys(e).sort().reduce((function(t,n){return t[e[n]]="&"+n+";",t}),{})}function Cu(e){for(var t=[],n=[],r=0,o=Object.keys(e);r<o.length;r++){var i=o[r];1===i.length?t.push("\\"+i):n.push(i)}t.sort();for(var s=0;s<t.length-1;s++){for(var a=s;a<t.length-1&&t[a].charCodeAt(1)+1===t[a+1].charCodeAt(1);)a+=1;var l=1+a-s;l<3||t.splice(s,l,t[s]+"-"+t[a])}return n.unshift("["+t.join("")+"]"),new RegExp(n.join("|"),"g")}fu.encodeHTML=(yu=wu,bu=ku,function(e){return e.replace(bu,(function(e){return yu[e]})).replace(Tu,Su)}),fu.encodeNonAsciiHTML=Nu(wu);var Tu=/(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g,Mu=null!=String.prototype.codePointAt?function(e){return e.codePointAt(0)}:function(e){return 1024*(e.charCodeAt(0)-55296)+e.charCodeAt(1)-56320+65536};function Su(e){return"&#x"+(e.length>1?Mu(e):e.charCodeAt(0)).toString(16).toUpperCase()+";"}var Eu=new RegExp(vu.source+"|"+Tu.source,"g");function Nu(e){return function(t){return t.replace(Eu,(function(t){return e[t]||Su(t)}))}}fu.escape=function(e){return e.replace(Eu,Su)},fu.escapeUTF8=function(e){return e.replace(vu,Su)},function(e){Object.defineProperty(e,"__esModule",{value:!0}),e.decodeXMLStrict=e.decodeHTML5Strict=e.decodeHTML4Strict=e.decodeHTML5=e.decodeHTML4=e.decodeHTMLStrict=e.decodeHTML=e.decodeXML=e.encodeHTML5=e.encodeHTML4=e.escapeUTF8=e.escape=e.encodeNonAsciiHTML=e.encodeHTML=e.encodeXML=e.encode=e.decodeStrict=e.decode=void 0;var t=Xc,n=fu;e.decode=function(e,n){return(!n||n<=0?t.decodeXML:t.decodeHTML)(e)},e.decodeStrict=function(e,n){return(!n||n<=0?t.decodeXML:t.decodeHTMLStrict)(e)},e.encode=function(e,t){return(!t||t<=0?n.encodeXML:n.encodeHTML)(e)};var r=fu;Object.defineProperty(e,"encodeXML",{enumerable:!0,get:function(){return r.encodeXML}}),Object.defineProperty(e,"encodeHTML",{enumerable:!0,get:function(){return r.encodeHTML}}),Object.defineProperty(e,"encodeNonAsciiHTML",{enumerable:!0,get:function(){return r.encodeNonAsciiHTML}}),Object.defineProperty(e,"escape",{enumerable:!0,get:function(){return r.escape}}),Object.defineProperty(e,"escapeUTF8",{enumerable:!0,get:function(){return r.escapeUTF8}}),Object.defineProperty(e,"encodeHTML4",{enumerable:!0,get:function(){return r.encodeHTML}}),Object.defineProperty(e,"encodeHTML5",{enumerable:!0,get:function(){return r.encodeHTML}});var o=Xc;Object.defineProperty(e,"decodeXML",{enumerable:!0,get:function(){return o.decodeXML}}),Object.defineProperty(e,"decodeHTML",{enumerable:!0,get:function(){return o.decodeHTML}}),Object.defineProperty(e,"decodeHTMLStrict",{enumerable:!0,get:function(){return o.decodeHTMLStrict}}),Object.defineProperty(e,"decodeHTML4",{enumerable:!0,get:function(){return o.decodeHTML}}),Object.defineProperty(e,"decodeHTML5",{enumerable:!0,get:function(){return o.decodeHTML}}),Object.defineProperty(e,"decodeHTML4Strict",{enumerable:!0,get:function(){return o.decodeHTMLStrict}}),Object.defineProperty(e,"decodeHTML5Strict",{enumerable:!0,get:function(){return o.decodeHTMLStrict}}),Object.defineProperty(e,"decodeXMLStrict",{enumerable:!0,get:function(){return o.decodeXML}})}(Zc);var Ou="&(?:#x[a-f0-9]{1,6}|#[0-9]{1,7}|[a-z][a-z0-9]{1,31});",Du=/[\\&]/,Au="[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]",Lu=new RegExp("\\\\"+Au+"|"+Ou,"gi"),Iu=new RegExp('[&<>"]',"g"),Ru=function(e){return 92===e.charCodeAt(0)?e.charAt(1):Zc.decodeHTML(e)};function Pu(e){return Du.test(e)?e.replace(Lu,Ru):e}function Bu(e){try{return Kc(e)}catch(t){return e}}function Fu(e){switch(e){case"&":return"&amp;";case"<":return"&lt;";case">":return"&gt;";case'"':return"&quot;";default:return e}}function Hu(e){return Iu.test(e)?e.replace(Iu,Fu):e}function zu(e,t){for(var n=[],r=0;r<t;r++)n.push(e);return n.join("")}function qu(e){return!e||!/[^ \t]+/.test(e)}var Vu=function(){function e(e){this.current=e,this.root=e,this.entering=!0}return e.prototype.next=function(){var e=this.current,t=this.entering;if(null===e)return null;var n=ju(e);return t&&n?e.firstChild?(this.current=e.firstChild,this.entering=!0):this.entering=!1:e===this.root?this.current=null:null===e.next?(this.current=e.parent,this.entering=!1):(this.current=e.next,this.entering=!0),{entering:t,node:e}},e.prototype.resumeAt=function(e,t){this.current=e,this.entering=!0===t},e}();function ju(e){switch(e.type){case"document":case"blockQuote":case"list":case"item":case"paragraph":case"heading":case"emph":case"strong":case"strike":case"link":case"image":case"table":case"tableHead":case"tableBody":case"tableRow":case"tableCell":case"tableDelimRow":case"customInline":return!0;default:return!1}}var $u=1,_u={};function Uu(e){delete _u[e]}var Wu=function(){function e(e,t){this.parent=null,this.prev=null,this.next=null,this.firstChild=null,this.lastChild=null,this.literal=null,this.id="document"===e?-1:$u++,this.type=e,this.sourcepos=t,_u[this.id]=this}return e.prototype.isContainer=function(){return ju(this)},e.prototype.unlink=function(){this.prev?this.prev.next=this.next:this.parent&&(this.parent.firstChild=this.next),this.next?this.next.prev=this.prev:this.parent&&(this.parent.lastChild=this.prev),this.parent=null,this.next=null,this.prev=null},e.prototype.replaceWith=function(e){this.insertBefore(e),this.unlink()},e.prototype.insertAfter=function(e){e.unlink(),e.next=this.next,e.next&&(e.next.prev=e),e.prev=this,this.next=e,this.parent&&(e.parent=this.parent,e.next||(e.parent.lastChild=e))},e.prototype.insertBefore=function(e){e.unlink(),e.prev=this.prev,e.prev&&(e.prev.next=e),e.next=this,this.prev=e,e.parent=this.parent,e.prev||(e.parent.firstChild=e)},e.prototype.appendChild=function(e){e.unlink(),e.parent=this,this.lastChild?(this.lastChild.next=e,e.prev=this.lastChild,this.lastChild=e):(this.firstChild=e,this.lastChild=e)},e.prototype.prependChild=function(e){e.unlink(),e.parent=this,this.firstChild?(this.firstChild.prev=e,e.next=this.firstChild,this.firstChild=e):(this.firstChild=e,this.lastChild=e)},e.prototype.walker=function(){return new Vu(this)},e}(),Ju=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.open=!0,r.lineOffsets=null,r.stringContent=null,r.lastLineBlank=!1,r.lastLineChecked=!1,r.type=t,r}return $c(t,e),t}(Wu),Gu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.listData=null,t}return $c(t,e),t}(Ju),Ku=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.level=0,t.headingType="atx",t}return $c(t,e),t}(Ju),Zu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.isFenced=!1,t.fenceChar=null,t.fenceLength=0,t.fenceOffset=-1,t.info=null,t.infoPadding=0,t}return $c(t,e),t}(Ju),Xu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.columns=[],t}return $c(t,e),t}(Ju),Qu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.startIdx=0,t.endIdx=0,t.paddingLeft=0,t.paddingRight=0,t.ignored=!1,t}return $c(t,e),t}(Ju),Yu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.title="",t.dest="",t.label="",t}return $c(t,e),t}(Ju),ed=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.syntaxLength=0,t.offset=-1,t.info="",t}return $c(t,e),t}(Ju),td=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.htmlBlockType=-1,t}return $c(t,e),t}(Ju),nd=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.destination=null,t.title=null,t.extendedAutolink=!1,t}return $c(t,e),t}(Wu),rd=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.tickCount=0,t}return $c(t,e),t}(Wu),od=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.info="",t}return $c(t,e),t}(Wu);function id(e,t){switch(e){case"heading":return new Ku(e,t);case"list":case"item":return new Gu(e,t);case"link":case"image":return new nd(e,t);case"codeBlock":return new Zu(e,t);case"htmlBlock":return new td(e,t);case"table":return new Xu(e,t);case"tableCell":return new Qu(e,t);case"document":case"paragraph":case"blockQuote":case"thematicBreak":case"tableRow":case"tableBody":case"tableHead":case"frontMatter":return new Ju(e,t);case"code":return new rd(e,t);case"refDef":return new Yu(e,t);case"customBlock":return new ed(e,t);case"customInline":return new od(e,t);default:return new Wu(e,t)}}function sd(e){return"codeBlock"===e.type}function ad(e){return"list"===e.type}function ld(e){return"refDef"===e.type}function cd(e){return"customBlock"===e.type}function ud(e,t){var n=id("text",t);return n.literal=e,n}var dd,pd="[A-Za-z][A-Za-z0-9-]*",hd="<"+pd+"(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>",fd="</"+pd+"\\s*[>]",md=new RegExp("^(?:<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>|</[A-Za-z][A-Za-z0-9-]*\\s*[>]|\x3c!----\x3e|\x3c!--(?:-?[^>-])(?:-?[^-])*--\x3e|[<][?].*?[?][>]|<![A-Z]+\\s+[^>]*>|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>)","i");if(String.fromCodePoint)dd=function(e){try{return String.fromCodePoint(e)}catch(e){if(e instanceof RangeError)return String.fromCharCode(65533);throw e}};else{var gd=String.fromCharCode,vd=Math.floor;dd=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n,r,o=16384,i=[],s=-1,a=e.length;if(!a)return"";for(var l="";++s<a;){var c=Number(e[s]);if(!isFinite(c)||c<0||c>1114111||vd(c)!==c)return String.fromCharCode(65533);c<=65535?i.push(c):(n=55296+((c-=65536)>>10),r=c%1024+56320,i.push(n,r)),(s+1===a||i.length>o)&&(l+=gd.apply(void 0,i),i.length=0)}return l}}var yd=dd;function bd(e){var t=/\)+$/.exec(e);if(t){for(var n=0,r=0,o=e;r<o.length;r++){var i=o[r];"("===i?n<0?n=1:n+=1:")"===i&&(n-=1)}if(n<0){var s=Math.min(-n,t[0].length);return e.substring(0,e.length-s)}}return e}function wd(e){return e.replace(/&[A-Za-z0-9]+;$/,"")}function kd(e){return Uc(Uc([],function(e){for(var t,n=new RegExp("(www|https?://).(?:[w-]+.)*[A-Za-z0-9-]+.[A-Za-z0-9-]+[^<\\s]*[^<?!.,:*_?~\\s]","g"),r=[];t=n.exec(e);){var o=wd(bd(t[0])),i="www"===t[1]?"http://":"";r.push({text:o,range:[t.index,t.index+o.length-1],url:""+i+o})}return r}(e)),function(e){for(var t,n=new RegExp("[\\w.+-]+@(?:[\\w-]+\\.)+[\\w-]+","g"),r=[];t=n.exec(e);){var o=t[0];/[_-]+$/.test(o)||r.push({text:o,range:[t.index,t.index+o.length-1],url:"mailto:"+o})}return r}(e)).sort((function(e,t){return e.range[0]-t.range[0]}))}function xd(e){return e[e.length-1]}function Cd(e){return e.slice(1,e.length-1).trim().replace(/[ \t\r\n]+/," ").toLowerCase().toUpperCase()}function Td(e,t){Object.keys(e).forEach((function(n){t(n,e[n])}))}function Md(e){return!Object.keys(e).length}var Sd=126,Ed=39,Nd=34,Od=36,Dd="\\\\"+Au,Ad=new RegExp(/[!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u0AF0\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E42\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC9\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDF3C-\uDF3E]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]/),Ld=new RegExp('^(?:"('+Dd+'|[^"\\x00])*"|\'('+Dd+"|[^'\\x00])*'|\\(("+Dd+"|[^()\\x00])*\\))"),Id=/^(?:<(?:[^<>\n\\\x00]|\\.)*>)/,Rd=new RegExp("^"+Au),Pd=new RegExp("^"+Ou,"i"),Bd=/`+/,Fd=/^`+/,Hd=/\.\.\./g,zd=/--+/g,qd=/^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/,Vd=/^<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*>/i,jd=/^ *(?:\n *)?/,$d=/^[ \t\n\x0b\x0c\x0d]/,_d=/^\s/,Ud=/ *$/,Wd=/^ */,Jd=/^ *(?:\n|$)/,Gd=/^\[(?:[^\\\[\]]|\\.){0,1000}\]/,Kd=/^[^\n`\[\]\\!<&*_'"~$]+/m,Zd=function(){function e(e){this.subject="",this.delimiters=null,this.brackets=null,this.pos=0,this.lineStartNum=0,this.lineIdx=0,this.lineOffsets=[0],this.linePosOffset=0,this.refMap={},this.refLinkCandidateMap={},this.refDefCandidateMap={},this.options=e}return e.prototype.sourcepos=function(e,t){var n=this.linePosOffset+this.lineOffsets[this.lineIdx],r=this.lineStartNum+this.lineIdx,o=[r,e+n];return"number"==typeof t?[o,[r,t+n]]:o},e.prototype.nextLine=function(){this.lineIdx+=1,this.linePosOffset=-this.pos},e.prototype.match=function(e){var t=e.exec(this.subject.slice(this.pos));return null===t?null:(this.pos+=t.index+t[0].length,t[0])},e.prototype.peek=function(){return this.pos<this.subject.length?this.subject.charCodeAt(this.pos):-1},e.prototype.spnl=function(){return this.match(jd),!0},e.prototype.parseBackticks=function(e){var t=this.pos+1,n=this.match(Fd);if(null===n)return!1;for(var r,o=this.pos;null!==(r=this.match(Bd));)if(r===n){var i=this.subject.slice(o,this.pos-n.length),s=this.sourcepos(t,this.pos),a=i.split("\n");if(a.length>1){var l=xd(a);this.lineIdx+=a.length-1,this.linePosOffset=-(this.pos-l.length-n.length),s[1]=this.sourcepos(this.pos),i=a.join(" ")}var c=id("code",s);return i.length>0&&null!==i.match(/[^ ]/)&&" "==i[0]&&" "==i[i.length-1]?c.literal=i.slice(1,i.length-1):c.literal=i,c.tickCount=n.length,e.appendChild(c),!0}return this.pos=o,e.appendChild(ud(n,this.sourcepos(t,this.pos-1))),!0},e.prototype.parseBackslash=function(e){var t,n=this.subject;this.pos+=1;var r=this.pos;return 10===this.peek()?(this.pos+=1,t=id("linebreak",this.sourcepos(this.pos-1,this.pos)),e.appendChild(t),this.nextLine()):Rd.test(n.charAt(this.pos))?(e.appendChild(ud(n.charAt(this.pos),this.sourcepos(r,this.pos))),this.pos+=1):e.appendChild(ud("\\",this.sourcepos(r,r))),!0},e.prototype.parseAutolink=function(e){var t,n,r,o=this.pos+1;return(t=this.match(qd))?(n=t.slice(1,t.length-1),(r=id("link",this.sourcepos(o,this.pos))).destination=Bu("mailto:"+n),r.title="",r.appendChild(ud(n,this.sourcepos(o+1,this.pos-1))),e.appendChild(r),!0):!!(t=this.match(Vd))&&(n=t.slice(1,t.length-1),(r=id("link",this.sourcepos(o,this.pos))).destination=Bu(n),r.title="",r.appendChild(ud(n,this.sourcepos(o+1,this.pos-1))),e.appendChild(r),!0)},e.prototype.parseHtmlTag=function(e){var t=this.pos+1,n=this.match(md);if(null===n)return!1;var r=id("htmlInline",this.sourcepos(t,this.pos));return r.literal=n,e.appendChild(r),!0},e.prototype.scanDelims=function(e){var t=0,n=this.pos;if(e===Ed||e===Nd)t++,this.pos++;else for(;this.peek()===e;)t++,this.pos++;if(0===t||t<2&&(e===Sd||e===Od))return this.pos=n,null;var r,o=0===n?"\n":this.subject.charAt(n-1),i=this.peek();r=-1===i?"\n":yd(i);var s,a,l=_d.test(r),c=Ad.test(r),u=_d.test(o),d=Ad.test(o),p=!l&&(!c||u||d),h=!u&&(!d||l||c);return 95===e?(s=p&&(!h||d),a=h&&(!p||c)):e===Ed||e===Nd?(s=p&&!h,a=h):e===Od?(s=!l,a=!u):(s=p,a=h),this.pos=n,{numdelims:t,canOpen:s,canClose:a}},e.prototype.handleDelim=function(e,t){var n=this.scanDelims(e);if(!n)return!1;var r=n.numdelims,o=this.pos+1;this.pos+=r;var i=ud(e===Ed?"’":e===Nd?"“":this.subject.slice(o-1,this.pos),this.sourcepos(o,this.pos));return t.appendChild(i),(n.canOpen||n.canClose)&&(this.options.smart||e!==Ed&&e!==Nd)&&(this.delimiters={cc:e,numdelims:r,origdelims:r,node:i,previous:this.delimiters,next:null,canOpen:n.canOpen,canClose:n.canClose},this.delimiters.previous&&(this.delimiters.previous.next=this.delimiters)),!0},e.prototype.removeDelimiter=function(e){null!==e.previous&&(e.previous.next=e.next),null===e.next?this.delimiters=e.previous:e.next.previous=e.previous},e.prototype.removeDelimitersBetween=function(e,t){e.next!==t&&(e.next=t,t.previous=e)},e.prototype.processEmphasis=function(e){var t,n,r,o,i,s,a,l=!1,c=((t={})[95]=[e,e,e],t[42]=[e,e,e],t[39]=[e],t[34]=[e],t[126]=[e],t[36]=[e],t);for(r=this.delimiters;null!==r&&r.previous!==e;)r=r.previous;for(;null!==r;){var u=r.cc,d=95===u||42===u;if(r.canClose){for(n=r.previous,a=!1;null!==n&&n!==e&&n!==c[u][d?r.origdelims%3:0];){if(l=d&&(r.canOpen||n.canClose)&&r.origdelims%3!=0&&(n.origdelims+r.origdelims)%3==0,n.cc===r.cc&&n.canOpen&&!l){a=!0;break}n=n.previous}if(o=r,d||u===Sd||u===Od)if(a){if(n){var p=r.numdelims>=2&&n.numdelims>=2?2:1,h=d?0:1;i=n.node,s=r.node;var f=d?1===p?"emph":"strong":"strike";u===Od&&(f="customInline");var m=id(f),g=i.sourcepos[1],v=s.sourcepos[0];m.sourcepos=[[g[0],g[1]-p+1],[v[0],v[1]+p-1]],i.sourcepos[1][1]-=p,s.sourcepos[0][1]+=p,i.literal=i.literal.slice(p),s.literal=s.literal.slice(p),n.numdelims-=p,r.numdelims-=p;for(var y=i.next,b=void 0;y&&y!==s;)b=y.next,y.unlink(),m.appendChild(y),y=b;if(u===Od){var w=m.firstChild,k=w.literal||"",x=k.split(/\s/)[0];m.info=x,k.length<=x.length?w.unlink():(w.sourcepos[0][1]+=x.length,w.literal=k.replace(x+" ",""))}if(i.insertAfter(m),this.removeDelimitersBetween(n,r),n.numdelims<=h&&(0===n.numdelims&&i.unlink(),this.removeDelimiter(n)),r.numdelims<=h){0===r.numdelims&&s.unlink();var C=r.next;this.removeDelimiter(r),r=C}}}else r=r.next;else u===Ed?(r.node.literal="’",a&&(n.node.literal="‘"),r=r.next):u===Nd&&(r.node.literal="”",a&&(n.node.literal="“"),r=r.next);a||(c[u][d?o.origdelims%3:0]=o.previous,o.canOpen||this.removeDelimiter(o))}else r=r.next}for(;null!==this.delimiters&&this.delimiters!==e;)this.removeDelimiter(this.delimiters)},e.prototype.parseLinkTitle=function(){var e=this.match(Ld);return null===e?null:Pu(e.substr(1,e.length-2))},e.prototype.parseLinkDestination=function(){var e=this.match(Id);if(null===e){if(60===this.peek())return null;for(var t=this.pos,n=0,r=void 0;-1!==(r=this.peek());)if(92===r&&Rd.test(this.subject.charAt(this.pos+1)))this.pos+=1,-1!==this.peek()&&(this.pos+=1);else if(40===r)this.pos+=1,n+=1;else if(41===r){if(n<1)break;this.pos+=1,n-=1}else{if(null!==$d.exec(yd(r)))break;this.pos+=1}return this.pos===t&&41!==r||0!==n?null:Bu(Pu(e=this.subject.substr(t,this.pos-t)))}return Bu(Pu(e.substr(1,e.length-2)))},e.prototype.parseLinkLabel=function(){var e=this.match(Gd);return null===e||e.length>1001?0:e.length},e.prototype.parseOpenBracket=function(e){var t=this.pos;this.pos+=1;var n=ud("[",this.sourcepos(this.pos,this.pos));return e.appendChild(n),this.addBracket(n,t,!1),!0},e.prototype.parseBang=function(e){var t=this.pos;if(this.pos+=1,91===this.peek()){this.pos+=1;var n=ud("![",this.sourcepos(this.pos-1,this.pos));e.appendChild(n),this.addBracket(n,t+1,!0)}else{n=ud("!",this.sourcepos(this.pos,this.pos));e.appendChild(n)}return!0},e.prototype.parseCloseBracket=function(e){var t=null,n=null,r=!1;this.pos+=1;var o=this.pos,i=this.brackets;if(null===i)return e.appendChild(ud("]",this.sourcepos(o,o))),!0;if(!i.active)return e.appendChild(ud("]",this.sourcepos(o,o))),this.removeBracket(),!0;var s=i.image,a=this.pos;40===this.peek()&&(this.pos++,this.spnl()&&null!==(t=this.parseLinkDestination())&&this.spnl()&&($d.test(this.subject.charAt(this.pos-1))&&(n=this.parseLinkTitle()),1)&&this.spnl()&&41===this.peek()?(this.pos+=1,r=!0):this.pos=a);var l="";if(!r){var c=this.pos,u=this.parseLinkLabel();if(u>2?l=this.subject.slice(c,c+u):i.bracketAfter||(l=this.subject.slice(i.index,o)),0===u&&(this.pos=a),l){l=Cd(l);var d=this.refMap[l];d&&(t=d.destination,n=d.title,r=!0)}}if(r){var p=id(s?"image":"link");p.destination=t,p.title=n||"",p.sourcepos=[i.startpos,this.sourcepos(this.pos)];for(var h=i.node.next,f=void 0;h;)f=h.next,h.unlink(),p.appendChild(h),h=f;if(e.appendChild(p),this.processEmphasis(i.previousDelimiter),this.removeBracket(),i.node.unlink(),!s)for(i=this.brackets;null!==i;)i.image||(i.active=!1),i=i.previous;return this.options.referenceDefinition&&(this.refLinkCandidateMap[e.id]={node:e,refLabel:l}),!0}return this.removeBracket(),this.pos=o,e.appendChild(ud("]",this.sourcepos(o,o))),this.options.referenceDefinition&&(this.refLinkCandidateMap[e.id]={node:e,refLabel:l}),!0},e.prototype.addBracket=function(e,t,n){null!==this.brackets&&(this.brackets.bracketAfter=!0),this.brackets={node:e,startpos:this.sourcepos(t+(n?0:1)),previous:this.brackets,previousDelimiter:this.delimiters,index:t,image:n,active:!0}},e.prototype.removeBracket=function(){this.brackets&&(this.brackets=this.brackets.previous)},e.prototype.parseEntity=function(e){var t,n=this.pos+1;return!!(t=this.match(Pd))&&(e.appendChild(ud(Zc.decodeHTML(t),this.sourcepos(n,this.pos))),!0)},e.prototype.parseString=function(e){var t,n=this.pos+1;if(t=this.match(Kd)){if(this.options.smart){var r=t.replace(Hd,"…").replace(zd,(function(e){var t=0,n=0;return e.length%3==0?n=e.length/3:e.length%2==0?t=e.length/2:e.length%3==2?(t=1,n=(e.length-2)/3):(t=2,n=(e.length-4)/3),zu("—",n)+zu("–",t)}));e.appendChild(ud(r,this.sourcepos(n,this.pos)))}else{var o=ud(t,this.sourcepos(n,this.pos));e.appendChild(o)}return!0}return!1},e.prototype.parseNewline=function(e){this.pos+=1;var t=e.lastChild;if(t&&"text"===t.type&&" "===t.literal[t.literal.length-1]){var n=" "===t.literal[t.literal.length-2],r=t.literal.length;t.literal=t.literal.replace(Ud,"");var o=r-t.literal.length;t.sourcepos[1][1]-=o,e.appendChild(id(n?"linebreak":"softbreak",this.sourcepos(this.pos-o,this.pos)))}else e.appendChild(id("softbreak",this.sourcepos(this.pos,this.pos)));return this.nextLine(),this.match(Wd),!0},e.prototype.parseReference=function(e,t){if(!this.options.referenceDefinition)return 0;this.subject=e.stringContent,this.pos=0;var n=null,r=this.pos,o=this.parseLinkLabel();if(0===o)return 0;var i=this.subject.substr(0,o);if(58!==this.peek())return this.pos=r,0;this.pos++,this.spnl();var s=this.parseLinkDestination();if(null===s)return this.pos=r,0;var a=this.pos;this.spnl(),this.pos!==a&&(n=this.parseLinkTitle()),null===n&&(n="",this.pos=a);var l=!0;if(null===this.match(Jd)&&(""===n?l=!1:(n="",this.pos=a,l=null!==this.match(Jd))),!l)return this.pos=r,0;var c=Cd(i);if(""===c)return this.pos=r,0;var u=this.getReferenceDefSourcepos(e);e.sourcepos[0][0]=u[1][0]+1;var d=id("refDef",u);return d.title=n,d.dest=s,d.label=c,e.insertBefore(d),t[c]?this.refDefCandidateMap[d.id]=d:t[c]=$p(d),this.pos-r},e.prototype.mergeTextNodes=function(e){for(var t,n=[];t=e.next();){var r=t.entering,o=t.node;if(r&&"text"===o.type)n.push(o);else if(1===n.length)n=[];else if(n.length>1){var i=n[0],s=n[n.length-1];i.sourcepos&&s.sourcepos&&(i.sourcepos[1]=s.sourcepos[1]),i.next=s.next,i.next&&(i.next.prev=i);for(var a=1;a<n.length;a+=1)i.literal+=n[a].literal,n[a].unlink();n=[]}}},e.prototype.getReferenceDefSourcepos=function(e){for(var t=e.stringContent.split(/\n|\r\n/),n=!1,r=0,o={line:0,ch:0},i=0;i<t.length;i+=1){var s=t[i];if($d.test(s))break;if(/\:/.test(s)&&0===r){if(n)break;var a=s.indexOf(":")===s.length-1?i+1:i;o={line:a,ch:t[a].length},n=!0}var l=s.match(/'|"/g);if(l&&(r+=l.length),2===r){o={line:i,ch:s.length};break}}return[[e.sourcepos[0][0],e.sourcepos[0][1]],[e.sourcepos[0][0]+o.line,o.ch]]},e.prototype.parseInline=function(e){var t,n=!1,r=this.peek();if(-1===r)return!1;switch(r){case 10:n=this.parseNewline(e);break;case 92:n=this.parseBackslash(e);break;case 96:n=this.parseBackticks(e);break;case 42:case 95:case Sd:case Od:n=this.handleDelim(r,e);break;case Ed:case Nd:n=!!(null===(t=this.options)||void 0===t?void 0:t.smart)&&this.handleDelim(r,e);break;case 91:n=this.parseOpenBracket(e);break;case 33:n=this.parseBang(e);break;case 93:n=this.parseCloseBracket(e);break;case 60:n=this.parseAutolink(e)||this.parseHtmlTag(e);break;case 38:e.disabledEntityParse||(n=this.parseEntity(e));break;default:n=this.parseString(e)}return n||(this.pos+=1,e.appendChild(ud(yd(r),this.sourcepos(this.pos,this.pos+1)))),!0},e.prototype.parse=function(e){for(this.subject=e.stringContent.trim(),this.pos=0,this.delimiters=null,this.brackets=null,this.lineOffsets=e.lineOffsets||[0],this.lineIdx=0,this.linePosOffset=0,this.lineStartNum=e.sourcepos[0][0],function(e){return"heading"===e.type}(e)&&(this.lineOffsets[0]+=e.level+1);this.parseInline(e););e.stringContent=null,this.processEmphasis(null),this.mergeTextNodes(e.walker());var t=this.options,n=t.extendedAutolinks,r=t.customParser;if(n&&function(e,t){var n;"boolean"==typeof t&&(t=kd);for(var r=function(){var e=n.entering,r=n.node;if(e&&"text"===r.type&&"link"!==r.parent.type){var o=r.literal,i=t(o);if(!i||!i.length)return"continue";for(var s=0,a=r.sourcepos[0],l=a[0],c=a[1],u=function(e,t){return[[l,c+e],[l,c+t]]},d=[],p=0,h=i;p<h.length;p++){var f=h[p],m=f.range,g=f.url,v=f.text;m[0]>s&&d.push(ud(o.substring(s,m[0]),u(s,m[0]-1)));var y=id("link",u.apply(void 0,m));y.appendChild(ud(v,u.apply(void 0,m))),y.destination=g,y.extendedAutolink=!0,d.push(y),s=m[1]+1}s<o.length&&d.push(ud(o.substring(s),u(s,o.length-1)));for(var b=0,w=d;b<w.length;b++){var k=w[b];r.insertBefore(k)}r.unlink()}};n=e.next();)r()}(e.walker(),n),r&&e.firstChild)for(var o,i=e.firstChild.walker();o=i.next();){var s=o.node,a=o.entering;r[s.type]&&r[s.type](s,{entering:a,options:this.options})}},e}(),Xd=/^\[([ \txX])\][ \t]+/;var Qd=/[^ \t\f\v\r\n]/,Yd=/^(?:`{3,}|~{3,})(?= *$)/;function ep(e){for(var t=e;t;){if(t.lastLineBlank)return!0;var n=t.type;if(t.lastLineChecked||"list"!==n&&"item"!==n){t.lastLineChecked=!0;break}t.lastLineChecked=!0,t=t.lastChild}return!1}function tp(e,t){return t<e.length?e.charCodeAt(t):-1}function np(e){return!Qd.test(e)}function rp(e){return 32===e||9===e}var op=/^\$\$$/,ip={continue:function(e,t){var n=e.currentLine,r=n.match(op);if(r)return e.lastLineLength=r[0].length,e.finalize(t,e.lineNumber),2;for(var o=t.offset;o>0&&rp(tp(n,e.offset));)e.advanceOffset(1,!0),o--;return 0},finalize:function(e,t){if(null!==t.stringContent){var n=t.stringContent,r=n.indexOf("\n"),o=n.slice(0,r),i=n.slice(r+1),s=o.match(/^(\s*)(.*)/);t.info=Pu(s[2].trim()),t.literal=i,t.stringContent=null}},canContain:function(){return!1},acceptsLines:!0},sp={continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!0},ap={continue:function(){return 0},finalize:function(e,t){for(var n=t.firstChild;n;){if(ep(n)&&n.next){t.listData.tight=!1;break}for(var r=n.firstChild;r;){if(ep(r)&&(n.next||r.next)){t.listData.tight=!1;break}r=r.next}n=n.next}},canContain:function(e){return"item"===e},acceptsLines:!1},lp={continue:function(e,t){if(e.blank){if(null===t.firstChild)return 1;e.advanceNextNonspace()}else{if(!(e.indent>=t.listData.markerOffset+t.listData.padding))return 1;e.advanceOffset(t.listData.markerOffset+t.listData.padding,!0)}return 0},finalize:function(e,t){if(t.firstChild&&"paragraph"===t.firstChild.type){var n=t.firstChild,r=n.stringContent.match(Xd);if(r){var o=r[0].length;n.stringContent=n.stringContent.substring(o-1),n.sourcepos[0][1]+=o,n.lineOffsets[0]+=o,t.listData.task=!0,t.listData.checked=/[xX]/.test(r[1])}}},canContain:function(e){return"item"!==e},acceptsLines:!1},cp={continue:function(e,t){var n=e.currentLine,r=e.indent;if(t.isFenced){var o=r<=3&&n.charAt(e.nextNonspace)===t.fenceChar&&n.slice(e.nextNonspace).match(Yd);if(o&&o[0].length>=t.fenceLength)return e.lastLineLength=e.offset+r+o[0].length,e.finalize(t,e.lineNumber),2;for(var i=t.fenceOffset;i>0&&rp(tp(n,e.offset));)e.advanceOffset(1,!0),i--}else if(r>=4)e.advanceOffset(4,!0);else{if(!e.blank)return 1;e.advanceNextNonspace()}return 0},finalize:function(e,t){var n;if(null!==t.stringContent){if(t.isFenced){var r=t.stringContent,o=r.indexOf("\n"),i=r.slice(0,o),s=r.slice(o+1),a=i.match(/^(\s*)(.*)/);t.infoPadding=a[1].length,t.info=Pu(a[2].trim()),t.literal=s}else t.literal=null===(n=t.stringContent)||void 0===n?void 0:n.replace(/(\n *)+$/,"\n");t.stringContent=null}},canContain:function(){return!1},acceptsLines:!0},up={continue:function(e){return e.blank?1:0},finalize:function(e,t){if(null!==t.stringContent){for(var n,r=!1;91===tp(t.stringContent,0)&&(n=e.inlineParser.parseReference(t,e.refMap));)t.stringContent=t.stringContent.slice(n),r=!0;r&&np(t.stringContent)&&t.unlink()}},canContain:function(){return!1},acceptsLines:!0},dp={document:{continue:function(){return 0},finalize:function(){},canContain:function(e){return"item"!==e},acceptsLines:!1},list:ap,blockQuote:{continue:function(e){var t=e.currentLine;return e.indented||62!==tp(t,e.nextNonspace)?1:(e.advanceNextNonspace(),e.advanceOffset(1,!1),rp(tp(t,e.offset))&&e.advanceOffset(1,!0),0)},finalize:function(){},canContain:function(e){return"item"!==e},acceptsLines:!1},item:lp,heading:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},thematicBreak:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},codeBlock:cp,htmlBlock:{continue:function(e,t){return!e.blank||6!==t.htmlBlockType&&7!==t.htmlBlockType?0:1},finalize:function(e,t){var n;t.literal=(null===(n=t.stringContent)||void 0===n?void 0:n.replace(/(\n *)+$/,""))||null,t.stringContent=null},canContain:function(){return!1},acceptsLines:!0},paragraph:up,table:{continue:function(){return 0},finalize:function(){},canContain:function(e){return"tableHead"===e||"tableBody"===e},acceptsLines:!1},tableBody:{continue:function(){return 0},finalize:function(){},canContain:function(e){return"tableRow"===e},acceptsLines:!1},tableHead:{continue:function(){return 1},finalize:function(){},canContain:function(e){return"tableRow"===e||"tableDelimRow"===e},acceptsLines:!1},tableRow:{continue:function(){return 1},finalize:function(){},canContain:function(e){return"tableCell"===e},acceptsLines:!1},tableCell:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},tableDelimRow:{continue:function(){return 1},finalize:function(){},canContain:function(e){return"tableDelimCell"===e},acceptsLines:!1},tableDelimCell:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},refDef:sp,customBlock:ip,frontMatter:sp};function pp(e){for(var t=0,n=0,r=[],o=0;o<e.length;o+=1)if("|"===e[o]&&"\\"!==e[o-1]){var i=e.substring(t,o);0===t&&qu(i)?n=o+1:r.push(i),t=o+1}t<e.length&&(qu(i=e.substring(t,e.length))||r.push(i));return[n,r]}function hp(e,t,n,r){for(var o=[],i=0,s=t;i<s.length;i++){var a=s[i],l=a.match(/^[ \t]+/),c=l?l[0].length:0,u=void 0,d=void 0;if(c===a.length)c=0,u=0,d="";else{var p=a.match(/[ \t]+$/);u=p?p[0].length:0,d=a.slice(c,a.length-u)}var h=r+c,f=id(e,[[n,r],[n,r+a.length-1]]);f.stringContent=d.replace(/\\\|/g,"|"),f.startIdx=o.length,f.endIdx=o.length,f.lineOffsets=[h-1],f.paddingLeft=c,f.paddingRight=u,o.push(f),r+=a.length+1}return o}function fp(e){var t=null,n=e.stringContent,r=n[0];return":"===n[n.length-1]?t=":"===r?"center":"right":":"===r&&(t="left"),{align:t}}var mp=/^(\$\$)(\s*[a-zA-Z])+/,gp=/^(\$\$)(\s*[a-zA-Z])+.*(\$\$)/,vp=/^`{3,}(?!.*`)|^~{3,}/,yp=[/./,/^<(?:script|pre|style)(?:\s|>|$)/i,/^<!--/,/^<[?]/,/^<![A-Z]/,/^<!\[CDATA\[/,/^<[/]?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[123456]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|[/]?[>]|$)/i,new RegExp("^(?:"+hd+"|"+fd+")\\s*$","i")],bp=/^(?:=+|-+)[ \t]*$/,wp=/^#{1,6}(?:[ \t]+|$)/,kp=/^(?:(?:\*[ \t]*){3,}|(?:_[ \t]*){3,}|(?:-[ \t]*){3,})[ \t]*$/,xp=/^[*+-]/,Cp=/^(\d{1,9})([.)])/;function Tp(e,t){return e.options.disallowDeepHeading&&("blockQuote"===t.type||"item"===t.type)}var Mp=[function(e){return e.indented||62!==tp(e.currentLine,e.nextNonspace)?0:(e.advanceNextNonspace(),e.advanceOffset(1,!1),rp(tp(e.currentLine,e.offset))&&e.advanceOffset(1,!0),e.closeUnmatchedBlocks(),e.addChild("blockQuote",e.nextNonspace),1)},function(e,t){var n;if(!e.indented&&!Tp(e,t)&&(n=e.currentLine.slice(e.nextNonspace).match(wp))){e.advanceNextNonspace(),e.advanceOffset(n[0].length,!1),e.closeUnmatchedBlocks();var r=e.addChild("heading",e.nextNonspace);return r.level=n[0].trim().length,r.headingType="atx",r.stringContent=e.currentLine.slice(e.offset).replace(/^[ \t]*#+[ \t]*$/,"").replace(/[ \t]+#+[ \t]*$/,""),e.advanceOffset(e.currentLine.length-e.offset),2}return 0},function(e){var t;if(!e.indented&&(t=e.currentLine.slice(e.nextNonspace).match(vp))){var n=t[0].length;e.closeUnmatchedBlocks();var r=e.addChild("codeBlock",e.nextNonspace);return r.isFenced=!0,r.fenceLength=n,r.fenceChar=t[0][0],r.fenceOffset=e.indent,e.advanceNextNonspace(),e.advanceOffset(n,!1),2}return 0},function(e,t){if(!e.indented&&60===tp(e.currentLine,e.nextNonspace)){var n=e.currentLine.slice(e.nextNonspace),r=e.options.disallowedHtmlBlockTags,o=void 0;for(o=1;o<=7;o++){var i=n.match(yp[o]);if(i){if(7===o){if("paragraph"===t.type)return 0;if(r.length>0)if(new RegExp("</?(?:"+r.join("|")+")","i").test(i[0]))return 0}return e.closeUnmatchedBlocks(),e.addChild("htmlBlock",e.offset).htmlBlockType=o,2}}}return 0},function(e,t){var n;if(null!==t.stringContent&&!e.indented&&"paragraph"===t.type&&!Tp(e,t.parent)&&(n=e.currentLine.slice(e.nextNonspace).match(bp))){e.closeUnmatchedBlocks();for(var r=void 0;91===tp(t.stringContent,0)&&(r=e.inlineParser.parseReference(t,e.refMap));)t.stringContent=t.stringContent.slice(r);if(t.stringContent.length>0){var o=id("heading",t.sourcepos);return o.level="="===n[0][0]?1:2,o.headingType="setext",o.stringContent=t.stringContent,t.insertAfter(o),t.unlink(),e.tip=o,e.advanceOffset(e.currentLine.length-e.offset,!1),2}return 0}return 0},function(e){return!e.indented&&kp.test(e.currentLine.slice(e.nextNonspace))?(e.closeUnmatchedBlocks(),e.addChild("thematicBreak",e.nextNonspace),e.advanceOffset(e.currentLine.length-e.offset,!1),2):0},function(e,t){var n,r,o,i=t;return e.indented&&"list"!==t.type||!(n=function(e,t){var n,r,o=e.currentLine.slice(e.nextNonspace),i={type:"bullet",tight:!0,bulletChar:"",start:0,delimiter:"",padding:0,markerOffset:e.indent,task:!1,checked:!1};if(e.indent>=4)return null;if(n=o.match(xp))i.type="bullet",i.bulletChar=n[0][0];else{if(!(n=o.match(Cp))||"paragraph"===t.type&&"1"!==n[1])return null;i.type="ordered",i.start=parseInt(n[1],10),i.delimiter=n[2]}if(-1!==(r=tp(e.currentLine,e.nextNonspace+n[0].length))&&9!==r&&32!==r)return null;if("paragraph"===t.type&&!e.currentLine.slice(e.nextNonspace+n[0].length).match(Qd))return null;e.advanceNextNonspace(),e.advanceOffset(n[0].length,!0);var s=e.column,a=e.offset;do{e.advanceOffset(1,!0),r=tp(e.currentLine,e.offset)}while(e.column-s<5&&rp(r));var l=-1===tp(e.currentLine,e.offset),c=e.column-s;return c>=5||c<1||l?(i.padding=n[0].length+1,e.column=s,e.offset=a,rp(tp(e.currentLine,e.offset))&&e.advanceOffset(1,!0)):i.padding=n[0].length+c,i}(e,i))?0:(e.closeUnmatchedBlocks(),"list"===e.tip.type&&(r=i.listData,o=n,r.type===o.type&&r.delimiter===o.delimiter&&r.bulletChar===o.bulletChar)||((i=e.addChild("list",e.nextNonspace)).listData=n),(i=e.addChild("item",e.nextNonspace)).listData=n,1)},function(e){return e.indented&&"paragraph"!==e.tip.type&&!e.blank?(e.advanceOffset(4,!0),e.closeUnmatchedBlocks(),e.addChild("codeBlock",e.offset),2):0},function(e,t){var n=t.stringContent;if("paragraph"===t.type&&!e.indented&&!e.blank){var r=n.length-1,o=n.lastIndexOf("\n",r-1)+1,i=n.slice(o,r),s=e.currentLine.slice(e.nextNonspace),a=pp(i),l=a[0],c=a[1],u=pp(s),d=u[0],p=u[1],h=/^[ \t]*:?-+:?[ \t]*$/;if(!c.length||!p.length||p.some((function(e){return!h.test(e)}))||1===p.length&&0!==s.indexOf("|"))return 0;var f=t.lineOffsets,m=e.lineNumber-1,g=xd(f)+1,v=id("table",[[m,g],[e.lineNumber,e.offset]]);if(v.columns=p.map((function(){return{align:null}})),t.insertAfter(v),1===f.length)t.unlink();else{t.stringContent=n.slice(0,o);var y=o-(n.lastIndexOf("\n",o-2)+1)-1;e.lastLineLength=f[f.length-2]+y,e.finalize(t,m-1)}e.advanceOffset(e.currentLine.length-e.offset,!1);var b=id("tableHead",[[m,g],[e.lineNumber,e.offset]]);v.appendChild(b);var w=id("tableRow",[[m,g],[m,g+i.length-1]]),k=id("tableDelimRow",[[e.lineNumber,e.nextNonspace+1],[e.lineNumber,e.offset]]);b.appendChild(w),b.appendChild(k),hp("tableCell",c,m,g+l).forEach((function(e){w.appendChild(e)}));var x=hp("tableDelimCell",p,e.lineNumber,e.nextNonspace+1+d);return x.forEach((function(e){k.appendChild(e)})),v.columns=x.map(fp),e.tip=v,2}return 0},function(e,t){if("table"!==t.type&&"tableBody"!==t.type||!e.blank&&-1===e.currentLine.indexOf("|"))return 0;if(e.advanceOffset(e.currentLine.length-e.offset,!1),e.blank){var n=t;return"tableBody"===t.type&&(n=t.parent,e.finalize(t,e.lineNumber-1)),e.finalize(n,e.lineNumber-1),0}var r=t;"table"===t.type&&((r=e.addChild("tableBody",e.nextNonspace)).stringContent=null);var o=id("tableRow",[[e.lineNumber,e.nextNonspace+1],[e.lineNumber,e.currentLine.length]]);r.appendChild(o);var i=r.parent,s=pp(e.currentLine.slice(e.nextNonspace)),a=s[0];return hp("tableCell",s[1],e.lineNumber,e.nextNonspace+1+a).forEach((function(e,t){t>=i.columns.length&&(e.ignored=!0),o.appendChild(e)})),2},function(e){var t;if(!e.indented&&!gp.test(e.currentLine)&&(t=e.currentLine.match(mp))){var n=t[1].length;e.closeUnmatchedBlocks();var r=e.addChild("customBlock",e.nextNonspace);return r.syntaxLength=n,r.offset=e.indent,e.advanceNextNonspace(),e.advanceOffset(n,!1),2}return 0}],Sp=/^(-{3}|\+{3}|;{3})$/,Ep=function(e,t){var n=e.currentLine,r=e.lineNumber,o=e.indented;return 1===r&&!o&&"document"===t.type&&Sp.test(n)?(e.closeUnmatchedBlocks(),e.addChild("frontMatter",e.nextNonspace).stringContent=n,e.advanceNextNonspace(),e.advanceOffset(n.length,!1),2):0},Np={continue:function(e,t){var n=e.currentLine,r=n.match(Sp);return"frontMatter"===t.type&&r?(t.stringContent+=n,e.lastLineLength=r[0].length,e.finalize(t,e.lineNumber),2):0},finalize:function(e,t){null!==t.stringContent&&(t.literal=t.stringContent,t.stringContent=null)},canContain:function(){return!1},acceptsLines:!0},Op=[/./,/<\/(?:script|pre|style)>/i,/-->/,/\?>/,/>/,/\]\]>/],Dp=/^[#`~*+_=<>0-9-;$]/,Ap=/\r\n|\n|\r/;function Lp(){return id("document",[[1,1],[0,0]])}var Ip={smart:!1,tagFilter:!1,extendedAutolinks:!1,disallowedHtmlBlockTags:[],referenceDefinition:!1,disallowDeepHeading:!1,customParser:null,frontMatter:!1},Rp=function(){function e(e){this.options=_c(_c({},Ip),e),this.doc=Lp(),this.tip=this.doc,this.oldtip=this.doc,this.lineNumber=0,this.offset=0,this.column=0,this.nextNonspace=0,this.nextNonspaceColumn=0,this.indent=0,this.currentLine="",this.indented=!1,this.blank=!1,this.partiallyConsumedTab=!1,this.allClosed=!0,this.lastMatchedContainer=this.doc,this.refMap={},this.refLinkCandidateMap={},this.refDefCandidateMap={},this.lastLineLength=0,this.lines=[],this.options.frontMatter&&(dp.frontMatter=Np,Mp.unshift(Ep)),this.inlineParser=new Zd(this.options)}return e.prototype.advanceOffset=function(e,t){void 0===t&&(t=!1);for(var n,r,o,i=this.currentLine;e>0&&(o=i[this.offset]);)"\t"===o?(n=4-this.column%4,t?(this.partiallyConsumedTab=n>e,r=n>e?e:n,this.column+=r,this.offset+=this.partiallyConsumedTab?0:1,e-=r):(this.partiallyConsumedTab=!1,this.column+=n,this.offset+=1,e-=1)):(this.partiallyConsumedTab=!1,this.offset+=1,this.column+=1,e-=1)},e.prototype.advanceNextNonspace=function(){this.offset=this.nextNonspace,this.column=this.nextNonspaceColumn,this.partiallyConsumedTab=!1},e.prototype.findNextNonspace=function(){for(var e,t=this.currentLine,n=this.offset,r=this.column;""!==(e=t.charAt(n));)if(" "===e)n++,r++;else{if("\t"!==e)break;n++,r+=4-r%4}this.blank="\n"===e||"\r"===e||""===e,this.nextNonspace=n,this.nextNonspaceColumn=r,this.indent=this.nextNonspaceColumn-this.column,this.indented=this.indent>=4},e.prototype.addLine=function(){if(this.partiallyConsumedTab){this.offset+=1;var e=4-this.column%4;this.tip.stringContent+=zu(" ",e)}this.tip.lineOffsets?this.tip.lineOffsets.push(this.offset):this.tip.lineOffsets=[this.offset],this.tip.stringContent+=this.currentLine.slice(this.offset)+"\n"},e.prototype.addChild=function(e,t){for(;!dp[this.tip.type].canContain(e);)this.finalize(this.tip,this.lineNumber-1);var n=t+1,r=id(e,[[this.lineNumber,n],[0,0]]);return r.stringContent="",this.tip.appendChild(r),this.tip=r,r},e.prototype.closeUnmatchedBlocks=function(){if(!this.allClosed){for(;this.oldtip!==this.lastMatchedContainer;){var e=this.oldtip.parent;this.finalize(this.oldtip,this.lineNumber-1),this.oldtip=e}this.allClosed=!0}},e.prototype.finalize=function(e,t){var n=e.parent;e.open=!1,e.sourcepos[1]=[t,this.lastLineLength],dp[e.type].finalize(this,e),this.tip=n},e.prototype.processInlines=function(e){var t,n=this.options.customParser,r=e.walker();for(this.inlineParser.refMap=this.refMap,this.inlineParser.refLinkCandidateMap=this.refLinkCandidateMap,this.inlineParser.refDefCandidateMap=this.refDefCandidateMap,this.inlineParser.options=this.options;t=r.next();){var o=t.node,i=t.entering,s=o.type;n&&n[s]&&n[s](o,{entering:i,options:this.options}),i||"paragraph"!==s&&"heading"!==s&&("tableCell"!==s||o.ignored)||this.inlineParser.parse(o)}},e.prototype.incorporateLine=function(e){var t=this.doc;this.oldtip=this.tip,this.offset=0,this.column=0,this.blank=!1,this.partiallyConsumedTab=!1,this.lineNumber+=1,-1!==e.indexOf("\0")&&(e=e.replace(/\0/g,"�")),this.currentLine=e;for(var n,r=!0;(n=t.lastChild)&&n.open;){switch(t=n,this.findNextNonspace(),dp[t.type].continue(this,t)){case 0:break;case 1:r=!1;break;case 2:return void(this.lastLineLength=e.length);default:throw new Error("continue returned illegal value, must be 0, 1, or 2")}if(!r){t=t.parent;break}}this.allClosed=t===this.oldtip,this.lastMatchedContainer=t;for(var o="paragraph"!==t.type&&dp[t.type].acceptsLines,i=Mp.length;!o;){if(this.findNextNonspace(),"table"!==t.type&&"tableBody"!==t.type&&"paragraph"!==t.type&&!this.indented&&!Dp.test(e.slice(this.nextNonspace))){this.advanceNextNonspace();break}for(var s=0;s<i;){var a=Mp[s](this,t);if(1===a){t=this.tip;break}if(2===a){t=this.tip,o=!0;break}s++}if(s===i){this.advanceNextNonspace();break}}if(this.allClosed||this.blank||"paragraph"!==this.tip.type){this.closeUnmatchedBlocks(),this.blank&&t.lastChild&&(t.lastChild.lastLineBlank=!0);for(var l=t.type,c=this.blank&&!("blockQuote"===l||sd(t)&&t.isFenced||"item"===l&&!t.firstChild&&t.sourcepos[0][0]===this.lineNumber),u=t;u;)u.lastLineBlank=c,u=u.parent;dp[l].acceptsLines?(this.addLine(),function(e){return"htmlBlock"===e.type}(t)&&t.htmlBlockType>=1&&t.htmlBlockType<=5&&Op[t.htmlBlockType].test(this.currentLine.slice(this.offset))&&(this.lastLineLength=e.length,this.finalize(t,this.lineNumber))):this.offset<e.length&&!this.blank&&(t=this.addChild("paragraph",this.offset),this.advanceNextNonspace(),this.addLine())}else this.addLine();this.lastLineLength=e.length},e.prototype.parse=function(e,t){this.doc=Lp(),this.tip=this.doc,this.lineNumber=0,this.lastLineLength=0,this.offset=0,this.column=0,this.lastMatchedContainer=this.doc,this.currentLine="";var n=e.split(Ap),r=n.length;this.lines=t||n,this.options.referenceDefinition&&this.clearRefMaps(),10===e.charCodeAt(e.length-1)&&(r-=1);for(var o=0;o<r;o++)this.incorporateLine(n[o]);for(;this.tip;)this.finalize(this.tip,r);return this.processInlines(this.doc),this.doc},e.prototype.partialParseStart=function(e,t){this.doc=Lp(),this.tip=this.doc,this.lineNumber=e-1,this.lastLineLength=0,this.offset=0,this.column=0,this.lastMatchedContainer=this.doc,this.currentLine="";for(var n=t.length,r=0;r<n;r++)this.incorporateLine(t[r]);return this.doc},e.prototype.partialParseExtends=function(e){for(var t=0;t<e.length;t++)this.incorporateLine(e[t])},e.prototype.partialParseFinish=function(){for(;this.tip;)this.finalize(this.tip,this.lineNumber);this.processInlines(this.doc)},e.prototype.setRefMaps=function(e,t,n){this.refMap=e,this.refLinkCandidateMap=t,this.refDefCandidateMap=n},e.prototype.clearRefMaps=function(){[this.refMap,this.refLinkCandidateMap,this.refDefCandidateMap].forEach((function(e){var t;t=e,Object.keys(t).forEach((function(e){delete t[e]}))}))},e}();function Pp(e,t){return e[0]<t[0]?1:e[0]>t[0]?-1:e[1]<t[1]?1:e[1]>t[1]?-1:0}function Bp(e,t){var n=e[0];return 1===Pp(e[1],t)?1:-1===Pp(n,t)?-1:0}function Fp(e,t){for(var n=0,r=t;n<r.length;n++){var o=r[n];e.insertBefore(o)}}function Hp(e,t){var n=e[0];return e[1][0]<t?1:n[0]>t?-1:0}function zp(e,t){for(var n=e.firstChild;n;){var r=Hp(n.sourcepos,t);if(0===r)return n;if(-1===r)return n.prev||n;n=n.next}return e.lastChild}function qp(e){return function(e){return _u[e]}(e)||null}function Vp(e,t,n){if(void 0===n&&(n=null),t)for(var r=t.walker();t&&t!==n;){e(t);var o=r.next();if(!o)break;t=o.node}}var jp=/\r\n|\n|\r/;function $p(e){return{id:e.id,title:e.title,sourcepos:e.sourcepos,unlinked:!1,destination:e.dest}}var _p=function(){function e(e,t){this.refMap={},this.refLinkCandidateMap={},this.refDefCandidateMap={},this.referenceDefinition=!!(null==t?void 0:t.referenceDefinition),this.parser=new Rp(t),this.parser.setRefMaps(this.refMap,this.refLinkCandidateMap,this.refDefCandidateMap),this.eventHandlerMap={change:[]},e=e||"",this.lineTexts=e.split(jp),this.root=this.parser.parse(e,this.lineTexts)}return e.prototype.updateLineTexts=function(e,t,n){var r,o=e[0],i=e[1],s=t[0],a=t[1],l=n.split(jp),c=l.length,u=this.lineTexts[o-1],d=this.lineTexts[s-1];l[0]=u.slice(0,i-1)+l[0],l[c-1]=l[c-1]+d.slice(a-1);var p=s-o+1;return(r=this.lineTexts).splice.apply(r,Uc([o-1,p],l)),c-p},e.prototype.updateRootNodeState=function(){if(1===this.lineTexts.length&&""===this.lineTexts[0])return this.root.lastLineBlank=!0,void(this.root.sourcepos=[[1,1],[1,0]]);this.root.lastChild&&(this.root.lastLineBlank=this.root.lastChild.lastLineBlank);for(var e=this.lineTexts,t=e.length-1;""===e[t];)t-=1;e.length-2>t&&(t+=1),this.root.sourcepos[1]=[t+1,e[t].length]},e.prototype.replaceRangeNodes=function(e,t,n){e?(Fp(e,n),function(e,t){if(e.parent===t.parent&&e!==t){for(var n=e.next;n&&n!==t;){for(var r=n.next,o=0,i=["parent","prev","next"];o<i.length;o++){var s=i[o];n[s]&&(Uu(n[s].id),n[s]=null)}n=r}e.next=t.next,t.next?t.next.prev=e:e.parent.lastChild=e}}(e,t),[e.id,t.id].forEach((function(e){return Uu(e)})),e.unlink()):t?(Fp(t,n),Uu(t.id),t.unlink()):function(e,t){for(var n=t.length-1;n>=0;n-=1)e.prependChild(t[n])}(this.root,n)},e.prototype.getNodeRange=function(e,t){var n=zp(this.root,e[0]),r=zp(this.root,t[0]);return r&&r.next&&t[0]+1===r.next.sourcepos[0][0]&&(r=r.next),[n,r]},e.prototype.trigger=function(e,t){this.eventHandlerMap[e].forEach((function(e){e(t)}))},e.prototype.extendEndLine=function(e){for(;""===this.lineTexts[e];)e+=1;return e},e.prototype.parseRange=function(e,t,n,r){var o;e&&e.prev&&(ad(e.prev)&&function(e){var t=e.match(/^[ \t]+/);if(t&&(t[0].length>=2||/\t/.test(t[0])))return!0;var n=t?e.slice(t.length):e;return xp.test(n)||Cp.test(n)}(this.lineTexts[n-1])||function(e){return"table"===e.type}(e.prev)&&(!np(o=this.lineTexts[n-1])&&-1!==o.indexOf("|")))&&(n=(e=e.prev).sourcepos[0][0]);for(var i=this.lineTexts.slice(n-1,r),s=this.parser.partialParseStart(n,i),a=t?t.next:this.root.firstChild,l=s.lastChild,c=l&&sd(l)&&l.open,u=l&&cd(l)&&l.open,d=l&&ad(l);(c||u)&&a||d&&a&&("list"===a.type||a.sourcepos[0][1]>=2);){var p=this.extendEndLine(a.sourcepos[1][0]);this.parser.partialParseExtends(this.lineTexts.slice(r,p)),e||(e=t),t=a,r=p,a=a.next}return this.parser.partialParseFinish(),{newNodes:function(e){for(var t=[],n=e.firstChild;n;)t.push(n),n=n.next;return t}(s),extStartNode:e,extEndNode:t}},e.prototype.getRemovedNodeRange=function(e,t){return!e||e&&ld(e)||t&&ld(t)?null:{id:[e.id,t.id],line:[e.sourcepos[0][0]-1,t.sourcepos[1][0]-1]}},e.prototype.markDeletedRefMap=function(e,t){var n=this;if(!Md(this.refMap)){var r=function(e){if(ld(e)){var t=n.refMap[e.label];t&&e.id===t.id&&(t.unlinked=!0)}};e&&Vp(r,e.parent,t),t&&Vp(r,t)}},e.prototype.replaceWithNewRefDefState=function(e){var t=this;if(!Md(this.refMap)){var n=function(e){if(ld(e)){var n=e.label,r=t.refMap[n];r&&!r.unlinked||(t.refMap[n]=$p(e))}};e.forEach((function(e){Vp(n,e)}))}},e.prototype.replaceWithRefDefCandidate=function(){var e=this;Md(this.refDefCandidateMap)||Td(this.refDefCandidateMap,(function(t,n){var r=n.label,o=n.sourcepos,i=e.refMap[r];(!i||i.unlinked||i.sourcepos[0][0]>o[0][0])&&(e.refMap[r]=$p(n))}))},e.prototype.getRangeWithRefDef=function(e,t,n,r,o){if(this.referenceDefinition&&!Md(this.refMap)){var i=zp(this.root,e-1),s=zp(this.root,t+1);i&&ld(i)&&i!==n&&i!==r&&(e=(n=i).sourcepos[0][0]),s&&ld(s)&&s!==n&&s!==r&&(r=s,t=this.extendEndLine(r.sourcepos[1][0]+o))}return[n,r,e,t]},e.prototype.parse=function(e,t,n){void 0===n&&(n=0);var r=this.getNodeRange(e,t),o=r[0],i=r[1],s=o?Math.min(o.sourcepos[0][0],e[0]):e[0],a=this.extendEndLine((i?Math.max(i.sourcepos[1][0],t[0]):t[0])+n),l=this.parseRange.apply(this,this.getRangeWithRefDef(s,a,o,i,n)),c=l.newNodes,u=l.extStartNode,d=l.extEndNode,p=this.getRemovedNodeRange(u,d),h=d?d.next:this.root.firstChild;return this.referenceDefinition?(this.markDeletedRefMap(u,d),this.replaceRangeNodes(u,d,c),this.replaceWithNewRefDefState(c)):this.replaceRangeNodes(u,d,c),{nodes:c,removedNodeRange:p,nextNode:h}},e.prototype.parseRefLink=function(){var e=this,t=[];return Md(this.refMap)||Td(this.refMap,(function(n,r){r.unlinked&&delete e.refMap[n],Td(e.refLinkCandidateMap,(function(r,o){var i=o.node;o.refLabel===n&&t.push(e.parse(i.sourcepos[0],i.sourcepos[1]))}))})),t},e.prototype.removeUnlinkedCandidate=function(){Md(this.refDefCandidateMap)||[this.refLinkCandidateMap,this.refDefCandidateMap].forEach((function(e){Td(e,(function(t){(function(e){var t=qp(e);if(!t)return!0;for(;t&&"document"!==t.type;){if(!t.parent&&!t.prev&&!t.next)return!0;t=t.parent}return!1})(t)&&delete e[t]}))}))},e.prototype.editMarkdown=function(e,t,n){var r=this.updateLineTexts(e,t,n),o=this.parse(e,t,r),i=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=_c({},e);return t.forEach((function(e){delete r[e]})),r}(o,"nextNode");!function(e,t){if(e&&e.parent&&0!==t){var n,r=e.parent.walker();for(r.resumeAt(e,!0);n=r.next();){var o=n.node;n.entering&&(o.sourcepos[0][0]+=t,o.sourcepos[1][0]+=t)}}}(o.nextNode,r),this.updateRootNodeState();var s=[i];return this.referenceDefinition&&(this.removeUnlinkedCandidate(),this.replaceWithRefDefCandidate(),s=s.concat(this.parseRefLink())),this.trigger("change",s),s},e.prototype.getLineTexts=function(){return this.lineTexts},e.prototype.getRootNode=function(){return this.root},e.prototype.findNodeAtPosition=function(e){var t=function(e,t){for(var n=e,r=null;n;){var o=Bp(n.sourcepos,t);if(0===o){if(!n.firstChild)return n;r=n,n=n.firstChild}else{if(-1===o)return r;if(!n.next)return r;n=n.next}}return n}(this.root,e);return t&&t!==this.root?t:null},e.prototype.findFirstNodeAtLine=function(e){return function(e,t){for(var n=e.firstChild,r=null;n;){var o=Hp(n.sourcepos,t);if(0===o){if(n.sourcepos[0][0]===t||!n.firstChild)return n;r=n,n=n.firstChild}else{if(-1===o)break;r=n,n=n.next}}return r?function(e){for(;e.parent&&"document"!==e.parent.type&&e.parent.sourcepos[0][0]===e.sourcepos[0][0];)e=e.parent;return e}(function(e){for(;e.lastChild;)e=e.lastChild;return e}(r)):null}(this.root,e)},e.prototype.on=function(e,t){this.eventHandlerMap[e].push(t)},e.prototype.off=function(e,t){var n=this.eventHandlerMap[e],r=n.indexOf(t);n.splice(r,1)},e.prototype.findNodeById=function(e){return qp(e)},e.prototype.removeAllNode=function(){_u={}},e}(),Up=new RegExp("<(/?(?:"+["title","textarea","style","xmp","iframe","noembed","noframes","script","plaintext"].join("|")+")[^>]*>)","ig");function Wp(e){return Up.test(e)?e.replace(Up,(function(e,t){return"&lt;"+t})):e}var Jp={heading:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"h"+e.level,outerNewLine:!0}},text:function(e){return{type:"text",content:e.literal}},softbreak:function(e,t){return{type:"html",content:t.options.softbreak}},linebreak:function(){return{type:"html",content:"<br />\n"}},emph:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"em"}},strong:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"strong"}},paragraph:function(e,t){var n,r=t.entering,o=null===(n=e.parent)||void 0===n?void 0:n.parent;return o&&"list"===o.type&&o.listData.tight?null:{type:r?"openTag":"closeTag",tagName:"p",outerNewLine:!0}},thematicBreak:function(){return{type:"openTag",tagName:"hr",outerNewLine:!0,selfClose:!0}},blockQuote:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"blockquote",outerNewLine:!0,innerNewLine:!0}},list:function(e,t){var n=t.entering,r=e.listData,o=r.type,i=r.start,s="bullet"===o?"ul":"ol",a={};return"ol"===s&&null!==i&&1!==i&&(a.start=i.toString()),{type:n?"openTag":"closeTag",tagName:s,attributes:a,outerNewLine:!0}},item:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"li",outerNewLine:!0}},htmlInline:function(e,t){return{type:"html",content:t.options.tagFilter?Wp(e.literal):e.literal}},htmlBlock:function(e,t){var n=t.options,r=n.tagFilter?Wp(e.literal):e.literal;return n.nodeId?[{type:"openTag",tagName:"div",outerNewLine:!0},{type:"html",content:r},{type:"closeTag",tagName:"div",outerNewLine:!0}]:{type:"html",content:r,outerNewLine:!0}},code:function(e){return[{type:"openTag",tagName:"code"},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"}]},codeBlock:function(e){var t=e.info,n=t?t.split(/\s+/):[],r=[];return n.length>0&&n[0].length>0&&r.push("language-"+Hu(n[0])),[{type:"openTag",tagName:"pre",outerNewLine:!0},{type:"openTag",tagName:"code",classNames:r},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"},{type:"closeTag",tagName:"pre",outerNewLine:!0}]},link:function(e,t){if(t.entering){var n=e,r=n.title,o=n.destination;return{type:"openTag",tagName:"a",attributes:_c({href:Hu(o)},r&&{title:Hu(r)})}}return{type:"closeTag",tagName:"a"}},image:function(e,t){var n=t.getChildrenText,r=t.skipChildren,o=e,i=o.title,s=o.destination;return r(),{type:"openTag",tagName:"img",selfClose:!0,attributes:_c({src:Hu(s),alt:n(e)},i&&{title:Hu(i)})}},customBlock:function(e,t,n){var r=e.info.trim().toLowerCase(),o=n[r];if(o)try{return o(e,t)}catch(e){console.warn("[@toast-ui/editor] - The error occurred when "+r+" block node was parsed in markdown renderer: "+e)}return[{type:"openTag",tagName:"div",outerNewLine:!0},{type:"text",content:e.literal},{type:"closeTag",tagName:"div",outerNewLine:!0}]},frontMatter:function(e){return[{type:"openTag",tagName:"div",outerNewLine:!0,attributes:{style:"white-space: pre; display: none;"}},{type:"text",content:e.literal},{type:"closeTag",tagName:"div",outerNewLine:!0}]},customInline:function(e,t,n){var r=e,o=r.info,i=r.firstChild,s=o.trim().toLowerCase(),a=n[s],l=t.entering;if(a)try{return a(e,t)}catch(e){console.warn("[@toast-ui/editor] - The error occurred when "+s+" inline node was parsed in markdown renderer: "+e)}return l?[{type:"openTag",tagName:"span"},{type:"text",content:"$$"+o+(i?" ":"")}]:[{type:"text",content:"$$"},{type:"closeTag",tagName:"span"}]}},Gp={strike:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"del"}},item:function(e,t){var n=t.entering,r=e.listData,o=r.checked,i=r.task;if(n){var s={type:"openTag",tagName:"li",outerNewLine:!0};return i?[s,{type:"openTag",tagName:"input",selfClose:!0,attributes:_c(_c({},o&&{checked:""}),{disabled:"",type:"checkbox"})},{type:"text",content:" "}]:s}return{type:"closeTag",tagName:"li",outerNewLine:!0}},table:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"table",outerNewLine:!0}},tableHead:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"thead",outerNewLine:!0}},tableBody:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"tbody",outerNewLine:!0}},tableRow:function(e,t){if(t.entering)return{type:"openTag",tagName:"tr",outerNewLine:!0};var n=[];if(e.lastChild)for(var r=e.parent.parent.columns.length,o=e.lastChild.endIdx+1;o<r;o+=1)n.push({type:"openTag",tagName:"td",outerNewLine:!0},{type:"closeTag",tagName:"td",outerNewLine:!0});return n.push({type:"closeTag",tagName:"tr",outerNewLine:!0}),n},tableCell:function(e,t){var n=t.entering;if(e.ignored)return{type:"text",content:""};var r=e.parent.parent,o="tableHead"===r.type?"th":"td",i=r.parent.columns[e.startIdx],s=(null==i?void 0:i.align)?{align:i.align}:null;return n?_c({type:"openTag",tagName:o,outerNewLine:!0},s&&{attributes:s}):{type:"closeTag",tagName:o,outerNewLine:!0}}},Kp={softbreak:"\n",gfm:!1,tagFilter:!1,nodeId:!1};function Zp(e){for(var t=[],n=e.walker(),r=null;r=n.next();){var o=r.node;"text"===o.type&&t.push(o.literal)}return t.join("")}var Xp=function(){function e(e){this.buffer=[],this.options=_c(_c({},Kp),e),this.convertors=this.createConvertors(),delete this.options.convertors}return e.prototype.createConvertors=function(){var e=_c({},Jp);if(this.options.gfm&&(e=_c(_c({},e),Gp)),this.options.convertors){var t=this.options.convertors,n=Object.keys(t),r=_c(_c({},Jp),Gp);n.forEach((function(n){var o=e[n],i=t[n],s=-1===Object.keys(r).indexOf(n)?n.toLowerCase():n;e[s]=o?function(e,t,n){return t.origin=function(){return o(e,t,n)},i(e,t)}:i}))}return e},e.prototype.getConvertors=function(){return this.convertors},e.prototype.getOptions=function(){return this.options},e.prototype.render=function(e){var t=this;this.buffer=[];for(var n=e.walker(),r=null,o=function(){var e=r.node,o=r.entering,s=i.convertors[e.type];if(!s)return"continue";var a=!1,l={entering:o,leaf:!ju(e),options:i.options,getChildrenText:Zp,skipChildren:function(){a=!0}},c=cd(e)||function(e){return"customInline"===e.type}(e)?s(e,l,i.convertors):s(e,l);c&&((Array.isArray(c)?c:[c]).forEach((function(n,r){"openTag"===n.type&&t.options.nodeId&&0===r&&(n.attributes||(n.attributes={}),n.attributes["data-nodeid"]=String(e.id)),t.renderHTMLNode(n)})),a&&(n.resumeAt(e,!1),n.next()))},i=this;r=n.next();)o();return this.addNewLine(),this.buffer.join("")},e.prototype.renderHTMLNode=function(e){switch(e.type){case"openTag":case"closeTag":this.renderElementNode(e);break;case"text":this.renderTextNode(e);break;case"html":this.renderRawHtmlNode(e)}},e.prototype.generateOpenTagString=function(e){var t=this,n=e.tagName,r=e.classNames,o=e.attributes;this.buffer.push("<"+n),r&&r.length>0&&this.buffer.push(' class="'+r.join(" ")+'"'),o&&Object.keys(o).forEach((function(e){var n=o[e];t.buffer.push(" "+e+'="'+n+'"')})),e.selfClose&&this.buffer.push(" /"),this.buffer.push(">")},e.prototype.generateCloseTagString=function(e){var t=e.tagName;this.buffer.push("</"+t+">")},e.prototype.addNewLine=function(){this.buffer.length&&"\n"!==xd(xd(this.buffer))&&this.buffer.push("\n")},e.prototype.addOuterNewLine=function(e){e.outerNewLine&&this.addNewLine()},e.prototype.addInnerNewLine=function(e){e.innerNewLine&&this.addNewLine()},e.prototype.renderTextNode=function(e){this.buffer.push(Hu(e.content))},e.prototype.renderRawHtmlNode=function(e){this.addOuterNewLine(e),this.buffer.push(e.content),this.addOuterNewLine(e)},e.prototype.renderElementNode=function(e){"openTag"===e.type?(this.addOuterNewLine(e),this.generateOpenTagString(e),e.selfClose?this.addOuterNewLine(e):this.addInnerNewLine(e)):(this.addInnerNewLine(e),this.generateCloseTagString(e),this.addOuterNewLine(e))},e}(),Qp=n(368),Yp=n.n(Qp),eh=["iframe","embed"],th=[];function nh(e){Ue(eh,e)&&th.push(e.toLowerCase())}function rh(e,t){return Yp().sanitize(e,o({ADD_TAGS:th,ADD_ATTR:["rel","target","hreflang","type"],FORBID_TAGS:["input","script","textarea","form","button","select","meta","style","link","title","object","base"]},t))}function oh(e,t){return e.literal.replace(new RegExp("(<\\s*"+t+"[^>]*>)|(</"+t+"\\s*[>])","ig"),"").trim()}function ih(e){var t=(e=e.match(ga)[0]).match(new RegExp(ha,"g"));return t?t.reduce((function(e,t){var n=t.trim().split("="),r=n[0],o=n.slice(1);return o.length&&(e[r]=o.join("=").replace(/'|"/g,"").trim()),e}),{}):{}}function sh(e){return vi()(e.attributes).reduce((function(e,t){return e[t.nodeName]=t.nodeValue,e}),{})}function ah(e,t,n,r){var o=r.getToDOMNode(t)(e),i=n(o.outerHTML),s=document.createElement("div");return s.innerHTML=i,{dom:o=s.firstChild,htmlAttrs:sh(o)}}var lh={htmlBlock:function(e,t,n){return{atom:!0,content:"block+",group:"block",attrs:{htmlAttrs:{default:{}},childrenHTML:{default:""},htmlBlock:{default:!0}},parseDOM:[{tag:e,getAttrs:function(e){return{htmlAttrs:sh(e),childrenHTML:e.innerHTML}}}],toDOM:function(r){var o=ah(r,e,t,n),s=o.dom,a=o.htmlAttrs;return a.class=a.class?a.class+" html-block":"html-block",i([e,a],vi()(s.childNodes))}}},htmlInline:function(e,t,n){return{attrs:{htmlAttrs:{default:{}},htmlInline:{default:!0}},parseDOM:[{tag:e,getAttrs:function(e){return{htmlAttrs:sh(e)}}}],toDOM:function(r){var o=ah(r,e,t,n).htmlAttrs;return[e,o,0]}}}};var ch=/^\s*<\s*\//,uh={paragraph:function(e,t){var n=t.entering,r=t.origin;return t.options.nodeId?{type:n?"openTag":"closeTag",outerNewLine:!0,tagName:"p"}:r()},softbreak:function(e){return{type:"html",content:e.prev&&"htmlInline"===e.prev.type&&/<br ?\/?>/.test(e.prev.literal)?"\n":"<br>\n"}},item:function(e,t){if(t.entering){var n={},r=[];return e.listData.task&&(n["data-task"]="",r.push("task-list-item"),e.listData.checked&&(r.push("checked"),n["data-task-checked"]="")),{type:"openTag",tagName:"li",classNames:r,attributes:n,outerNewLine:!0}}return{type:"closeTag",tagName:"li",outerNewLine:!0}},code:function(e){return[{type:"openTag",tagName:"code",attributes:{"data-backticks":String(e.tickCount)}},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"}]},codeBlock:function(e){var t=e,n=t.fenceLength,r=t.info,o=r?r.split(/\s+/):[],i=[],s={};if(n>3&&(s["data-backticks"]=n),o.length>0&&o[0].length>0){var a=o[0];i.push("lang-"+a),s["data-language"]=a}return[{type:"openTag",tagName:"pre",classNames:i},{type:"openTag",tagName:"code",attributes:s},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"},{type:"closeTag",tagName:"pre"}]},customInline:function(e,t){var n=t.origin,r=t.entering,o=t.skipChildren,i=e.info;return-1!==i.indexOf("widget")&&r?(o(),[{type:"openTag",tagName:"span",classNames:["tui-widget"]},{type:"html",content:Ys(i,oa(e)).outerHTML},{type:"closeTag",tagName:"span"}]):n()}};function dh(e,t){var n=o({},uh);return e&&(n.link=function(t,n){var r=n.entering,i=(0,n.origin)();return r&&(i.attributes=o(o({},i.attributes),e)),i}),t&&Object.keys(t).forEach((function(e){var r=n[e],i=t[e];r&&Ga()(i)?n[e]=function(e,t){var n=o({},t);return n.origin=function(){return r(e,t)},i(e,n)}:Ue(["htmlBlock","htmlInline"],e)&&!Ga()(i)?n[e]=function(e,t){var n=e.literal.match(ga);if(n){var r=n[0],s=n[1],a=n[3],l=(s||a).toLowerCase(),c=i[l],u=oh(e,l);if(c){var d=o({},e);return d.attrs=ih(r),d.childrenHTML=u,d.type=l,t.entering=!ch.test(e.literal),c(d,t)}}return t.origin()}:n[e]=i})),n}var ph=["list","item","blockQuote"],hh=["UL","OL","BLOCKQUOTE"];function fh(e,t){var n,r=e.child(t);return!r.childCount||1===r.childCount&&!(null===(n=r.firstChild.text)||void 0===n?void 0:n.trim())}function mh(e,t,n){var r=Is(t)-1,o=Rs(t)-1,i=n[r].getBoundingClientRect(),s=n[o].offsetTop-n[r].offsetTop+n[o].clientHeight;return{height:s<=0?n[r].clientHeight:s+gh(e,n,Math.min(o+1,e.childCount-1)),rect:i}}function gh(e,t,n){for(var r=e.childCount-1,o=0;n<=r&&fh(e,n);)o+=t[n].clientHeight,n+=1;return o}function vh(e,t){for(var n=0;e&&e!==t&&(Ue(hh,e.tagName)||(n+=e.offsetTop),e.offsetParent!==t.offsetParent);)e=e.parentElement;return n}function yh(e,t,n){return e&&t>n+e.offsetTop?yh(e.nextElementSibling,t,n)||e:null}function bh(e,t){for(var n=e.querySelector('[data-nodeid="'+t.id+'"]');!n||Fs(t);)t=t.parent,n=e.querySelector('[data-nodeid="'+t.id+'"]');return function(e){var t=e.mdNode,n=e.el;for(;(Ue(ph,t.type)||"table"===t.type)&&t.firstChild;)t=t.firstChild,n=n.firstElementChild;return{mdNode:t,el:n}}({mdNode:t,el:n})}var wh={};function kh(e){e&&(delete wh[Number(e.getAttribute("data-nodeid"))],vi()(e.children).forEach((function(e){kh(e)})))}function xh(e,t,n){var r,o=wh[r=n]&&wh[r].height,i=function(e){return wh[e]&&wh[e].offsetTop}(n),s=o||e.clientHeight,a=i||vh(e,t)||e.offsetTop;return o||function(e,t){wh[e]=wh[e]||{},wh[e].height=t}(n,s),i||function(e,t){wh[e]=wh[e]||{},wh[e].offsetTop=t}(n,a),{nodeHeight:s,offsetTop:a}}var Ch=xa("md-preview-highlight");var Th=function(){function e(e,t){var n=document.createElement("div");this.el=n,this.eventEmitter=e,this.isViewer=!!t.isViewer,this.el.className=xa("md-preview");var r=t.linkAttributes,o=t.customHTMLRenderer,i=t.sanitizer,s=t.highlight,a=void 0!==s&&s;this.renderer=new Xp({gfm:!0,nodeId:!0,convertors:dh(r,o)}),this.cursorNodeId=null,this.sanitizer=i,this.initEvent(a),this.initContentSection(),this.isViewer&&(this.previewContent.style.overflowWrap="break-word")}return e.prototype.initContentSection=function(){this.previewContent=Ea('<div class="'+xa("contents")+'"></div>'),this.isViewer||this.el.appendChild(this.previewContent)},e.prototype.toggleActive=function(e){Sa(this.el,"active",e)},e.prototype.initEvent=function(e){var t=this;this.eventEmitter.listen("updatePreview",this.update.bind(this)),this.isViewer||(e&&(this.eventEmitter.listen("changeToolbarState",(function(e){var n=e.mdNode,r=e.cursorPos;t.updateCursorNode(n,r)})),this.eventEmitter.listen("blur",(function(){t.removeHighlight()}))),Vc()(this.el,"scroll",(function(e){t.eventEmitter.emit("scroll","preview",function(e,t){for(var n=t,r=null;n;){var o=n.firstElementChild;if(!o)break;r=n,n=yh(o,e,vh(n,t))}var i=n||r;return i===t?null:i}(e.target.scrollTop,t.previewContent))})),this.eventEmitter.listen("changePreviewTabPreview",(function(){return t.toggleActive(!0)})),this.eventEmitter.listen("changePreviewTabWrite",(function(){return t.toggleActive(!1)})))},e.prototype.removeHighlight=function(){if(this.cursorNodeId){var e=this.getElementByNodeId(this.cursorNodeId);e&&Ce()(e,Ch)}},e.prototype.updateCursorNode=function(e,t){e&&("tableRow"===(e=js(e,(function(e){return!function(e){switch(e.type){case"code":case"text":case"emph":case"strong":case"strike":case"link":case"image":case"htmlInline":case"linebreak":case"softbreak":case"customInline":return!0;default:return!1}}(e)}))).type?e=function(e,t){for(var n=e.firstChild;n&&n.next&&!(Ps(n.next)>t+1);)n=n.next;return n}(e,t[1]):"tableBody"===e.type&&(e=null));var n=e?e.id:null;if(this.cursorNodeId!==n){var r=this.getElementByNodeId(this.cursorNodeId),o=this.getElementByNodeId(n);r&&Ce()(r,Ch),o&&ke()(o,Ch),this.cursorNodeId=n}},e.prototype.getElementByNodeId=function(e){return e?this.previewContent.querySelector('[data-nodeid="'+e+'"]'):null},e.prototype.update=function(e){var t=this;e.forEach((function(e){return t.replaceRangeNodes(e)})),this.eventEmitter.emit("afterPreviewRender",this)},e.prototype.replaceRangeNodes=function(e){var t=this,n=e.nodes,r=e.removedNodeRange,o=this.previewContent,i=this.eventEmitter.emitReduce("beforePreviewRender",this.sanitizer(n.map((function(e){return t.renderer.render(e)})).join("")));if(r){var s=r.id,a=s[0],l=s[1],c=this.getElementByNodeId(a),u=this.getElementByNodeId(l);if(c){c.insertAdjacentHTML("beforebegin",i);for(var d=c;d&&d!==u;){var p=d.nextElementSibling;Ma(d),kh(d),d=p}(null==d?void 0:d.parentNode)&&(Ma(d),kh(d))}}else o.insertAdjacentHTML("afterbegin",i)},e.prototype.getRenderer=function(){return this.renderer},e.prototype.destroy=function(){zc()(this.el,"scroll"),this.el=null},e.prototype.getElement=function(){return this.el},e.prototype.getHTML=function(){return La(this.previewContent.innerHTML)},e.prototype.setHTML=function(e){this.previewContent.innerHTML=e},e.prototype.setHeight=function(e){be()(this.el,{height:e+"px"})},e.prototype.setMinHeight=function(e){be()(this.el,{minHeight:e+"px"})},e}(),Mh=Th;function Sh(e,t){for(var n=e.depth;n;){var r=e.node(n);if(t(r,n))return{node:r,depth:n,offset:n>0?e.before(n):0};n-=1}return null}function Eh(e){return!!Sh(e,(function(e){var t=e.type;return"listItem"===t.name||"bulletList"===t.name||"orderedList"===t.name}))}function Nh(e){return!!Sh(e,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}))}function Oh(e){return Sh(e,(function(e){return"listItem"===e.type.name}))}function Dh(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}function Ah(e){return Object.keys(e).reduce((function(t,n){return"rawHTML"!==n&&e[n]&&(t[n="className"===n?"class":n]=e[n]),t}),{})}function Lh(e){return{tag:e,getAttrs:function(e){return["rawHTML","colspan","rowspan","extended"].reduce((function(t,n){var r="rawHTML"===n?"data-raw-html":n,o=e.getAttribute(r);return o&&(t[n]=Ue(["rawHTML","extended"],n)?o:Number(o)),t}),{})}}}function Ih(e){var t=e.htmlAttrs,n=e.classNames;return o(o({},t),{class:n?n.join(" "):null})}function Rh(e,t,n,r){var o=t.$from,i=t.$to,s=t.depth,a=t,l=!1;if(s>=2&&o.node(s-1).type.compatibleContent(n)&&0===t.startIndex&&o.index(s-1)){var c=e.doc.resolve(t.start-2);a=new I(c,c,s),t.endIndex<t.parent.childCount&&(t=new I(o,e.doc.resolve(i.end(s)),s)),l=!0}var u=function(e,t,n,r){var o=function(e,t){var n=e.parent,r=e.startIndex,o=e.endIndex,i=n.contentMatchAt(r).findWrapping(t);if(i){var s=i.length?i[0]:t;return n.canReplaceWith(r,o,s)?i:null}return null}(e,n),i=function(e,t){var n=e.parent,r=e.startIndex,o=e.endIndex,i=n.child(r),s=t.contentMatch.findWrapping(i.type);if(s){for(var a=(s.length?s[s.length-1]:t).contentMatch,l=r;a&&l<o;l+=1)a=a.matchType(n.child(l).type);if(a&&a.validEnd)return s}return null}(t,n);if(o&&i){var s=o.map((function(e){return{type:e}})),a=i.map((function(e){return{type:e,attrs:r}}));return s.concat({type:n}).concat(a)}return null}(a,t,n,r);return u?function(e,t,n,r,o){for(var i=t.start,s=t.end,a=t.startIndex,l=t.endIndex,c=t.parent,u=d.empty,p=n.length-1;p>=0;p-=1)u=d.from(n[p].type.create(n[p].attrs,u));e.step(new wt(i-(r?2:0),s,i,s,new v(u,0,0),n.length,!0));var h=0;for(p=0;p<n.length;p+=1)if(n[p].type===o){h=p+1;break}for(var f=n.length-h,m=i+n.length-(r?2:0),g=(p=a,l);p<g;p+=1)!(p===a)&&Mt(e.doc,m,f)&&(e.split(m,f),m+=2*f),m+=c.child(p).nodeSize;return e}(e,t,u,l,n):e}function Ph(e,t){for(var n=e.resolve(t);"paragraph"!==n.node().type.name;)t-=2,n=e.resolve(t);return Oh(n)}function Bh(e){return function(t,n){var r=t.selection,o=t.tr,i=r.$from,s=r.$to,a=i.blockRange(s);if(a){var l=Eh(i)?function(e,t,n){var r=t.$from,o=t.$to,i=Oh(r),s=Oh(o);if(i&&s)for(;s;){var a=s.offset,l=s.node,c=s.depth;l.attrs.task&&e.setNodeMarkup(a,null,{task:!1,checked:!1});var u=e.doc.resolve(a);if(u.parent.type!==n){var d=u.before(c-1);e.setNodeMarkup(d,n)}if(a===i.offset)break;s=Ph(e.doc,a)}return e}(o,a,e):Rh(o,a,e);return n(l),!0}return!1}}function Fh(){return function(e,t){var n=e.selection,r=e.tr,o=e.schema,i=n.$from,s=n.$to,a=i.blockRange(s);if(a){var l=Eh(i)?function(e,t){var n=t.$from,r=t.$to,o=Oh(n),i=Oh(r);if(o&&i)for(;i;){var s=i.offset,a={task:!i.node.attrs.task,checked:!1};if(e.setNodeMarkup(s,null,a),s===o.offset)break;i=Ph(e.doc,s)}return e}(r,a):Rh(r,a,o.nodes.bulletList,{task:!0});return t(l),!0}return!1}}function Hh(e){return function(t,n){var r=t.tr,o=t.selection,i=o.$from,s=o.$to,a=i.blockRange(s,(function(t){var n=t.childCount,r=t.firstChild;return!!n&&r.type===e}));if(a){var l=i.node(a.depth-1).type===e?function(e,t,n){var r=t.$from,o=t.$to,i=t.end,s=t.depth,a=t.parent,l=o.end(s);return i<l&&(e.step(new wt(i-1,l,i,l,new v(d.from(n.create(null,a.copy())),1,0),1,!0)),t=new I(e.doc.resolve(r.pos),e.doc.resolve(l),s)),e.lift(t,Ct(t)),e}(r,a,e):function(e,t){for(var n=t.parent,r=t.end,o=t.endIndex-1,i=t.startIndex;o>i;o-=1)r-=n.child(o).nodeSize,e.delete(r-1,r+1);var s=e.doc.resolve(t.start),a=s.nodeAfter,l=0===t.startIndex,c=t.endIndex===n.childCount,u=s.node(-1),p=s.index(-1),h=u.canReplace(p+(l?0:1),p+1,null==a?void 0:a.content.append(c?d.empty:d.from(n)));if(a&&h){var f=s.pos,m=f+a.nodeSize;e.step(new wt(f-(l?1:0),m+(c?1:0),f+1,m-1,new v((l?d.empty:d.from(n.copy(d.empty))).append(c?d.empty:d.from(n.copy(d.empty))),l?0:1,c?0:1),l?0:1))}return e}(r,a);return n(l),!0}return!1}}function zh(){return function(){return function(e,t){var n=e.selection,r=e.schema,o=n.$from,i=n.$to;return!(!o.blockRange(i)||!Eh(o))&&function(e){return function(t,n){var r=t.tr,o=t.selection,i=o.$from,s=o.$to,a=i.blockRange(s,(function(t){var n=t.childCount,r=t.firstChild;return!!n&&r.type===e}));if(a&&a.startIndex>0){var l=a.parent,c=l.child(a.startIndex-1);if(c.type!==e)return!1;var u=c.lastChild&&c.lastChild.type===l.type,p=u?d.from(e.create()):null,h=new v(d.from(e.create(null,d.from(l.type.create(null,p)))),u?3:1,0),f=a.start,m=a.end;return r.step(new wt(f-(u?3:1),m,f,m,h,1,!0)),n(r),!0}return!1}}(r.nodes.listItem)(e,t)}}}function qh(){return{indent:zh(),outdent:function(){return function(e,t){var n=e.selection,r=e.schema,o=n.$from,i=n.$to;return!(!o.blockRange(i)||!Eh(o))&&Hh(r.nodes.listItem)(e,t)}}}}var Vh=new Map,jh=function(){function e(e,t,n,r){this.table=e,this.tableRows=t,this.tableStartPos=n,this.rowInfo=r}return e.create=function(t){var n=Sh(t,(function(e){return"table"===e.type.name}));if(n){var r=n.node,o=n.depth,i=n.offset,s=Vh.get(r);if((null==s?void 0:s.tableStartPos)===i+1)return s;var a=[],l=t.start(o),c=r.child(0),u=r.child(1),d=$h(c,l),p=$h(u,l+c.nodeSize);c.forEach((function(e){return a.push(e)})),u.forEach((function(e){return a.push(e)}));var h=new e(r,a,l,d.concat(p));return Vh.set(r,h),h}return null},Object.defineProperty(e.prototype,"totalRowCount",{get:function(){return this.rowInfo.length},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"totalColumnCount",{get:function(){return this.rowInfo[0].length},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"tableStartOffset",{get:function(){return this.tableStartPos},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"tableEndOffset",{get:function(){return this.tableStartPos+this.table.nodeSize-1},enumerable:!1,configurable:!0}),e.prototype.getCellInfo=function(e,t){return this.rowInfo[e][t]},e.prototype.posAt=function(e,t){for(var n=0,r=this.tableStartPos;;n+=1){var o=r+this.tableRows[n].nodeSize;if(n===e){for(var i=t;i<this.totalColumnCount&&this.rowInfo[n][i].offset<r;)i+=1;return i===this.totalColumnCount?o:this.rowInfo[n][i].offset}r=o}},e.prototype.getNodeAndPos=function(e,t){var n=this.rowInfo[e][t];return{node:this.table.nodeAt(n.offset-this.tableStartOffset),pos:n.offset}},e.prototype.extendedRowspan=function(e,t){return!1},e.prototype.extendedColspan=function(e,t){return!1},e.prototype.getRowspanCount=function(e,t){return 0},e.prototype.getColspanCount=function(e,t){return 0},e.prototype.decreaseColspanCount=function(e,t){return 0},e.prototype.decreaseRowspanCount=function(e,t){return 0},e.prototype.getColspanStartInfo=function(e,t){return null},e.prototype.getRowspanStartInfo=function(e,t){return null},e.prototype.getCellStartOffset=function(e,t){var n=this.rowInfo[e][t].offset;return this.extendedRowspan(e,t)?this.posAt(e,t):n},e.prototype.getCellEndOffset=function(e,t){var n=this.rowInfo[e][t],r=n.offset,o=n.nodeSize;return this.extendedRowspan(e,t)?this.posAt(e,t):r+o},e.prototype.getCellIndex=function(e){for(var t=0;t<this.totalRowCount;t+=1)for(var n=this.rowInfo[t],r=0;r<this.totalColumnCount;r+=1)if(n[r].offset+1>e.pos)return[t,r];return[0,0]},e.prototype.getRectOffsets=function(e,t){var n,r,o;void 0===t&&(t=e),e.pos>t.pos&&(e=(n=[t,e])[0],t=n[1]);var i=this.getCellIndex(e),s=i[0],a=i[1],l=this.getCellIndex(t),c=l[0],u=l[1];return s=(r=st(s,c))[0],c=r[1],a=(o=st(a,u))[0],u=o[1],this.getSpannedOffsets({startRowIdx:s,startColIdx:a,endRowIdx:c,endColIdx:u})},e.prototype.getSpannedOffsets=function(e){return e},e}(),$h=function(e,t){var n=[];return e.forEach((function(e,r){var o={rowspanMap:{},colspanMap:{},length:0};e.forEach((function(e,n){for(var i=e.nodeSize,s=0;o[s];)s+=1;o[s]={offset:t+r+n+2,nodeSize:i},o.length+=1})),n.push(o)})),n};function _h(e,t){return it(jh.prototype,e),$h=t,jh}var Uh=function(e){function n(t,n){void 0===n&&(n=t);var r=this,o=t.node(0),i=jh.create(t),s=i.getRectOffsets(t,n),a=function(e,t,n){for(var r=n.startRowIdx,o=n.startColIdx,i=n.endRowIdx,s=n.endColIdx,a=[],l=r;l<=i;l+=1)for(var c=o;c<=s;c+=1){var u=t.getCellInfo(l,c),d=u.offset,p=u.nodeSize;a.push(new jt(e.resolve(d+1),e.resolve(d+p-1)))}return a}(o,i,s);return(r=e.call(this,a[0].$from,a[0].$to,a)||this).startCell=t,r.endCell=n,r.offsetMap=i,r.isCellSelection=!0,r.visible=!1,r}return t(n,e),n.prototype.map=function(e,t){var r=this.startCell.pos,o=this.endCell.pos,i=e.resolve(t.map(r)),s=e.resolve(t.map(o)),a=jh.create(i);if(this.offsetMap.totalColumnCount>a.totalColumnCount||this.offsetMap.totalRowCount>a.totalRowCount){var l={tableBody:1,tableRow:2,tableCell:3,paragraph:4}[s.parent.type.name],c=s.end(s.depth-l),u=Math.min(c-4,s.pos);return Ut.create(e,u)}return new n(i,s)},n.prototype.eq=function(e){return e instanceof n&&e.startCell.pos===this.startCell.pos&&e.endCell.pos===this.endCell.pos},n.prototype.content=function(){for(var e=this.startCell.node(-2),t=this.startCell.start(-2),n=e.child(1).firstChild,r=e.child(0).type.create(),o=e.child(1).type.create(),i=jh.create(this.startCell),s=i.getRectOffsets(this.startCell,this.endCell),a=s.startRowIdx,l=s.startColIdx,c=s.endRowIdx,u=s.endColIdx,p=!1,h=a;h<=c;h+=1){for(var f=[],m=l;m<=u;m+=1){var g=i.getCellInfo(h,m).offset,y=e.nodeAt(g-t);y&&(p="tableHeadCell"===y.type.name,i.extendedRowspan(h,m)||i.extendedColspan(h,m)?f.push(y.type.create({extended:!0})):f.push(y.copy(y.content)))}var b=n.copy(d.from(f)),w=p?r:o;w.content=w.content.append(d.from(b))}return new v(function(e,t){var n=[];return e.childCount&&n.push(e),t.childCount&&n.push(t),d.from(n)}(r,o),1,1)},n.prototype.toJSON=function(){return JSON.stringify(this)},n}(Vt),Wh=Uh;function Jh(e,t,n,r){for(var o=n.nodes,i=o.tableRow,s=o.tableBodyCell,a=o.paragraph,l=[],c=0;c<e;c+=1){for(var u=[],d=0;d<t;d+=1){var p=r&&r[c*t+d],h=a.create(null,p?n.text(p):[]);u.push(s.create(null,h))}l.push(i.create(null,u))}return l}function Gh(e,t,n,r){void 0===r&&(r=null);for(var o=n.nodes,i=o.tableHeadCell,s=o.tableBodyCell,a=o.paragraph,l=0===t?i:s,c=[],u=0;u<e;u+=1)c.push(l.create(r,a.create()));return c}function Kh(e,t){for(;e&&e!==t;){if("TD"===e.nodeName||"TH"===e.nodeName)return e;e=e.parentNode}return null}function Zh(e){return Sh(e,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}))}function Xh(e){if(e instanceof Ut){var t=e.$anchor,n=Zh(t);if(n){var r=t.node(0).resolve(t.before(n.depth));return{anchor:r,head:r}}}var o=e;return{anchor:o.startCell,head:o.endCell}}function Qh(e){var t;if(e.size){var n=e.content,r=e.openStart,o=e.openEnd;if(1!==n.childCount)return null;for(;1===n.childCount&&(r>0&&o>0||"table"===(null===(t=n.firstChild)||void 0===t?void 0:t.type.name));)r-=1,o-=1,n=n.firstChild.content;if("tableHead"===n.firstChild.type.name||"tableBody"===n.firstChild.type.name)return n}return null}function Yh(e){var t=e.startRowIdx,n=e.startColIdx;return{rowCount:e.endRowIdx-t+1,columnCount:e.endColIdx-n+1}}function ef(e,t){return o(o({},e.attrs),t)}var tf=new un("cellSelection"),nf=function(){function e(e){this.view=e,this.handlers={mousedown:this.handleMousedown.bind(this),mousemove:this.handleMousemove.bind(this),mouseup:this.handleMouseup.bind(this)},this.startCellPos=null,this.init()}return e.prototype.init=function(){this.view.dom.addEventListener("mousedown",this.handlers.mousedown)},e.prototype.handleMousedown=function(e){var t=Kh(e.target,this.view.dom);if(2!==e.button){if(t){var n=this.getCellPos(e);n&&(this.startCellPos=n),this.bindEvent()}}else e.preventDefault()},e.prototype.handleMousemove=function(e){var t,n=tf.getState(this.view.state),r=this.getCellPos(e),o=this.startCellPos;n?t=this.view.state.doc.resolve(n):o!==r&&(t=o),t&&o&&r&&this.setCellSelection(o,r)},e.prototype.handleMouseup=function(){this.startCellPos=null,this.unbindEvent(),null!==tf.getState(this.view.state)&&this.view.dispatch(this.view.state.tr.setMeta(tf,-1))},e.prototype.bindEvent=function(){var e=this.view.dom;e.addEventListener("mousemove",this.handlers.mousemove),e.addEventListener("mouseup",this.handlers.mouseup)},e.prototype.unbindEvent=function(){var e=this.view.dom;e.removeEventListener("mousemove",this.handlers.mousemove),e.removeEventListener("mouseup",this.handlers.mouseup)},e.prototype.getCellPos=function(e){var t=e.clientX,n=e.clientY,r=this.view.posAtCoords({left:t,top:n});if(r){var o=this.view.state.doc,i=o.resolve(r.pos),s=Zh(i);if(s){var a=i.before(s.depth);return o.resolve(a)}}return null},e.prototype.setCellSelection=function(e,t){var n=this.view.state,r=n.selection,o=n.tr,i=null===tf.getState(this.view.state),s=new Wh(e,t);if(i||!r.eq(s)){var a=o.setSelection(s);i&&a.setMeta(tf,t.pos),this.view.dispatch(a)}},e.prototype.destroy=function(){this.view.dom.removeEventListener("mousedown",this.handlers.mousedown)},e}(),rf=nf,of=xa("cell-selected");function sf(e){var t=e.selection,n=e.doc;if(t instanceof Wh){var r=[];return t.ranges.forEach((function(e){var t=e.$from,n=e.$to;r.push(Vo.node(t.pos-1,n.pos+1,{class:of}))})),_o.create(n,r)}return null}var af=n(928),lf=n.n(af),cf=function(){function e(){this.keys=[],this.values=[]}return e.prototype.getKeyIndex=function(e){return lf()(e,this.keys)},e.prototype.get=function(e){return this.values[this.getKeyIndex(e)]},e.prototype.set=function(e,t){var n=this.getKeyIndex(e);return n>-1?this.values[n]=t:(this.keys.push(e),this.values.push(t)),this},e.prototype.has=function(e){return this.getKeyIndex(e)>-1},e.prototype.delete=function(e){var t=this.getKeyIndex(e);return t>-1&&(this.keys.splice(t,1),this.values.splice(t,1),!0)},e.prototype.forEach=function(e,t){var n=this;void 0===t&&(t=this),this.values.forEach((function(r,o){r&&n.keys[o]&&e.call(t,r,n.keys[o],n)}))},e.prototype.clear=function(){this.keys=[],this.values=[]},e}(),uf=cf,df="en-US",pf=function(){function e(){this.code=df,this.langs=new uf}return e.prototype.setCode=function(e){this.code=e||df},e.prototype.setLanguage=function(e,t){var n=this;(e=[].concat(e)).forEach((function(e){if(n.langs.has(e)){var r=n.langs.get(e);n.langs.set(e,ve()(r,t))}else n.langs.set(e,t)}))},e.prototype.get=function(e,t){t||(t=this.code);var n=this.langs.get(t);n||(n=this.langs.get(df));var r=n[e];if(!r)throw new Error('There is no text key "'+e+'" in '+t);return r},e}(),hf=new pf,ff=[[{action:"Add row to up",command:"addRowToUp",disableInThead:!0,className:"add-row-up"},{action:"Add row to down",command:"addRowToDown",disableInThead:!0,className:"add-row-down"},{action:"Remove row",command:"removeRow",disableInThead:!0,className:"remove-row"}],[{action:"Add column to left",command:"addColumnToLeft",className:"add-column-left"},{action:"Add column to right",command:"addColumnToRight",className:"add-column-right"},{action:"Remove column",command:"removeColumn",className:"remove-column"}],[{action:"Align column to left",command:"alignColumn",payload:{align:"left"},className:"align-column-left"},{action:"Align column to center",command:"alignColumn",payload:{align:"center"},className:"align-column-center"},{action:"Align column to right",command:"alignColumn",payload:{align:"right"},className:"align-column-right"}],[{action:"Remove table",command:"removeTable",className:"remove-table"}]];function mf(e,t){return ff.map((function(n){return n.map((function(n){var r=n.action,o=n.command,i=n.payload,s=n.disableInThead,a=n.className;return{label:hf.get(r),onClick:function(){e.emit("command",o,i)},disabled:t&&!!s,className:a}}))})).concat()}function gf(e){return new an({props:{handleDOMEvents:{contextmenu:function(t,n){var r=Kh(n.target,t.dom);if(r){n.preventDefault();var o=n,i=o.clientX,s=o.clientY,a=t.dom.parentNode.getBoundingClientRect(),l=a.left,c=a.top,u="TH"===r.nodeName;return e.emit("contextmenu",{pos:{left:i-l+10+"px",top:s-c+30+"px"},menuGroups:mf(e,u),tableCell:r}),!0}return!1}}}})}var vf=["image","link","customBlock","frontMatter"],yf=["strong","strike","emph","code"],bf=["bulletList","orderedList","taskList"];function wf(e,t,n){var r=e.$from,o=e.$to,i=e.from,s=e.to,a={indent:{active:!1,disabled:!0},outdent:{active:!1,disabled:!0}};return t.nodesBetween(i,s,(function(e,t,i){var s=function(e,t){var n=e.type.name;return"listItem"===n?e.attrs.task?"taskList":t.type.name:-1!==n.indexOf("table")?"table":n}(e,i);Ue(vf,s)||(Ue(bf,s)?(!function(e,t){t[e]={active:!0},bf.filter((function(t){return t!==e})).forEach((function(e){t[e]&&delete t[e]}))}(s,a),a.indent.disabled=!1,a.outdent.disabled=!1):"paragraph"===s||"text"===s?function(e,t,n,r){yf.forEach((function(o){var i=n.marks[o],s=e.marksAcross(t)||[];i.isInSet(s)&&(r[o]={active:!0})}))}(r,o,n,a):a[s]={active:!0})})),a}function kf(e){return new an({view:function(){return{update:function(t){var n=t.state,r=n.selection,o=n.doc,i=n.schema;e.emit("changeToolbarState",{toolbarState:wf(r,o,i)})}}}})}var xf=function(){function e(e,t,n,r){var o=this;this.openEditor=function(){if(o.innerEditorView)throw new Error("The editor is already opened.");o.dom.draggable=!1,o.wrapper.style.display="none",o.innerViewContainer.style.display="block",o.innerEditorView=new ui(o.innerViewContainer,{state:on.create({doc:o.node,plugins:[Ai({"Mod-z":function(){return Ms(o.innerEditorView.state,o.innerEditorView.dispatch)},"Shift-Mod-z":function(){return Ss(o.innerEditorView.state,o.innerEditorView.dispatch)},Tab:function(e,t){return t(e.tr.insertText("\t")),!0},Enter:Hi,Escape:function(){return o.cancelEditing(),!0},"Ctrl-Enter":function(){return o.saveAndFinishEditing(),!0}}),Ts()]}),dispatchTransaction:function(e){return o.dispatchInner(e)},handleDOMEvents:{mousedown:function(){return o.editorView.hasFocus()&&o.innerEditorView.focus(),!0},blur:function(){return o.saveAndFinishEditing(),!0}}}),o.innerEditorView.focus()},this.node=e,this.editorView=t,this.getPos=n,this.toDOMAdaptor=r,this.innerEditorView=null,this.canceled=!1,this.dom=document.createElement("div"),this.dom.className=xa("custom-block"),this.wrapper=document.createElement("div"),this.wrapper.className=xa("custom-block-view"),this.createInnerViewContainer(),this.renderCustomBlock(),this.dom.appendChild(this.innerViewContainer),this.dom.appendChild(this.wrapper)}return e.prototype.renderToolArea=function(){var e=this,t=document.createElement("div"),n=document.createElement("span"),r=document.createElement("button");t.className="tool",n.textContent=this.node.attrs.info,n.className="info",r.type="button",r.addEventListener("click",(function(){return e.openEditor()})),t.appendChild(n),t.appendChild(r),this.wrapper.appendChild(t)},e.prototype.renderCustomBlock=function(){var e=this.toDOMAdaptor.getToDOMNode(this.node.attrs.info);if(e){for(var t=e(this.node);this.wrapper.hasChildNodes();)this.wrapper.removeChild(this.wrapper.lastChild);t&&this.wrapper.appendChild(t),this.renderToolArea()}},e.prototype.createInnerViewContainer=function(){this.innerViewContainer=document.createElement("div"),this.innerViewContainer.className=xa("custom-block-editor"),this.innerViewContainer.style.display="none"},e.prototype.closeEditor=function(){this.innerEditorView&&(this.innerEditorView.destroy(),this.innerEditorView=null,this.innerViewContainer.style.display="none"),this.wrapper.style.display="block"},e.prototype.saveAndFinishEditing=function(){var e=this.editorView.state.selection.to,t=this.editorView.state;this.editorView.dispatch(t.tr.setSelection(Os(t.tr,e))),this.editorView.focus(),this.renderCustomBlock(),this.closeEditor()},e.prototype.cancelEditing=function(){var e=function(e){let t=xs.getState(e);return t?t.done.eventCount:0}(this.innerEditorView.state);for(this.canceled=!0;e--;)Ms(this.innerEditorView.state,this.innerEditorView.dispatch),Ms(this.editorView.state,this.editorView.dispatch);this.canceled=!1;var t=this.editorView.state.selection.to,n=this.editorView.state;this.editorView.dispatch(n.tr.setSelection(Ut.create(n.doc,t))),this.editorView.focus(),this.closeEditor()},e.prototype.dispatchInner=function(e){var t=this.innerEditorView.state.applyTransaction(e),n=t.state,r=t.transactions;if(this.innerEditorView.updateState(n),!this.canceled&&Ga()(this.getPos)){for(var o=this.editorView.state.tr,i=dt.offset(this.getPos()+1),s=0;s<r.length;s+=1)for(var a=r[s].steps,l=0;l<a.length;l+=1)o.step(a[l].map(i));o.docChanged&&this.editorView.dispatch(o)}},e.prototype.update=function(e){return!!e.sameMarkup(this.node)&&(this.node=e,this.innerEditorView||this.renderCustomBlock(),!0)},e.prototype.stopEvent=function(e){return!!this.innerEditorView&&!!e.target&&this.innerEditorView.dom.contains(e.target)},e.prototype.ignoreMutation=function(){return!0},e.prototype.destroy=function(){this.dom.removeEventListener("dblclick",this.openEditor),this.closeEditor()},e}(),Cf="image-link",Tf=function(){function e(e,t,n,r){var o,i=this;this.handleMousedown=function(e){e.preventDefault();var t=e.target,n=e.offsetX,r=e.offsetY;if(i.imageLink&&Ga()(i.getPos)&&ca()(t,Cf)){var o=getComputedStyle(t,":before");if(e.stopPropagation(),wa(o,n,r)){var s=i.view.state.tr,a=i.getPos();s.setSelection(Os(s,a,a+1)),i.view.dispatch(s),i.eventEmitter.emit("openPopup","link",i.imageLink.attrs)}}},this.node=e,this.view=t,this.getPos=n,this.eventEmitter=r,this.imageLink=null!==(o=e.marks.filter((function(e){return"link"===e.type.name}))[0])&&void 0!==o?o:null,this.dom=this.createElement(),this.bindEvent()}return e.prototype.createElement=function(){var e=this.createImageElement(this.node);if(this.imageLink){var t=document.createElement("span");return t.className=Cf,t.appendChild(e),t}return e},e.prototype.createImageElement=function(e){var t=document.createElement("img"),n=e.attrs,r=n.imageUrl,o=n.altText,i=Ih(e.attrs);return t.src=r,o&&(t.alt=o),Aa(i,t),t},e.prototype.bindEvent=function(){this.imageLink&&this.dom.addEventListener("mousedown",this.handleMousedown)},e.prototype.stopEvent=function(){return!0},e.prototype.destroy=function(){this.imageLink&&this.dom.removeEventListener("mousedown",this.handleMousedown)},e}(),Mf=function(){function e(e,t,n,r){var o=this;this.contentDOM=null,this.input=null,this.timer=null,this.handleMousedown=function(e){var t=e.target;if("none"!==getComputedStyle(t,":after").backgroundImage&&Ga()(o.getPos)){var n=o.view.coordsAtPos(o.getPos()),r=n.top,i=n.right;o.createLanguageEditor({top:r,right:i})}},this.handleKeydown=function(e){"Enter"===e.key&&o.input&&(e.preventDefault(),o.changeLanguage())},this.node=e,this.view=t,this.getPos=n,this.eventEmitter=r,this.createElement(),this.bindDOMEvent(),this.bindEvent()}return e.prototype.createElement=function(){var e=this.node.attrs.language,t=document.createElement("div");t.setAttribute("data-language",e||"text"),t.className="toastui-editor-ww-code-block";var n=this.createCodeBlockElement(),r=n.firstChild;t.appendChild(n),this.dom=t,this.contentDOM=r},e.prototype.createCodeBlockElement=function(){var e=document.createElement("pre"),t=document.createElement("code"),n=this.node.attrs.language,r=Ih(this.node.attrs);return n&&t.setAttribute("data-language",n),Aa(r,e),e.appendChild(t),e},e.prototype.createLanguageEditor=function(e){var t=this,n=e.top,r=e.right,o=document.createElement("span");o.className="toastui-editor-ww-code-block-language";var i=document.createElement("input");i.type="text",i.value=this.node.attrs.language,o.appendChild(i),this.view.dom.parentElement.appendChild(o);var s=o.clientWidth;be()(o,{top:n+10+"px",left:r-s-10+"px",width:s+"px"}),this.input=i,this.input.addEventListener("blur",(function(){return t.changeLanguage()})),this.input.addEventListener("keydown",this.handleKeydown),this.clearTimer(),this.timer=setTimeout((function(){t.input.focus()}))},e.prototype.bindDOMEvent=function(){this.dom&&this.dom.addEventListener("click",this.handleMousedown)},e.prototype.bindEvent=function(){var e=this;this.eventEmitter.listen("scroll",(function(){e.input&&e.reset()}))},e.prototype.changeLanguage=function(){if(this.input&&Ga()(this.getPos)){var e=this.input.value;this.reset();var t=this.getPos(),n=this.view.state.tr;n.setNodeMarkup(t,null,{language:e}),this.view.dispatch(n)}},e.prototype.reset=function(){var e;if(null===(e=this.input)||void 0===e?void 0:e.parentElement){var t=this.input.parentElement;this.input=null,Ma(t)}},e.prototype.clearTimer=function(){this.timer&&(clearTimeout(this.timer),this.timer=null)},e.prototype.stopEvent=function(){return!0},e.prototype.update=function(e){return!!e.sameMarkup(this.node)&&(this.node=e,!0)},e.prototype.destroy=function(){this.reset(),this.clearTimer(),this.dom&&this.dom.removeEventListener("click",this.handleMousedown)},e}(),Sf=/MsoListParagraph/,Ef=/style=(.|\n)*mso-/,Nf=/mso-list:(.*)/,Of=/O:P/,Df=/^(n|u|l)/;function Af(e){for(var t=[],n=document.createTreeWalker(e,1,null,!1);n.nextNode();){var r=n.currentNode;if(Ta(r)){var o=r,i=o.outerHTML,s=o.textContent,a=Ef.test(i),l=Nf.test(i);a&&!l&&s?t.push([r,!0]):(Of.test(r.nodeName)||a&&!s||l)&&t.push([r,!1])}}return t.forEach((function(e){var t=e[0];e[1]?function(e){for(var t=[];e.firstChild;)t.push(e.firstChild),e.parentNode&&e.parentNode.insertBefore(e.firstChild,e);Ma(e)}(t):Ma(t)})),e.innerHTML.trim()}function Lf(e){var t=[];return e.forEach((function(e,n){var r=t[n-1],o=function(e,t){var n=e.getAttribute("style");if(n){var r=n.match(Nf)[1].trim().split(" ")[1];return{id:t,level:parseInt(r.replace("level",""),10),prev:null,parent:null,children:[],unordered:Df.test(e.textContent||""),contents:Af(e)}}return null}(e,n);o&&(r&&function(e,t){if(t.level<e.level)t.children.push(e),e.parent=t;else{for(;t&&t.level!==e.level;)t=t.parent;t&&(e.prev=t,e.parent=t.parent,e.parent&&e.parent.children.push(e))}}(o,r),t.push(o))})),t}function If(e){var t=e[0].unordered?"ul":"ol",n=document.createElement(t);return e.forEach((function(e){var t=e.children,r=e.contents,o=document.createElement("li");o.innerHTML=r,n.appendChild(o),t.length&&n.appendChild(If(t))})),n}function Rf(e){return If(Lf(e).filter((function(e){return!e.parent})))}function Pf(e){var t=document.createElement("div");t.innerHTML=e;var n,r,o,i=[],s=(n=t,r="p.MsoListParagraph",(o=vi()(n.querySelectorAll(r))).length?o:[]);return s.forEach((function(e){var n=function(e){for(;e&&!Ta(e);)e=e.nextSibling;return!e||!Sf.test(e.className)}(e.nextSibling);if(i.push(e),n){var r=Rf(i),o=e.nextSibling;o?function(e,t){t.parentNode&&t.parentNode.insertBefore(e,t)}(r,o):function(e,t){(t=aa()(t)?vi()(t):[t]).forEach((function(t){e.appendChild(t)}))}(t,r),i=[]}Ma(e)})),""+(s.length?"<p></p>":"")+t.innerHTML}var Bf="\x3c!--StartFragment--\x3e";function Ff(e){return function(e){return Ef.test(e)}(e=function(e){return/<\/td>((?!<\/tr>)[\s\S])*$/i.test(e)&&(e="<tr>"+e+"</tr>"),/<\/tr>((?!<\/table>)[\s\S])*$/i.test(e)&&(e="<table>"+e+"</table>"),e}(e=function(e){var t=e.indexOf(Bf),n=e.lastIndexOf("\x3c!--EndFragment--\x3e");return t>-1&&n>-1&&(e=e.slice(t+Bf.length,n)),e.replace(/<br[^>]*>/g,ba)}(e)))&&(e=Pf(e)),e}function Hf(e,t,n){for(var r=[],o=e.childCount,i=0;i<o;i+=1)if(!e.child(i).attrs.extended){var s=i<o?n.create(e.child(i).attrs,e.child(i).content):n.createAndFill();r.push(s)}return r}function zf(e,t,n){var r=n.nodes,o=r.tableRow,i=Hf(e,0,r.tableHeadCell);return o.create(null,i)}function qf(e,t,n){var r=n.nodes,o=r.tableRow,i=Hf(e,0,r.tableBodyCell);return o.create(null,i)}function Vf(e){var t=[],n=[];"tableHead"===e.firstChild.type.name&&e.firstChild.forEach((function(e){return t.push(e)}));"tableBody"===e.lastChild.type.name&&e.lastChild.forEach((function(e){return n.push(e)}));return i(i([],t),n)}function jf(e,t,n){var r=zf(e,0,n);return n.nodes.tableHead.create(null,r)}function $f(e,t,n){var r=e.map((function(e){return qf(e,0,n)}));if(!e.length){var o=function(e,t){for(var n=t.nodes,r=n.tableRow,o=n.tableBodyCell,i=[],s=0;s<e;s+=1){var a=o.createAndFill();i.push(a)}return r.create({dummyRowForPasting:!0},i)}(t,n);r.push(o)}return n.nodes.tableBody.create(null,r)}function _f(e,t,n){var r=[],o=e.content,i=e.openStart,s=e.openEnd;return o.forEach((function(e){if("table"===e.type.name){var o=Qh(new v(d.from(e),0,0));if(o){var i=Vf(o),s="tableBody"===o.firstChild.type.name,a=function(e,t,n,r){var o=function(e){return e.reduce((function(e,t){return e.childCount>t.childCount?e:t})).childCount}(e);if(n&&r)return t.nodes.table.create(null,[$f(e,o,t)]);var i=e[0],s=e.slice(1),a=[jf(i,0,t)];return s.length&&a.push($f(s,o,t)),t.nodes.table.create(null,a)}(i,t,s,n);r.push(a)}}else r.push(e)})),new v(d.from(r),i,s)}function Uf(e){return 4*e}function Wf(e,t){var n=e.state,r=n.selection,o=n.schema,i=n.tr,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){var c=Qh(t);if(!c)return!1;var u=jh.create(a),d=u.getRectOffsets(a,l),p=function(e,t,n){var r=[],o=Vf(e),i=(o[0].childCount,o.length),s=0===t.startRowIdx,a=o.slice(0,i);if(s){var l=a.shift();if(l){var c=zf(l,0,n).content;r.push(c)}}return a.forEach((function(e){if(!e.attrs.dummyRowForPasting){var t=qf(e,0,n).content;r.push(t)}})),r}(c,d,o),h=function(e,t,n){for(var r=t.startRowIdx,o=t.startColIdx,i=n.length,s=0,a=function(e){var t=n[e].childCount;n[e].forEach((function(e){var n=e.attrs.colspan;n>1&&(t+=n-1)})),s=Math.max(s,t)},l=0;l<i;l+=1)a(l);var c=r+i-1,u=o+s-1;return{startRowIdx:r,startColIdx:o,endRowIdx:c,endColIdx:u,addedRowCount:Math.max(c+1-e.totalRowCount,0),addedColumnCount:Math.max(u+1-e.totalColumnCount,0)}}(u,d,p),f=[];return function(e,t){var n=Yh(e.getSpannedOffsets(t)),r=n.rowCount,o=n.columnCount,i=Yh(t),s=i.rowCount,a=i.columnCount;return r===s&&o===a}(u,h)&&(function(e,t){for(var n=e.startRowIdx,r=e.startColIdx,o=e.endRowIdx,i=e.endColIdx,s=e.addedRowCount,a=e.addedColumnCount,l=n;l<=o-s;l+=1)t.push({rowIdx:l,startColIdx:r,endColIdx:i-a})}(h,f),h.addedColumnCount&&function(e,t,n,r,o){for(var i=r.startRowIdx,s=r.startColIdx,a=r.endRowIdx,l=r.endColIdx,c=r.addedRowCount,u=r.addedColumnCount,d=n.totalRowCount,p=0,h=0;h<d;h+=1){var f=n.getCellInfo(h,l-u),m=f.offset,g=f.nodeSize,v=e.mapping.map(m+g),y=Gh(u,h,t);if(e.insert(v,y),h>=i&&h<=a-c){var b=n.getCellInfo(h,l-u),w=e.mapping.map(b.offset),k=v+Uf(u);o[p]={rowIdx:h,startColIdx:s,endColIdx:l,dummyOffsets:[w,k]},p+=1}}}(i,o,u,h,f),h.addedRowCount&&function(e,t,n,r,o){var i=r.addedRowCount,s=r.addedColumnCount,a=r.startColIdx,l=r.endColIdx,c=e.mapping.maps.length,u=n.tableEndOffset-2,d=Jh(i,n.totalColumnCount+s,t),p=u;e.insert(e.mapping.slice(c).map(p),d);for(var h=0;h<i;h+=1){var f=p+Uf(a)+1,m=p+Uf(l+1)+1,g=p+Uf(n.totalColumnCount+s)+2;o.push({rowIdx:h+n.totalRowCount,startColIdx:a,endColIdx:l,dummyOffsets:[f,m]}),p=g}}(i,o,u,h,f),function(e,t,n,r){var o=e.mapping.maps.length;n.forEach((function(n,i){var s=n.rowIdx,a=n.startColIdx,l=n.endColIdx,c=n.dummyOffsets,u=e.mapping.slice(o),d=new v(t[i],0,0),p=c?c[0]:r.getCellStartOffset(s,a),h=c?c[1]:r.getCellEndOffset(s,l);e.replace(u.map(p),u.map(h),d)}))}(i,p,f,u),e.dispatch(i),function(e,t,n){var r=e.state,o=r.tr,i=r.doc,s=jh.create(i.resolve(n)),a=t[0],l=a.rowIdx,c=a.startColIdx,u=et(t),d=u.rowIdx,p=u.endColIdx,h=s.getCellInfo(l,c).offset,f=s.getCellInfo(d,p).offset;e.dispatch(o.setSelection(new Wh(i.resolve(h),i.resolve(f))))}(e,f,u.getCellInfo(0,0).offset)),!0}return!1}var Jf,Gf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"doc"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"block+"}},enumerable:!1,configurable:!0}),n}(Va),Kf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"paragraph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"inline*",group:"block",attrs:o({},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"p"}],toDOM:function(e){return["p",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),Zf=/\s{1,4}$/,Xf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"text"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{group:"inline"}},enumerable:!1,configurable:!0}),n.prototype.addSpaces=function(){return function(e,t){var n=e.selection,r=e.tr,o=n.$from,i=n.$to;return!(!o.blockRange(i)||Eh(o)||Nh(o))&&(t(r.insertText("    ",o.pos,i.pos)),!0)}},n.prototype.removeSpaces=function(){return function(e,t){var n=e.selection,r=e.tr,o=n.$from,i=n.$to,s=n.from;if(o.blockRange(i)&&!Eh(o)&&!Nh(o)){var a=o.nodeBefore;if(a&&a.isText){var l=a.text,c=l.replace(Zf,""),u=l.length-c.length;return t(r.delete(s-u,s)),!0}}return!1}},n.prototype.keymaps=function(){return{Tab:this.addSpaces(),"Shift-Tab":this.removeSpaces()}},n}(Va),Qf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"heading"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"levels",{get:function(){return[1,2,3,4,5,6]},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=this.levels.map((function(e){return{tag:"h"+e,getAttrs:function(t){var n=t.getAttribute("data-raw-html");return o({level:e},n&&{rawHTML:n})}}}));return{attrs:o({level:{default:1},headingType:{default:"atx"},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),content:"inline*",group:"block",defining:!0,parseDOM:e,toDOM:function(e){var t=e.attrs;return["h"+t.level,Ih(t),0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(e){return function(t,n){return Gi(t.schema.nodes[e.level?"heading":"paragraph"],e)(t,n)}}},n}(Va),Yf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"codeBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",attrs:o({language:{default:null},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),code:!0,defining:!0,marks:"",parseDOM:[{tag:"pre",preserveWhitespace:"full",getAttrs:function(e){var t=e.getAttribute("data-raw-html"),n=e.firstElementChild;return o({language:(null==n?void 0:n.getAttribute("data-language"))||null},t&&{rawHTML:t})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"pre",["code",o({"data-language":t.language},Ih(t)),0]]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Gi(e.schema.nodes.codeBlock)(e,t)}}},n.prototype.moveCursor=function(e){var t=this;return function(n,r){var o,i,s=n.tr,a=n.doc,l=n.schema,c=n.selection.$from;if(t.context.view.endOfTextblock(e)&&"codeBlock"===c.node().type.name){var u=c.parent.textContent.split("\n"),d="up"===e?c.start():c.end(),p="up"===e?[d,u[0].length+d]:[d-et(u).length,d],h=a.resolve("up"===e?c.before():c.after()),f="up"===e?h.nodeBefore:h.nodeAfter;if(o=c.pos,i=p[1],o>=p[0]&&o<=i&&!f){var m=Ds(s,h,l);if(m)return r(m),!0}}return!1}},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-p":e,"Shift-Mod-P":e,ArrowUp:this.moveCursor("up"),ArrowDown:this.moveCursor("down")}},n}(Va),em=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"bulletList"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"listItem+",group:"block",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[Dh("ul")],toDOM:function(e){return["ul",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n.prototype.changeList=function(){return function(e,t){return Bh(e.schema.nodes.bulletList)(e,t)}},n.prototype.commands=function(){return{bulletList:this.changeList,taskList:Fh}},n.prototype.keymaps=function(){var e=this.changeList(),t=qh(),n=t.indent,r=t.outdent;return{"Mod-u":e,"Mod-U":e,Tab:n(),"Shift-Tab":r()}},n}(Va),tm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"orderedList"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"listItem+",group:"block",attrs:o({order:{default:1},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"ol",getAttrs:function(e){var t=e.getAttribute("start"),n=e.getAttribute("data-raw-html");return o({order:e.hasAttribute("start")?Number(t):1},n&&{rawHTML:n})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"ol",o({start:1===t.order?null:t.order},Ih(t)),0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Bh(e.schema.nodes.orderedList)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()(),t=qh(),n=t.indent,r=t.outdent;return{"Mod-o":e,"Mod-O":e,Tab:n(),"Shift-Tab":r()}},n}(Va),nm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"listItem"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"paragraph block*",selectable:!1,attrs:{task:{default:!1},checked:{default:!1},rawHTML:{default:null}},defining:!0,parseDOM:[{tag:"li",getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({task:e.hasAttribute("data-task"),checked:e.hasAttribute("data-task-checked")},t&&{rawHTML:t})}}],toDOM:function(e){var t=e.attrs,n=t.task,r=t.checked;if(!n)return[t.rawHTML||"li",0];var i=["task-list-item"];return r&&i.push("checked"),[t.rawHTML||"li",o({class:i.join(" "),"data-task":n},r&&{"data-task-checked":r}),0]}}},enumerable:!1,configurable:!0}),n.prototype.liftToPrevListItem=function(){return function(e,t){var n=e.selection,r=e.tr,o=e.schema,i=n.$from,s=n.empty,a=o.nodes.listItem,l=i.parent,c=i.node(-1);if(s&&!l.childCount&&c.type===a){if(i.index(-2)>=1)return r.delete(i.start(-1)-1,i.end(-1)),t(r),!0;if(i.node(-3).type===a)return r.delete(i.start(-2)-1,i.end(-1)),t(r),!0}return!1}},n.prototype.keymaps=function(){return{Backspace:this.liftToPrevListItem(),Enter:function(e,t){return function(e){return function(t,n){var r=t.tr,o=t.selection,i=o.$from,s=o.$to;if(i.depth<2||!i.sameParent(s))return!1;var a=i.node(-1);if(a.type!==e)return!1;if(0===i.parent.content.size&&i.node(-1).childCount===i.indexAfter(-1)){if(2===i.depth||i.node(-3).type!==e||i.index(-2)!==i.node(-2).childCount-1)return!1;for(var l=i.index(-1)>0,c=d.empty,u=i.depth-(l?1:2);u>=i.depth-3;u-=1)c=d.from(i.node(u).copy(c));return c=c.append(d.from(e.createAndFill())),r.replace(l?i.before():i.before(-1),i.after(-3),new v(c,l?3:2,2)),r.setSelection(Vt.near(r.doc.resolve(i.pos+(l?3:2)))),n(r),!0}var p=s.pos===i.end()?a.contentMatchAt(0).defaultType:null,h=p&&[null,{type:p}];return r.delete(i.pos,s.pos),!!Mt(r.doc,i.pos,2,h)&&(r.split(i.pos,2,h),n(r),!0)}}(e.schema.nodes.listItem)(e,t)}}},n}(Va),rm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"blockQuote"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),content:"block+",group:"block",parseDOM:[Dh("blockquote")],toDOM:function(e){return["blockquote",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Ji(e.schema.nodes.blockQuote)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()();return{"Alt-q":e,"Alt-Q":e}},n}(Va),om={left:function(e,t){var n=e[0],r=e[1],o=t.totalColumnCount,i=0===r;if(0!==n||!i){r-=1,i&&(n-=1,r=o-1);var s=t.getCellInfo(n,r),a=s.offset,l=s.nodeSize;return a+l-2}return null},right:function(e,t){var n=e[0],r=e[1],o=t.totalRowCount,i=t.totalColumnCount,s=r===i-1;if(n!==o-1||!s){var a=r+1,l=t.getColspanStartInfo(n,r);return(null==l?void 0:l.count)>1&&(a+=l.count-1),(s||a===i)&&(n+=1,a=0),t.getCellInfo(n,a).offset+2}return null},up:function(e,t){var n=e[0],r=e[1];if(n>0){var o=t.getCellInfo(n-1,r),i=o.offset,s=o.nodeSize;return i+s-2}return null},down:function(e,t){var n=e[0],r=e[1],o=t.totalRowCount;if(n<o-1){var i=n+1,s=t.getRowspanStartInfo(n,r);return(null==s?void 0:s.count)>1&&(i+=s.count-1),t.getCellInfo(i,r).offset+2}return null}};function im(e,t,n,r){var o=t[0],i=t[1],s=o+3,a=i>=s,l=a?o+1:i,c=function(e,t,n,r,o){var i=t[0],s=t[1],a=t[2];if(e===Jf.LEFT||e===Jf.UP){if(o&&!function(e,t,n){var r=n[0],o=n[1],i=t.resolve(e.before(r-1));return o===r&&!i.nodeBefore}(n,r,[i,s]))return!1;var l=n.before(a);if(r.resolve(l).nodeBefore)return!1}return!0}(e,[i,s,l],n,r,a),u=function(e,t,n,r,o){if(e===Jf.RIGHT||e===Jf.DOWN){if(o&&!function(e){for(var t,n,r=e.depth;r&&"tableBodyCell"!==(n=e.node(r)).type.name;){if("listItem"===n.type.name){var o=e.node(r-1).lastChild===n,i="paragraph"!==(null===(t=n.lastChild)||void 0===t?void 0:t.type.name);return!!o&&!i}r-=1}return!1}(n))return!1;var i=n.after(t);if(r.resolve(i).nodeAfter)return!1}return!0}(e,l,n,r,a);return c&&u}function sm(e,t,n){var r=n[0],o=n[1],i=t.getRowspanStartInfo(r,o),s=e===Jf.UP&&0===r,a=e===Jf.DOWN&&((null==i?void 0:i.count)>1?r+i.count-1:r)===t.totalRowCount-1;return s||a}function am(e,t,n,r){void 0===r&&(r=!1);var o=e.doc.resolve(t.tableEndOffset);return r||!o.nodeAfter?Ds(e,o,n):e.setSelection(Vt.near(o,1))}function lm(e,t,n,r){var o=(0,om[e])(n,r);if(o){var i=e===Jf.RIGHT||e===Jf.DOWN?1:-1;return t.setSelection(Vt.near(t.doc.resolve(o),i))}return null}function cm(e,t,n){var r=e.getCellInfo(t,0).offset,o=e.getCellInfo(t,n-1);return{from:r,to:o.offset+o.nodeSize}}!function(e){e.LEFT="left",e.RIGHT="right",e.UP="up",e.DOWN="down"}(Jf||(Jf={}));var um=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"table"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"tableHead{1} tableBody{1}",group:"block",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[Dh("table")],toDOM:function(e){return["table",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n.prototype.addTable=function(){return function(e){return void 0===e&&(e={rowCount:2,columnCount:1,data:[]}),function(t,n){var r=e.rowCount,o=e.columnCount,i=e.data,s=t.schema,a=t.selection,l=t.tr,c=a.from,u=a.to,d=a.$from;if(c===u&&!Nh(d)){var p=s.nodes,h=p.tableHead,f=p.tableBody,m=null==i?void 0:i.slice(0,o),g=null==i?void 0:i.slice(o,i.length),v=function(e,t,n){for(var r=t.nodes,o=r.tableRow,i=r.tableHeadCell,s=r.paragraph,a=[],l=0;l<e;l+=1){var c=n&&n[l],u=s.create(null,c?t.text(c):[]);a.push(i.create(null,u))}return[o.create(null,a)]}(o,s,m),y=Jh(r-1,o,s,g),b=s.nodes.table.create(null,[h.create(null,v),f.create(null,y)]);return n(l.replaceSelectionWith(b)),!0}return!1}}},n.prototype.removeTable=function(){return function(){return function(e,t){var n=e.selection,r=e.tr,o=jh.create(n.$anchor);if(o){var i=o.tableStartOffset,s=o.tableEndOffset,a=i-1,l=Os(r.delete(a,s),a);return t(r.setSelection(l)),!0}return!1}}},n.prototype.addColumn=function(e){return function(){return function(t,n){var r=t.selection,o=t.tr,i=t.schema,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){for(var c=jh.create(a),u=c.getRectOffsets(a,l),d=e===Jf.LEFT?u.startColIdx:u.endColIdx+1,p=Yh(u).columnCount,h=c.totalRowCount,f=0;f<h;f+=1){var m=Gh(p,f,i);o.insert(o.mapping.map(c.posAt(f,d)),m)}return n(o),!0}return!1}}},n.prototype.removeColumn=function(){return function(){return function(e,t){var n=e.selection,r=e.tr,o=Xh(n),i=o.anchor,s=o.head;if(i&&s){var a=jh.create(i),l=a.getRectOffsets(i,s),c=a.totalColumnCount,u=a.totalRowCount;if(Yh(l).columnCount===c)return!1;for(var d=l.startColIdx,p=l.endColIdx,h=r.mapping.maps.length,f=0;f<u;f+=1)for(var m=p;m>=d;m-=1){var g=a.getCellInfo(f,m),v=g.offset,y=g.nodeSize,b=r.mapping.slice(h).map(v),w=b+y;r.delete(b,w)}return t(r),!0}return!1}}},n.prototype.addRow=function(e){return function(){return function(t,n){var r=t.selection,o=t.schema,i=t.tr,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){var c=jh.create(a),u=c.totalColumnCount,d=c.getRectOffsets(a,l),p=Yh(d).rowCount,h=function(e,t,n){var r,o,i;return e===Jf.UP?(r=n.startRowIdx,o=0,i=-1):(r=n.endRowIdx,o=t.totalColumnCount-1,i=t.getCellInfo(r,o).nodeSize+1),{targetRowIdx:r,insertColIdx:o,nodeSize:i}}(e,c,d),f=h.targetRowIdx,m=h.insertColIdx,g=h.nodeSize;if(!(0===f)){for(var v=[],y=i.mapping.map(c.posAt(f,m))+g,b=[],w=0;w<u;w+=1)b=b.concat(Gh(1,f,o));for(var k=0;k<p;k+=1)v.push(o.nodes.tableRow.create(null,b));return n(i.insert(y,v)),!0}}return!1}}},n.prototype.removeRow=function(){return function(){return function(e,t){var n=e.selection,r=e.tr,o=Xh(n),i=o.anchor,s=o.head;if(i&&s){var a=jh.create(i),l=a.totalRowCount,c=a.totalColumnCount,u=a.getRectOffsets(i,s),d=Yh(u).rowCount,p=u.startRowIdx,h=u.endRowIdx;if(d===l-1||0===p)return!1;for(var f=h;f>=p;f-=1){var m=cm(a,f,c),g=m.from,v=m.to;r.delete(g-1,v+1)}return t(r),!0}return!1}}},n.prototype.alignColumn=function(){return function(e){return void 0===e&&(e={align:"center"}),function(t,n){var r=e.align,o=t.selection,i=t.tr,s=Xh(o),a=s.anchor,l=s.head;if(a&&l){for(var c=jh.create(a),u=c.totalRowCount,d=c.getRectOffsets(a,l),p=d.startColIdx,h=d.endColIdx,f=0;f<u;f+=1)for(var m=p;m<=h;m+=1)if(!c.extendedRowspan(f,m)&&!c.extendedColspan(f,m)){var g=c.getNodeAndPos(f,m),v=g.node,y=g.pos,b=ef(v,{align:r});i.setNodeMarkup(y,null,b)}return n(i),!0}return!1}}},n.prototype.moveToCell=function(e){return function(t,n){var r=t.selection,o=t.tr,i=t.schema,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){var c=jh.create(a),u=c.getCellIndex(a),d=void 0;if(d=sm(e,c,u)?am(o,c,i):lm(e,o,u,c))return n(d),!0}return!1}},n.prototype.moveInCell=function(e){var t=this;return function(n,r){var o=n.selection,i=n.tr,s=n.doc,a=n.schema,l=o.$from;if(!t.context.view.endOfTextblock(e))return!1;var c=Sh(l,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}));if(c){var u=Sh(l,(function(e){return"paragraph"===e.type.name})),d=c.depth;if(u&&im(e,[d,u.depth],l,s)){var p=Xh(o).anchor,h=jh.create(p),f=h.getCellIndex(p),m=void 0;if(!function(e,t,n){var r=n[0],o=n[1];if(e===Jf.UP||e===Jf.DOWN)return!1;var i=t.tableStartOffset,s=t.tableEndOffset,a=t.getCellInfo(r,o),l=a.offset,c=a.nodeSize;return(e===Jf.LEFT?i:s)===(e===Jf.LEFT?l-2:l+c+3)}(e,h,f)?sm(e,h,f)?e===Jf.UP?m=function(e,t,n){var r=e.doc.resolve(t.tableStartOffset-1);return r.nodeBefore?e.setSelection(Vt.near(r,-1)):Ds(e,r,n)}(i,h,a):e===Jf.DOWN&&(m=am(i,h,a)):m=lm(e,i,f,h):m=function(e,t,n){var r=e.doc.resolve(t.before(n-3));return e.setSelection(new Jt(r))}(i,l,d),m)return r(m),!0}}return!1}},n.prototype.deleteCells=function(){return function(e,t){var n=e.schema,r=e.selection,o=e.tr,i=Xh(r),s=i.anchor,a=i.head;if(s&&a&&!(r instanceof Ut)){for(var l=jh.create(s),c=l.getRectOffsets(s,a),u=c.startRowIdx,d=c.startColIdx,p=c.endRowIdx,h=c.endColIdx,f=u;f<=p;f+=1)for(var m=d;m<=h;m+=1)if(!l.extendedRowspan(f,m)&&!l.extendedColspan(f,m)){var g=l.getNodeAndPos(f,m),v=g.node,y=g.pos,b=Gh(1,f,n,v.attrs);o.replaceWith(o.mapping.map(y),o.mapping.map(y+v.nodeSize),b)}return t(o),!0}return!1}},n.prototype.exitTable=function(){return function(e,t){var n=e.selection,r=e.tr,o=e.schema,i=n.$from;if(Sh(i,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}))&&Sh(i,(function(e){return"paragraph"===e.type.name}))){var s=Xh(n).anchor;return t(am(r,jh.create(s),o,!0)),!0}return!1}},n.prototype.commands=function(){return{addTable:this.addTable(),removeTable:this.removeTable(),addColumnToLeft:this.addColumn(Jf.LEFT),addColumnToRight:this.addColumn(Jf.RIGHT),removeColumn:this.removeColumn(),addRowToUp:this.addRow(Jf.UP),addRowToDown:this.addRow(Jf.DOWN),removeRow:this.removeRow(),alignColumn:this.alignColumn()}},n.prototype.keymaps=function(){var e=this.deleteCells();return{Tab:this.moveToCell(Jf.RIGHT),"Shift-Tab":this.moveToCell(Jf.LEFT),ArrowUp:this.moveInCell(Jf.UP),ArrowDown:this.moveInCell(Jf.DOWN),ArrowLeft:this.moveInCell(Jf.LEFT),ArrowRight:this.moveInCell(Jf.RIGHT),Backspace:e,"Mod-Backspace":e,Delete:e,"Mod-Delete":e,"Mod-Enter":this.exitTable()}},n}(Va),dm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableHead"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"tableRow{1}",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[Dh("thead")],toDOM:function(e){return["thead",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),pm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableBody"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"tableRow+",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"tbody",getAttrs:function(e){var t=e.querySelectorAll("tr")[0].children.length,n=e.getAttribute("data-raw-html");return!!t&&o({},n&&{rawHTML:n})}}],toDOM:function(e){return["tbody",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),hm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableRow"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"(tableHeadCell | tableBodyCell)*",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"tr",getAttrs:function(e){var t=e.children.length,n=e.getAttribute("data-raw-html");return!!t&&o({},n&&{rawHTML:n})}}],toDOM:function(e){return["tr",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),fm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableHeadCell"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"paragraph+",attrs:o({align:{default:null},className:{default:null},rawHTML:{default:null},colspan:{default:null},extended:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),isolating:!0,parseDOM:[Lh("th")],toDOM:function(e){var t=e.attrs,n=Ah(t);return["th",o(o({},n),Ih(t)),0]}}},enumerable:!1,configurable:!0}),n}(Va),mm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableBodyCell"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"(paragraph | bulletList | orderedList)+",attrs:{align:{default:null},className:{default:null},rawHTML:{default:null},colspan:{default:null},rowspan:{default:null},extended:{default:null}},isolating:!0,parseDOM:[Lh("td")],toDOM:function(e){return["td",Ah(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),gm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"image"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{inline:!0,attrs:o({imageUrl:{default:""},altText:{default:null},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),group:"inline",selectable:!1,parseDOM:[{tag:"img[src]",getAttrs:function(e){var t=rh(e,{RETURN_DOM_FRAGMENT:!0}).firstChild,n=t.getAttribute("src")||"",r=t.getAttribute("data-raw-html"),i=t.getAttribute("alt");return o({imageUrl:n,altText:i},r&&{rawHTML:r})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"img",o(o({src:_e(t.imageUrl)},t.altText&&{alt:t.altText}),Ih(t))]}}},enumerable:!1,configurable:!0}),n.prototype.addImage=function(){return function(e){return function(t,n){var r=t.schema,i=t.tr,s=e,a=s.imageUrl,l=s.altText;if(!a)return!1;var c=r.nodes.image.createAndFill(o({imageUrl:a},l&&{altText:l}));return n(i.replaceSelectionWith(c).scrollIntoView()),!0}}},n.prototype.commands=function(){return{addImage:this.addImage()}},n}(Va),vm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"thematicBreak"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),group:"block",parseDOM:[{tag:"hr"}],selectable:!1,toDOM:function(e){var t=e.attrs;return["div",Ih(t),[t.rawHTML||"hr"]]}}},enumerable:!1,configurable:!0}),n.prototype.hr=function(){var e=this;return function(){return function(t,n){var r,o=t.selection,i=o.$from;if(i===o.$to){var s=t.doc,a=t.schema.nodes,l=a.thematicBreak,c=a.paragraph,u=[l.create()],d=i.node(1),p=s.child(s.childCount-1)===d,h=s.resolve(i.after(1)),f=(null===(r=i.nodeAfter)||void 0===r?void 0:r.type.name)===e.name;return(p||f)&&u.push(c.create()),n(t.tr.insert(h.pos,u).scrollIntoView()),!0}return!1}}},n.prototype.commands=function(){return{hr:this.hr()}},n.prototype.keymaps=function(){var e=this.hr()();return{"Mod-l":e,"Mod-L":e}},n}(Va),ym=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strong"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=["b","strong"].map((function(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}));return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:e,toDOM:function(e){var t=e.attrs;return[t.rawHTML||"strong",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.bold=function(){return function(){return function(e,t){return Ki(e.schema.marks.strong)(e,t)}}},n.prototype.commands=function(){return{bold:this.bold()}},n.prototype.keymaps=function(){var e=this.bold()();return{"Mod-b":e,"Mod-B":e}},n}(Al),bm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"emph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=["i","em"].map((function(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}));return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:e,toDOM:function(e){var t=e.attrs;return[t.rawHTML||"em",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.italic=function(){return function(){return function(e,t){return Ki(e.schema.marks.emph)(e,t)}}},n.prototype.commands=function(){return{italic:this.italic()}},n.prototype.keymaps=function(){var e=this.italic()();return{"Mod-i":e,"Mod-I":e}},n}(Al),wm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strike"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=["s","del"].map((function(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}));return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:e,toDOM:function(e){var t=e.attrs;return[t.rawHTML||"del",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Ki(e.schema.marks.strike)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()();return{"Mod-s":e,"Mod-S":e}},n}(Al),km=function(e){function n(t){var n=e.call(this)||this;return n.linkAttributes=t,n}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"link"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=this;return{attrs:o({linkUrl:{default:""},title:{default:null},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),inclusive:!1,parseDOM:[{tag:"a[href]",getAttrs:function(e){var t=rh(e,{RETURN_DOM_FRAGMENT:!0}).firstChild,n=t.getAttribute("href")||"",r=t.getAttribute("title")||"",i=t.getAttribute("data-raw-html");return o({linkUrl:n,title:r},i&&{rawHTML:i})}}],toDOM:function(t){var n=t.attrs;return[n.rawHTML||"a",o(o({href:_e(n.linkUrl)},e.linkAttributes),Ih(n))]}}},enumerable:!1,configurable:!0}),n.prototype.addLink=function(){return function(e){return function(t,n){var r=e,o=r.linkUrl,i=r.linkText,s=void 0===i?"":i,a=t.schema,l=t.tr,c=t.selection,u=c.empty,d=c.from,p=c.to;if(d&&p&&o){var h={linkUrl:o},f=a.mark("link",h);if(u&&s){var m=Ns(a,s,f);l.replaceRangeWith(d,p,m)}else l.addMark(d,p,f);return n(l.scrollIntoView()),!0}return!1}}},n.prototype.toggleLink=function(){return function(e){return function(t,n){return Ki(t.schema.marks.link,e)(t,n)}}},n.prototype.commands=function(){return{addLink:this.addLink(),toggleLink:this.toggleLink()}},n}(Al),xm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"code"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"code",getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"code",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Ki(e.schema.marks.code)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-c":e,"Shift-Mod-C":e}},n}(Al),Cm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"customBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",attrs:{info:{default:null}},atom:!0,code:!0,defining:!0,parseDOM:[{tag:"div[data-custom-info]",getAttrs:function(e){return{info:e.getAttribute("data-custom-info")}}}],toDOM:function(e){return["div",{"data-custom-info":e.attrs.info||null},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(e){return function(t,n){return!!(null==e?void 0:e.info)&&Gi(t.schema.nodes.customBlock,e)(t,n)}}},n}(Va),Tm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"frontMatter"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",code:!0,defining:!0,parseDOM:[{preserveWhitespace:"full",tag:"div[data-front-matter]"}],toDOM:function(){return["div",{"data-front-matter":"true"},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t,n){var r=e.selection.$from;return!(!n.endOfTextblock("down")||"frontMatter"!==r.node().type.name)&&qi(e,t)}}},n.prototype.keymaps=function(){return{Enter:this.commands()()}},n}(Va),Mm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"htmlComment"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",code:!0,defining:!0,parseDOM:[{preserveWhitespace:"full",tag:"div[data-html-comment]"}],toDOM:function(){return["div",{"data-html-comment":"true"},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t,n){var r=e.selection.$from;return!(!n.endOfTextblock("down")||"htmlComment"!==r.node().type.name)&&qi(e,t)}}},n.prototype.keymaps=function(){return{Enter:this.commands()()}},n}(Va);var Sm=xa("contents"),Em=function(e){function n(t,n){var r=e.call(this,t)||this,i=n.toDOMAdaptor,s=n.htmlSchemaMap,a=void 0===s?{}:s,l=n.linkAttributes,c=void 0===l?{}:l,u=n.useCommandShortcut,d=void 0===u||u,p=n.wwPlugins,h=void 0===p?[]:p,f=n.wwNodeViews,m=void 0===f?{}:f;return r.editorType="wysiwyg",r.el.classList.add("ww-mode"),r.toDOMAdaptor=i,r.linkAttributes=c,r.extraPlugins=h,r.pluginNodeViews=m,r.specs=r.createSpecs(),r.schema=r.createSchema(a),r.context=r.createContext(),r.keymaps=r.createKeymaps(d),r.view=r.createView(),r.commands=r.createCommands(),r.specs.setContext(o(o({},r.context),{view:r.view})),r.initEvent(),r}return t(n,e),n.prototype.createSpecs=function(){return e=this.linkAttributes,new Qa([new Gf,new Kf,new Xf,new Qf,new Yf,new em,new tm,new nm,new rm,new um,new dm,new pm,new hm,new fm,new mm,new gm,new vm,new ym,new bm,new wm,new km(e),new xm,new Cm,new Tm,new _a,new Mm]);var e},n.prototype.createContext=function(){return{schema:this.schema,eventEmitter:this.eventEmitter}},n.prototype.createSchema=function(e){return new Y({nodes:o(o({},this.specs.nodes),e.nodes),marks:o(o({},this.specs.marks),e.marks)})},n.prototype.createPlugins=function(){return i([new an({key:tf,state:{init:function(){return null},apply:function(e,t){var n=e.getMeta(tf);if(n)return-1===n?null:n;if(Ae()(t)||!e.docChanged)return t;var r=e.mapping.mapResult(t),o=r.deleted,i=r.pos;return o?null:i}},props:{decorations:sf,createSelectionBetween:function(e){var t=e.state;return Ae()(tf.getState(t))?null:t.selection}},view:function(e){return new rf(e)}}),gf(this.eventEmitter),new an({props:{handleDOMEvents:{mousedown:function(e,t){var n=t,r=n.clientX,i=n.clientY,s=e.posAtCoords({left:r,top:i});if(s){var a=e.state,l=a.doc,c=a.tr,u=l.resolve(s.pos),d=Oh(u),p=t.target,h=getComputedStyle(p,":before"),f=t,m=f.offsetX,g=f.offsetY;if(!d||!wa(h,m,g))return!1;t.preventDefault();var v=u.before(d.depth),y=d.node.attrs;return c.setNodeMarkup(v,null,o(o({},y),{checked:!y.checked})),e.dispatch(c),!0}return!1}}}}),kf(this.eventEmitter)],this.createPluginProps()).concat(this.defaultPlugins)},n.prototype.createPluginNodeViews=function(){var e=this.eventEmitter,t=this.pluginNodeViews,n={};return t&&Object.keys(t).forEach((function(r){n[r]=function(n,o,i){return t[r](n,o,i,e)}})),n},n.prototype.createView=function(){var e=this,t=this.toDOMAdaptor,n=this.eventEmitter;return new ui(this.el,{state:this.createState(),attributes:{class:Sm},nodeViews:o({customBlock:function(e,n,r){return new xf(e,n,r,t)},image:function(e,t,r){return new Tf(e,t,r,n)},codeBlock:function(e,t,r){return new Mf(e,t,r,n)},widget:ja},this.createPluginNodeViews()),dispatchTransaction:function(t){var n=e.view.state.applyTransaction(t).state;e.view.updateState(n),e.emitChangeEvent(t.scrollIntoView()),e.eventEmitter.emit("setFocusedNode",n.selection.$from.node(1))},transformPastedHTML:Ff,transformPasted:function(t){return _f(t,e.schema,Nh(e.view.state.selection.$from))},handlePaste:function(e,t,n){return Wf(e,n)},handleKeyDown:function(t,n){return e.eventEmitter.emit("keydown",e.editorType,n),!1},handleDOMEvents:{paste:function(t,n){var r=n.clipboardData||window.clipboardData,o=null==r?void 0:r.items;if(o){var i=vi()(o).some((function(e){return"string"===e.kind&&"text/rtf"===e.type}));if(!i){var s=za(o);s&&(n.preventDefault(),Ha(e.eventEmitter,s,n.type))}}return!1},keyup:function(t,n){return e.eventEmitter.emit("keyup",e.editorType,n),!1},scroll:function(){return e.eventEmitter.emit("scroll","editor"),!0}}})},n.prototype.createCommands=function(){return this.specs.commands(this.view,qh())},n.prototype.getHTML=function(){return La(this.view.dom.innerHTML)},n.prototype.getModel=function(){return this.view.state.doc},n.prototype.getSelection=function(){var e=this.view.state.selection;return[e.from,e.to]},n.prototype.getSchema=function(){return this.view.state.schema},n.prototype.replaceSelection=function(e,t,n){var r=this.view.state,o=r.schema,i=r.tr,s=e.split("\n").map((function(e){return Es(o,ra(e,o))})),a=new v(d.from(s),1,1),l=Ee()(t)&&Ee()(n)?i.replaceRange(t,n,a):i.replaceSelection(a);this.view.dispatch(l),this.focus()},n.prototype.deleteSelection=function(e,t){var n=this.view.state.tr,r=Ee()(e)&&Ee()(t)?n.deleteRange(e,t):n.deleteSelection();this.view.dispatch(r.scrollIntoView())},n.prototype.getSelectedText=function(e,t){var n=this.view.state,r=n.doc,o=n.selection,i=o.from,s=o.to;return Ee()(e)&&Ee()(t)&&(i=e,s=t),r.textBetween(i,s,"\n")},n.prototype.setModel=function(e,t){void 0===t&&(t=!1);var n=this.view.state,r=n.tr,o=n.doc;this.view.dispatch(r.replaceWith(0,o.content.size,e)),t&&this.moveCursorToEnd(!0)},n.prototype.setSelection=function(e,t){void 0===t&&(t=e);var n=this.view.state.tr,r=Os(n,e,t);this.view.dispatch(n.setSelection(r).scrollIntoView())},n.prototype.addWidget=function(e,t,n){var r=this.view,o=r.dispatch,i=r.state;o(i.tr.setMeta("widget",{pos:null!=n?n:i.selection.to,node:e,style:t}))},n.prototype.replaceWithWidget=function(e,t,n){var r=this.view.state,o=r.tr,i=ra(n,r.schema);this.view.dispatch(o.replaceWith(e,t,i))},n.prototype.getRangeInfoOfNode=function(e){var t=this.view.state,n=t.doc,r=t.selection,o=e?n.resolve(e):r.$from,i=o.marks(),s=o.node(),a=o.start(),l=o.end(),c=s.type.name;if(i.length||"paragraph"===c){var u=i[i.length-1];c=u?u.type.name:"text",s.forEach((function(e,t){var n=e.isText,r=e.nodeSize,i=e.marks,s=o.pos-a;n&&t<=s&&t+r>=s&&function(e){return!e.length||Ue(e,u)}(i)&&(l=(a+=t)+r)}))}return{range:[a,l],type:c}},n}(Wa),Nm=Em,Om=n(404),Dm=n.n(Om),Am=["afterPreviewRender","updatePreview","changeMode","needChangeMode","command","changePreviewStyle","changePreviewTabPreview","changePreviewTabWrite","scroll","contextmenu","show","hide","changeLanguage","changeToolbarState","toggleScrollSync","mixinTableOffsetMapPrototype","setFocusedNode","removePopupWidget","query","openPopup","closePopup","addImageBlobHook","beforePreviewRender","beforeConvertWysiwygToMarkdown","load","loadUI","change","caretChange","destroy","focus","blur","keydown","keyup"],Lm=function(){function e(){var e=this;this.events=new uf,this.eventTypes=Am.reduce((function(e,t){return o(o({},e),{type:t})}),{}),this.hold=!1,Am.forEach((function(t){e.addEventType(t)}))}return e.prototype.listen=function(e,t){var n=this.getTypeInfo(e),r=this.events.get(n.type)||[];if(!this.hasEventType(n.type))throw new Error("There is no event type "+n.type);n.namespace&&(t.namespace=n.namespace),r.push(t),this.events.set(n.type,r)},e.prototype.emit=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=this.getTypeInfo(e),o=this.events.get(r.type),i=[];return!this.hold&&o&&o.forEach((function(e){var n=e.apply(void 0,t);Oe()(n)||i.push(n)})),i},e.prototype.emitReduce=function(e,t){for(var n=[],r=2;r<arguments.length;r++)n[r-2]=arguments[r];var o=this.events.get(e);return!this.hold&&o&&o.forEach((function(e){var r=e.apply(void 0,i([t],n));Dm()(r)||(t=r)})),t},e.prototype.getTypeInfo=function(e){var t=e.split(".");return{type:t[0],namespace:t[1]}},e.prototype.hasEventType=function(e){return!Oe()(this.eventTypes[this.getTypeInfo(e).type])},e.prototype.addEventType=function(e){if(this.hasEventType(e))throw new Error("There is already have event type "+e);this.eventTypes[e]=e},e.prototype.removeEventHandler=function(e,t){var n=this,r=this.getTypeInfo(e),o=r.type,i=r.namespace;o&&t?this.removeEventHandlerWithHandler(o,t):o&&!i?this.events.delete(o):!o&&i?this.events.forEach((function(e,t){n.removeEventHandlerWithTypeInfo(t,i)})):o&&i&&this.removeEventHandlerWithTypeInfo(o,i)},e.prototype.removeEventHandlerWithHandler=function(e,t){var n=this.events.get(e);if(n){var r=n.indexOf(t);n.indexOf(t)>=0&&n.splice(r,1)}},e.prototype.removeEventHandlerWithTypeInfo=function(e,t){var n=[],r=this.events.get(e);r&&(r.map((function(e){return e.namespace!==t&&n.push(e),null})),this.events.set(e,n))},e.prototype.getEvents=function(){return this.events},e.prototype.holdEventInvoke=function(e){this.hold=!0,e(),this.hold=!1},e}(),Im=Lm,Rm=function(){function e(e,t,n,r){this.eventEmitter=e,this.mdCommands=t,this.wwCommands=n,this.getEditorType=r,this.initEvent()}return e.prototype.initEvent=function(){var e=this;this.eventEmitter.listen("command",(function(t,n){e.exec(t,n)}))},e.prototype.addCommand=function(e,t,n){"markdown"===e?this.mdCommands[t]=n:this.wwCommands[t]=n},e.prototype.deleteCommand=function(e,t){"markdown"===e?delete this.mdCommands[t]:delete this.wwCommands[t]},e.prototype.exec=function(e,t){"markdown"===this.getEditorType()?this.mdCommands[e](t):this.wwCommands[e](t)},e}(),Pm=Rm;function Bm(e){return"\n"===e[e.length-1]?e.slice(0,e.length-1):e}function Fm(e,t){var n=e.schema,r=t.literal.match(ga);if(r){var o=r[1],i=r[3],s=(o||i).toLowerCase();return"htmlInline"===t.type&&!(!n.marks[s]&&!n.nodes[s])}return!1}function Hm(e){return Ue(["text","strong","emph","strike","image","link","code"],e.type)}function zm(e){return"softbreak"===(null==e?void 0:e.type)}function qm(e){var t=e.type,n=e.literal,r="htmlInline"===t&&n.match(ga);if(r){var o=r[1],i=r[3],s=o||i;if(s)return Ue(["ul","ol","li"],s.toLowerCase())}return!1}function Vm(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=document.createElement("div");r.innerHTML=rh(e);var o=r.firstChild;return t.map((function(e){return o.getAttribute(e)||""}))}var jm={"b, strong":function(e,t,n){var r=e.schema.marks.strong;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},"i, em":function(e,t,n){var r=e.schema.marks.emph;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},"s, del":function(e,t,n){var r=e.schema.marks.strike;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},code:function(e,t,n){var r=e.schema.marks.code;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},a:function(e,t,n){var r=t.literal,o=e.schema.marks.link;if(n){var i=Vm(r,"href")[0];e.openMark(o.create({linkUrl:i,rawHTML:n}))}else e.closeMark(o)},img:function(e,t,n){var r=t.literal;if(n){var i=Vm(r,"src","alt"),s=i[0],a=i[1],l=e.schema.nodes.image;e.addNode(l,o({rawHTML:n,imageUrl:s},a&&{altText:a}))}},hr:function(e,t,n){e.addNode(e.schema.nodes.thematicBreak,{rawHTML:n})},br:function(e,t){var n=e.schema.nodes.paragraph,r=t.parent,o=t.prev,i=t.next;"paragraph"===(null==r?void 0:r.type)?(zm(o)&&e.openNode(n),zm(i)?e.closeNode():i&&(e.closeNode(),e.openNode(n))):"tableCell"===(null==r?void 0:r.type)&&(o&&(Hm(o)||Fm(e,o))&&e.closeNode(),i&&(Hm(i)||Fm(e,i))&&e.openNode(n))},pre:function(e,t,n){var r,o,i=document.createElement("div");i.innerHTML=t.literal;var s=null===(o=null===(r=i.firstChild)||void 0===r?void 0:r.firstChild)||void 0===o?void 0:o.textContent;e.openNode(e.schema.nodes.codeBlock,{rawHTML:n}),e.addText(Bm(s)),e.closeNode()},"ul, ol":function(e,t,n){if("tableCell"===t.parent.type){var r=e.schema.nodes,o=r.bulletList,i=r.orderedList,s=r.paragraph,a="ul"===n?o:i;n?(t.prev&&!qm(t.prev)&&e.closeNode(),e.openNode(a,{rawHTML:n})):(e.closeNode(),t.next&&!qm(t.next)&&e.openNode(s))}},li:function(e,t,n){var r;if("tableCell"===(null===(r=t.parent)||void 0===r?void 0:r.type)){var i=e.schema.nodes,s=i.listItem,a=i.paragraph;if(n){var l=function(e){var t=e.literal;return{task:/data-task/.test(t),checked:/data-task-checked/.test(t)}}(t);t.prev&&!qm(t.prev)&&e.closeNode(),e.openNode(s,o({rawHTML:n},l)),t.next&&!qm(t.next)&&e.openNode(a)}else t.prev&&!qm(t.prev)&&e.closeNode(),e.closeNode()}}},$m=function(e){var t={};return Object.keys(e).forEach((function(n){n.split(", ").forEach((function(r){var o=r.toLowerCase();t[o]=e[n]}))})),t}(jm);function _m(e){return"htmlInline"===e.type&&va.test(e.literal)}function Um(e){vi()(e.childNodes).forEach((function(e){if(Ta(e)){var t=e.nodeName.toLowerCase();e.setAttribute("data-raw-html",t),e.childNodes&&Um(e)}}))}var Wm={text:function(e,t){e.addText(t.literal||"")},paragraph:function(e,t,n,r){var o;if(n.entering){var i=e.schema.nodes.paragraph;"paragraph"===(null===(o=t.prev)||void 0===o?void 0:o.type)&&(e.openNode(i,r),e.closeNode()),e.openNode(i,r)}else e.closeNode()},heading:function(e,t,n,r){if(n.entering){var i=t,s=i.level,a=i.headingType;e.openNode(e.schema.nodes.heading,o({level:s,headingType:a},r))}else e.closeNode()},codeBlock:function(e,t,n){var r=e.schema.nodes.codeBlock,i=t,s=i.info,a=i.literal;e.openNode(r,o({language:s},n)),e.addText(Bm(a||"")),e.closeNode()},list:function(e,t,n,r){if(n.entering){var i=e.schema.nodes,s=i.bulletList,a=i.orderedList,l=t.listData,c=l.type,u=l.start;"bullet"===c?e.openNode(s,r):e.openNode(a,o({order:u},r))}else e.closeNode()},item:function(e,t,n,r){var i=n.entering,s=e.schema.nodes.listItem,a=t.listData,l=a.task,c=a.checked;if(i){var u=o(o(o({},l&&{task:l}),c&&{checked:c}),r);e.openNode(s,u)}else e.closeNode()},blockQuote:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.blockQuote,r):e.closeNode()},image:function(e,t,n,r){var i=n.entering,s=n.skipChildren,a=e.schema.nodes.image,l=t,c=l.destination,u=l.firstChild;i&&s&&s(),e.addNode(a,o(o({imageUrl:c},u&&{altText:u.literal}),r))},thematicBreak:function(e,t,n,r){e.addNode(e.schema.nodes.thematicBreak,r)},strong:function(e,t,n,r){var o=n.entering,i=e.schema.marks.strong;o?e.openMark(i.create(r)):e.closeMark(i)},emph:function(e,t,n,r){var o=n.entering,i=e.schema.marks.emph;o?e.openMark(i.create(r)):e.closeMark(i)},link:function(e,t,n,r){var i=n.entering,s=e.schema.marks.link,a=t,l=a.destination,c=a.title;if(i){var u=o({linkUrl:l,title:c},r);e.openMark(s.create(u))}else e.closeMark(s)},softbreak:function(e,t){if("paragraph"===t.parent.type){var n=t.prev,r=t.next;n&&!_m(n)&&e.closeNode(),r&&!_m(r)&&e.openNode(e.schema.nodes.paragraph)}},table:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.table,r):e.closeNode()},tableHead:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.tableHead,r):e.closeNode()},tableBody:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.tableBody,r):e.closeNode()},tableRow:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.tableRow,r):e.closeNode()},tableCell:function(e,t,n){var r=n.entering;if(!t.ignored){var i=function(t){return t&&(Hm(t)||Fm(e,t))};if(r){var s=e.schema.nodes,a=s.tableHeadCell,l=s.tableBodyCell,c=s.paragraph,u=t.parent.parent,d="tableHead"===u.type?a:l,p=(u.parent.columns[t.startIdx]||{}).align,h=o({},t.attrs);p&&(h.align=p),e.openNode(d,h),i(t.firstChild)&&e.openNode(c)}else i(t.lastChild)&&e.closeNode(),e.closeNode()}},strike:function(e,t,n,r){var o=n.entering,i=e.schema.marks.strike;o?e.openMark(i.create(r)):e.closeMark(i)},code:function(e,t,n,r){var o=e.schema.marks.code;e.openMark(o.create(r)),e.addText(Bm(t.literal||"")),e.closeMark(o)},customBlock:function(e,t){var n=e.schema.nodes,r=n.customBlock,o=n.paragraph,i=t,s=i.info,a=i.literal;e.openNode(r,{info:s}),e.addText(Bm(a||"")),e.closeNode(),t.next||(e.openNode(o),e.closeNode())},frontMatter:function(e,t){e.openNode(e.schema.nodes.frontMatter),e.addText(t.literal),e.closeNode()},htmlInline:function(e,t){var n=t.literal,r=n.match(ga),o=r[1],i=r[3],s=(o||i).toLowerCase(),a=e.schema.marks[s],l=rh(n);if(null==a?void 0:a.spec.attrs.htmlInline)if(o){var c=ih(l);e.openMark(a.create({htmlAttrs:c}))}else e.closeMark(a);else{var u=$m[s];u&&u(e,t,o)}},htmlBlock:function(e,t){var n=t.literal,r=document.createElement("div");if(ya.test(n))e.openNode(e.schema.nodes.htmlComment),e.addText(t.literal),e.closeNode();else{var o=n.match(ga),i=o[1],s=o[3],a=(i||s).toLowerCase(),l=e.schema.nodes[a],c=rh(n);if(null==l?void 0:l.spec.attrs.htmlBlock){var u=ih(c),d=oh(t,a);e.addNode(l,{htmlAttrs:u,childrenHTML:d})}else r.innerHTML=c,Um(r),e.convertByDOMParser(r)}},customInline:function(e,t,n){var r=n.entering,o=n.skipChildren,i=t,s=i.info,a=i.firstChild,l=e.schema;if(-1!==s.indexOf("widget")&&r){var c=oa(t);o(),e.addNode(l.nodes.widget,{info:s},[l.text(Qs(s,c))])}else{var u="$$";r&&(u+=a?s+" ":s),e.addText(u)}}};var Jm=function(){function e(e,t){this.schema=e,this.convertors=t,this.stack=[{type:this.schema.topNodeType,attrs:null,content:[]}],this.marks=m.none}return e.prototype.top=function(){return et(this.stack)},e.prototype.push=function(e){this.stack.length&&this.top().content.push(e)},e.prototype.addText=function(e){if(e){var t=this.top().content,n=et(t),r=this.schema.text(e,this.marks),o=n&&(s=r,!!((i=n).isText&&s.isText&&m.sameSet(i.marks,s.marks))&&i.withText(i.text+s.text));o?t[t.length-1]=o:t.push(r)}var i,s},e.prototype.openMark=function(e){this.marks=e.addToSet(this.marks)},e.prototype.closeMark=function(e){this.marks=e.removeFromSet(this.marks)},e.prototype.addNode=function(e,t,n){var r=e.createAndFill(t,n,this.marks);return r?(this.push(r),r):null},e.prototype.openNode=function(e,t){this.stack.push({type:e,attrs:t,content:[]})},e.prototype.closeNode=function(){this.marks.length&&(this.marks=m.none);var e=this.stack.pop(),t=e.type,n=e.attrs,r=e.content;return this.addNode(t,n,r)},e.prototype.convertByDOMParser=function(e){var t=this;te.fromSchema(this.schema).parse(e).content.forEach((function(e){return t.push(e)}))},e.prototype.closeUnmatchedHTMLInline=function(e,t){var n;if(!t&&"htmlInline"!==e.type)for(var r=this.stack.length-1;r>=0;r-=1){var o=this.stack[r];if(!(null===(n=o.attrs)||void 0===n?void 0:n.rawHTML))break;o.content.length?this.closeNode():this.stack.pop()}},e.prototype.convert=function(e,t){for(var n=e.walker(),r=n.next(),o=function(){var e=r.node,o=r.entering,s=i.convertors[e.type],a=!1;if(s){var l={entering:o,leaf:!Ws(e),getChildrenText:Js,options:{gfm:!0,nodeId:!1,tagFilter:!1,softbreak:"\n"},skipChildren:function(){a=!0}};if(i.closeUnmatchedHTMLInline(e,o),s(i,e,l),(null==t?void 0:t.node)===e){var c=i.stack.reduce((function(e,t){return e+t.content.reduce((function(e,t){return e+t.nodeSize}),0)}),0)+1;t.setMappedPos(c)}}a&&(n.resumeAt(e,!1),n.next()),r=n.next()},i=this;r;)o()},e.prototype.convertNode=function(e,t){return this.convert(e,t),this.stack.length?this.closeNode():null},e}(),Gm=Jm;var Km={text:function(e,t){var n,r=t.node,o=null!==(n=r.text)&&void 0!==n?n:"";(r.marks||[]).some((function(e){return"link"===e.type.name}))?e.text(Ze(o),!1):e.text(o)},paragraph:function(e,t){var n=t.node,r=t.parent,o=t.index,i=void 0===o?0:o;if(e.stopNewline)e.convertInline(n);else{var s=0===i,a=!s&&r.child(i-1),l=a&&0===a.childCount,c=i<r.childCount-1&&r.child(i+1),u=c&&"paragraph"===c.type.name,d=0===n.childCount;if(d&&l)e.write("<br>\n");else if(!d||l||s)e.convertInline(n),u?e.write("\n"):e.closeBlock(n);else{if("listItem"===(null==r?void 0:r.type.name)){var p=e.getDelim();e.setDelim(""),e.write("<br>"),e.setDelim(p)}e.write("\n")}}},heading:function(e,t,n){var r=t.node,o=n.delim;"atx"===r.attrs.headingType?(e.write(o+" "),e.convertInline(r),e.closeBlock(r)):(e.convertInline(r),e.ensureNewLine(),e.write(o),e.closeBlock(r))},codeBlock:function(e,t,n){var r=t.node,o=n.delim,i=n.text,s=o,a=s[0],l=s[1];e.write(a),e.ensureNewLine(),e.text(i,!1),e.ensureNewLine(),e.write(l),e.closeBlock(r)},blockQuote:function(e,t,n){var r=t.node,o=t.parent,i=n.delim;(null==o?void 0:o.type.name)===r.type.name&&e.flushClose(1),e.wrapBlock(i,null,r,(function(){return e.convertNode(r)}))},bulletList:function(e,t,n){var r=t.node,o=n.delim;e.convertList(r,Ke(" ",4),(function(){return o+" "}))},orderedList:function(e,t){var n=t.node,r=n.attrs.order||1;e.convertList(n,Ke(" ",4),(function(e){return String(r+e)+". "}))},listItem:function(e,t){var n=t.node,r=n.attrs,o=r.task,i=r.checked;o&&e.write("["+(i?"x":" ")+"] "),e.convertNode(n)},image:function(e,t,n){var r=n.attrs;e.write("!["+(null==r?void 0:r.altText)+"]("+(null==r?void 0:r.imageUrl)+")")},thematicBreak:function(e,t,n){var r=t.node,o=n.delim;e.write(o),e.closeBlock(r)},table:function(e,t){var n=t.node;e.convertNode(n),e.closeBlock(n)},tableHead:function(e,t,n){var r=t.node,o=n.delim,i=r.firstChild;e.convertNode(r);var s=null!=o?o:"";!o&&i&&i.forEach((function(e){var t=function(e,t){var n=e.length,r="",o="";return"left"===t?(r=":",n-=1):"right"===t?(o=":",n-=1):"center"===t&&(r=":",o=":",n-=2),""+r+Ke("-",Math.max(n,3))+o}(e.textContent,e.attrs.align);s+="| "+t+" "})),e.write(s+"|"),e.ensureNewLine()},tableBody:function(e,t){var n=t.node;e.convertNode(n)},tableRow:function(e,t){var n=t.node;e.convertNode(n),e.write("|"),e.ensureNewLine()},tableHeadCell:function(e,t,n){var r=t.node,o=n.delim,i=void 0===o?"| ":o;e.write(i),e.convertTableCell(r),e.write(" ")},tableBodyCell:function(e,t,n){var r=t.node,o=n.delim,i=void 0===o?"| ":o;e.write(i),e.convertTableCell(r),e.write(" ")},customBlock:function(e,t,n){var r=t.node,o=n.delim,i=n.text,s=o,a=s[0],l=s[1];e.write(a),e.ensureNewLine(),e.text(i,!1),e.ensureNewLine(),e.write(l),e.closeBlock(r)},frontMatter:function(e,t,n){var r=t.node,o=n.text;e.text(o,!1),e.closeBlock(r)},widget:function(e,t,n){var r=n.text;e.write(r)},html:function(e,t,n){var r=t.node,o=n.text;e.write(o),r.attrs.htmlBlock&&e.closeBlock(r)},htmlComment:function(e,t,n){var r=t.node,o=n.text;e.write(o),e.closeBlock(r)}};function Zm(e,t){var n=e.text,r=/`+/g,o=0;if(e.isText&&n)for(var i=r.exec(n);i;)o=Math.max(o,i[0].length),i=r.exec(n);for(var s=o>0&&t>0?" `":"`",a=0;a<o;a+=1)s+="`";return o>0&&t<0&&(s+=" "),s}function Xm(e){return e?["<"+e+">","</"+e+">"]:null}function Qm(e){return e?"<"+e+">":null}function Ym(e){return e?"</"+e+">":null}var eg={heading:function(e){var t=e.node.attrs,n=t.level,r=Ke("#",n);return"setext"===t.headingType&&(r=1===n?"===":"---"),{delim:r,rawHTML:Xm(t.rawHTML)}},codeBlock:function(e){var t=e.node,n=t.attrs,r=t.textContent;return{delim:["```"+(n.language||""),"```"],rawHTML:Xm(n.rawHTML),text:r}},blockQuote:function(e){return{delim:"> ",rawHTML:Xm(e.node.attrs.rawHTML)}},bulletList:function(e,t){var n=e.node,r=t.inTable,o=n.attrs.rawHTML;return r&&(o=o||"ul"),{delim:"*",rawHTML:Xm(o)}},orderedList:function(e,t){var n=e.node,r=t.inTable,o=n.attrs.rawHTML;return r&&(o=o||"ol"),{rawHTML:Xm(o)}},listItem:function(e,t){var n=e.node,r=t.inTable,o=n.attrs,i=o.task,s=o.checked,a=n.attrs.rawHTML;return r&&(a=a||"li"),{rawHTML:a?["<"+a+(i?' class="task-list-item'+(s?" checked":"")+'"':"")+(i?" data-task"+(s?" data-task-checked":""):"")+">","</"+a+">"]:null}},table:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableHead:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableBody:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableRow:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableHeadCell:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableBodyCell:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},image:function(e){var t=e.node.attrs,n=t.rawHTML,r=t.altText,o=t.imageUrl.replace(/&amp;/g,"&"),i=r?' alt="'+_e(r)+'"':"";return{rawHTML:n?"<"+n+' src="'+_e(o)+'"'+i+">":null,attrs:{altText:Ze(r||""),imageUrl:o}}},thematicBreak:function(e){return{delim:"***",rawHTML:Qm(e.node.attrs.rawHTML)}},customBlock:function(e){var t=e.node,n=t.attrs,r=t.textContent;return{delim:["$$"+n.info,"$$"],text:r}},frontMatter:function(e){return{text:e.node.textContent}},widget:function(e){return{text:e.node.textContent}},strong:function(e,t){var n=e.node,r=t.entering,o=n.attrs.rawHTML;return{delim:"**",rawHTML:r?Qm(o):Ym(o)}},emph:function(e,t){var n=e.node,r=t.entering,o=n.attrs.rawHTML;return{delim:"*",rawHTML:r?Qm(o):Ym(o)}},strike:function(e,t){var n=e.node,r=t.entering,o=n.attrs.rawHTML;return{delim:"~~",rawHTML:r?Qm(o):Ym(o)}},link:function(e,t){var n,r,o=e.node,i=t.entering,s=o.attrs,a=s.title,l=s.rawHTML,c=s.linkUrl.replace(/&amp;/g,"&"),u=a?' title="'+_e(a)+'"':"";return i?{delim:"[",rawHTML:l?"<"+l+' href="'+_e(c)+'"'+u+">":null}:{delim:"]("+c+(a?" "+(n=Ze(a),(r=-1===n.indexOf('"')?'""':-1===n.indexOf("'")?"''":"()")[0]+n+r[1]):"")+")",rawHTML:Ym(l)}},code:function(e,t){var n=e.node,r=e.parent,o=e.index,i=void 0===o?0:o,s=t.entering;return{delim:s?Zm(r.child(i),-1):Zm(r.child(i-1),1),rawHTML:s?Qm(n.attrs.rawHTML):Ym(n.attrs.rawHTML)}},htmlComment:function(e){return{text:e.node.textContent}},html:function(e,t){var n=e.node,r=t.entering,o=n.type.name,i=n.attrs.htmlAttrs,s="<"+o,a="</"+o+">";return Object.keys(i).forEach((function(e){s+=" "+e+'="'+i[e].replace(/"/g,"'")+'"'})),s+=">",n.attrs.htmlInline?{rawHTML:r?s:a}:{text:""+s+n.attrs.childrenHTML+a}}},tg={strong:{mixable:!0,removedEnclosingWhitespace:!0},emph:{mixable:!0,removedEnclosingWhitespace:!0},strike:{mixable:!0,removedEnclosingWhitespace:!0},code:{escape:!1},link:null,html:null};function ng(e){var t={};return Object.keys(Km).forEach((function(n){t[n]=function(t,r){if(Km[n]){var o=e[n],i=o?o(r,{inTable:t.inTable}):{};!function(e,t){var n=t.state,r=t.nodeInfo,o=t.params,i=o.rawHTML;i?lf()(e,["heading","codeBlock"])>-1?function(e,t,n){var r=n[0],o=n[1];e.write(r),e.convertInline(t),e.write(o)}(n,r.node,i):lf()(e,["image","thematicBreak"])>-1?n.write(i):function(e,t,n){var r=t.node,o=t.parent,i=n[0],s=n[1];e.stopNewline=!0,e.write(i),e.convertNode(r),e.write(s),"doc"===(null==o?void 0:o.type.name)&&(e.closeBlock(r),e.stopNewline=!1)}(n,r,i):Km[e](n,r,o)}(n,{state:t,nodeInfo:r,params:i})}}})),t}function rg(e){Object.keys(e).forEach((function(t){var n=eg[t],r=e[t];eg[t]=n?function(e,t){return t.origin=function(){return n(e,t)},r(e,t)}:r,delete e[t]}));var t=ng(eg),n=function(e){var t={};return Object.keys(tg).forEach((function(n){t[n]=function(t,r){var i=tg[n],s=e[n],a=s&&t&&!Oe()(r)?s(t,{entering:r}):{};return o(o({},a),i)}})),t}(eg);return{nodeTypeConvertors:t,markTypeConvertors:n}}var og=function(){function e(e){var t=e.nodeTypeConvertors,n=e.markTypeConvertors;this.nodeTypeConvertors=t,this.markTypeConvertors=n,this.delim="",this.result="",this.closed=!1,this.tightList=!1,this.stopNewline=!1,this.inTable=!1}return e.prototype.getMarkConvertor=function(e){var t=e.attrs.htmlInline?"html":e.type.name;return this.markTypeConvertors[t]},e.prototype.isInBlank=function(){return/(^|\n)$/.test(this.result)},e.prototype.markText=function(e,t,n,r){var o=this.getMarkConvertor(e);if(o){var i=o({node:e,parent:n,index:r},t),s=i.delim;return i.rawHTML||s}return""},e.prototype.setDelim=function(e){this.delim=e},e.prototype.getDelim=function(){return this.delim},e.prototype.flushClose=function(e){if(!this.stopNewline&&this.closed){if(this.isInBlank()||(this.result+="\n"),e||(e=2),e>1){var t=this.delim,n=/\s+$/.exec(t);n&&(t=t.slice(0,t.length-n[0].length));for(var r=1;r<e;r+=1)this.result+=t+"\n"}this.closed=!1}},e.prototype.wrapBlock=function(e,t,n,r){var o=this.getDelim();this.write(t||e),this.setDelim(this.getDelim()+e),r(),this.setDelim(o),this.closeBlock(n)},e.prototype.ensureNewLine=function(){this.isInBlank()||(this.result+="\n")},e.prototype.write=function(e){void 0===e&&(e=""),this.flushClose(),this.delim&&this.isInBlank()&&(this.result+=this.delim),e&&(this.result+=e)},e.prototype.closeBlock=function(e){this.closed=e},e.prototype.text=function(e,t){void 0===t&&(t=!0);for(var n=e.split("\n"),r=0;r<n.length;r+=1)this.write(),this.result+=t?Xe(n[r]):n[r],r!==n.length-1&&(this.result+="\n")},e.prototype.convertBlock=function(e,t,n){var r=e.type.name,o=this.nodeTypeConvertors[r],i={node:e,parent:t,index:n};e.attrs.htmlBlock?this.nodeTypeConvertors.html(this,i):o&&o(this,i)},e.prototype.convertInline=function(e){var t=this,n=[],r="",o=function(o,i,s){var a=o?o.marks:[],l=r;r="";var c=o&&o.isText&&a.some((function(e){var n=t.getMarkConvertor(e),r=n&&n();return r&&r.removedEnclosingWhitespace}));if(c&&o&&o.text){var u=/^(\s*)(.*?)(\s*)$/m.exec(o.text),d=u[1],p=u[2],h=u[3];l+=d,r=h,(d||h)&&((o=p?o.withText(p):null)||(a=n))}for(var f=a.length&&et(a),m=f&&t.getMarkConvertor(f),g=m&&m(),v=g&&!1===g.escape,y=a.length-(v?1:0),b=0;b<y;b+=1){p=a[b];if(g&&!g.mixable)break;for(var w=0;w<n.length;w+=1){var k=n[w];if(g&&!g.mixable)break;if(p.eq(k)){b>w?a=a.slice(0,w).concat(p).concat(a.slice(w,b)).concat(a.slice(b+1,y)):w>b&&(a=a.slice(0,b).concat(a.slice(b+1,w)).concat(p).concat(a.slice(w,y)));break}}}for(var x=0;x<Math.min(n.length,y)&&a[x].eq(n[x]);)x+=1;for(;x<n.length;){var C=n.pop();C&&t.text(t.markText(C,!1,e,s),!1)}if(l&&t.text(l),o){for(;n.length<y;){p=a[n.length];n.push(p),t.text(t.markText(p,!0,e,s),!1)}v&&o.isText?t.text(t.markText(f,!0,e,s)+o.text+t.markText(f,!1,e,s+1),!1):t.convertBlock(o,e,s)}};e.forEach(o),o(null,0,e.childCount)},e.prototype.convertList=function(e,t,n){var r,o=this;this.closed&&this.closed.type===e.type?this.flushClose(3):this.tightList&&this.flushClose(1);var i=null===(r=e.attrs.tight)||void 0===r||r,s=this.tightList;this.tightList=i,e.forEach((function(r,s,a){a&&i&&o.flushClose(1),o.wrapBlock(t,n(a),e,(function(){return o.convertBlock(r,e,a)}))})),this.tightList=s},e.prototype.convertTableCell=function(e){var t=this;this.stopNewline=!0,this.inTable=!0,e.forEach((function(n,r,o){Ue(["bulletList","orderedList"],n.type.name)?(t.convertBlock(n,e,o),t.closed=!1):(t.convertInline(n),o<e.childCount-1&&"paragraph"===e.child(o+1).type.name&&t.write("<br>"))})),this.stopNewline=!1,this.inTable=!1},e.prototype.convertNode=function(e,t){var n=this;return e.forEach((function(r,o,i){if(n.convertBlock(r,e,i),(null==t?void 0:t.node)===r){var s=n.result.split("\n");t.setMappedPos([s.length,et(s).length+1])}})),this.result},e}(),ig=og,sg=function(){function e(e,t,n,r){var i=this;this.setMappedPos=function(e){i.mappedPosWhenConverting=e},this.schema=e,this.eventEmitter=r,this.focusedNode=null,this.mappedPosWhenConverting=null,this.toWwConvertors=function(e){var t=Object.keys(e),n=o({},Wm),r=new Xp({gfm:!0,nodeId:!0,convertors:e}).getConvertors();return t.forEach((function(t){var o=Wm[t];o&&!Ue(["htmlBlock","htmlInline"],t)&&(n[t]=function(n,i,s){s.origin=function(){return r[t](i,s,r)};var a,l=e[t](i,s);if(l){var c=Array.isArray(l)?l[0]:l;a={htmlAttrs:c.attributes,classNames:c.classNames}}o(n,i,s,a)})})),n}(n),this.toMdConvertors=rg(t||{}),this.eventEmitter.listen("setFocusedNode",(function(e){return i.focusedNode=e}))}return e.prototype.getMappedPos=function(){return this.mappedPosWhenConverting},e.prototype.getInfoForPosSync=function(){return{node:this.focusedNode,setMappedPos:this.setMappedPos}},e.prototype.toWysiwygModel=function(e){return new Gm(this.schema,this.toWwConvertors).convertNode(e,this.getInfoForPosSync())},e.prototype.toMarkdownText=function(e){var t=new ig(this.toMdConvertors).convertNode(e,this.getInfoForPosSync());return t=this.eventEmitter.emitReduce("beforeConvertWysiwygToMarkdown",t)},e}(),ag=sg;function lg(e){var t=e.plugins,n=e.eventEmitter,r=e.usageStatistics,i=e.instance;return n.listen("mixinTableOffsetMapPrototype",_h),(null!=t?t:[]).reduce((function(e,t){var s=function(e){var t=e.plugin,n={eventEmitter:e.eventEmitter,usageStatistics:e.usageStatistics,instance:e.instance,pmState:{Plugin:an,PluginKey:un,Selection:Vt,TextSelection:Ut},pmView:{Decoration:Vo,DecorationSet:_o},pmModel:{Fragment:d},pmRules:{InputRule:ns,inputRules:rs,undoInputRule:ss},pmKeymap:{keymap:Ai},i18n:hf};if(aa()(t)){var r=t[0],o=t[1];return r(n,void 0===o?{}:o)}return t(n)}({plugin:t,eventEmitter:n,usageStatistics:r,instance:i});if(!s)throw new Error("The return value of the executed plugin is empty.");var a=s.markdownParsers,l=s.toHTMLRenderers,c=s.toMarkdownRenderers,u=s.markdownPlugins,p=s.wysiwygPlugins,h=s.wysiwygNodeViews,f=s.markdownCommands,m=s.wysiwygCommands,g=s.toolbarItems;return l&&(e.toHTMLRenderers=nt(e.toHTMLRenderers,l)),c&&(e.toMarkdownRenderers=nt(e.toMarkdownRenderers,c)),u&&(e.mdPlugins=e.mdPlugins.concat(u)),p&&(e.wwPlugins=e.wwPlugins.concat(p)),h&&(e.wwNodeViews=o(o({},e.wwNodeViews),h)),f&&(e.mdCommands=o(o({},e.mdCommands),f)),m&&(e.wwCommands=o(o({},e.wwCommands),m)),g&&(e.toolbarItems=e.toolbarItems.concat(g)),a&&(e.markdownParsers=o(o({},e.markdownParsers),a)),e}),{toHTMLRenderers:{},toMarkdownRenderers:{},mdPlugins:[],wwPlugins:[],wwNodeViews:{},mdCommands:{},wwCommands:{},toolbarItems:[],markdownParsers:{}})}var cg=function(){function e(e){var t=this;this.options=ve()({linkAttributes:null,extendedAutolinks:!1,customHTMLRenderer:null,referenceDefinition:!1,customHTMLSanitizer:null,frontMatter:!1,usageStatistics:!0,theme:"light"},e),this.eventEmitter=new Im;var n,r=Ge(this.options.linkAttributes),i=lg({plugins:this.options.plugins,eventEmitter:this.eventEmitter,usageStatistics:this.options.usageStatistics,instance:this})||{},s=i.toHTMLRenderers,a=i.markdownParsers,l=this.options,c=l.customHTMLRenderer,u=l.extendedAutolinks,d=l.referenceDefinition,p=l.frontMatter,h=l.customHTMLSanitizer,f={linkAttributes:r,customHTMLRenderer:o(o({},s),c),extendedAutolinks:u,referenceDefinition:d,frontMatter:p,sanitizer:h||rh};n=f.customHTMLRenderer,["htmlBlock","htmlInline"].forEach((function(e){n[e]&&Object.keys(n[e]).forEach((function(e){return nh(e)}))})),this.options.events&&me()(this.options.events,(function(e,n){t.on(n,e)}));var m=this.options,g=m.el,v=m.initialValue,y=m.theme,b=g.innerHTML;"light"!==y&&g.classList.add(xa(y)),g.innerHTML="",this.toastMark=new _p("",{disallowedHtmlBlockTags:["br","img"],extendedAutolinks:u,referenceDefinition:d,disallowDeepHeading:!0,frontMatter:p,customParser:a}),this.preview=new Mh(this.eventEmitter,o(o({},f),{isViewer:!0})),Vc()(this.preview.previewContent,"mousedown",this.toggleTask.bind(this)),v?this.setMarkdown(v):b&&this.preview.setHTML(b),g.appendChild(this.preview.previewContent),this.eventEmitter.emit("load",this)}return e.prototype.toggleTask=function(e){var t=e.target,n=getComputedStyle(t,":before");!t.hasAttribute("data-task-disabled")&&t.hasAttribute("data-task")&&wa(n,e.offsetX,e.offsetY)&&(Sa(t,"checked"),this.eventEmitter.emit("change",{source:"viewer",date:e}))},e.prototype.setMarkdown=function(e){var t=this.toastMark.getLineTexts(),n=[t.length,et(t).length+1],r=this.toastMark.editMarkdown([1,1],n,e||"");this.eventEmitter.emit("updatePreview",r)},e.prototype.on=function(e,t){this.eventEmitter.listen(e,t)},e.prototype.off=function(e){this.eventEmitter.removeEventHandler(e)},e.prototype.addHook=function(e,t){this.eventEmitter.removeEventHandler(e),this.eventEmitter.listen(e,t)},e.prototype.destroy=function(){zc()(this.preview.el,"mousedown",this.toggleTask.bind(this)),this.preview.destroy(),this.eventEmitter.emit("destroy")},e.prototype.isViewer=function(){return!0},e.prototype.isMarkdownMode=function(){return!1},e.prototype.isWysiwygMode=function(){return!1},e}(),ug=cg;function dg(e){return e instanceof P}function pg(e){return Ue(["document","blockQuote","bulletList","orderedList","listItem","paragraph","heading","emph","strong","strike","link","image","table","tableHead","tableBody","tableRow","tableHeadCell","tableBodyCell"],e)}var hg={openTag:function(e,t){var n=e,r=n.tagName,i=n.classNames,s=n.attributes,a=document.createElement(r),l={};i&&(a.className=i.join(" ")),s&&(l=o(o({},l),s)),Aa(l,a),t.push(a)},closeTag:function(e,t){if(t.length>1){var n=t.pop();et(t).appendChild(n)}},html:function(e,t){et(t).insertAdjacentHTML("beforeend",e.content)},text:function(e,t){var n=document.createTextNode(e.content);et(t).appendChild(n)}},fg=function(){function e(e,t){var n=dh(e,t),r=o(o({},t.htmlBlock),t.htmlInline);this.customConvertorKeys=Object.keys(t).concat(Object.keys(r)),this.renderer=new Xp({gfm:!0,convertors:o(o({},n),r)}),this.convertors=this.renderer.getConvertors()}return e.prototype.generateTokens=function(e){var t=function(e){var t=e.attrs,n=e.type.name,r={type:n,wysiwygNode:!0,literal:!pg(n)&&dg(e)?e.textContent:null},i={heading:{level:t.level},link:{destination:t.linkUrl,title:t.title},image:{destination:t.imageUrl},codeBlock:{info:t.language},bulletList:{type:"list",listData:{type:"bullet"}},orderedList:{type:"list",listData:{type:"ordered",start:t.order}},listItem:{type:"item",listData:{task:t.task,checked:t.checked}},tableHeadCell:{type:"tableCell",cellType:"head",align:t.align},tableBodyCell:{type:"tableCell",cellType:"body",align:t.align},customBlock:{info:t.info}}[n],s=o(o({},r),i),a=e.attrs,l=a.htmlAttrs,c=a.childrenHTML;return l?o(o({},s),{attrs:l,childrenHTML:c}):s}(e),n={entering:!0,leaf:!!dg(e)&&e.isLeaf,options:this.renderer.getOptions(),getChildrenText:function(){return dg(e)?e.textContent:""},skipChildren:function(){return!1}},r=this.convertors[e.type.name],i=r(t,n,this.convertors),s=aa()(i)?i:[i];return(pg(e.type.name)||e.attrs.htmlInline)&&(n.entering=!1,s.push({type:"text",content:dg(e)?e.textContent:""}),s=s.concat(r(t,n,this.convertors))),s},e.prototype.toDOMNode=function(e){var t=this.generateTokens(e),n=[];return t.forEach((function(e){return hg[e.type](e,n)})),n[0]},e.prototype.getToDOMNode=function(e){return Ue(this.customConvertorKeys,e)?this.toDOMNode.bind(this):null},e}(),mg=null,gg=null;function vg(e,t){var n=t.syncScrollTop,r=t.releaseEventBlock;gg&&clearTimeout(gg),n(e),gg=setTimeout((function(){r()}),15)}var yg=function(){function e(e,t,n){this.latestEditorScrollTop=null,this.latestPreviewScrollTop=null,this.blockedScroll=null,this.active=!0,this.timer=null;var r=t.previewContent,o=t.el;this.previewRoot=r,this.previewEl=o,this.mdEditor=e,this.editorView=e.view,this.toastMark=e.getToastMark(),this.eventEmitter=n,this.addScrollSyncEvent()}return e.prototype.addScrollSyncEvent=function(){var e=this;this.eventEmitter.listen("afterPreviewRender",(function(){e.clearTimer(),e.timer=setTimeout((function(){e.syncPreviewScrollTop(!0)}),200)})),this.eventEmitter.listen("scroll",(function(t,n){e.active&&("editor"===t&&"editor"!==e.blockedScroll?e.syncPreviewScrollTop():"preview"===t&&"preview"!==e.blockedScroll&&e.syncEditorScrollTop(n))})),this.eventEmitter.listen("toggleScrollSync",(function(t){e.active=t}))},e.prototype.getMdNodeAtPos=function(e,t){var n=e.content.findIndex(t.pos).index;return this.toastMark.findFirstNodeAtLine(n+1)},e.prototype.getScrollTopByCaretPos=function(){var e=this.mdEditor.getSelection(),t=this.toastMark.findFirstNodeAtLine(e[0][0]),n=this.previewEl.clientHeight,r=bh(this.previewRoot,t).el,o=(vh(r,this.previewRoot)||r.offsetTop)+r.clientHeight-.5*n;return this.latestEditorScrollTop=null,r.getBoundingClientRect().top-this.previewEl.getBoundingClientRect().top<n?null:o},e.prototype.syncPreviewScrollTop=function(e){void 0===e&&(e=!1);var t=this,n=t.editorView,r=t.previewEl,o=t.previewRoot,i=n.dom.getBoundingClientRect(),s=i.left,a=i.top,l=n.posAtCoords({left:s,top:a}),c=n.state.doc,u=this.getMdNodeAtPos(c,l);if(u&&!function(e){var t=e.type;return"htmlBlock"===t||"htmlInline"===t}(u)){var d=r.scrollTop,p=n.dom,h=p.scrollTop,f=p.scrollHeight,m=p.clientHeight,g=p.children,v=f-h<=m+18,y=v?r.scrollHeight:0;if(h&&!v){if(e){var b=this.getScrollTopByCaretPos();if(!b)return;y=b}else{var w=bh(this.previewRoot,u),k=w.el,x=mh(c,w.mdNode,g),C=x.height,T=x.rect;y=(vh(k,o)||k.offsetTop)+k.clientHeight*(a>T.top?Math.min((a-T.top)/C,1):0)}y=this.getResolvedScrollTop("editor",h,y,d),this.latestEditorScrollTop=h}y!==d&&this.run("editor",y,d)}},e.prototype.syncEditorScrollTop=function(e){var t=this,n=t.toastMark,r=t.editorView,o=t.previewRoot,i=t.previewEl,s=r.dom,a=r.state,l=i.scrollTop,c=i.clientHeight,u=i.scrollHeight-l<=c,d=s.scrollTop,p=u?s.scrollHeight:0;if(l&&e&&!u){if(e=function(e,t){for(;!e.getAttribute("data-nodeid")&&e.parentElement!==t;)e=e.parentElement;return e}(e,o),!e.getAttribute("data-nodeid"))return;var h=s.children,f=Number(e.getAttribute("data-nodeid")),m=bh(this.previewRoot,n.findNodeById(f)),g=m.mdNode,v=m.el;p=h[Is(g)-1].offsetTop;var y=mh(a.doc,g,h).height,b=xh(v,o,f),w=b.nodeHeight;p+=function(e,t,n,r){return Math.min((e-t)/n,1)*r}(l,b.offsetTop,w,y),p=this.getResolvedScrollTop("preview",l,p,d),this.latestPreviewScrollTop=l}p!==d&&this.run("preview",p,d)},e.prototype.getResolvedScrollTop=function(e,t,n,r){var o="editor"===e?this.latestEditorScrollTop:this.latestPreviewScrollTop;return null===o?n:o<t?Math.max(n,r):Math.min(n,r)},e.prototype.run=function(e,t,n){var r,o=this;"editor"===e?(r=this.previewEl,this.blockedScroll="preview"):(r=this.editorView.dom,this.blockedScroll="editor"),function(e,t,n){var r=t-e,o=Date.now(),i=function(){var s,a=(Date.now()-o)/100;mg&&clearTimeout(mg),a<1?(s=e+r*Math.cos((1-a)*Math.PI/2),vg(Math.ceil(s),n),mg=setTimeout(i,1)):(vg(t,n),mg=null)};i()}(n,t,{syncScrollTop:function(e){return r.scrollTop=e},releaseEventBlock:function(){return o.blockedScroll=null}})},e.prototype.clearTimer=function(){this.timer&&(clearTimeout(this.timer),this.timer=null)},e.prototype.destroy=function(){this.clearTimer(),this.eventEmitter.removeEventHandler("scroll"),this.eventEmitter.removeEventHandler("afterPreviewRender")},e}(),bg={getPopupInitialValues:function(e,t){return"link"===t.popupName?{linkText:e.getSelectedText()}:{}}};var wg=function(){function e(e){var t=this;this.initialHTML=e.el.innerHTML,e.el.innerHTML="",this.options=ve()({previewStyle:"tab",previewHighlight:!0,initialEditType:"markdown",height:"300px",minHeight:"200px",language:"en-US",useCommandShortcut:!0,usageStatistics:!0,toolbarItems:[["heading","bold","italic","strike"],["hr","quote"],["ul","ol","task","indent","outdent"],["table","image","link"],["code","codeblock"],["scrollSync"]],hideModeSwitch:!1,linkAttributes:null,extendedAutolinks:!1,customHTMLRenderer:null,customMarkdownRenderer:null,referenceDefinition:!1,customHTMLSanitizer:null,frontMatter:!1,widgetRules:[],theme:"light",autofocus:!0},e);var n=this.options,r=n.customHTMLRenderer,i=n.extendedAutolinks,s=n.referenceDefinition,a=n.frontMatter,l=n.customMarkdownRenderer,c=n.useCommandShortcut,u=n.initialEditType,d=n.widgetRules,p=n.customHTMLSanitizer;this.mode=u||"markdown",this.mdPreviewStyle=this.options.previewStyle,this.i18n=hf,this.i18n.setCode(this.options.language),this.eventEmitter=new Im,ta(d);var h=Ge(this.options.linkAttributes);this.pluginInfo=lg({plugins:this.options.plugins,eventEmitter:this.eventEmitter,usageStatistics:this.options.usageStatistics,instance:this});var f=this.pluginInfo,m=f.toHTMLRenderers,g=f.toMarkdownRenderers,v=f.mdPlugins,y=f.wwPlugins,b=f.wwNodeViews,w=f.mdCommands,k=f.wwCommands,x=f.markdownParsers,C={linkAttributes:h,customHTMLRenderer:nt(m,r),extendedAutolinks:i,referenceDefinition:s,frontMatter:a,sanitizer:p||rh},T=new fg(h,C.customHTMLRenderer),M=function(e,t,n){var r={nodes:{},marks:{}};return["htmlBlock","htmlInline"].forEach((function(o){e[o]&&Object.keys(e[o]).forEach((function(e){var i="htmlBlock"===o?"nodes":"marks";nh(e),r[i][e]=lh[o](e,t,n)}))})),r}(C.customHTMLRenderer,C.sanitizer,T);this.toastMark=new _p("",{disallowedHtmlBlockTags:["br","img"],extendedAutolinks:i,referenceDefinition:s,disallowDeepHeading:!0,frontMatter:a,customParser:x}),this.mdEditor=new Fc(this.eventEmitter,{toastMark:this.toastMark,useCommandShortcut:c,mdPlugins:v}),this.preview=new Mh(this.eventEmitter,o(o({},C),{isViewer:!1,highlight:this.options.previewHighlight})),this.wwEditor=new Nm(this.eventEmitter,{toDOMAdaptor:T,useCommandShortcut:c,htmlSchemaMap:M,linkAttributes:h,wwPlugins:y,wwNodeViews:b}),this.convertor=new ag(this.wwEditor.getSchema(),o(o({},g),l),dh(h,C.customHTMLRenderer),this.eventEmitter),this.setMinHeight(this.options.minHeight),this.setHeight(this.options.height),this.setMarkdown(this.options.initialValue,!1),this.options.placeholder&&this.setPlaceholder(this.options.placeholder),this.options.initialValue||this.setHTML(this.initialHTML,!1),this.commandManager=new Pm(this.eventEmitter,this.mdEditor.commands,this.wwEditor.commands,(function(){return t.mode})),this.options.usageStatistics&&Ie()("editor","UA-129966929-1"),this.scrollSync=new yg(this.mdEditor,this.preview,this.eventEmitter),this.addInitEvent(),this.addInitCommand(w,k),function(e){e.eventEmitter.listen("query",(function(t,n){return bg[t](e,n)}))}(this),this.options.hooks&&me()(this.options.hooks,(function(e,n){return t.addHook(n,e)})),this.options.events&&me()(this.options.events,(function(e,n){return t.on(n,e)})),this.eventEmitter.emit("load",this),this.moveCursorToStart(this.options.autofocus)}return e.prototype.addInitEvent=function(){var e=this;this.on("needChangeMode",this.changeMode.bind(this)),this.on("loadUI",(function(){if("auto"!==e.height){var t=Math.min(parseInt(e.minHeight,10),parseInt(e.height,10)-75)+"px";e.setMinHeight(t)}})),function(e){e.listen("addImageBlobHook",(function(e,t){var n=new FileReader;n.onload=function(e){var n=e.target;return t(n.result)},n.readAsDataURL(e)}))}(this.eventEmitter)},e.prototype.addInitCommand=function(e,t){var n=this,r=function(e,t){Object.keys(t).forEach((function(r){n.addCommand(e,r,t[r])}))};this.addCommand("markdown","toggleScrollSync",(function(e){return n.eventEmitter.emit("toggleScrollSync",e.active),!0})),r("markdown",e),r("wysiwyg",t)},e.prototype.getCurrentModeEditor=function(){return this.isMarkdownMode()?this.mdEditor:this.wwEditor},e.factory=function(t){return t.viewer?new ug(t):new e(t)},e.setLanguage=function(e,t){hf.setLanguage(e,t)},e.prototype.changePreviewStyle=function(e){this.mdPreviewStyle!==e&&(this.mdPreviewStyle=e,this.eventEmitter.emit("changePreviewStyle",e))},e.prototype.exec=function(e,t){this.commandManager.exec(e,t)},e.prototype.addCommand=function(e,t,n){var r=this;this.commandManager.addCommand(e,t,(function(t){void 0===t&&(t={});var o=("markdown"===e?r.mdEditor:r.wwEditor).view;n(t,o.state,o.dispatch,o)}))},e.prototype.on=function(e,t){this.eventEmitter.listen(e,t)},e.prototype.off=function(e){this.eventEmitter.removeEventHandler(e)},e.prototype.addHook=function(e,t){this.eventEmitter.removeEventHandler(e),this.eventEmitter.listen(e,t)},e.prototype.removeHook=function(e){this.eventEmitter.removeEventHandler(e)},e.prototype.focus=function(){this.getCurrentModeEditor().focus()},e.prototype.blur=function(){this.getCurrentModeEditor().blur()},e.prototype.moveCursorToEnd=function(e){void 0===e&&(e=!0),this.getCurrentModeEditor().moveCursorToEnd(e)},e.prototype.moveCursorToStart=function(e){void 0===e&&(e=!0),this.getCurrentModeEditor().moveCursorToStart(e)},e.prototype.setMarkdown=function(e,t){if(void 0===e&&(e=""),void 0===t&&(t=!0),this.mdEditor.setMarkdown(e,t),this.isWysiwygMode()){var n=this.toastMark.getRootNode(),r=this.convertor.toWysiwygModel(n);this.wwEditor.setModel(r,t)}},e.prototype.setHTML=function(e,t){void 0===e&&(e=""),void 0===t&&(t=!0);var n=document.createElement("div");n.innerHTML=function(e){var t=e.replace(/<p><br\s*\/*><\/p>/gi,"<p></p>"),n=new RegExp(ma,"ig"),r=t.match(n);return null==r||r.forEach((function(e,n){if(va.test(e)){var o=ba;if(n){var i=r[n-1].match(fa);if(i&&!/br/i.test(i[1])){var s=i[1];o="</"+s+"><"+s+">"}}t=t.replace(va,o)}})),t}(e);var r=te.fromSchema(this.wwEditor.schema).parse(n);this.isMarkdownMode()?this.mdEditor.setMarkdown(this.convertor.toMarkdownText(r),t):this.wwEditor.setModel(r,t)},e.prototype.getMarkdown=function(){return this.isMarkdownMode()?this.mdEditor.getMarkdown():this.convertor.toMarkdownText(this.wwEditor.getModel())},e.prototype.getHTML=function(){var e=this;this.eventEmitter.holdEventInvoke((function(){if(e.isMarkdownMode()){var t=e.toastMark.getRootNode(),n=e.convertor.toWysiwygModel(t);e.wwEditor.setModel(n)}}));var t=La(this.wwEditor.view.dom.innerHTML);if(this.placeholder){var n=new RegExp('<span class="placeholder[^>]+>'+this.placeholder+"</span>","i");return t.replace(n,"")}return t},e.prototype.insertText=function(e){this.getCurrentModeEditor().replaceSelection(e)},e.prototype.setSelection=function(e,t){this.getCurrentModeEditor().setSelection(e,t)},e.prototype.replaceSelection=function(e,t,n){this.getCurrentModeEditor().replaceSelection(e,t,n)},e.prototype.deleteSelection=function(e,t){this.getCurrentModeEditor().deleteSelection(e,t)},e.prototype.getSelectedText=function(e,t){return this.getCurrentModeEditor().getSelectedText(e,t)},e.prototype.getRangeInfoOfNode=function(e){return this.getCurrentModeEditor().getRangeInfoOfNode(e)},e.prototype.addWidget=function(e,t,n){this.getCurrentModeEditor().addWidget(e,t,n)},e.prototype.replaceWithWidget=function(e,t,n){this.getCurrentModeEditor().replaceWithWidget(e,t,n)},e.prototype.setHeight=function(e){var t=this.options.el;Me()(e)&&("auto"===e?ke()(t,"auto-height"):Ce()(t,"auto-height"),this.setMinHeight(this.getMinHeight())),be()(t,{height:e}),this.height=e},e.prototype.getHeight=function(){return this.height},e.prototype.setMinHeight=function(e){if(e!==this.minHeight){var t=this.height||this.options.height;"auto"!==t&&this.options.el.querySelector("."+xa("main"))&&(e=Math.min(parseInt(e,10),parseInt(t,10)-75)+"px");var n=parseInt(e,10);this.minHeight=e,this.wwEditor.setMinHeight(n),this.mdEditor.setMinHeight(n),this.preview.setMinHeight(n)}},e.prototype.getMinHeight=function(){return this.minHeight},e.prototype.isMarkdownMode=function(){return"markdown"===this.mode},e.prototype.isWysiwygMode=function(){return"wysiwyg"===this.mode},e.prototype.isViewer=function(){return!1},e.prototype.getCurrentPreviewStyle=function(){return this.mdPreviewStyle},e.prototype.changeMode=function(e,t){if(this.mode!==e){if(this.mode=e,this.isWysiwygMode()){var n=this.toastMark.getRootNode(),r=this.convertor.toWysiwygModel(n);this.wwEditor.setModel(r)}else{r=this.wwEditor.getModel();this.mdEditor.setMarkdown(this.convertor.toMarkdownText(r),!t)}if(this.eventEmitter.emit("removePopupWidget"),this.eventEmitter.emit("changeMode",e),!t){var o=this.convertor.getMappedPos();this.focus(),this.isWysiwygMode()&&Ee()(o)?this.wwEditor.setSelection(o):Array.isArray(o)&&this.mdEditor.setSelection(o)}}},e.prototype.destroy=function(){var e=this;this.wwEditor.destroy(),this.mdEditor.destroy(),this.preview.destroy(),this.scrollSync.destroy(),this.eventEmitter.emit("destroy"),this.eventEmitter.getEvents().forEach((function(t,n){return e.off(n)}))},e.prototype.hide=function(){this.eventEmitter.emit("hide")},e.prototype.show=function(){this.eventEmitter.emit("show")},e.prototype.setScrollTop=function(e){this.getCurrentModeEditor().setScrollTop(e)},e.prototype.getScrollTop=function(){return this.getCurrentModeEditor().getScrollTop()},e.prototype.reset=function(){this.wwEditor.setModel([]),this.mdEditor.setMarkdown("")},e.prototype.getSelection=function(){return this.getCurrentModeEditor().getSelection()},e.prototype.setPlaceholder=function(e){this.placeholder=e,this.mdEditor.setPlaceholder(e),this.wwEditor.setPlaceholder(e)},e.prototype.getEditorElements=function(){return{mdEditor:this.mdEditor.getElement(),mdPreview:this.preview.getElement(),wwEditor:this.wwEditor.getElement()}},e.prototype.convertPosToMatchEditorMode=function(e,t,n){var r,o;void 0===t&&(t=e),void 0===n&&(n=this.mode);var i=this.mdEditor.view.state.doc,s=Array.isArray(e),a=Array.isArray(t),l=e,c=t;if(s!==a)throw new Error("Types of arguments must be same");return"markdown"!==n||s||a?"wysiwyg"===n&&s&&a&&(l=(o=ol(i,e,t))[0],c=o[1]):(l=(r=nl(i,e,t))[0],c=r[1]),[l,c]},e}(),kg=wg;var xg=n(326),Cg=n.n(xg),Tg=function(){function e(e){this.current=e,this.root=e,this.entering=!0}return e.prototype.walk=function(){var e=this.entering,t=this.current;return t?(e?t.firstChild?(this.current=t.firstChild,this.entering=!0):this.entering=!1:t===this.root?this.current=null:t.next?(this.current=t.next,this.entering=!0):(this.current=t.parent,this.entering=!1),{vnode:t,entering:e}):null},e}(),Mg=function(){function e(e,t,n){this.parent=null,this.old=null,this.firstChild=null,this.next=null,this.skip=!1,this.type=e,this.props=t,this.children=n,this.props.children=n,t.ref&&(this.ref=t.ref,delete t.ref),t.key&&(this.key=t.key,delete t.key)}return e.prototype.walker=function(){return new Tg(this)},e.removalNodes=[],e}();function Sg(e,t){var n,r=e;Cg()(e)||null==e?r=null:(Me()(e)||Ee()(e))&&(n=String(e),r=new Mg("TEXT_NODE",{nodeValue:n},[])),r&&t.push(r)}var Eg=function(e){for(var t,n,r=arguments,o=1,i="",s="",a=[0],l=function(e){1===o&&(e||(i=i.replace(/^\s*\n\s*|\s*\n\s*$/g,"")))?a.push(e?r[e]:i):3===o&&(e||i)?(a[1]=e?r[e]:i,o=2):2===o&&"..."===i&&e?a[2]=it(a[2]||{},r[e]):2===o&&i&&!e?(a[2]=a[2]||{})[i]=!0:o>=5&&(5===o?((a[2]=a[2]||{})[n]=e?i?i+r[e]:r[e]:i,o=6):(e||i)&&(a[2][n]+=e?i+r[e]:i)),i=""},c=0;c<e.length;c++){c&&(1===o&&l(),l(c));for(var u=0;u<e[c].length;u++)t=e[c][u],1===o?"<"===t?(l(),a=[a,"",null],o=3):i+=t:4===o?"--"===i&&">"===t?(o=1,i=""):i=t+i[0]:s?t===s?s="":i+=t:'"'===t||"'"===t?s=t:">"===t?(l(),o=1):o&&("="===t?(o=5,n=i,i=""):"/"===t&&(o<5||">"===e[c][u+1])?(l(),3===o&&(a=a[0]),o=a,(a=a[0]).push(this.apply(null,o.slice(1))),o=0):" "===t||"\t"===t||"\n"===t||"\r"===t?(l(),o=2):i+=t),3===o&&"!--"===i&&(o=4,a=a[0])}return l(),a.length>2?a.slice(1):a[1]}.bind((function(e,t){for(var n=[],r=2;r<arguments.length;r++)n[r-2]=arguments[r];var o=[];return n.forEach((function(e){Array.isArray(e)?e.forEach((function(e){Sg(e,o)})):Sg(e,o)})),new Mg(e,t||{},o)})),Ng=n(73),Og=n.n(Ng);function Dg(e){var t;return"TEXT_NODE"===e.type?t=document.createTextNode(e.props.nodeValue):Rg(t=document.createElement(e.type),{},e.props),t}function Ag(e,t){e.node?t.removeChild(e.node):Ag(e.firstChild,t)}function Lg(e,t,n){Object.keys(t).forEach((function(r){if(/^on/.test(r)){if(!n[r]||t[r]!==n[r]){var o=r.slice(2).toLowerCase();e.removeEventListener(o,t[r])}}else"children"===r||n[r]||function(e){return(null==e?void 0:e.nodeType)===Node.TEXT_NODE}(e)||e.removeAttribute(r)})),Rg(e,t,n,(function(e){return!Ye(t[e],n[e])}))}var Ig=/acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;function Rg(e,t,n,r){Object.keys(n).forEach((function(o){if(!r||r(o))if(/^on/.test(o)){var i=o.slice(2).toLowerCase();e.addEventListener(i,n[o])}else"nodeValue"===o?e[o]=n[o]:"style"===o&&Og()(n[o])?function(e,t,n){t&&Object.keys(t).forEach((function(t){e.style[t]=""}));Object.keys(n).forEach((function(t){var r=n[t];e.style[t]=Ee()(r)&&!Ig.test(t)?r+"px":r}))}(e,t[o],n[o]):"children"!==o&&(!1===n[o]?e.removeAttribute(o):e.setAttribute(o,n[o]))}))}function Pg(e){if(Mg.removalNodes.forEach((function(e){return Fg(e)})),e)for(var t=void 0,n=e.walker();t=n.walk();)if(e=t.vnode,t.entering)Fg(e);else if(Ga()(e.type)){var r=e.component;if(!e.old&&r.mounted&&r.mounted(),e.old&&r.updated){var o=r.prevProps||{};r.updated(o)}}}function Bg(e){for(var t=e.parent;!t.node;)t=t.parent;return t.node}function Fg(e){if(e&&e.parent){if(e.node){var t=Bg(e);"A"===e.effect?t.appendChild(e.node):"U"===e.effect&&Lg(e.node,e.old.props,e.props)}if("D"===e.effect)for(var n=void 0,r=e.walker();n=r.walk();)if(e=n.vnode,!n.entering)if(Ga()(e.type)){var o=e.component;o.beforeDestroy&&o.beforeDestroy()}else{Ag(e,t=Bg(e))}e.ref&&(e.component?e.ref(e.component):e.node&&e.ref(e.node))}}function Hg(e,t){var n=t.props,r=t.component;return r?(r.prevProps=r.props,r.props=t.props,r):new e(n)}function zg(e){for(var t=e;e&&!e.skip;){if(Ga()(e.type)){var n=Hg(e.type,e);n.vnode=e,e.component=n,e.props.children=e.children=[n.render()],qg(e)}else e.node||(e.node=Dg(e)),qg(e);if(e.firstChild)e=e.firstChild;else{for(;e&&e.parent&&!e.next&&(e=e.parent)!==t;);e=e.next}}}function qg(e){var t=e.children,n=e.old?e.old.firstChild:null,r=null;t.forEach((function(t,o){var i=function(e,t){return e&&t&&t.type===e.type&&(!t.key||t.key===e.key)}(n,t);i&&(t.old=n,t.parent=e,t.node=n.node,t.component=n.component,t.effect="U"),t&&!i&&(t.old=null,t.parent=e,t.node=null,t.effect="A"),n&&!i&&(Mg.removalNodes.push(n),n.effect="D"),n&&(n=n.next),0===o?e.firstChild=t:t&&(r.next=t),r=t}));var o=et(t);if(!t.length)for(;n;)Mg.removalNodes.push(n),n.effect="D",n=n.next;for(;n&&o;)n&&o.old!==n&&(Mg.removalNodes.push(n),n.effect="D",n=n.next)}function Vg(e,t){var n=new Mg(e.tagName.toLowerCase(),{},[t]);return n.node=e,Mg.removalNodes=[],zg(n),Pg(n),function(){return function(e){e.effect="D",Mg.removalNodes=[e],Pg(),Mg.removalNodes=[]}(n.firstChild)}}var jg,$g=function(){function e(e){this.props=e,this.state={},this.refs={}}return e.prototype.setState=function(e){var t=o(o({},this.state),e);Ye(this.state,t)||(this.state=t,function(e){var t=e.vnode;t.effect="U",t.old=t,t.next&&(t.next.skip=!0),Mg.removalNodes=[],zg(t),Pg(t),t.next&&(t.next.skip=!1)}(this))},e}(),_g=function(e){function n(t){var n=e.call(this,t)||this;return n.state={hide:!1},n}return t(n,e),n.prototype.show=function(){this.setState({hide:!1})},n.prototype.hide=function(){this.setState({hide:!0})},n.prototype.render=function(){var e=this.props,t=e.editorType,n=e.eventEmitter;return Eg(jg||(jg=s(['\n      <div class="','" style="display: ','">\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ",'\n        </div>\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ","\n        </div>\n      </div>\n    "],['\n      <div class="','" style="display: ','">\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ",'\n        </div>\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ","\n        </div>\n      </div>\n    "])),xa("mode-switch"),this.state.hide?"none":"block","markdown"===t?" active":"",(function(){n.emit("needChangeMode","markdown")}),hf.get("Markdown"),"wysiwyg"===t?" active":"",(function(){n.emit("needChangeMode","wysiwyg")}),hf.get("WYSIWYG"))},n}($g),Ug=n(423),Wg=n.n(Ug),Jg=function(){if("undefined"!=typeof Map)return Map;function e(e,t){var n=-1;return e.some((function(e,r){return e[0]===t&&(n=r,!0)})),n}return function(){function t(){this.__entries__=[]}return Object.defineProperty(t.prototype,"size",{get:function(){return this.__entries__.length},enumerable:!0,configurable:!0}),t.prototype.get=function(t){var n=e(this.__entries__,t),r=this.__entries__[n];return r&&r[1]},t.prototype.set=function(t,n){var r=e(this.__entries__,t);~r?this.__entries__[r][1]=n:this.__entries__.push([t,n])},t.prototype.delete=function(t){var n=this.__entries__,r=e(n,t);~r&&n.splice(r,1)},t.prototype.has=function(t){return!!~e(this.__entries__,t)},t.prototype.clear=function(){this.__entries__.splice(0)},t.prototype.forEach=function(e,t){void 0===t&&(t=null);for(var n=0,r=this.__entries__;n<r.length;n++){var o=r[n];e.call(t,o[1],o[0])}},t}()}(),Gg="undefined"!=typeof window&&"undefined"!=typeof document&&window.document===document,Kg=void 0!==n.g&&n.g.Math===Math?n.g:"undefined"!=typeof self&&self.Math===Math?self:"undefined"!=typeof window&&window.Math===Math?window:Function("return this")(),Zg="function"==typeof requestAnimationFrame?requestAnimationFrame.bind(Kg):function(e){return setTimeout((function(){return e(Date.now())}),1e3/60)};var Xg=["top","right","bottom","left","width","height","size","weight"],Qg="undefined"!=typeof MutationObserver,Yg=function(){function e(){this.connected_=!1,this.mutationEventsAdded_=!1,this.mutationsObserver_=null,this.observers_=[],this.onTransitionEnd_=this.onTransitionEnd_.bind(this),this.refresh=function(e,t){var n=!1,r=!1,o=0;function i(){n&&(n=!1,e()),r&&a()}function s(){Zg(i)}function a(){var e=Date.now();if(n){if(e-o<2)return;r=!0}else n=!0,r=!1,setTimeout(s,t);o=e}return a}(this.refresh.bind(this),20)}return e.prototype.addObserver=function(e){~this.observers_.indexOf(e)||this.observers_.push(e),this.connected_||this.connect_()},e.prototype.removeObserver=function(e){var t=this.observers_,n=t.indexOf(e);~n&&t.splice(n,1),!t.length&&this.connected_&&this.disconnect_()},e.prototype.refresh=function(){this.updateObservers_()&&this.refresh()},e.prototype.updateObservers_=function(){var e=this.observers_.filter((function(e){return e.gatherActive(),e.hasActive()}));return e.forEach((function(e){return e.broadcastActive()})),e.length>0},e.prototype.connect_=function(){Gg&&!this.connected_&&(document.addEventListener("transitionend",this.onTransitionEnd_),window.addEventListener("resize",this.refresh),Qg?(this.mutationsObserver_=new MutationObserver(this.refresh),this.mutationsObserver_.observe(document,{attributes:!0,childList:!0,characterData:!0,subtree:!0})):(document.addEventListener("DOMSubtreeModified",this.refresh),this.mutationEventsAdded_=!0),this.connected_=!0)},e.prototype.disconnect_=function(){Gg&&this.connected_&&(document.removeEventListener("transitionend",this.onTransitionEnd_),window.removeEventListener("resize",this.refresh),this.mutationsObserver_&&this.mutationsObserver_.disconnect(),this.mutationEventsAdded_&&document.removeEventListener("DOMSubtreeModified",this.refresh),this.mutationsObserver_=null,this.mutationEventsAdded_=!1,this.connected_=!1)},e.prototype.onTransitionEnd_=function(e){var t=e.propertyName,n=void 0===t?"":t;Xg.some((function(e){return!!~n.indexOf(e)}))&&this.refresh()},e.getInstance=function(){return this.instance_||(this.instance_=new e),this.instance_},e.instance_=null,e}(),ev=function(e,t){for(var n=0,r=Object.keys(t);n<r.length;n++){var o=r[n];Object.defineProperty(e,o,{value:t[o],enumerable:!1,writable:!1,configurable:!0})}return e},tv=function(e){return e&&e.ownerDocument&&e.ownerDocument.defaultView||Kg},nv=lv(0,0,0,0);function rv(e){return parseFloat(e)||0}function ov(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];return t.reduce((function(t,n){return t+rv(e["border-"+n+"-width"])}),0)}function iv(e){var t=e.clientWidth,n=e.clientHeight;if(!t&&!n)return nv;var r=tv(e).getComputedStyle(e),o=function(e){for(var t={},n=0,r=["top","right","bottom","left"];n<r.length;n++){var o=r[n],i=e["padding-"+o];t[o]=rv(i)}return t}(r),i=o.left+o.right,s=o.top+o.bottom,a=rv(r.width),l=rv(r.height);if("border-box"===r.boxSizing&&(Math.round(a+i)!==t&&(a-=ov(r,"left","right")+i),Math.round(l+s)!==n&&(l-=ov(r,"top","bottom")+s)),!function(e){return e===tv(e).document.documentElement}(e)){var c=Math.round(a+i)-t,u=Math.round(l+s)-n;1!==Math.abs(c)&&(a-=c),1!==Math.abs(u)&&(l-=u)}return lv(o.left,o.top,a,l)}var sv="undefined"!=typeof SVGGraphicsElement?function(e){return e instanceof tv(e).SVGGraphicsElement}:function(e){return e instanceof tv(e).SVGElement&&"function"==typeof e.getBBox};function av(e){return Gg?sv(e)?function(e){var t=e.getBBox();return lv(0,0,t.width,t.height)}(e):iv(e):nv}function lv(e,t,n,r){return{x:e,y:t,width:n,height:r}}var cv=function(){function e(e){this.broadcastWidth=0,this.broadcastHeight=0,this.contentRect_=lv(0,0,0,0),this.target=e}return e.prototype.isActive=function(){var e=av(this.target);return this.contentRect_=e,e.width!==this.broadcastWidth||e.height!==this.broadcastHeight},e.prototype.broadcastRect=function(){var e=this.contentRect_;return this.broadcastWidth=e.width,this.broadcastHeight=e.height,e},e}(),uv=function(e,t){var n=function(e){var t=e.x,n=e.y,r=e.width,o=e.height,i="undefined"!=typeof DOMRectReadOnly?DOMRectReadOnly:Object,s=Object.create(i.prototype);return ev(s,{x:t,y:n,width:r,height:o,top:n,right:t+r,bottom:o+n,left:t}),s}(t);ev(this,{target:e,contentRect:n})},dv=function(){function e(e,t,n){if(this.activeObservations_=[],this.observations_=new Jg,"function"!=typeof e)throw new TypeError("The callback provided as parameter 1 is not a function.");this.callback_=e,this.controller_=t,this.callbackCtx_=n}return e.prototype.observe=function(e){if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");if("undefined"!=typeof Element&&Element instanceof Object){if(!(e instanceof tv(e).Element))throw new TypeError('parameter 1 is not of type "Element".');var t=this.observations_;t.has(e)||(t.set(e,new cv(e)),this.controller_.addObserver(this),this.controller_.refresh())}},e.prototype.unobserve=function(e){if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");if("undefined"!=typeof Element&&Element instanceof Object){if(!(e instanceof tv(e).Element))throw new TypeError('parameter 1 is not of type "Element".');var t=this.observations_;t.has(e)&&(t.delete(e),t.size||this.controller_.removeObserver(this))}},e.prototype.disconnect=function(){this.clearActive(),this.observations_.clear(),this.controller_.removeObserver(this)},e.prototype.gatherActive=function(){var e=this;this.clearActive(),this.observations_.forEach((function(t){t.isActive()&&e.activeObservations_.push(t)}))},e.prototype.broadcastActive=function(){if(this.hasActive()){var e=this.callbackCtx_,t=this.activeObservations_.map((function(e){return new uv(e.target,e.broadcastRect())}));this.callback_.call(e,t,e),this.clearActive()}},e.prototype.clearActive=function(){this.activeObservations_.splice(0)},e.prototype.hasActive=function(){return this.activeObservations_.length>0},e}(),pv="undefined"!=typeof WeakMap?new WeakMap:new Jg,hv=function e(t){if(!(this instanceof e))throw new TypeError("Cannot call a class as a function.");if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");var n=Yg.getInstance(),r=new dv(t,n,this);pv.set(this,r)};["observe","unobserve","disconnect"].forEach((function(e){hv.prototype[e]=function(){var t;return(t=pv.get(this))[e].apply(t,arguments)}}));var fv,mv,gv,vv,yv,bv,wv,kv,xv,Cv,Tv,Mv,Sv,Ev,Nv,Ov,Dv=void 0!==Kg.ResizeObserver?Kg.ResizeObserver:hv,Av=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.execCommand=function(e){var t=Oa(e.target,"li");this.props.execCommand("heading",{level:Number(t.getAttribute("data-level"))})},n.prototype.render=function(){var e=this;return Eg(mv||(mv=s(["\n      <ul\n        onClick=",'\n        aria-role="menu"\n        aria-label="','"\n      >\n        ','\n        <li data-type="Paragraph" aria-role="menuitem">\n          <div>',"</div>\n        </li>\n      </ul>\n    "],["\n      <ul\n        onClick=",'\n        aria-role="menu"\n        aria-label="','"\n      >\n        ','\n        <li data-type="Paragraph" aria-role="menuitem">\n          <div>',"</div>\n        </li>\n      </ul>\n    "])),(function(t){return e.execCommand(t)}),hf.get("Headings"),[1,2,3,4,5,6].map((function(e){return Eg(fv||(fv=s(['\n              <li data-level="','" data-type="Heading" aria-role="menuitem">\n                <',">"," ","</$>\n              </li>\n            "],['\n              <li data-level="','" data-type="Heading" aria-role="menuitem">\n                <',">"," ","</$>\n              </li>\n            "])),e,"h"+e,hf.get("Heading"),e)})),hf.get("Paragraph"))},n}($g),Lv=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.toggleTab=function(e,t){this.props.onClick(e,t)},n.prototype.render=function(){var e=this;return Eg(vv||(vv=s(['\n      <div class="','" aria-role="tabpanel">\n        ',"\n      </div>\n    "],['\n      <div class="','" aria-role="tabpanel">\n        ',"\n      </div>\n    "])),xa("tabs"),this.props.tabs.map((function(t){var n=t.name,r=t.text,o=e.props.activeTab===n;return Eg(gv||(gv=s(['\n            <div\n              class="tab-item','"\n              onClick=','\n              aria-role="tab"\n              aria-label="','"\n              aria-selected="','"\n              tabindex="','"\n            >\n              ',"\n            </div>\n          "],['\n            <div\n              class="tab-item','"\n              onClick=','\n              aria-role="tab"\n              aria-label="','"\n              aria-selected="','"\n              tabindex="','"\n            >\n              ',"\n            </div>\n          "])),o?" active":"",(function(t){return e.toggleTab(t,n)}),hf.get(r),o?"true":"false",o?"0":"-1",hf.get(r))})))},n}($g),Iv=function(e){function n(t){var n=e.call(this,t)||this;return n.initialize=function(e){void 0===e&&(e="file");var t=n.refs.url;t.value="",n.refs.altText.value="",n.refs.file.value="",Ce()(t,"wrong"),n.setState({activeTab:e,file:null,fileNameElClassName:""})},n.execCommand=function(){"file"===n.state.activeTab?n.emitAddImageBlob():n.emitAddImage()},n.toggleTab=function(e,t){t!==n.state.activeTab&&n.initialize(t)},n.showFileSelectBox=function(){n.refs.file.click()},n.changeFile=function(e){var t=e.target.files;(null==t?void 0:t.length)&&n.setState({file:t[0]})},n.state={activeTab:"file",file:null,fileNameElClassName:""},n.tabs=[{name:"file",text:"File"},{name:"url",text:"URL"}],n}return t(n,e),n.prototype.emitAddImageBlob=function(){var e=this,t=this.refs.file.files,n=this.refs.altText,r=" wrong";if(null==t?void 0:t.length){r="";var o=t.item(0);this.props.eventEmitter.emit("addImageBlobHook",o,(function(t,r){return e.props.execCommand("addImage",{imageUrl:t,altText:r||n.value})}),"ui")}this.setState({fileNameElClassName:r})},n.prototype.emitAddImage=function(){var e=this.refs.url,t=this.refs.altText,n=e.value,r=t.value||"image";Ce()(e,"wrong"),n.length?n&&this.props.execCommand("addImage",{imageUrl:n,altText:r}):ke()(e,"wrong")},n.prototype.preventSelectStart=function(e){e.preventDefault()},n.prototype.updated=function(){this.props.show||this.initialize()},n.prototype.render=function(){var e=this,t=this.state,n=t.activeTab,r=t.file,o=t.fileNameElClassName;return Eg(yv||(yv=s(['\n      <div aria-label="','">\n        <'," tabs="," activeTab="," onClick=",' />\n        <div style="display:','">\n          <label for="toastuiImageUrlInput">','</label>\n          <input\n            id="toastuiImageUrlInput"\n            type="text"\n            ref=','\n          />\n        </div>\n        <div style="display:',';position: relative;">\n          <label for="toastuiImageFileInput">','</label>\n          <span\n            class="',"",'"\n            onClick=',"\n            onSelectstart=","\n          >\n            ",'\n          </span>\n          <button\n            type="button"\n            class="','"\n            onClick=',"\n          >\n            ",'\n          </button>\n          <input\n            id="toastuiImageFileInput"\n            type="file"\n            accept="image/*"\n            onChange=',"\n            ref=",'\n          />\n        </div>\n        <label for="toastuiAltTextInput">','</label>\n        <input\n          id="toastuiAltTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "],['\n      <div aria-label="','">\n        <'," tabs="," activeTab="," onClick=",' />\n        <div style="display:','">\n          <label for="toastuiImageUrlInput">','</label>\n          <input\n            id="toastuiImageUrlInput"\n            type="text"\n            ref=','\n          />\n        </div>\n        <div style="display:',';position: relative;">\n          <label for="toastuiImageFileInput">','</label>\n          <span\n            class="',"",'"\n            onClick=',"\n            onSelectstart=","\n          >\n            ",'\n          </span>\n          <button\n            type="button"\n            class="','"\n            onClick=',"\n          >\n            ",'\n          </button>\n          <input\n            id="toastuiImageFileInput"\n            type="file"\n            accept="image/*"\n            onChange=',"\n            ref=",'\n          />\n        </div>\n        <label for="toastuiAltTextInput">','</label>\n        <input\n          id="toastuiAltTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "])),hf.get("Insert image"),Lv,this.tabs,n,this.toggleTab,"url"===n?"block":"none",hf.get("Image URL"),(function(t){return e.refs.url=t}),"file"===n?"block":"none",hf.get("Select image file"),xa("file-name"),r?" has-file":o,this.showFileSelectBox,this.preventSelectStart,r?r.name:hf.get("No file"),xa("file-select-button"),this.showFileSelectBox,hf.get("Choose a file"),this.changeFile,(function(t){return e.refs.file=t}),hf.get("Description"),(function(t){return e.refs.altText=t}),xa("button-container"),xa("close-button"),this.props.hidePopup,hf.get("Cancel"),xa("ok-button"),this.execCommand,hf.get("OK"))},n}($g),Rv=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.execCommand=function(){var e=t.refs.url,n=t.refs.text;(Ce()(e,"wrong"),Ce()(n,"wrong"),e.value.length<1)?ke()(e,"wrong"):Oe()(t.props.initialValues.linkUrl)&&n.value.length<1?ke()(n,"wrong"):t.props.execCommand("addLink",{linkUrl:e.value,linkText:n.value})},t}return t(n,e),n.prototype.initialize=function(){var e=this.props.initialValues,t=e.linkUrl,n=e.linkText,r=this.refs.url,o=this.refs.text;Ce()(r,"wrong"),Ce()(o,"wrong","disabled"),o.removeAttribute("disabled"),t&&(ke()(o,"disabled"),o.setAttribute("disabled","disabled")),r.value=t||"",o.value=n||""},n.prototype.mounted=function(){this.initialize()},n.prototype.updated=function(e){!e.show&&this.props.show&&this.initialize()},n.prototype.render=function(){var e=this;return Eg(bv||(bv=s(['\n      <div aria-label="','">\n        <label for="toastuiLinkUrlInput">','</label>\n        <input\n          id="toastuiLinkUrlInput"\n          type="text"\n          ref=','\n        />\n        <label for="toastuiLinkTextInput">','</label>\n        <input\n          id="toastuiLinkTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "],['\n      <div aria-label="','">\n        <label for="toastuiLinkUrlInput">','</label>\n        <input\n          id="toastuiLinkUrlInput"\n          type="text"\n          ref=','\n        />\n        <label for="toastuiLinkTextInput">','</label>\n        <input\n          id="toastuiLinkTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "])),hf.get("Insert link"),hf.get("URL"),(function(t){return e.refs.url=t}),hf.get("Link text"),(function(t){return e.refs.text=t}),xa("button-container"),xa("close-button"),this.props.hidePopup,hf.get("Cancel"),xa("ok-button"),this.execCommand,hf.get("OK"))},n}($g),Pv=function(e){function n(t){var n=e.call(this,t)||this;return n.extendSelectionRange=function(e){var t=e.pageX,r=e.pageY,i=t-n.offsetRect.left,s=r-n.offsetRect.top,a=n.getSelectionRangeByOffset(i,s);n.setState(o({},a))},n.execCommand=function(){n.props.execCommand("addTable",{rowCount:n.state.rowIdx+1,columnCount:n.state.colIdx+1})},n.state={rowIdx:-1,colIdx:-1},n}return t(n,e),n.prototype.getDescription=function(){return-1===this.state.colIdx?"":this.state.colIdx+1+" x "+(this.state.rowIdx+1)},n.prototype.getBoundByRange=function(e,t){return{width:20*(e+1),height:20*(t+1)}},n.prototype.getRangeByOffset=function(e,t){return{colIdx:Math.floor(e/20),rowIdx:Math.floor(t/20)}},n.prototype.getTableRange=function(){var e=this.state,t=e.colIdx,n=e.rowIdx,r=Math.max(t,5),o=Math.max(n,5);return t>=5&&r<9&&(r+=1),n>=5&&o<14&&(o+=1),{colIdx:r+1,rowIdx:o+1}},n.prototype.getSelectionAreaBound=function(){var e=this.getBoundByRange(this.state.colIdx,this.state.rowIdx),t=e.width,n=e.height;return t||n?{width:t-1,height:n-1,display:"block"}:{display:"none"}},n.prototype.getSelectionRangeByOffset=function(e,t){var n=this.getRangeByOffset(e,t);return n.rowIdx=Math.min(Math.max(n.rowIdx,1),14),n.colIdx=Math.min(Math.max(n.colIdx,1),9),n},n.prototype.updated=function(){if(this.props.show){if(-1===this.state.colIdx&&-1===this.state.rowIdx){var e=this.refs.tableEl.getBoundingClientRect(),t=e.left,n=e.top;this.offsetRect={left:window.pageXOffset+t,top:window.pageYOffset+n}}}else this.setState({colIdx:-1,rowIdx:-1})},n.prototype.createTableArea=function(e){for(var t=e.colIdx,n=e.rowIdx,r=[],o=0;o<n;o+=1){for(var i=[],a=0;a<t;a+=1){var l=xa("table-cell")+(o>0?"":" header");i.push(Eg(wv||(wv=s(['<div class="','"></div>'],['<div class="','"></div>'])),l))}r.push(Eg(kv||(kv=s(['<div class="','">',"</div>"],['<div class="','">',"</div>"])),xa("table-row"),i))}return Eg(xv||(xv=s(['<div class="','">',"</div>"],['<div class="','">',"</div>"])),xa("table"),r)},n.prototype.render=function(){var e=this,t=this.getTableRange(),n=this.getSelectionAreaBound();return Eg(Cv||(Cv=s(['\n      <div aria-label="','">\n        <div\n          class="','"\n          ref=',"\n          onMousemove=","\n          onClick=","\n        >\n          ",'\n          <div class="','" style=','></div>\n        </div>\n        <p class="','">',"</p>\n      </div>\n    "],['\n      <div aria-label="','">\n        <div\n          class="','"\n          ref=',"\n          onMousemove=","\n          onClick=","\n        >\n          ",'\n          <div class="','" style=','></div>\n        </div>\n        <p class="','">',"</p>\n      </div>\n    "])),hf.get("Insert table"),xa("table-selection"),(function(t){return e.refs.tableEl=t}),this.extendSelectionRange,this.execCommand,this.createTableArea(t),xa("table-selection-layer"),n,xa("table-description"),this.getDescription())},n}($g),Bv=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.mounted=function(){this.refs.el.appendChild(this.props.body)},n.prototype.updated=function(e){this.refs.el.replaceChild(this.props.body,e.body)},n.prototype.render=function(){var e=this;return Eg(Tv||(Tv=s(["<div ref=","></div>"],["<div ref=","></div>"])),(function(t){return e.refs.el=t}))},n}($g);function Fv(e){return Me()(e)?function(e){var t;switch(e){case"heading":t={name:"heading",className:"heading",tooltip:hf.get("Headings"),state:"heading"};break;case"bold":t={name:"bold",className:"bold",command:"bold",tooltip:hf.get("Bold"),state:"strong"};break;case"italic":t={name:"italic",className:"italic",command:"italic",tooltip:hf.get("Italic"),state:"emph"};break;case"strike":t={name:"strike",className:"strike",command:"strike",tooltip:hf.get("Strike"),state:"strike"};break;case"hr":t={name:"hr",className:"hrline",command:"hr",tooltip:hf.get("Line"),state:"thematicBreak"};break;case"quote":t={name:"quote",className:"quote",command:"blockQuote",tooltip:hf.get("Blockquote"),state:"blockQuote"};break;case"ul":t={name:"ul",className:"bullet-list",command:"bulletList",tooltip:hf.get("Unordered list"),state:"bulletList"};break;case"ol":t={name:"ol",className:"ordered-list",command:"orderedList",tooltip:hf.get("Ordered list"),state:"orderedList"};break;case"task":t={name:"task",className:"task-list",command:"taskList",tooltip:hf.get("Task"),state:"taskList"};break;case"table":t={name:"table",className:"table",tooltip:hf.get("Insert table"),state:"table"};break;case"image":t={name:"image",className:"image",tooltip:hf.get("Insert image")};break;case"link":t={name:"link",className:"link",tooltip:hf.get("Insert link")};break;case"code":t={name:"code",className:"code",command:"code",tooltip:hf.get("Code"),state:"code"};break;case"codeblock":t={name:"codeblock",className:"codeblock",command:"codeBlock",tooltip:hf.get("Insert CodeBlock"),state:"codeBlock"};break;case"indent":t={name:"indent",className:"indent",command:"indent",tooltip:hf.get("Indent"),state:"indent"};break;case"outdent":t={name:"outdent",className:"outdent",command:"outdent",tooltip:hf.get("Outdent"),state:"outdent"};break;case"scrollSync":t=function(){var e=document.createElement("label"),t=document.createElement("input"),n=document.createElement("span");e.className="scroll-sync active",t.type="checkbox",t.checked=!0,n.className="switch";var r=function(n){return t.addEventListener("change",(function(t){var r=t.target.checked;r?ke()(e,"active"):Ce()(e,"active"),n("toggleScrollSync",{active:r})}))};return e.appendChild(t),e.appendChild(n),{name:"scrollSync",el:e,onMounted:r}}();break;case"more":t={name:"more",className:"more",tooltip:hf.get("More")}}"scrollSync"!==t.name&&(t.className+=" "+xa("toolbar-icons"));return t}(e):e}function Hv(e,t){var n=t.el,r=t.pos,i=t.popup,a=t.initialValues;switch(e){case"heading":return{render:function(e){return Eg(Mv||(Mv=s(["<"," ..."," />"],["<"," ..."," />"])),Av,e)},className:xa("popup-add-heading"),fromEl:n,pos:r};case"link":return{render:function(e){return Eg(Sv||(Sv=s(["<"," ..."," />"],["<"," ..."," />"])),Rv,e)},className:xa("popup-add-link"),fromEl:n,pos:r,initialValues:a};case"image":return{render:function(e){return Eg(Ev||(Ev=s(["<"," ..."," />"],["<"," ..."," />"])),Iv,e)},className:xa("popup-add-image"),fromEl:n,pos:r};case"table":return{render:function(e){return Eg(Nv||(Nv=s(["<"," ..."," />"],["<"," ..."," />"])),Pv,e)},className:xa("popup-add-table"),fromEl:n,pos:r};case"customPopupBody":return i?o({render:function(e){return Eg(Ov||(Ov=s(["<"," ..."," body="," />"],["<"," ..."," body="," />"])),Bv,e,i.body)},fromEl:n,pos:r},i):null;default:return null}}function zv(e){e.hidden=e.length===e.filter((function(e){return e.hidden})).length}function qv(e,t){return e.reduce((function(e,n){e.push(n.map((function(e){return function(e){return e.hidden="scrollSync"===e.name&&t,e}(Fv(e))})));var r=e[(e.length||1)-1];return r&&zv(r),e}),[])}var Vv,jv,$v=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.handleMousedown=function(e){Oa(e.target,"."+xa("popup"))||Oa(e.target,t.props.info.fromEl)||t.props.hidePopup()},t}return t(n,e),n.prototype.mounted=function(){document.addEventListener("mousedown",this.handleMousedown),this.props.eventEmitter.listen("closePopup",this.props.hidePopup)},n.prototype.beforeDestroy=function(){document.removeEventListener("mousedown",this.handleMousedown)},n.prototype.updated=function(e){var t=this.props,n=t.show,r=t.info;if(n&&r.pos&&e.show!==n){var i=o({},r.pos),s=this.refs.el.offsetWidth,a=Oa(this.refs.el,"."+xa("toolbar")).offsetWidth;i.left+s>=a&&(i.left=a-s-20),Ye(this.state.popupPos,i)||this.setState({popupPos:i})}},n.prototype.render=function(){var e=this,t=this.props,n=t.info,r=t.show,i=t.hidePopup,a=t.eventEmitter,l=t.execCommand,c=n||{},u=c.className,d=void 0===u?"":u,p=c.style,h=c.render,f=c.initialValues,m=void 0===f?{}:f,g=o(o({display:r?"block":"none"},p),this.state.popupPos);return Eg(Vv||(Vv=s(['\n      <div\n        class="'," ",'"\n        style=',"\n        ref=",'\n        aria-role="dialog"\n      >\n        <div class="','">\n          ',"\n        </div>\n      </div>\n    "],['\n      <div\n        class="'," ",'"\n        style=',"\n        ref=",'\n        aria-role="dialog"\n      >\n        <div class="','">\n          ',"\n        </div>\n      </div>\n    "])),xa("popup"),d,g,(function(t){return e.refs.el=t}),xa("popup-body"),h&&h({eventEmitter:a,show:r,hidePopup:i,execCommand:l,initialValues:m}))},n}($g);function _v(e){return function(n){function r(e){var t=n.call(this,e)||this;return t.showTooltip=function(e){var n=t.props.item.tooltip;if(!t.props.disabled&&n){var r=t.getBound(e),o=r.left+6+"px",i=r.top+6+"px";be()(t.props.tooltipRef.current,{display:"block",left:o,top:i}),t.props.tooltipRef.current.querySelector(".text").textContent=n}},t.hideTooltip=function(){be()(t.props.tooltipRef.current,"display","none")},t.state={active:!1,disabled:e.disabled},t.addEvent(),t}return t(r,n),r.prototype.addEvent=function(){var e=this,t=this.props,n=t.item,r=t.eventEmitter;n.state&&r.listen("changeToolbarState",(function(t){var r,o=null!==(r=t.toolbarState[n.state])&&void 0!==r?r:{},i=o.active,s=o.disabled;e.setState({active:!!i,disabled:null!=s?s:e.props.disabled})}))},r.prototype.getBound=function(e){var t=Da(e,Oa(e,"."+xa("toolbar"))),n=t.offsetLeft,r=t.offsetTop;return{left:n,top:e.offsetHeight+r}},r.prototype.render=function(){return Eg(jv||(jv=s(["\n        <","\n          ...","\n          active=","\n          showTooltip=","\n          hideTooltip=","\n          getBound=","\n          disabled=","\n        />\n      "],["\n        <","\n          ...","\n          active=","\n          showTooltip=","\n          hideTooltip=","\n          getBound=","\n          disabled=","\n        />\n      "])),e,this.props,this.state.active,this.showTooltip,this.hideTooltip,this.getBound,this.state.disabled||this.props.disabled)},r}($g)}var Uv,Wv,Jv,Gv,Kv,Zv,Xv,Qv,Yv,ey,ty,ny,ry,oy,iy=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.showTooltip=function(){t.props.showTooltip(t.refs.el)},t.execCommand=function(){var e=t.props,n=e.item,r=e.execCommand,o=e.setPopupInfo,i=e.getBound,s=e.eventEmitter,a=n.command,l=n.name,c=n.popup;if(a)r(a);else{var u=c?"customPopupBody":l,d=s.emit("query","getPopupInitialValues",{popupName:u})[0],p=Hv(u,{el:t.refs.el,pos:i(t.refs.el),popup:c,initialValues:d});p&&o(p)}},t}return t(n,e),n.prototype.mounted=function(){this.setItemWidth()},n.prototype.updated=function(e){e.item.name!==this.props.item.name&&this.setItemWidth()},n.prototype.setItemWidth=function(){var e=this.props,t=e.setItemWidth,n=e.item;t&&t(n.name,Na(this.refs.el)+(n.hidden?80:0))},n.prototype.render=function(){var e=this,t=this.props,n=t.hideTooltip,r=t.disabled,i=t.item,a=t.active,l=o({display:i.hidden?"none":null},i.style),c=(i.className||"")+(a?" active":"");return Eg(Uv||(Uv=s(["\n      <button\n        ref=",'\n        type="button"\n        style=',"\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n        disabled=","\n        aria-label=","\n      >\n        ","\n      </button>\n    "],["\n      <button\n        ref=",'\n        type="button"\n        style=',"\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n        disabled=","\n        aria-label=","\n      >\n        ","\n      </button>\n    "])),(function(t){return e.refs.el=t}),l,c,this.execCommand,this.showTooltip,n,!!r,i.text||i.tooltip||"",i.text||"")},n}($g),sy=_v(iy),ay=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.showTooltip=function(){t.props.showTooltip(t.refs.el)},t.showPopup=function(){var e=Hv("customPopupBody",{el:t.refs.el,pos:t.props.getBound(t.refs.el),popup:t.props.item.popup});e&&t.props.setPopupInfo(e)},t}return t(n,e),n.prototype.mounted=function(){var e=this.props,t=e.setItemWidth,n=e.item;this.refs.el.appendChild(n.el),t&&t(n.name,Na(this.refs.el)),n.onMounted&&n.onMounted(this.props.execCommand)},n.prototype.updated=function(e){var t,n=this.props,r=n.item,o=n.active,i=n.disabled;e.active===o&&e.disabled===i||null===(t=r.onUpdated)||void 0===t||t.call(r,{active:o,disabled:i})},n.prototype.render=function(){var e=this,t=this.props,n=t.disabled,r={display:t.item.hidden?"none":"inline-block"},o=function(e){return n?null:e};return Eg(Wv||(Wv=s(["\n      <div\n        ref=","\n        style=","\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n      ></div>\n    "],["\n      <div\n        ref=","\n        style=","\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n      ></div>\n    "])),(function(t){return e.refs.el=t}),r,xa("toolbar-item-wrapper"),o(this.showPopup),o(this.showTooltip),o(this.props.hideTooltip))},n}($g),ly=_v(ay),cy=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.render=function(){var e=this,t=this.props,n=t.group,r=t.hiddenDivider,o=n.hidden?{display:"none"}:null,i=r?{display:"none"}:null;return Eg(Gv||(Gv=s(['\n      <div class="','" style=',">\n        ",'\n        <div class="','" style=',"></div>\n      </div>\n    "],['\n      <div class="','" style=',">\n        ",'\n        <div class="','" style=',"></div>\n      </div>\n    "])),xa("toolbar-group"),o,n.map((function(t){var n=t.el?ly:sy;return Eg(Jv||(Jv=s(["<"," key="," ..."," item="," />"],["<"," key="," ..."," item="," />"])),n,t.name,e.props,t)})),xa("toolbar-divider"),i)},n}($g),uy=function(e){function n(t){var n=e.call(this,t)||this;return n.handleClickDocument=function(e){var t=e.target;Oa(t,"."+xa("dropdown-toolbar"))||Oa(t,".more")||n.setState({showDropdown:!1,dropdownPos:null})},n.showTooltip=function(){n.props.showTooltip(n.refs.el)},n.state={showDropdown:!1,dropdownPos:null},n}return t(n,e),n.prototype.getBound=function(){var e=this.props.getBound(this.refs.el);return e.top+=4,o(o({},e),{left:null,right:10})},n.prototype.mounted=function(){document.addEventListener("click",this.handleClickDocument)},n.prototype.updated=function(){this.state.showDropdown&&!this.state.dropdownPos&&this.setState({dropdownPos:this.getBound()})},n.prototype.beforeDestroy=function(){document.removeEventListener("click",this.handleClickDocument)},n.prototype.render=function(){var e=this,t=this.state,n=t.showDropdown,r=t.dropdownPos,i=this.props,a=i.disabled,l=i.item,c=i.items,u=i.hideTooltip,d=c.filter((function(e){return!e.hidden})),p=d.length?null:{display:"none"},h=n?null:{display:"none"};return Eg(Zv||(Zv=s(['\n      <div class="','" style=',">\n        <button\n          ref=",'\n          type="button"\n          class=',"\n          onClick=","\n          onMouseover=","\n          onMouseout=","\n          disabled=",'\n        ></button>\n        <div\n          class="','"\n          style=',"\n          ref=","\n        >\n          ","\n        </div>\n      </div>\n    "],['\n      <div class="','" style=',">\n        <button\n          ref=",'\n          type="button"\n          class=',"\n          onClick=","\n          onMouseover=","\n          onMouseout=","\n          disabled=",'\n        ></button>\n        <div\n          class="','"\n          style=',"\n          ref=","\n        >\n          ","\n        </div>\n      </div>\n    "])),xa("toolbar-group"),p,(function(t){return e.refs.el=t}),l.className,(function(){return e.setState({showDropdown:!0})}),this.showTooltip,u,a,xa("dropdown-toolbar"),o(o({},h),r),(function(t){return e.refs.dropdownEl=t}),d.length?d.map((function(t,n){var r;return Eg(Kv||(Kv=s(["\n                  <","\n                    group=","\n                    hiddenDivider=","\n                    ...","\n                  />\n                "],["\n                  <","\n                    group=","\n                    hiddenDivider=","\n                    ...","\n                  />\n                "])),cy,t,n===d.length-1||(null===(r=d[n+1])||void 0===r?void 0:r.hidden),e.props)})):null)},n}($g),dy=_v(uy),py=function(e){function n(t){var n=e.call(this,t)||this;return n.toggleTab=function(e,t){var r=n.props.eventEmitter;if(n.state.activeTab!==t){var o="write"===t?"changePreviewTabWrite":"changePreviewTabPreview";r.emit(o),n.setState({activeTab:t})}},n.setItemWidth=function(e,t){n.itemWidthMap[e]=t},n.setPopupInfo=function(e){n.setState({showPopup:!0,popupInfo:e})},n.openPopup=function(e,t){void 0===t&&(t={});var r=n.refs.el.querySelector("."+xa("toolbar-group")+" ."+e);if(r){var o=Da(r,Oa(r,"."+xa("toolbar"))),i=o.offsetLeft,s=o.offsetTop,a=Hv(e,{el:r,pos:{left:i,top:r.offsetHeight+s},initialValues:t});a&&n.setPopupInfo(a)}},n.hidePopup=function(){n.state.showPopup&&n.setState({showPopup:!1})},n.execCommand=function(e,t){n.props.eventEmitter.emit("command",e,t),n.hidePopup()},n.tabs=[{name:"write",text:"Write"},{name:"preview",text:"Preview"}],n.itemWidthMap={},n.initialItems=qv(t.toolbarItems||[],n.hiddenScrollSync()),n.state={items:n.initialItems,dropdownItems:[],showPopup:!1,popupInfo:{},activeTab:"write"},n.tooltipRef={current:null},n.resizeObserver=new Dv((function(){return n.handleResize()})),n.addEvent(),n}return t(n,e),n.prototype.insertToolbarItem=function(e,t){var n=e.groupIndex,r=e.itemIndex,o=this.initialItems[n];t=Fv(t),o?o.splice(r,0,t):this.initialItems.push([t]),this.setState(this.classifyToolbarItems())},n.prototype.removeToolbarItem=function(e){var t=this;Fa()(this.initialItems,(function(n){var r=!1;return Fa()(n,(function(o,i){return o.name!==e||(r=!0,n.splice(i,1),t.setState(t.classifyToolbarItems()),!1)})),!r}))},n.prototype.addEvent=function(){var e=this,t=this.props.eventEmitter;this.handleResize=Wg()((function(){e.setState({items:e.initialItems,dropdownItems:[]}),e.setState(e.classifyToolbarItems())}),200),t.listen("openPopup",this.openPopup)},n.prototype.appendTooltipToRoot=function(){var e='<div class="'+xa("tooltip")+'" style="display:none">\n        <div class="arrow"></div>\n        <span class="text"></span>\n      </div>';this.tooltipRef.current=Ea(e,this.refs.el)},n.prototype.hiddenScrollSync=function(){return"wysiwyg"===this.props.editorType||"tab"===this.props.previewStyle},n.prototype.movePrevItemToDropdownToolbar=function(e,t,n,r){var o=function(e){var t=e.pop();t&&r.push(t)};if(e>1)o(n);else{var i=et(t);i&&o(i)}},n.prototype.classifyToolbarItems=function(){var e=this,t=0,n=this.refs.el.clientWidth,r=this.refs.el.querySelector("."+xa("toolbar-divider")),o=r?Na(r):0,i=[],s=[],a=!1;return this.initialItems.forEach((function(r,l){var c=[],u=[];r.forEach((function(r,o){r.hidden||((t+=e.itemWidthMap[r.name])>n-50?(a||(e.movePrevItemToDropdownToolbar(o,i,c,u),a=!0),u.push(r)):c.push(r))})),c.length&&(zv(c),i.push(c)),u.length&&(zv(u),s.push(u)),l<e.state.items.length-1&&(t+=o)})),{items:i,dropdownItems:s}},n.prototype.mounted=function(){"tab"===this.props.previewStyle&&this.props.eventEmitter.emit("changePreviewTabWrite",!0),this.setState(this.classifyToolbarItems()),this.appendTooltipToRoot(),this.resizeObserver.observe(this.refs.el)},n.prototype.updated=function(e){var t,n,r=this.props,o=r.editorType,i=r.previewStyle,s=r.eventEmitter,a=i!==e.previewStyle,l=o!==e.editorType;if(a||l){t=this.initialItems,n=this.hiddenScrollSync(),t.forEach((function(e){e.forEach((function(e){return e.hidden="scrollSync"===e.name&&n})),zv(e)}));var c=this.classifyToolbarItems();(a||"tab"===i&&"markdown"===o)&&(s.emit("changePreviewTabWrite"),c.activeTab="write"),this.setState(c)}},n.prototype.beforeDestroy=function(){window.removeEventListener("resize",this.handleResize),this.resizeObserver.disconnect(),Ma(this.tooltipRef.current)},n.prototype.render=function(){var e=this,t=this.props,n=t.previewStyle,r=t.eventEmitter,o=t.editorType,i=this.state,a=i.popupInfo,l=i.showPopup,c=i.activeTab,u=i.items,d=i.dropdownItems,p={eventEmitter:r,tooltipRef:this.tooltipRef,disabled:"markdown"===o&&"tab"===n&&"preview"===c,execCommand:this.execCommand,setPopupInfo:this.setPopupInfo},h="tab"===n?{borderTopLeftRadius:0}:null;return Eg(Qv||(Qv=s(['\n      <div class="','">\n        <div\n          class="','"\n          style="display: ','"\n        >\n          <'," tabs="," activeTab="," onClick=",' />\n        </div>\n        <div\n          class="','"\n          ref=',"\n          style=","\n        >\n          ","\n          <","\n            item=","\n            items=","\n            ...","\n          />\n        </div>\n        <","\n          info=","\n          show=","\n          eventEmitter=","\n          hidePopup=","\n          execCommand=","\n        />\n      </div>\n    "],['\n      <div class="','">\n        <div\n          class="','"\n          style="display: ','"\n        >\n          <'," tabs="," activeTab="," onClick=",' />\n        </div>\n        <div\n          class="','"\n          ref=',"\n          style=","\n        >\n          ","\n          <","\n            item=","\n            items=","\n            ...","\n          />\n        </div>\n        <","\n          info=","\n          show=","\n          eventEmitter=","\n          hidePopup=","\n          execCommand=","\n        />\n      </div>\n    "])),xa("toolbar"),xa("md-tab-container"),"wysiwyg"===o||"vertical"===n?"none":"block",Lv,this.tabs,c,this.toggleTab,xa("defaultUI-toolbar"),(function(t){return e.refs.el=t}),h,u.map((function(t,n){var r;return Eg(Xv||(Xv=s(["\n              <","\n                group=","\n                hiddenDivider=","\n                setItemWidth=","\n                ...","\n              />\n            "],["\n              <","\n                group=","\n                hiddenDivider=","\n                setItemWidth=","\n                ...","\n              />\n            "])),cy,t,n===u.length-1||(null===(r=u[n+1])||void 0===r?void 0:r.hidden),e.setItemWidth,p)})),dy,Fv("more"),d,p,$v,a,l,r,this.hidePopup,this.execCommand)},n}($g),hy=function(e){function n(t){var n=e.call(this,t)||this;return n.handleClickDocument=function(e){Oa(e.target,"."+xa("context-menu"))||n.setState({pos:null})},n.state={pos:null,menuGroups:[]},n.addEvent(),n}return t(n,e),n.prototype.addEvent=function(){var e=this;this.props.eventEmitter.listen("contextmenu",(function(t){var n=t.pos,r=t.menuGroups;e.setState({pos:n,menuGroups:r})}))},n.prototype.mounted=function(){document.addEventListener("click",this.handleClickDocument)},n.prototype.beforeDestroy=function(){document.removeEventListener("click",this.handleClickDocument)},n.prototype.getMenuGroupElements=function(){var e=this,t=this.state,n=t.pos,r=t.menuGroups;return n?r.reduce((function(t,n){var r=[];return n.forEach((function(t){var n=t.label,o=t.className,i=void 0!==o&&o,a=t.disabled,l=t.onClick;r.push(Eg(Yv||(Yv=s(["\n                <li\n                  onClick=",'\n                  class="menu-item','"\n                  aria-role="menuitem"\n                >\n                  <span class="','">',"</span>\n                </li>\n              "],["\n                <li\n                  onClick=",'\n                  class="menu-item','"\n                  aria-role="menuitem"\n                >\n                  <span class="','">',"</span>\n                </li>\n              "])),(function(){a||(l(),e.setState({pos:null}))}),a?" disabled":"",i,n))})),t.push(Eg(ey||(ey=s(['<ul class="menu-group">\n              ',"\n            </ul>"],['<ul class="menu-group">\n              ',"\n            </ul>"])),r)),t}),[]):[]},n.prototype.render=function(){var e=o({display:this.state.pos?"block":"none"},this.state.pos);return Eg(ty||(ty=s(['<div class="','" style=',' aria-role="menu">\n      ',"\n    </div>"],['<div class="','" style=',' aria-role="menu">\n      ',"\n    </div>"])),xa("context-menu"),e,this.getMenuGroupElements())},n}($g),fy=function(e){function n(t){var n=e.call(this,t)||this;n.changeMode=function(e){e!==n.state.editorType&&n.setState({editorType:e})},n.changePreviewStyle=function(e){e!==n.state.previewStyle&&n.setState({previewStyle:e})},n.hide=function(){n.setState({hide:!0})},n.show=function(){n.setState({hide:!1})};var r=t.editorType,o=t.previewStyle;return n.state={editorType:r,previewStyle:o,hide:!1},n.addEvent(),n}return t(n,e),n.prototype.mounted=function(){var e=this.props.slots,t=e.wwEditor,n=e.mdEditor,r=e.mdPreview;this.refs.wwContainer.appendChild(t),this.refs.mdContainer.insertAdjacentElement("afterbegin",n),this.refs.mdContainer.appendChild(r)},n.prototype.insertToolbarItem=function(e,t){this.toolbar.insertToolbarItem(e,t)},n.prototype.removeToolbarItem=function(e){this.toolbar.removeToolbarItem(e)},n.prototype.render=function(){var e=this,t=this.props,n=t.eventEmitter,r=t.hideModeSwitch,o=t.toolbarItems,i=t.theme,a=this.state,l=a.hide,c=a.previewStyle,u=a.editorType,d=l?" hidden":"",p=xa("markdown"===u?"md-mode":"ww-mode"),h=xa("md")+"-"+c+"-style",f=xa(["light"!==i,i+" "]);return Eg(ry||(ry=s(['\n      <div\n        class="',"","",'"\n        ref=',"\n      >\n        <","\n          ref=","\n          eventEmitter=","\n          previewStyle=","\n          toolbarItems=","\n          editorType=",'\n        />\n        <div\n          class="'," ",'"\n          ref=','\n        >\n          <div class="','">\n            <div\n              class="'," ",'"\n              ref=','\n            >\n              <div class="','"></div>\n            </div>\n            <div\n              class="','"\n              ref=',"\n            />\n          </div>\n        </div>\n        ","\n        <"," eventEmitter="," />\n      </div>\n    "],['\n      <div\n        class="',"","",'"\n        ref=',"\n      >\n        <","\n          ref=","\n          eventEmitter=","\n          previewStyle=","\n          toolbarItems=","\n          editorType=",'\n        />\n        <div\n          class="'," ",'"\n          ref=','\n        >\n          <div class="','">\n            <div\n              class="'," ",'"\n              ref=','\n            >\n              <div class="','"></div>\n            </div>\n            <div\n              class="','"\n              ref=',"\n            />\n          </div>\n        </div>\n        ","\n        <"," eventEmitter="," />\n      </div>\n    "])),f,xa("defaultUI"),d,(function(t){return e.refs.el=t}),py,(function(t){return e.toolbar=t}),n,c,o,u,xa("main"),p,(function(t){return e.refs.editorSection=t}),xa("main-container"),xa("md-container"),h,(function(t){return e.refs.mdContainer=t}),xa("md-splitter"),xa("ww-container"),(function(t){return e.refs.wwContainer=t}),!r&&Eg(ny||(ny=s(["<"," eventEmitter="," editorType="," />"],["<"," eventEmitter="," editorType="," />"])),_g,n,u),hy,n)},n.prototype.addEvent=function(){var e=this.props.eventEmitter;e.listen("hide",this.hide),e.listen("show",this.show),e.listen("changeMode",this.changeMode),e.listen("changePreviewStyle",this.changePreviewStyle)},n}($g),my=function(e){function n(t){var n,r,o=e.call(this,t)||this,i=Vg(o.options.el,Eg(oy||(oy=s(["\n        <","\n          ref=","\n          eventEmitter=","\n          slots=","\n          hideModeSwitch=","\n          toolbarItems=","\n          previewStyle=","\n          editorType=","\n          theme=","\n        />\n      "],["\n        <","\n          ref=","\n          eventEmitter=","\n          slots=","\n          hideModeSwitch=","\n          toolbarItems=","\n          previewStyle=","\n          editorType=","\n          theme=","\n        />\n      "])),fy,(function(e){return r=e}),o.eventEmitter,o.getEditorElements(),o.options.hideModeSwitch,o.options.toolbarItems,o.options.previewStyle,o.options.initialEditType,o.options.theme));return o.setMinHeight(o.options.minHeight),o.setHeight(o.options.height),o.defaultUI={insertToolbarItem:r.insertToolbarItem.bind(r),removeToolbarItem:r.removeToolbarItem.bind(r),destroy:i},null===(n=o.pluginInfo.toolbarItems)||void 0===n||n.forEach((function(e){var t=e.groupIndex,n=e.itemIndex,r=e.item;o.defaultUI.insertToolbarItem({groupIndex:t,itemIndex:n},r)})),o.eventEmitter.emit("loadUI",o),o}return t(n,e),n.factory=function(e){return e.viewer?new ug(e):new n(e)},n.prototype.insertToolbarItem=function(e,t){this.defaultUI.insertToolbarItem(e,t)},n.prototype.removeToolbarItem=function(e){this.defaultUI.removeToolbarItem(e)},n.prototype.destroy=function(){e.prototype.destroy.call(this),this.defaultUI.destroy()},n}(kg),gy=my;kg.setLanguage(["en","en-US"],{Markdown:"Markdown",WYSIWYG:"WYSIWYG",Write:"Write",Preview:"Preview",Headings:"Headings",Paragraph:"Paragraph",Bold:"Bold",Italic:"Italic",Strike:"Strike",Code:"Inline code",Line:"Line",Blockquote:"Blockquote","Unordered list":"Unordered list","Ordered list":"Ordered list",Task:"Task",Indent:"Indent",Outdent:"Outdent","Insert link":"Insert link","Insert CodeBlock":"Insert codeBlock","Insert table":"Insert table","Insert image":"Insert image",Heading:"Heading","Image URL":"Image URL","Select image file":"Select image file","Choose a file":"Choose a file","No file":"No file",Description:"Description",OK:"OK",More:"More",Cancel:"Cancel",File:"File",URL:"URL","Link text":"Link text","Add row to up":"Add row to up","Add row to down":"Add row to down","Add column to left":"Add column to left","Add column to right":"Add column to right","Remove row":"Remove row","Remove column":"Remove column","Align column to left":"Align column to left","Align column to center":"Align column to center","Align column to right":"Align column to right","Remove table":"Remove table","Would you like to paste as table?":"Would you like to paste as table?","Text color":"Text color","Auto scroll enabled":"Auto scroll enabled","Auto scroll disabled":"Auto scroll disabled","Choose language":"Choose language"});var vy=gy}(),r=r.default}()}));
\ No newline at end of file
diff --git a/mdedit/vendor/toastui-editor.min.css b/mdedit/vendor/toastui-editor.min.css
new file mode 100644
index 0000000..b433784
--- /dev/null
+++ b/mdedit/vendor/toastui-editor.min.css
@@ -0,0 +1,6 @@
+/*!
+ * @toast-ui/editor
+ * @version 3.2.2 | Fri Feb 17 2023
+ * @author NHN Cloud FE Development Lab <dl_javascript@nhn.com>
+ * @license MIT
+ */.ProseMirror{word-wrap:break-word;font-feature-settings:"liga" 0;-webkit-font-variant-ligatures:none;font-variant-ligatures:none;position:relative;white-space:pre-wrap;white-space:break-spaces}.ProseMirror pre{white-space:pre-wrap}.ProseMirror li{position:relative}.ProseMirror-hideselection ::selection{background:transparent}.ProseMirror-hideselection ::-moz-selection{background:transparent}.ProseMirror-hideselection{caret-color:transparent}.ProseMirror-selectednode{outline:2px solid #8cf}li.ProseMirror-selectednode{outline:none}li.ProseMirror-selectednode:after{border:2px solid #8cf;bottom:-2px;content:"";left:-32px;pointer-events:none;position:absolute;right:-2px;top:-2px}img.ProseMirror-separator{border:none!important;display:inline!important;margin:0!important}.auto-height,.auto-height .toastui-editor-defaultUI{height:auto}.auto-height .toastui-editor-md-container{position:relative}:not(.auto-height)>.toastui-editor-defaultUI,:not(.auto-height)>.toastui-editor-defaultUI>.toastui-editor-main{display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column}:not(.auto-height)>.toastui-editor-defaultUI>.toastui-editor-main{-ms-flex:1;flex:1}.toastui-editor-defaultUI-toolbar:after,.toastui-editor-md-container:after{clear:both;content:"";display:block;height:0}.toastui-editor-main{box-sizing:border-box;height:inherit;min-height:0;position:relative}.toastui-editor-md-container{display:none;height:100%;overflow:hidden}.toastui-editor-md-container .toastui-editor{line-height:1.5;position:relative}.toastui-editor-md-container .toastui-editor,.toastui-editor-md-container .toastui-editor-md-preview{box-sizing:border-box;height:inherit;padding:0}.toastui-editor-md-container .toastui-editor-md-preview{height:100%;overflow:auto;padding:0 25px}.toastui-editor-md-container .toastui-editor-md-preview>p:first-child{margin-top:0!important}.toastui-editor-md-container .toastui-editor-md-preview .toastui-editor-contents{padding-top:8px}.toastui-editor-main .toastui-editor-md-tab-style>.toastui-editor,.toastui-editor-main .toastui-editor-md-tab-style>.toastui-editor-md-preview{display:none;width:100%}.toastui-editor-main .toastui-editor-md-tab-style>.active{display:block}.toastui-editor-main .toastui-editor-md-vertical-style>.toastui-editor-tabs{display:none}.toastui-editor-main .toastui-editor-md-tab-style>.toastui-editor-tabs{display:block}.toastui-editor-main .toastui-editor-md-vertical-style .toastui-editor,.toastui-editor-main .toastui-editor-md-vertical-style .toastui-editor-md-preview{width:50%}.toastui-editor-main .toastui-editor-md-splitter{background-color:#ebedf2;display:none;height:100%;left:50%;position:absolute;width:1px}.toastui-editor-main .toastui-editor-md-vertical-style .toastui-editor-md-splitter{display:block}.toastui-editor-ww-container{background-color:#fff;display:none;height:inherit;overflow:hidden}.auto-height .toastui-editor-main-container{position:relative}.toastui-editor-main-container{color:#222;height:inherit;line-height:1;position:absolute;width:100%}.toastui-editor-ww-container>.toastui-editor{height:inherit;position:relative;width:100%}.toastui-editor-ww-container .toastui-editor-contents{box-sizing:border-box;height:inherit;margin:0;overflow:auto;padding:16px 25px 0}.toastui-editor-ww-container .toastui-editor-contents p{margin:0}.toastui-editor-md-mode .toastui-editor-md-container,.toastui-editor-ww-mode .toastui-editor-ww-container{display:block;z-index:20}.toastui-editor-md-mode .toastui-editor-md-vertical-style{display:-ms-flexbox;display:flex}.toastui-editor-defaultUI.hidden,.toastui-editor-main.hidden{display:none}.toastui-editor-defaultUI .ProseMirror{padding:18px 25px}.toastui-editor-defaultUI{border:1px solid #dadde6;border-radius:4px;font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;height:100%;position:relative}.toastui-editor-defaultUI button{border:none;border-radius:2px;color:#333;cursor:pointer;font-size:13px;height:28px}.toastui-editor-defaultUI .toastui-editor-ok-button{background-color:#00a9ff;color:#fff;height:32px;min-width:63px;outline-color:#009bf2}.toastui-editor-defaultUI .toastui-editor-ok-button:hover{background-color:#009bf2}.toastui-editor-defaultUI .toastui-editor-close-button{background-color:#f7f9fc;border:1px solid #dadde6;height:32px;margin-right:5px;min-width:63px;outline-color:#cbcfdb}.toastui-editor-defaultUI .toastui-editor-close-button:hover{border-color:#cbcfdb}.toastui-editor-mode-switch{background-color:#fff;border-radius:0 0 3px 3px;border-top:1px solid #dadde6;font-size:12px;height:28px;padding-right:10px;text-align:right}.toastui-editor-mode-switch .tab-item{background:#f7f9fc;border:1px solid #dadde6;border-radius:0 0 4px 4px;box-sizing:border-box;color:#969aa5;cursor:pointer;display:inline-block;font-weight:500;height:24px;line-height:24px;margin-right:-1px;margin-top:-1px;text-align:center;width:96px}.toastui-editor-mode-switch .tab-item.active{background-color:#fff;border-top:1px solid #fff;color:#555}.toastui-editor-defaultUI .toastui-editor-md-tab-container{background:#f7f9fc;border-bottom:1px solid #ebedf2;border-top-left-radius:3px;float:left;font-size:13px;height:45px}.toastui-editor-md-tab-container .toastui-editor-tabs{height:100%;margin-left:15px}.toastui-editor-md-tab-container .tab-item{background:#eaedf1;border:1px solid #dadde6;border-radius:4px 4px 0 0;box-sizing:border-box;color:#969aa5;cursor:pointer;display:inline-block;font-size:12px;font-weight:500;height:33px;line-height:33px;margin-top:13px;text-align:center;width:70px}.toastui-editor-md-tab-container .tab-item.active{background-color:#fff;border-bottom:1px solid #fff;color:#555}.toastui-editor-md-tab-container .tab-item:last-child{margin-left:-1px}.toastui-editor-defaultUI-toolbar{background-color:#f7f9fc;border-bottom:1px solid #ebedf2;border-radius:3px 3px 0 0;display:-ms-flexbox;display:flex;height:45px;padding:0 25px}.toastui-editor-toolbar{box-sizing:border-box;height:46px}.toastui-editor-toolbar-divider{background-color:#e1e3e9;display:inline-block;height:18px;margin:14px 12px;width:1px}.toastui-editor-toolbar-group{display:-ms-flexbox;display:flex}.toastui-editor-defaultUI-toolbar button{border:1px solid #f7f9fc;border-radius:3px;box-sizing:border-box;cursor:pointer;height:32px;margin:7px 5px;padding:0;width:32px}.toastui-editor-defaultUI-toolbar button:not(:disabled):hover{background-color:#fff;border:1px solid #e4e7ee}.toastui-editor-defaultUI-toolbar .scroll-sync{color:#81858f;cursor:pointer;display:inline-block;height:10px;line-height:10px;position:relative;text-align:center;width:70px}.toastui-editor-defaultUI-toolbar .scroll-sync:before{content:"Scroll";font-size:14px;left:0;position:absolute}.toastui-editor-defaultUI-toolbar .scroll-sync.active:before{color:#00a9ff}.toastui-editor-defaultUI-toolbar .scroll-sync input{height:0;opacity:0;width:0}.toastui-editor-defaultUI-toolbar .switch{background-color:#d6d8de;border-radius:50px;bottom:0;left:45px;position:absolute;right:0;top:0;-webkit-transition:.4s;transition:.4s}.toastui-editor-defaultUI-toolbar input:checked+.switch{background-color:#acddfa}.toastui-editor-defaultUI-toolbar .switch:before{background-color:#94979f;border-radius:50%;bottom:-2px;content:"";height:14px;left:0;position:absolute;-webkit-transition:.4s;transition:.4s;width:14px}.toastui-editor-defaultUI-toolbar input:checked+.switch:before{background-color:#00a9ff;-webkit-transform:translateX(12px);-moz-transform:translateX(12px);-ms-transform:translateX(12px);transform:translateX(12px)}.toastui-editor-dropdown-toolbar .scroll-sync{margin:0 5px}.toastui-editor-dropdown-toolbar{background-color:#f7f9fc;border:1px solid #dadde6;border-radius:2px;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);display:-ms-flexbox;display:flex;height:46px;position:absolute;z-index:30}.toastui-editor-toolbar-item-wrapper{height:32px;line-height:32px;margin:7px 5px}.toastui-editor-popup{background:#fff;border:1px solid #dadde6;border-radius:2px;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);margin-right:auto;position:absolute;width:400px;z-index:30}.toastui-editor-popup-body{font-size:12px;padding:15px}.toastui-editor-popup-body label{color:#555;display:block;font-weight:600;margin:20px 0 5px}.toastui-editor-popup-body .toastui-editor-button-container{margin-top:20px;text-align:right}.toastui-editor-popup-body input[type=text]{border:1px solid #e1e3e9;border-radius:2px;color:#333;height:30px;padding:0 12px;width:calc(100% - 26px)}.toastui-editor-popup-body input[type=text]:focus{border-color:transparent;outline:1px solid #00a9ff}.toastui-editor-popup-body input[type=text].disabled{background-color:#f7f9fc;border-color:#e1e3e9;color:#969aa5}.toastui-editor-popup-body input[type=file]{border:none;height:1px;left:0;opacity:0;position:absolute;top:0;width:1px}.toastui-editor-popup-body input.wrong,.toastui-editor-popup-body span.wrong{border-color:#fa2828}.toastui-editor-popup-add-image .toastui-editor-popup-body,.toastui-editor-popup-add-link .toastui-editor-popup-body{padding:0 20px 20px}.toastui-editor-popup-add-image .toastui-editor-tabs{margin:5px 0 10px}.toastui-editor-popup-add-image .toastui-editor-tabs .tab-item{border-bottom:1px solid #dadde6;box-sizing:border-box;color:#333;cursor:pointer;display:inline-block;font-size:13px;font-weight:600;height:40px;line-height:40px;text-align:center;width:60px}.toastui-editor-popup-add-image .toastui-editor-tabs .tab-item:hover{border-bottom:1px solid #cbcfdb}.toastui-editor-popup-add-image .toastui-editor-tabs .tab-item.active{border-bottom:2px solid #00a9ff;color:#00a9ff}.toastui-editor-popup-add-image .toastui-editor-file-name{border:1px solid #e1e3e9;border-radius:2px;color:#dadde6;cursor:pointer;display:inline-block;height:30px;line-height:30px;overflow:hidden;padding:0 12px;text-overflow:ellipsis;white-space:nowrap;width:58%}.toastui-editor-popup-add-image .toastui-editor-file-name.has-file{color:#333}.toastui-editor-popup-add-image .toastui-editor-file-select-button{background-color:#f7f9fc;border:1px solid #dadde6;border-radius:2px;height:32px;margin-left:5px;vertical-align:top;width:33%}.toastui-editor-popup-add-image .toastui-editor-file-select-button:hover{border-color:#cbcfdb}.toastui-editor-popup-add-table{width:auto}.toastui-editor-popup-add-table .toastui-editor-table-selection{position:relative}.toastui-editor-popup-add-table .toastui-editor-table-cell{background:#fff;border:1px solid #e1e3e9;box-sizing:border-box;display:table-cell;height:20px;width:20px}.toastui-editor-popup-add-table .toastui-editor-table-cell.header{background:#f7f9fc}.toastui-editor-popup-add-table .toastui-editor-table-row{display:table-row}.toastui-editor-popup-add-table .toastui-editor-table{border-collapse:collapse;display:table}.toastui-editor-popup-add-table .toastui-editor-table-selection-layer{background:rgba(0,169,255,.1);border:1px solid #00a9ff;left:0;position:absolute;top:0;z-index:30}.toastui-editor-popup-add-table .toastui-editor-table-description{color:#333;margin:5px 0 0;text-align:center}.toastui-editor-popup-add-heading{width:auto}.toastui-editor-popup-add-heading .toastui-editor-popup-body{padding:0}.toastui-editor-popup-add-heading h1,.toastui-editor-popup-add-heading h2,.toastui-editor-popup-add-heading h3,.toastui-editor-popup-add-heading h4,.toastui-editor-popup-add-heading h5,.toastui-editor-popup-add-heading h6,.toastui-editor-popup-add-heading p,.toastui-editor-popup-add-heading ul{margin:0;padding:0}.toastui-editor-popup-add-heading ul{list-style:none;padding:5px 0}.toastui-editor-popup-add-heading ul li{cursor:pointer;padding:4px 12px}.toastui-editor-popup-add-heading ul li:hover{background-color:#dff4ff}.toastui-editor-popup-add-heading h1{font-size:24px}.toastui-editor-popup-add-heading h2{font-size:22px}.toastui-editor-popup-add-heading h3{font-size:20px}.toastui-editor-popup-add-heading h4{font-size:18px}.toastui-editor-popup-add-heading h5{font-size:16px}.toastui-editor-popup-add-heading h6{font-size:14px}.toastui-editor-context-menu{background-color:#fff;border:1px solid #dadde6;border-radius:2px;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);color:#333;min-width:197px;padding:5px 0;position:absolute;width:auto;z-index:30}.toastui-editor-context-menu .menu-group{border-bottom:1px solid #ebedf2;font-size:13px;list-style:none;margin:0;padding:0}.toastui-editor-context-menu .menu-group:last-child{border-bottom:none!important}.toastui-editor-context-menu .menu-item{cursor:pointer;height:32px;line-height:32px;padding:0 14px}.toastui-editor-context-menu span{display:inline-block}.toastui-editor-context-menu span:before{background:url(data:image/png;base64,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) no-repeat;background-size:466px 146px;content:"";display:inline-block;height:20px;margin-right:10px;vertical-align:middle;width:20px}.toastui-editor-context-menu .add-row-up:before{background-position:3px -104px}.toastui-editor-context-menu .add-row-down:before{background-position:-19px -104px}.toastui-editor-context-menu .remove-row:before{background-position:-41px -104px}.toastui-editor-context-menu .add-column-left:before{background-position:-63px -104px}.toastui-editor-context-menu .add-column-right:before{background-position:-85px -104px}.toastui-editor-context-menu .remove-column:before{background-position:-111px -104px}.toastui-editor-context-menu .align-column-left:before{background-position:-129px -104px}.toastui-editor-context-menu .align-column-center:before{background-position:-151px -104px}.toastui-editor-context-menu .align-column-right:before{background-position:-173px -104px}.toastui-editor-context-menu .remove-table:before{background-position:-197px -104px}.toastui-editor-context-menu .disabled span:before{opacity:.3}.toastui-editor-context-menu li:not(.disabled):hover{background-color:#dff4ff}.toastui-editor-context-menu li.disabled{color:#c9ccd5}.toastui-editor-tooltip{background-color:#444;border-radius:3px;color:#fff;font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;font-size:12px;padding:4px 7px;position:absolute;z-index:40}.toastui-editor-tooltip .arrow{background-color:#444;content:"";display:inline-block;height:10px;left:6px;position:absolute;top:-3px;-webkit-transform:rotate(45deg);-moz-transform:rotate(45deg);-ms-transform:rotate(45deg);-o-transform:rotate(45deg);transform:rotate(45deg);width:10px;z-index:-1}.toastui-editor-toolbar-icons{background:url(data:image/png;base64,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) no-repeat;background-size:466px 146px}@media only screen and (-o-min-device-pixel-ratio:2/1),only screen and (-webkit-min-device-pixel-ratio:2),only screen and (min--moz-device-pixel-ratio:2),only screen and (min-device-pixel-ratio:2),only screen and (min-resolution:192dpi),only screen and (min-resolution:2dppx){.toastui-editor-context-menu span:before,.toastui-editor-toolbar-icons{background:url(data:image/png;base64,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) no-repeat;background-size:466px 146px}}.toastui-editor-toolbar-icons{background-position-y:3px}.toastui-editor-toolbar-icons:disabled{opacity:.3}.toastui-editor-toolbar-icons.heading{background-position-x:3px}.toastui-editor-toolbar-icons.bold{background-position-x:-23px}.toastui-editor-toolbar-icons.italic{background-position-x:-49px}.toastui-editor-toolbar-icons.strike{background-position-x:-75px}.toastui-editor-toolbar-icons.hrline{background-position-x:-101px}.toastui-editor-toolbar-icons.quote{background-position-x:-127px}.toastui-editor-toolbar-icons.bullet-list{background-position-x:-153px}.toastui-editor-toolbar-icons.ordered-list{background-position-x:-179px}.toastui-editor-toolbar-icons.task-list{background-position-x:-205px}.toastui-editor-toolbar-icons.indent{background-position-x:-231px}.toastui-editor-toolbar-icons.outdent{background-position-x:-257px}.toastui-editor-toolbar-icons.table{background-position-x:-283px}.toastui-editor-toolbar-icons.image{background-position-x:-309px}.toastui-editor-toolbar-icons.link{background-position-x:-334px}.toastui-editor-toolbar-icons.code{background-position-x:-361px}.toastui-editor-toolbar-icons.codeblock{background-position-x:-388px}.toastui-editor-toolbar-icons.more{background-position-x:-412px}.toastui-editor-toolbar-icons:not(:disabled).active{background-position-y:-23px}@media only screen and (max-width:480px){.toastui-editor-popup{margin-left:-150px;max-width:300px}.toastui-editor-dropdown-toolbar{max-width:none}}.ProseMirror{overflow-X:hidden;color:#222;font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;font-size:13px;height:calc(100% - 36px);overflow-y:auto}.ProseMirror .placeholder{color:#999}.ProseMirror-selectednode,.ProseMirror:focus{outline:none}.html-block.ProseMirror-selectednode,table.ProseMirror-selectednode{border-radius:2px;outline:2px solid #00a9ff}.toastui-editor-contents{font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;font-size:13px;margin:0;padding:0;z-index:20}.toastui-editor-contents :not(table){box-sizing:content-box;line-height:160%}.toastui-editor-contents address,.toastui-editor-contents cite,.toastui-editor-contents dfn,.toastui-editor-contents em,.toastui-editor-contents i,.toastui-editor-contents var{font-style:italic}.toastui-editor-contents strong{font-weight:700}.toastui-editor-contents p{color:#222;margin:10px 0}.toastui-editor-contents>div>div:first-of-type h1,.toastui-editor-contents>h1:first-of-type{margin-top:14px}.toastui-editor-contents h1,.toastui-editor-contents h2,.toastui-editor-contents h3,.toastui-editor-contents h4,.toastui-editor-contents h5,.toastui-editor-contents h6{color:#222;font-weight:700}.toastui-editor-contents h1{border-bottom:3px double #999;font-size:24px;line-height:28px;margin:52px 0 15px;padding-bottom:7px}.toastui-editor-contents h2{border-bottom:1px solid #dbdbdb;font-size:22px;line-height:23px;margin:20px 0 13px;padding-bottom:7px}.toastui-editor-contents h3{font-size:20px;margin:18px 0 2px}.toastui-editor-contents h4{font-size:18px;margin:10px 0 2px}.toastui-editor-contents h3,.toastui-editor-contents h4{line-height:18px}.toastui-editor-contents h5{font-size:16px}.toastui-editor-contents h6{font-size:14px}.toastui-editor-contents h5,.toastui-editor-contents h6{line-height:17px;margin:9px 0 -4px}.toastui-editor-contents del{color:#999}.toastui-editor-contents blockquote{border-left:4px solid #e5e5e5;color:#999;margin:14px 0;padding:0 16px}.toastui-editor-contents blockquote ol,.toastui-editor-contents blockquote p,.toastui-editor-contents blockquote ul{color:#999}.toastui-editor-contents blockquote>:first-child{margin-top:0}.toastui-editor-contents blockquote>:last-child{margin-bottom:0}.toastui-editor-contents code,.toastui-editor-contents pre{border:0;border-radius:0;font-family:Consolas,Courier,Apple SD 산돌고딕 Neo,-apple-system,Lucida Grande,Apple SD Gothic Neo,맑은 고딕,Malgun Gothic,Segoe UI,돋움,dotum,sans-serif}.toastui-editor-contents pre{background-color:#f4f7f8;margin:2px 0 8px;padding:18px}.toastui-editor-contents code{background-color:#f9f2f4;border-radius:2px;color:#c1798b;letter-spacing:-.3px;padding:2px 3px}.toastui-editor-contents pre code{background-color:transparent;color:inherit;padding:0;white-space:pre-wrap}.toastui-editor-contents img{box-sizing:border-box;margin:4px 0 10px;max-width:100%;vertical-align:top}.toastui-editor-contents table{border:1px solid rgba(0,0,0,.1);border-collapse:collapse;box-sizing:border-box;color:#222;margin:12px 0 14px;width:auto}.toastui-editor-contents table td,.toastui-editor-contents table th{border:1px solid rgba(0,0,0,.1);height:32px;padding:5px 14px 5px 12px}.toastui-editor-contents table th{background-color:#555;color:#fff;font-weight:300;padding-top:6px}.toastui-editor-contents th p{color:#fff;margin:0}.toastui-editor-contents td p{margin:0;padding:0 2px}.toastui-editor-contents td.toastui-editor-cell-selected{background-color:#d8dfec}.toastui-editor-contents th.toastui-editor-cell-selected{background-color:#908f8f}.toastui-editor-contents dir,.toastui-editor-contents menu,.toastui-editor-contents ol,.toastui-editor-contents ul{color:#222;display:block;list-style-type:none;margin:6px 0 10px;padding-left:24px}.toastui-editor-contents ol{counter-reset:li;list-style-type:none}.toastui-editor-contents ol>li{counter-increment:li}.toastui-editor-contents ol>li:before,.toastui-editor-contents ul>li:before{display:inline-block;position:absolute}.toastui-editor-contents ul>li:before{background-color:#ccc;border-radius:50%;content:"";height:5px;margin-left:-17px;margin-top:6px;width:5px}.toastui-editor-contents ol>li:before{color:#aaa;content:"." counter(li);direction:rtl;margin-left:-28px;text-align:right;width:24px}.toastui-editor-contents ol ol,.toastui-editor-contents ol ul,.toastui-editor-contents ul ol,.toastui-editor-contents ul ul{margin-bottom:0!important;margin-top:0!important}.toastui-editor-contents ol li,.toastui-editor-contents ul li{position:relative}.toastui-editor-contents ol p,.toastui-editor-contents ul p{margin:0}.toastui-editor-contents hr{border-top:1px solid #eee;margin:16px 0}.toastui-editor-contents a{color:#4b96e6;text-decoration:underline}.toastui-editor-contents a:hover{color:#1f70de}.toastui-editor-contents .image-link{position:relative}.toastui-editor-contents .image-link:hover:before{background:#fff url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyMCIgaGVpZ2h0PSIyMCI+PGcgc3Ryb2tlPSIjNTU1IiBzdHJva2Utd2lkdGg9IjEuNSIgZmlsbD0ibm9uZSIgZmlsbC1ydWxlPSJldmVub2RkIiBzdHJva2UtbGluZWNhcD0icm91bmQiPjxwYXRoIGQ9Im01LjY4NyAxMC4yOTQtMS4yODUgMS4yODhjLTEuMDUgMS4wNS0xLjAzNSAyLjc3Mi4wMzcgMy44NDRsLjEzNS4xMzVjMS4wNzIgMS4wNzIgMi43OTQgMS4wODggMy44NDQuMDM3bDIuNzItMi43MmMxLjA1MS0xLjA1IDEuMDM0LTIuNzcyLS4wMzctMy44NDNsLS4xMzYtLjEzNiIvPjxwYXRoIGQ9Im0xNC4zMDUgOS43MTMgMS4yODctMS4yOWMxLjA1Mi0xLjA1MSAxLjAzNi0yLjc3My0uMDM2LTMuODQ0bC0uMTM1LS4xMzZjLTEuMDcyLTEuMDcyLTIuNzk0LTEuMDg4LTMuODQ1LS4wMzZMOC44NTcgNy4xMjZjLTEuMDUxIDEuMDUxLTEuMDM0IDIuNzcyLjAzNyAzLjg0M2wuMTM2LjEzNiIvPjwvZz48L3N2Zz4=) no-repeat;background-position:50%;border:1px solid #c9ccd5;border-radius:50%;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);content:"";cursor:pointer;height:30px;position:absolute;right:0;width:30px}.toastui-editor-contents .task-list-item{border:0;list-style:none;margin-left:-24px;padding-left:24px}.toastui-editor-contents .task-list-item:before{background-position:50%;background-repeat:no-repeat;background-size:18px 18px;background:transparent url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxOCIgaGVpZ2h0PSIxOCI+PHJlY3Qgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiB4PSIuNSIgeT0iLjUiIHJ4PSIyIiBmaWxsPSIjRkZGIiBzdHJva2U9IiNDQ0MiIGZpbGwtcnVsZT0iZXZlbm9kZCIvPjwvc3ZnPg==);border-radius:2px;content:"";cursor:pointer;height:18px;left:0;margin-left:0;margin-top:0;position:absolute;top:1px;width:18px}.toastui-editor-contents .task-list-item.checked:before{background-image:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxOCIgaGVpZ2h0PSIxOCI+PHBhdGggZD0iTTE2IDBhMiAyIDAgMCAxIDIgMnYxNGEyIDIgMCAwIDEtMiAySDJhMiAyIDAgMCAxLTItMlYyYTIgMiAwIDAgMSAyLTJoMTR6bS0xLjc5MyA1LjI5M2ExIDEgMCAwIDAtMS40MTQgMEw3LjUgMTAuNTg1IDUuMjA3IDguMjkzbC0uMDk0LS4wODNhMSAxIDAgMCAwLTEuMzIgMS40OTdsMyAzIC4wOTQuMDgzYTEgMSAwIDAgMCAxLjMyLS4wODNsNi02IC4wODMtLjA5NGExIDEgMCAwIDAtLjA4My0xLjMyeiIgZmlsbD0iIzRCOTZFNiIgZmlsbC1ydWxlPSJldmVub2RkIi8+PC9zdmc+)}.toastui-editor-custom-block .toastui-editor-custom-block-editor{background:#f9f7fd;border:1px solid #dbd4ea;color:#452d6b}.toastui-editor-custom-block .toastui-editor-custom-block-view{padding:9px 13px 8px 12px;position:relative}.toastui-editor-custom-block.ProseMirror-selectednode .toastui-editor-custom-block-view{border:1px solid #dbd4ea;border-radius:2px}.toastui-editor-custom-block .toastui-editor-custom-block-view .tool{display:none;position:absolute;right:10px;top:7px}.toastui-editor-custom-block.ProseMirror-selectednode .toastui-editor-custom-block-view .tool{display:block}.toastui-editor-custom-block-view button{background:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMCAzMCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMzAgMzAiIHhtbDpzcGFjZT0icHJlc2VydmUiPjxwYXRoIGQ9Im0xNS41IDEyLjUgMiAyTDEyIDIwaC0ydi0ybDUuNS01LjV6TTE4IDEwbDIgMi0xLjUgMS41LTItMkwxOCAxMHoiIHN0eWxlPSJmaWxsLXJ1bGU6ZXZlbm9kZDtjbGlwLXJ1bGU6ZXZlbm9kZDtmaWxsOiM1NTUiLz48L3N2Zz4=) no-repeat;background-position:50%;background-size:30px 30px;border:1px solid #ccc;height:15px;margin-left:8px;padding:3px;vertical-align:middle;width:15px}.toastui-editor-custom-block-view .info{color:#5200d0;font-size:13px;font-weight:700;vertical-align:middle}.toastui-editor-contents .toastui-editor-ww-code-block{position:relative}.toastui-editor-contents .toastui-editor-ww-code-block:after{background:#e5e9ea url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMCAzMCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMzAgMzAiIHhtbDpzcGFjZT0icHJlc2VydmUiPjxwYXRoIGQ9Im0xNS41IDEyLjUgMiAyTDEyIDIwaC0ydi0ybDUuNS01LjV6TTE4IDEwbDIgMi0xLjUgMS41LTItMkwxOCAxMHoiIHN0eWxlPSJmaWxsLXJ1bGU6ZXZlbm9kZDtjbGlwLXJ1bGU6ZXZlbm9kZDtmaWxsOiM1NTUiLz48L3N2Zz4=) no-repeat;background-position:100%;background-size:30px 30px;border-radius:2px;color:#333;content:attr(data-language);cursor:pointer;display:inline-block;font-size:13px;font-weight:700;height:24px;padding:3px 35px 0 10px;position:absolute;right:10px;top:10px}.toastui-editor-ww-code-block-language{background-color:#fff;border:1px solid #ccc;border-radius:2px;display:inline-block;height:27px;position:fixed;right:35px;width:100px;z-index:30}.toastui-editor-ww-code-block-language input{background-color:transparent;border:none;box-sizing:border-box;height:100%;margin:0;outline:none;padding:0 10px;width:100%}.toastui-editor-contents-placeholder:before{color:grey;content:attr(data-placeholder);line-height:160%;position:absolute}.toastui-editor-md-preview .toastui-editor-contents h1{min-height:28px}.toastui-editor-md-preview .toastui-editor-contents h2{min-height:23px}.toastui-editor-md-preview .toastui-editor-contents blockquote{min-height:20px}.toastui-editor-md-preview .toastui-editor-contents li{min-height:22px}.toastui-editor-pseudo-clipboard{height:0;left:-1000px;opacity:0;position:fixed;top:-1000px;width:0;z-index:-1}.toastui-editor-contents .toastui-editor-md-preview-highlight{position:relative;z-index:0}.toastui-editor-contents .toastui-editor-md-preview-highlight:after{background-color:rgba(255,245,131,.5);border-radius:4px;bottom:-4px;content:"";left:-4px;position:absolute;right:-4px;top:-4px;z-index:-1}.toastui-editor-contents h1.toastui-editor-md-preview-highlight:after,.toastui-editor-contents h2.toastui-editor-md-preview-highlight:after{bottom:0}.toastui-editor-contents td.toastui-editor-md-preview-highlight:after,.toastui-editor-contents th.toastui-editor-md-preview-highlight:after{display:none}.toastui-editor-contents td.toastui-editor-md-preview-highlight,.toastui-editor-contents th.toastui-editor-md-preview-highlight{background-color:rgba(255,245,131,.5)}.toastui-editor-contents th.toastui-editor-md-preview-highlight{color:#222}.toastui-editor-md-heading1{font-size:24px}.toastui-editor-md-heading2{font-size:22px}.toastui-editor-md-heading3{font-size:20px}.toastui-editor-md-heading4{font-size:18px}.toastui-editor-md-heading5{font-size:16px}.toastui-editor-md-heading6{font-size:14px}.toastui-editor-md-heading.toastui-editor-md-delimiter.setext{line-height:15px}.toastui-editor-md-heading,.toastui-editor-md-list-item .toastui-editor-md-meta,.toastui-editor-md-list-item-style,.toastui-editor-md-strong{font-weight:700}.toastui-editor-md-emph{font-style:italic}.toastui-editor-md-strike{text-decoration:line-through}.toastui-editor-md-strike.toastui-editor-md-delimiter{text-decoration:none}.toastui-editor-md-block-quote,.toastui-editor-md-delimiter,.toastui-editor-md-link,.toastui-editor-md-table,.toastui-editor-md-thematic-break{color:#ccc}.toastui-editor-md-code.toastui-editor-md-delimiter{color:#aaa}.toastui-editor-md-html,.toastui-editor-md-link.toastui-editor-md-link-url.toastui-editor-md-marked-text,.toastui-editor-md-meta{color:#999}.toastui-editor-md-block-quote .toastui-editor-md-marked-text,.toastui-editor-md-list-item .toastui-editor-md-meta{color:#555}.toastui-editor-md-table .toastui-editor-md-table-cell{color:#222}.toastui-editor-md-link.toastui-editor-md-link-desc.toastui-editor-md-marked-text,.toastui-editor-md-list-item-style.toastui-editor-md-list-item-odd{color:#4b96e6}.toastui-editor-md-list-item-style.toastui-editor-md-list-item-even{color:#cb4848}.toastui-editor-md-code.toastui-editor-md-marked-text{color:#c1798b}.toastui-editor-md-code{background-color:rgba(243,229,233,.5);letter-spacing:-.3px;padding:2px 0}.toastui-editor-md-code.toastui-editor-md-start{border-bottom-left-radius:2px;border-top-left-radius:2px;padding-left:2px}.toastui-editor-md-code.toastui-editor-md-end{border-bottom-right-radius:2px;border-top-right-radius:2px;padding-right:2px}.toastui-editor-md-code-block-line-background{background-color:#f5f7f8}.toastui-editor-md-code-block-line-background.start,.toastui-editor-md-custom-block-line-background.start{margin-top:2px}.toastui-editor-md-code,.toastui-editor-md-code-block{font-family:Consolas,Courier,Lucida Grande,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif}.toastui-editor-md-custom-block{color:#452d6b}.toastui-editor-md-custom-block-line-background{background-color:#f9f7fd}.toastui-editor-md-custom-block .toastui-editor-md-delimiter{color:#b8b3c0}.toastui-editor-md-custom-block .toastui-editor-md-meta{color:#5200d0}
\ No newline at end of file
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..0dfb5e3
--- /dev/null
+++ b/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "zddc",
+  "version": "0.1.0",
+  "description": "Zero Day Document Control - lightweight project management tools",
+  "private": true,
+  "scripts": {
+    "test": "npx playwright test",
+    "test:headed": "npx playwright test --headed",
+    "test:debug": "npx playwright test --debug",
+    "test:install": "npx playwright install chromium"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.50.0",
+    "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://codeberg.org/VARASYS/ZDDC.git"
+  },
+  "keywords": [
+    "project-management",
+    "document-control",
+    "markdown-editor",
+    "document-transmittal"
+  ],
+  "license": "AGPL-3.0"
+}
diff --git a/pandoc/README.md b/pandoc/README.md
new file mode 100644
index 0000000..da557cd
--- /dev/null
+++ b/pandoc/README.md
@@ -0,0 +1,162 @@
+# ZDDC Pandoc Tools
+
+A collection of tools for converting Markdown documents to HTML with a professional viewer interface, optimized for technical documentation and engineering documents.
+
+## Features
+
+### Document Conversion (`convert`)
+- **Batch processing**: Convert multiple Markdown files at once
+- **Force overwrite**: `-f` flag to overwrite existing output files
+- **Custom output directory**: `-o` flag to specify output location
+- **Configuration-driven**: Uses `zddc.conf` for project-specific settings
+- **Template integration**: Automatically applies the viewer template
+- **Progress tracking**: Real-time conversion status and summary
+
+### Professional Viewer Template (`viewer-template.html`)
+- **Modern responsive design**: Works on desktop, tablet, and mobile
+- **Table of Contents (TOC)**: Auto-generated sidebar navigation with smooth scrolling
+- **Print optimization**: Professional formatting for PDF generation
+  - Page break controls for tables
+  - Repeating table headers
+  - Proper page numbering
+  - Clean print layout
+- **URL hash navigation**: Shareable links to specific document sections
+- **Mobile-friendly**: Collapsible sidebar and touch-optimized interface
+- **Professional styling**: Clean typography optimized for technical documents
+
+## Usage
+
+### Basic Conversion
+```bash
+# Convert all Markdown files in current directory
+./convert *.md
+
+# Convert with force overwrite
+./convert -f *.md
+
+# Convert to specific output directory
+./convert -o rendered/ *.md
+
+# Combine flags
+./convert -f -o rendered/ *.md
+```
+
+### Configuration (`zddc.conf`)
+Create a `zddc.conf` file in your project directory:
+```ini
+# Project metadata
+title = "Project Documentation"
+author = "Your Organization"
+date = "2024"
+
+# Template settings
+template = "/path/to/viewer-template.html"
+css = "custom-styles.css"
+
+# Output settings
+output_dir = "rendered"
+```
+
+### Directory Structure
+```
+your-project/
+├── zddc.conf              # Configuration file
+├── document1.md           # Source Markdown files
+├── document2.md
+└── rendered/              # Generated HTML files
+    ├── document1.html
+    └── document2.html
+```
+
+## Template Features
+
+### Navigation
+- **TOC Generation**: Automatically creates navigation from document headings
+- **Smooth Scrolling**: Click TOC items for smooth navigation to sections
+- **Hash URLs**: Address bar updates with section anchors for sharing
+- **Mobile Menu**: Collapsible sidebar for mobile devices
+
+### Print Styling
+- **Page Breaks**: Tables won't split across pages
+- **Header Repetition**: Table headers repeat on each page
+- **Professional Layout**: Optimized margins and typography
+- **Page Numbers**: Sequential page numbering in footer
+
+### Responsive Design
+- **Desktop**: Full sidebar with TOC always visible
+- **Tablet**: Collapsible sidebar with overlay
+- **Mobile**: Hamburger menu with full-screen TOC overlay
+
+## Advanced Usage
+
+### Custom Templates
+You can customize the viewer template by:
+1. Copying `viewer-template.html` to your project
+2. Modifying the CSS and HTML structure
+3. Updating `zddc.conf` to point to your custom template
+
+### Batch Processing
+For large document sets:
+```bash
+# Process all markdown files recursively
+find . -name "*.md" -exec ./convert -f -o rendered/ {} +
+
+# Process specific document types
+./convert -f -o rendered/ *-SOW-*.md *-DBD-*.md
+```
+
+### Integration with Build Systems
+The convert tool returns proper exit codes and can be integrated into CI/CD pipelines:
+```bash
+# In a build script
+if ./convert -f -o dist/ *.md; then
+    echo "Documentation built successfully"
+else
+    echo "Documentation build failed"
+    exit 1
+fi
+```
+
+## File Types Supported
+
+- **Input**: Markdown (`.md`) files with pandoc extensions
+- **Output**: HTML files with embedded CSS and JavaScript
+- **Images**: Supports embedded images and diagrams
+- **Tables**: Full table support with print optimization
+- **Code**: Syntax highlighting for code blocks
+
+## Dependencies
+
+- **pandoc**: Document conversion engine
+- **Modern browser**: For viewing generated HTML files
+- **Optional**: Web server for serving files (prevents CORS issues)
+
+## Troubleshooting
+
+### Common Issues
+1. **Template not found**: Ensure `zddc.conf` points to correct template path
+2. **Permission errors**: Make sure `convert` script is executable (`chmod +x convert`)
+3. **Missing output**: Check that output directory exists or use `-o` to create it
+4. **Print issues**: Use "Print to PDF" in browser for best results
+
+### Performance
+- Large documents (>1000 pages) may take longer to render
+- Consider splitting very large documents into sections
+- Use batch processing for multiple files
+
+## Examples
+
+### Engineering Documentation
+Perfect for:
+- Design basis documents
+- Specifications and standards
+- Project requirements
+- Technical procedures
+- Quality documentation
+
+### Features Optimized For
+- **Professional appearance**: Clean, corporate styling
+- **Technical content**: Tables, diagrams, code blocks
+- **Print output**: PDF generation with proper formatting
+- **Navigation**: Easy browsing of long documents
+- **Sharing**: URL fragments for referencing specific sections
diff --git a/pandoc/convert b/pandoc/convert
new file mode 100644
index 0000000..7083394
--- /dev/null
+++ b/pandoc/convert
@@ -0,0 +1,552 @@
+#!/bin/bash
+
+# Function to show help
+show_help() {
+    echo "Universal File Converter"
+    echo "Supported conversions: DOCX→MD, MD→HTML, HTML→MD, MD→DOCX, HTML→DOCX"
+    echo "Usage: $0 [-f] [-o outputdir] [-t format] [-T template] [--no-toc] input1.ext [input2.ext ...]"
+    echo "  -f: Force overwrite existing output files"
+    echo "  -o: Output directory (default: same as input)"
+    echo "  -t: Target format (md, html, docx) - overrides auto-detection"
+    echo "  -T: Template file path (default: viewer-template.html)"
+    echo "  --no-toc: Skip table of contents generation"
+}
+
+# Function to source ZDDC config files if they exist
+source_config_file() {
+    local config_file="$1"
+    if [ -f "$config_file" ]; then
+        echo "  → Loading ZDDC configuration from: $config_file"
+        set -a  # automatically export all variables
+        . "$config_file"
+        set +a  # turn off automatic export
+        return 0
+    fi
+    return 1
+}
+
+# Load ZDDC configuration file
+load_zddc_config() {
+    local search_dir="$1"
+    
+    # Search for zddc.conf then .zddc.conf in the search directory
+    if source_config_file "$search_dir/zddc.conf"; then
+        return 0
+    elif source_config_file "$search_dir/.zddc.conf"; then
+        return 0
+    fi
+    
+    # No config file found - continue with defaults
+    return 1
+}
+
+# Source global ZDDC config from current working directory
+# This is called once at startup - do NOT call again inside convert functions
+load_zddc_config "$(pwd)"
+
+# Parse arguments
+FORCE_OVERWRITE=false
+OUTPUT_DIR=""
+TARGET_FORMAT=""
+CUSTOM_TEMPLATE=""
+NO_TOC=false
+
+while [ $# -gt 0 ]; do
+    case $1 in
+        -h|--help)
+            show_help
+            exit 0
+            ;;
+        -f)
+            FORCE_OVERWRITE=true
+            echo "Force overwrite mode: ON"
+            shift
+            ;;
+        -o)
+            OUTPUT_DIR="$2"
+            echo "Output directory: $OUTPUT_DIR"
+            shift 2
+            ;;
+        -t)
+            TARGET_FORMAT="$2"
+            echo "Target format: $TARGET_FORMAT"
+            shift 2
+            ;;
+        -T)
+            CUSTOM_TEMPLATE="$2"
+            echo "Custom template: $CUSTOM_TEMPLATE"
+            shift 2
+            ;;
+        --no-toc)
+            NO_TOC=true
+            echo "Table of contents: DISABLED"
+            shift
+            ;;
+        -*)
+            echo "Unknown option: $1"
+            show_help
+            exit 1
+            ;;
+        *)
+            break
+            ;;
+    esac
+done
+
+if [ "$FORCE_OVERWRITE" = "false" ]; then
+    echo "Force overwrite mode: OFF (will skip existing output files)"
+fi
+
+if [ -z "$OUTPUT_DIR" ]; then
+    echo "Output directory: same as input files"
+fi
+
+if [ $# -eq 0 ]; then
+    echo "Error: No input files specified"
+    show_help
+    exit 1
+fi
+
+# Validate target format if specified
+if [ -n "$TARGET_FORMAT" ]; then
+    TARGET_FORMAT_LOWER=$(echo "$TARGET_FORMAT" | tr '[:upper:]' '[:lower:]')
+    if [ "$TARGET_FORMAT_LOWER" != "md" ] && [ "$TARGET_FORMAT_LOWER" != "html" ] && [ "$TARGET_FORMAT_LOWER" != "docx" ]; then
+        echo "Error: Invalid target format '$TARGET_FORMAT'. Supported: md, html, docx"
+        exit 1
+    fi
+    echo "Target format override: $TARGET_FORMAT_LOWER"
+fi
+
+echo "Processing $# files..."
+
+TOTAL_FILES=$#
+SUCCESSFUL=0
+FAILED=0
+SKIPPED=0
+
+# Function to convert DOCX to Markdown
+convert_docx_to_md() {
+    local INPUT="$1"
+    local OUTPUT_FILE="$2"
+    local TEMP_FILE="$3"
+    local MEDIA_DIR="$4"
+    local BASENAME="$5"
+    local FILENAME_NO_EXT="$6"
+    
+    # Convert using pandoc with proper extension stripping to temp file first
+    if pandoc -f docx -t gfm --markdown-headings=atx --extract-media="$MEDIA_DIR" --wrap=none --standalone "$INPUT" -o "$TEMP_FILE"; then
+        
+        # Parse ZDDC filename pattern: trackingNumber_revision (status) - title.extension
+        # Use sed to extract ZDDC components
+        ZDDC_MATCH=$(echo "$FILENAME_NO_EXT" | sed -n 's/^\([^_]*\)_\([^ ]*\) *(\([^)]*\)) *- *\(.*\)$/\1|\2|\3|\4/p')
+        if [ -n "$ZDDC_MATCH" ]; then
+            TRACKING_NUMBER=$(echo "$ZDDC_MATCH" | cut -d'|' -f1)
+            REVISION=$(echo "$ZDDC_MATCH" | cut -d'|' -f2)
+            STATUS=$(echo "$ZDDC_MATCH" | cut -d'|' -f3)
+            TITLE=$(echo "$ZDDC_MATCH" | cut -d'|' -f4)
+            
+            echo "  → ZDDC metadata detected:"
+            echo "    • Tracking: $TRACKING_NUMBER"
+            echo "    • Revision: $REVISION"
+            echo "    • Status: $STATUS"
+            echo "    • Title: $TITLE"
+            
+            # Create YAML front matter and combine with content
+            {
+                echo "---"
+                echo "client: \"${CLIENT:-}\""
+                echo "project: \"${PROJECT:-}\""
+                echo "tracking_number: \"$TRACKING_NUMBER\""
+                echo "revision: \"$REVISION\""
+                echo "status: \"$STATUS\""
+                echo "title: \"$TITLE\""
+                echo "source_file: \"$BASENAME\""
+                echo "created: \"$(date -u +%Y-%m-%d)\""
+                echo "---"
+                echo ""
+                cat "$TEMP_FILE"
+            } > "$OUTPUT_FILE"
+            
+            rm "$TEMP_FILE"
+        else
+            # No ZDDC pattern detected, just move temp file to final location
+            mv "$TEMP_FILE" "$OUTPUT_FILE"
+        fi
+        
+        echo "  ✓ Successfully converted: $BASENAME (DOCX→MD)"
+        return 0
+    else
+        echo "  ✗ Failed to convert: $BASENAME (DOCX→MD)"
+        # Clean up temp file on failure
+        [ -f "$TEMP_FILE" ] && rm "$TEMP_FILE"
+        return 1
+    fi
+}
+
+# Function to convert HTML to Markdown
+convert_html_to_md() {
+    local INPUT="$1"
+    local OUTPUT_FILE="$2"
+    local BASENAME="$3"
+    
+    if pandoc "$INPUT" -f html -t gfm --markdown-headings=atx --wrap=none -o "$OUTPUT_FILE"; then
+        echo "  ✓ Successfully converted: $BASENAME (HTML→MD)"
+        return 0
+    else
+        echo "  ✗ Failed to convert: $BASENAME (HTML→MD)"
+        return 1
+    fi
+}
+
+# Function to convert Markdown to DOCX
+convert_md_to_docx() {
+    local INPUT="$1"
+    local OUTPUT_FILE="$2"
+    local BASENAME="$3"
+    
+    if pandoc "$INPUT" -f gfm -t docx -o "$OUTPUT_FILE"; then
+        echo "  ✓ Successfully converted: $BASENAME (MD→DOCX)"
+        return 0
+    else
+        echo "  ✗ Failed to convert: $BASENAME (MD→DOCX)"
+        return 1
+    fi
+}
+
+# Function to convert HTML to DOCX
+convert_html_to_docx() {
+    local INPUT="$1"
+    local OUTPUT_FILE="$2"
+    local BASENAME="$3"
+    
+    if pandoc "$INPUT" -f html -t docx -o "$OUTPUT_FILE"; then
+        echo "  ✓ Successfully converted: $BASENAME (HTML→DOCX)"
+        return 0
+    else
+        echo "  ✗ Failed to convert: $BASENAME (HTML→DOCX)"
+        return 1
+    fi
+}
+
+# Function to convert Markdown to HTML
+convert_md_to_html() {
+    local INPUT="$1"
+    local OUTPUT_FILE="$2"
+    local BASENAME="$3"
+    local INPUT_DIR="$4"
+    
+    # No need to reload config - already loaded at startup
+    # Config variables from zddc.conf are already in environment
+    
+    # Get absolute paths - use pwd-based approach for POSIX compatibility
+    case "$INPUT" in
+        /*) INPUT_ABS="$INPUT" ;;
+        *) INPUT_ABS="$(pwd)/$INPUT" ;;
+    esac
+    case "$OUTPUT_FILE" in
+        /*) OUTPUT_ABS="$OUTPUT_FILE" ;;
+        *) OUTPUT_ABS="$(pwd)/$OUTPUT_FILE" ;;
+    esac
+    # Determine template to use
+    if [ -n "$CUSTOM_TEMPLATE" ]; then
+        # Use custom template if specified
+        if [ -f "$CUSTOM_TEMPLATE" ]; then
+            TEMPLATE_ABS="$CUSTOM_TEMPLATE"
+            echo "  → Using custom template: $TEMPLATE_ABS"
+        else
+            echo "  ⚠ Warning: Custom template not found: $CUSTOM_TEMPLATE, using default discovery"
+            CUSTOM_TEMPLATE=""
+        fi
+    fi
+    
+    # Default template discovery if no custom template or custom template not found
+    if [ -z "$CUSTOM_TEMPLATE" ]; then
+        # Convert script directory to absolute path
+        SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+        
+        # Check if script is a symlink and resolve target directory
+        SCRIPT_TARGET_DIR=""
+        if [ -L "$0" ]; then
+            # Script is a symlink - resolve the target fully
+            # readlink -f is available on Linux with GNU coreutils
+            SCRIPT_TARGET=$(readlink -f "$0")
+            SCRIPT_TARGET_DIR=$(dirname "$SCRIPT_TARGET")
+        fi
+        
+        # Template search order: input dir, script dir, symlink target dir
+        if [ -f "$INPUT_DIR/viewer-template.html" ]; then
+            TEMPLATE_ABS="$INPUT_DIR/viewer-template.html"
+            echo "  → Using template from input directory: $TEMPLATE_ABS"
+        elif [ -f "$SCRIPT_DIR/viewer-template.html" ]; then
+            TEMPLATE_ABS="$SCRIPT_DIR/viewer-template.html"
+            echo "  → Using template from script directory: $TEMPLATE_ABS"
+        elif [ -n "$SCRIPT_TARGET_DIR" ] && [ -f "$SCRIPT_TARGET_DIR/viewer-template.html" ]; then
+            TEMPLATE_ABS="$SCRIPT_TARGET_DIR/viewer-template.html"
+            echo "  → Using template from symlink target directory: $TEMPLATE_ABS"
+        else
+            echo "  ⚠ Warning: viewer-template.html not found, using pandoc default template"
+            TEMPLATE_ABS=""
+        fi
+    fi
+    
+    # Change to input directory so pandoc can find relative resources
+    ORIGINAL_DIR=$(pwd)
+    cd "$INPUT_DIR"
+    
+    # Build pandoc command using positional arguments (安全方式，无 eval)
+    # 以空格分隔的参数数组，避免 shell 注入
+    PANDOC_ARGS=()
+    PANDOC_ARGS+=("--from" "markdown+yaml_metadata_block")
+    PANDOC_ARGS+=("--standalone")
+    PANDOC_ARGS+=("--embed-resources")
+    PANDOC_ARGS+=("--section-divs")
+    
+    # Add TOC options if not disabled
+    if [ "$NO_TOC" = "false" ]; then
+        PANDOC_ARGS+=("--toc" "--toc-depth=6")
+    fi
+    
+    if [ -n "$TEMPLATE_ABS" ]; then
+        PANDOC_ARGS+=("--template" "$TEMPLATE_ABS")
+    fi
+    
+    # Generate timestamp for conversion (force English locale)
+    GENERATION_TIME=$(LC_TIME=C date '+%B %d, %Y at %I:%M:%S %p %Z')
+    
+    # Extract ZDDC metadata from filename for template variables
+    FILENAME_NO_EXT=$(basename "$INPUT" .md)
+    ZDDC_MATCH=$(echo "$FILENAME_NO_EXT" | sed -n 's/^\([^_]*\)_\([^ ]*\) *(\([^)]*\)) *- *\(.*\)$/\1|\2|\3|\4/p')
+    if [ -n "$ZDDC_MATCH" ]; then
+        TRACKING_NUMBER=$(echo "$ZDDC_MATCH" | cut -d'|' -f1)
+        REVISION=$(echo "$ZDDC_MATCH" | cut -d'|' -f2)
+        STATUS=$(echo "$ZDDC_MATCH" | cut -d'|' -f3)
+        TITLE=$(echo "$ZDDC_MATCH" | cut -d'|' -f4)
+        
+        # Pass ZDDC variables to template (each as separate args to avoid injection)
+        PANDOC_ARGS+=("--variable" "tracking_number=$TRACKING_NUMBER")
+        PANDOC_ARGS+=("--variable" "revision=$REVISION")
+        PANDOC_ARGS+=("--variable" "status=$STATUS")
+        PANDOC_ARGS+=("--variable" "generation_time=$GENERATION_TIME")
+        PANDOC_ARGS+=("--variable" "title=$TITLE")
+        case "$REVISION" in
+            *~*)
+                PANDOC_ARGS+=("--variable" "is_draft=true")
+                ;;
+        esac
+    else
+        # Still pass generation time even if no ZDDC match
+        PANDOC_ARGS+=("--variable" "generation_time=$GENERATION_TIME")
+    fi
+
+    # Add ZDDC configuration variables from zddc.conf
+    if [ -n "$client" ]; then
+        PANDOC_ARGS+=("--variable" "client=$client")
+    fi
+    if [ -n "$project" ]; then
+        PANDOC_ARGS+=("--variable" "project=$project")
+    fi
+    if [ -n "$contractor" ]; then
+        PANDOC_ARGS+=("--variable" "contractor=$contractor")
+    fi
+    if [ -n "$project_number" ]; then
+        PANDOC_ARGS+=("--variable" "project_number=$project_number")
+    fi
+    
+    # Pass TOC status to template
+    if [ "$NO_TOC" = "true" ]; then
+        PANDOC_ARGS+=("--variable" "no-toc=true")
+    fi
+    
+    PANDOC_ARGS+=("--section-divs")
+    PANDOC_ARGS+=("--id-prefix=")
+    PANDOC_ARGS+=("--html-q-tags")
+    
+    # Run pandoc with positional arguments (安全方式)
+    # All variables passed as separate arguments to avoid shell injection
+    if pandoc "$(basename "$INPUT_ABS")" -o "$OUTPUT_ABS" "${PANDOC_ARGS[@]}"; then
+        
+        echo "  ✓ Successfully converted: $BASENAME (MD→HTML)"
+        cd "$ORIGINAL_DIR"
+        return 0
+    else
+        echo "  ✗ Failed to convert: $BASENAME (MD→HTML)"
+        cd "$ORIGINAL_DIR"
+        return 1
+    fi
+}
+
+for INPUT in "$@"; do
+    echo ""
+    echo "Processing: $INPUT"
+    
+    # Validate input file exists
+    if [ ! -f "$INPUT" ]; then
+        echo "  ✗ Input file not found: $INPUT"
+        FAILED=$((FAILED + 1))
+        continue
+    fi
+    
+    # Extract filename without path and extension 
+    BASENAME=$(basename "$INPUT")
+    FILENAME_NO_EXT="${BASENAME%.*}"
+    EXTENSION="${BASENAME##*.}"
+    INPUT_DIR=$(dirname "$INPUT")
+    
+    # Convert extension to lowercase for comparison
+    EXTENSION_LOWER=$(echo "$EXTENSION" | tr '[:upper:]' '[:lower:]')
+    
+    # Determine conversion type based on target format override or auto-detection
+    if [ -n "$TARGET_FORMAT" ]; then
+        # Target format specified - determine conversion type
+        TARGET_EXT="$TARGET_FORMAT_LOWER"
+        case "$EXTENSION_LOWER" in
+            docx)
+                if [ "$TARGET_EXT" = "md" ]; then
+                    CONVERSION_TYPE="docx2md"
+                elif [ "$TARGET_EXT" = "html" ]; then
+                    echo "  ✗ Direct DOCX→HTML conversion not supported. Convert to MD first."
+                    FAILED=$((FAILED + 1))
+                    continue
+                elif [ "$TARGET_EXT" = "docx" ]; then
+                    echo "  ⚠ Skipping: $BASENAME (already DOCX format)"
+                    SKIPPED=$((SKIPPED + 1))
+                    continue
+                fi
+                ;;
+            md)
+                if [ "$TARGET_EXT" = "html" ]; then
+                    CONVERSION_TYPE="md2html"
+                elif [ "$TARGET_EXT" = "docx" ]; then
+                    CONVERSION_TYPE="md2docx"
+                elif [ "$TARGET_EXT" = "md" ]; then
+                    echo "  ⚠ Skipping: $BASENAME (already MD format)"
+                    SKIPPED=$((SKIPPED + 1))
+                    continue
+                fi
+                ;;
+            html|htm)
+                if [ "$TARGET_EXT" = "md" ]; then
+                    CONVERSION_TYPE="html2md"
+                elif [ "$TARGET_EXT" = "docx" ]; then
+                    CONVERSION_TYPE="html2docx"
+                elif [ "$TARGET_EXT" = "html" ]; then
+                    echo "  ⚠ Skipping: $BASENAME (already HTML format)"
+                    SKIPPED=$((SKIPPED + 1))
+                    continue
+                fi
+                ;;
+            *)
+                echo "  ✗ Unsupported input file type: .$EXTENSION (supported: .docx, .md, .html, .htm)"
+                FAILED=$((FAILED + 1))
+                continue
+                ;;
+        esac
+    else
+        # Auto-detect conversion type based on input extension
+        case "$EXTENSION_LOWER" in
+            docx)
+                CONVERSION_TYPE="docx2md"
+                TARGET_EXT="md"
+                ;;
+            md)
+                CONVERSION_TYPE="md2html"
+                TARGET_EXT="html"
+                ;;
+            html|htm)
+                CONVERSION_TYPE="html2md"
+                TARGET_EXT="md"
+                ;;
+            *)
+                echo "  ✗ Unsupported file type: .$EXTENSION (supported: .docx, .md, .html, .htm)"
+                FAILED=$((FAILED + 1))
+                continue
+                ;;
+        esac
+    fi
+    
+    # Determine output location
+    if [ -n "$OUTPUT_DIR" ]; then
+        OUTPUT_FILE="$OUTPUT_DIR/$FILENAME_NO_EXT.$TARGET_EXT"
+        if [ "$CONVERSION_TYPE" = "docx2md" ]; then
+            TEMP_FILE="$OUTPUT_DIR/temp_$FILENAME_NO_EXT.md"
+            MEDIA_DIR="$OUTPUT_DIR/$FILENAME_NO_EXT"
+        fi
+    else
+        OUTPUT_FILE="$INPUT_DIR/$FILENAME_NO_EXT.$TARGET_EXT"
+        if [ "$CONVERSION_TYPE" = "docx2md" ]; then
+            TEMP_FILE="$INPUT_DIR/temp_$FILENAME_NO_EXT.md"
+            MEDIA_DIR="$INPUT_DIR/$FILENAME_NO_EXT"
+        fi
+    fi
+    
+    echo "  → Output file: $OUTPUT_FILE"
+    if [ "$CONVERSION_TYPE" = "docx2md" ]; then
+        echo "  → Media dir: $MEDIA_DIR/"
+    fi
+    
+    # Create output directory if needed
+    OUTPUT_FILE_DIR=$(dirname "$OUTPUT_FILE")
+    if [ ! -d "$OUTPUT_FILE_DIR" ]; then
+        mkdir -p "$OUTPUT_FILE_DIR"
+    fi
+    
+    # Check if output file exists and handle accordingly
+    if [ -f "$OUTPUT_FILE" ] && [ "$FORCE_OVERWRITE" = "false" ]; then
+        echo "  ⚠ Skipped (file exists): $BASENAME"
+        SKIPPED=$((SKIPPED + 1))
+        continue
+    fi
+    
+    # Perform conversion based on type
+    case "$CONVERSION_TYPE" in
+        docx2md)
+            if convert_docx_to_md "$INPUT" "$OUTPUT_FILE" "$TEMP_FILE" "$MEDIA_DIR" "$BASENAME" "$FILENAME_NO_EXT"; then
+                SUCCESSFUL=$((SUCCESSFUL + 1))
+            else
+                FAILED=$((FAILED + 1))
+            fi
+            ;;
+        md2html)
+            if convert_md_to_html "$INPUT" "$OUTPUT_FILE" "$BASENAME" "$INPUT_DIR"; then
+                SUCCESSFUL=$((SUCCESSFUL + 1))
+            else
+                FAILED=$((FAILED + 1))
+            fi
+            ;;
+        html2md)
+            if convert_html_to_md "$INPUT" "$OUTPUT_FILE" "$BASENAME"; then
+                SUCCESSFUL=$((SUCCESSFUL + 1))
+            else
+                FAILED=$((FAILED + 1))
+            fi
+            ;;
+        md2docx)
+            if convert_md_to_docx "$INPUT" "$OUTPUT_FILE" "$BASENAME"; then
+                SUCCESSFUL=$((SUCCESSFUL + 1))
+            else
+                FAILED=$((FAILED + 1))
+            fi
+            ;;
+        html2docx)
+            if convert_html_to_docx "$INPUT" "$OUTPUT_FILE" "$BASENAME"; then
+                SUCCESSFUL=$((SUCCESSFUL + 1))
+            else
+                FAILED=$((FAILED + 1))
+            fi
+            ;;
+        *)
+            echo "  ✗ Unknown conversion type: $CONVERSION_TYPE"
+            FAILED=$((FAILED + 1))
+            ;;
+    esac
+done
+
+echo ""
+echo "=========================================="
+echo "CONVERSION SUMMARY"
+echo "=========================================="
+echo "Total files processed: $TOTAL_FILES"
+echo "Successful conversions: $SUCCESSFUL"
+echo "Failed conversions: $FAILED"
+echo "Skipped (existing files): $SKIPPED"
+echo "=========================================="
diff --git a/pandoc/convert-diff b/pandoc/convert-diff
new file mode 100644
index 0000000..d4e6b68
--- /dev/null
+++ b/pandoc/convert-diff
@@ -0,0 +1,579 @@
+#!/bin/bash
+
+# convert-diff - Batch diff converter for markdown files
+# Compares pairs of files and outputs HTML diffs using the same template as convert script
+
+# ===== Configuration and variables =====
+CUSTOM_TEMPLATE=""
+NO_TOC=false
+
+# Function to show help
+show_help() {
+    echo "Batch Markdown Diff Converter"
+    echo "Compares pairs of markdown files and outputs HTML diffs using the same template as convert script"
+    echo "Usage: $0 [-f] [-o outputdir] [-T template] [--no-toc] file1_rev_a.md file1_rev_b.md [file2_rev_a.md file1_rev_b.md ...]"
+    echo "  -f: Force overwrite existing output files"
+    echo "  -o: Output directory (default: same as first input file)"
+    echo "  -T: Template file path (default: viewer-template.html)"
+    echo "  --no-toc: Skip table of contents generation"
+    echo ""
+    echo "Arguments:"
+    echo "  Files must be provided in pairs (revision A, revision B)"
+    echo "  Total number of files must be even"
+    echo "  Output files will be named: basename_diff.html"
+}
+
+# Function to source ZDDC config files if they exist
+source_config_file() {
+    local config_file="$1"
+    if [ -f "$config_file" ]; then
+        echo "  → Loading ZDDC configuration from: $config_file"
+        set -a  # automatically export all variables
+        . "$config_file"
+        set +a  # turn off automatic export
+        return 0
+    fi
+    return 1
+}
+
+# Load ZDDC configuration file
+load_zddc_config() {
+    local search_dir="$1"
+    
+    # Search for zddc.conf then .zddc.conf in the search directory
+    if source_config_file "$search_dir/zddc.conf"; then
+        return 0
+    elif source_config_file "$search_dir/.zddc.conf"; then
+        return 0
+    fi
+    
+    # No config file found - continue with defaults
+    return 1
+}
+
+# Function to inject diff controls and styling into HTML
+inject_diff_controls() {
+    local html_file="$1"
+    
+    if [ ! -f "$html_file" ]; then
+        echo "Error: HTML file not found: $html_file"
+        return 1
+    fi
+    
+    # Create temporary files for each component
+    local temp_dir=$(mktemp -d)
+    local css_file="$temp_dir/diff.css"
+    local controls_file="$temp_dir/controls.html"
+    local js_file="$temp_dir/diff.js"
+    
+    # Write CSS to file
+    cat > "$css_file" << 'EOF'
+/* Diff element styling */
+del {
+  background-color: #f8d7da;
+  color: #721c24;
+  text-decoration: line-through;
+  padding: 0.1em 0.2em;
+  border-radius: 0.2em;
+}
+
+u {
+  background-color: #d4edda;
+  color: #155724;
+  text-decoration: none;
+  padding: 0.1em 0.2em;
+  border-radius: 0.2em;
+}
+
+/* Dark mode diff styling */
+@media (prefers-color-scheme: dark) {
+  u {
+    background-color: #1e4620;
+    color: #75dd79;
+  }
+  
+  del {
+    background-color: #4a1e1e;
+    color: #f97583;
+  }
+}
+
+/* View mode controls */
+.diff-controls {
+  position: fixed;
+  top: 20px;
+  right: 20px;
+  background: var(--bg-secondary, #ffffff);
+  border: 1px solid var(--border-color, #e1e5e9);
+  border-radius: 8px;
+  padding: 12px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+  z-index: 1000;
+  font-size: 0.875rem;
+}
+
+.diff-controls h4 {
+  margin: 0 0 8px 0;
+  font-size: 0.875rem;
+  font-weight: 600;
+  color: var(--text-primary, #333);
+}
+
+.view-mode-buttons {
+  display: flex;
+  gap: 4px;
+}
+
+.view-mode-btn {
+  padding: 6px 12px;
+  border: 1px solid var(--border-color, #e1e5e9);
+  background: var(--bg-primary, #ffffff);
+  color: var(--text-color, #333);
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 0.75rem;
+  transition: all 0.2s;
+}
+
+.view-mode-btn:hover {
+  background: var(--hover-bg, #f8f9fa);
+}
+
+.view-mode-btn.active {
+  background: var(--primary-color, #007bff);
+  color: white;
+  border-color: var(--primary-color, #007bff);
+}
+
+/* View mode states */
+body.view-original u {
+  display: none;
+}
+
+body.view-original del {
+  text-decoration: none;
+}
+
+body.view-final del {
+  display: none;
+}
+EOF
+
+    # Write controls HTML to file
+    cat > "$controls_file" << 'EOF'
+        <!-- Diff View Controls -->
+        <div class="diff-controls">
+          <h4>View Mode</h4>
+          <div class="view-mode-buttons">
+            <button class="view-mode-btn active" data-mode="diff">Diff</button>
+            <button class="view-mode-btn" data-mode="original">Original</button>
+            <button class="view-mode-btn" data-mode="final">Final</button>
+          </div>
+        </div>
+EOF
+
+    # Write JavaScript to file
+    cat > "$js_file" << 'EOF'
+<script>
+    // View mode toggle functionality
+    document.addEventListener("DOMContentLoaded", function() {
+      var buttons = document.querySelectorAll(".view-mode-btn");
+      var body = document.body;
+      
+      buttons.forEach(function(button) {
+        button.addEventListener("click", function() {
+          // Remove active class from all buttons
+          buttons.forEach(function(btn) { btn.classList.remove("active"); });
+          
+          // Add active class to clicked button
+          this.classList.add("active");
+          
+          // Update body class for view mode
+          body.className = body.className.replace(/view-\w+/g, "");
+          if (this.dataset.mode !== "diff") {
+            body.classList.add("view-" + this.dataset.mode);
+          }
+        });
+      });
+    });
+</script>
+EOF
+    
+    # Create working copy
+    local temp_html="$temp_dir/temp.html"
+    cp "$html_file" "$temp_html"
+    
+    # Insert CSS before </head>
+    sed -i '/<\/head>/r '"$css_file" "$temp_html"
+    
+    # Insert controls after opening <body> tag
+    sed -i '/<body[^>]*>/r '"$controls_file" "$temp_html"
+    
+    # Insert JavaScript before </body>
+    sed -i '/<\/body>/r '"$js_file" "$temp_html"
+    
+    # Replace original file
+    mv "$temp_html" "$html_file"
+    
+    # Cleanup
+    rm -rf "$temp_dir"
+    
+    echo "  ✓ Diff controls injected successfully"
+}
+
+# Source global ZDDC config from current working directory
+load_zddc_config "$(pwd)"
+
+# Resolve script directory for template discovery
+SCRIPT_DIR=$(cd "$(dirname "$0")" && pwd)
+# Resolve symlink if needed
+if [ -L "$0" ]; then
+    SCRIPT_TARGET=$(readlink -f "$0")
+    SCRIPT_TARGET_DIR=$(dirname "$SCRIPT_TARGET")
+else
+    SCRIPT_TARGET_DIR="$SCRIPT_DIR"
+fi
+
+# Parse arguments
+FORCE_OVERWRITE=false
+OUTPUT_DIR=""
+
+while [ $# -gt 0 ]; do
+    case $1 in
+        -h|--help)
+            show_help
+            exit 0
+            ;;
+        -f)
+            FORCE_OVERWRITE=true
+            echo "Force overwrite mode: ON"
+            shift
+            ;;
+        -o)
+            OUTPUT_DIR="$2"
+            echo "Output directory: $OUTPUT_DIR"
+            shift 2
+            ;;
+        -T)
+            CUSTOM_TEMPLATE="$2"
+            echo "Custom template: $CUSTOM_TEMPLATE"
+            shift 2
+            ;;
+        --no-toc)
+            NO_TOC=true
+            echo "Table of contents: DISABLED"
+            shift
+            ;;
+        -*)
+            echo "Unknown option: $1"
+            show_help
+            exit 1
+            ;;
+        *)
+            break
+            ;;
+    esac
+done
+
+if [ "$FORCE_OVERWRITE" = "false" ]; then
+    echo "Force overwrite mode: OFF (will skip existing output files)"
+fi
+
+if [ -z "$OUTPUT_DIR" ]; then
+    echo "Output directory: same as input files"
+fi
+
+# Validate file count
+if [ $# -eq 0 ]; then
+    echo "Error: No input files specified"
+    show_help
+    exit 1
+fi
+
+if [ $(($# % 2)) -ne 0 ]; then
+    echo "Error: Number of files must be even (pairs of files for comparison)"
+    echo "Provided $# files, but need pairs"
+    show_help
+    exit 1
+fi
+
+TOTAL_PAIRS=$(($# / 2))
+echo "Processing $TOTAL_PAIRS file pairs..."
+
+SUCCESSFUL=0
+FAILED=0
+SKIPPED=0
+
+# Process files in pairs
+while [ $# -gt 0 ]; do
+    FILE1="$1"
+    FILE2="$2"
+    shift 2
+    
+    echo ""
+    echo "Processing pair: $(basename "$FILE1") vs $(basename "$FILE2")"
+    
+    # Validate input files exist
+    if [ ! -f "$FILE1" ]; then
+        echo "  ✗ First file not found: $FILE1"
+        FAILED=$((FAILED + 1))
+        continue
+    fi
+    
+    if [ ! -f "$FILE2" ]; then
+        echo "  ✗ Second file not found: $FILE2"
+        FAILED=$((FAILED + 1))
+        continue
+    fi
+    
+    # Extract base filename for output
+    BASENAME1=$(basename "$FILE1" .md)
+    BASENAME2=$(basename "$FILE2" .md)
+    
+    # Generate output filename with _diff suffix (ZDDC compliant)
+    OUTPUT_BASENAME="${BASENAME1}_diff.html"
+    
+    if [ -n "$OUTPUT_DIR" ]; then
+        OUTPUT_FILE="$OUTPUT_DIR/${OUTPUT_BASENAME}"
+    else
+        FILE1_DIR=$(dirname "$FILE1")
+        OUTPUT_FILE="$FILE1_DIR/${OUTPUT_BASENAME}"
+    fi
+    
+    echo "  → Output file: $OUTPUT_FILE"
+    
+    # Check if output file already exists and skip if not forcing overwrite
+    if [ -f "$OUTPUT_FILE" ] && [ "$FORCE_OVERWRITE" = "false" ]; then
+        echo "  → Output file already exists, skipping (use -f to overwrite)"
+        SKIPPED=$((SKIPPED + 1))
+        continue
+    fi
+    
+    # Load ZDDC configuration from first file's directory
+    FILE1_DIR=$(dirname "$FILE1")
+    load_zddc_config "$FILE1_DIR"
+    
+    echo "  → Loading ZDDC configuration from: $FILE1_DIR/zddc.conf"
+    
+    # Determine template to use
+    TEMPLATE_ABS=""
+    if [ -n "$CUSTOM_TEMPLATE" ]; then
+        if [ -f "$CUSTOM_TEMPLATE" ]; then
+            TEMPLATE_ABS="$CUSTOM_TEMPLATE"
+            echo "  → Using custom template: $TEMPLATE_ABS"
+        else
+            echo "  → Custom template not found: $CUSTOM_TEMPLATE"
+            echo "  → Falling back to default template"
+        fi
+    fi
+    
+    # Check for symlinked template in current directory
+    if [ -z "$TEMPLATE_ABS" ] && [ -L "viewer-template.html" ]; then
+        TEMPLATE_TARGET=$(readlink "viewer-template.html")
+        if [ -f "$TEMPLATE_TARGET" ]; then
+            TEMPLATE_ABS="$TEMPLATE_TARGET"
+            echo "  → Using template from symlink target: $TEMPLATE_ABS"
+        fi
+    fi
+    
+    # Check for template in current directory
+    if [ -z "$TEMPLATE_ABS" ] && [ -f "viewer-template.html" ]; then
+        TEMPLATE_ABS="$(pwd)/viewer-template.html"
+        echo "  → Using template from current directory: $TEMPLATE_ABS"
+    fi
+    
+    # Resolve template to absolute path if it's relative
+    if [ -n "$TEMPLATE_ABS" ] && [ "${TEMPLATE_ABS:0:1}" != "/" ]; then
+        if [ -f "$TEMPLATE_ABS" ]; then
+            TEMPLATE_ABS="$(pwd)/$TEMPLATE_ABS"
+        elif [ -f "$SCRIPT_DIR/$TEMPLATE_ABS" ]; then
+            TEMPLATE_ABS="$SCRIPT_DIR/$TEMPLATE_ABS"
+        elif [ -f "$SCRIPT_TARGET_DIR/$TEMPLATE_ABS" ]; then
+            TEMPLATE_ABS="$SCRIPT_TARGET_DIR/$TEMPLATE_ABS"
+        elif [ -f "$SCRIPT_DIR/viewer-template.html" ]; then
+            TEMPLATE_ABS="$SCRIPT_DIR/viewer-template.html"
+        elif [ -f "$SCRIPT_TARGET_DIR/viewer-template.html" ]; then
+            TEMPLATE_ABS="$SCRIPT_TARGET_DIR/viewer-template.html"
+        fi
+    elif [ -z "$TEMPLATE_ABS" ]; then
+        # Fallback to script-relative template discovery
+        if [ -f "$SCRIPT_DIR/viewer-template.html" ]; then
+            TEMPLATE_ABS="$SCRIPT_DIR/viewer-template.html"
+        elif [ -f "$SCRIPT_TARGET_DIR/viewer-template.html" ]; then
+            TEMPLATE_ABS="$SCRIPT_TARGET_DIR/viewer-template.html"
+        fi
+    fi
+    
+    # Create temp file for pandiff output
+    TEMP_DIFF=$(mktemp)
+    
+    # Create temp files for metadata extraction (unique per invocation)
+    TEMP_METADATA_REV1=$(mktemp)
+    TEMP_METADATA_REV2=$(mktemp)
+    
+    echo "Stage 1: Generating diff with pandiff..."
+    
+    # Run pandiff to generate HTML diff
+    if ! pandiff --to html "$FILE1" "$FILE2" > "$TEMP_DIFF"; then
+        echo "  ✗ Failed to generate diff"
+        rm -f "$TEMP_DIFF" "$TEMP_METADATA_REV1" "$TEMP_METADATA_REV2"
+        FAILED=$((FAILED + 1))
+        continue
+    fi
+    
+    echo "  ✓ Diff generated successfully"
+    echo "Stage 2: Adding TOC and styling with pandoc..."
+    
+    # Extract revision info from filenames for metadata
+    REV_A=$(basename "$FILE1" .md | sed 's/.*_\([^_]*\)$/\1/')
+    REV_B=$(basename "$FILE2" .md | sed 's/.*_\([^_]*\)$/\1/')
+    
+    # Extract metadata from both files (safe - no eval, uses heredoc)
+    {
+        # Extract YAML frontmatter and parse fields safely
+        awk '/^---$/{if(NR==1){p=1}else{p=0}} p && !/^---$/{print}' "$FILE1" > "$TEMP_METADATA_REV1"
+        rev1_tracking_number=$(grep '^tracking_number:' "$TEMP_METADATA_REV1" | sed 's/^tracking_number: *"\(.*\)"$/\1/' | head -1)
+        rev1_title=$(grep '^title:' "$TEMP_METADATA_REV1" | sed 's/^title: *"\(.*\)"$/\1/' | head -1)
+        rev1_revision=$(grep '^revision:' "$TEMP_METADATA_REV1" | sed 's/^revision: *"\(.*\)"$/\1/' | head -1)
+        rev1_status=$(grep '^status:' "$TEMP_METADATA_REV1" | sed 's/^status: *"\(.*\)"$/\1/' | head -1)
+        rev1_project=$(grep '^project:' "$TEMP_METADATA_REV1" | sed 's/^project: *"\(.*\)"$/\1/' | head -1)
+        rev1_date=$(grep '^date:' "$TEMP_METADATA_REV1" | sed 's/^date: *"\(.*\)"$/\1/' | head -1)
+    }
+    {
+        awk '/^---$/{if(NR==1){p=1}else{p=0}} p && !/^---$/{print}' "$FILE2" > "$TEMP_METADATA_REV2"
+        rev2_tracking_number=$(grep '^tracking_number:' "$TEMP_METADATA_REV2" | sed 's/^tracking_number: *"\(.*\)"$/\1/' | head -1)
+        rev2_title=$(grep '^title:' "$TEMP_METADATA_REV2" | sed 's/^title: *"\(.*\)"$/\1/' | head -1)
+        rev2_revision=$(grep '^revision:' "$TEMP_METADATA_REV2" | sed 's/^revision: *"\(.*\)"$/\1/' | head -1)
+        rev2_status=$(grep '^status:' "$TEMP_METADATA_REV2" | sed 's/^status: *"\(.*\)"$/\1/' | head -1)
+        rev2_project=$(grep '^project:' "$TEMP_METADATA_REV2" | sed 's/^project: *"\(.*\)"$/\1/' | head -1)
+        rev2_date=$(grep '^date:' "$TEMP_METADATA_REV2" | sed 's/^date: *"\(.*\)"$/\1/' | head -1)
+    }
+    
+    # Clean up metadata temp files
+    rm -f "$TEMP_METADATA_REV1" "$TEMP_METADATA_REV2"
+    
+    # Generate diff-aware header HTML with view mode classes
+    generate_diff_header() {
+        local header_html=""
+        
+        # Project title (should be same for both)
+        header_html="<div class=\"header-line client-project\">$rev2_project (AR 28088)</div>"
+        
+        # Document title with diff
+        if [ "$rev1_title" != "$rev2_title" ]; then
+            header_html="$header_html<div class=\"header-line document-title\"><del>$rev1_title</del><ins>$rev2_title</ins></div>"
+        else
+            header_html="$header_html<div class=\"header-line document-title\">$rev2_title</div>"
+        fi
+        
+        # Tracking number and revision with diff
+        local tracking_rev_line=""
+        if [ "$rev1_tracking_number" != "$rev2_tracking_number" ]; then
+            tracking_rev_line="<del>$rev1_tracking_number</del><ins>$rev2_tracking_number</ins>"
+        else
+            tracking_rev_line="$rev1_tracking_number"
+        fi
+        
+        if [ "$rev1_revision" != "$rev2_revision" ]; then
+            tracking_rev_line="$tracking_rev_line Revision: <del>$rev1_revision</del><ins>$rev2_revision</ins>"
+        else
+            tracking_rev_line="$tracking_rev_line Revision: $rev1_revision"
+        fi
+        
+        if [ "$rev1_status" != "$rev2_status" ]; then
+            tracking_rev_line="$tracking_rev_line Status: <del>$rev1_status</del><ins>$rev2_status</ins>"
+        else
+            tracking_rev_line="$tracking_rev_line Status: $rev1_status"
+        fi
+        
+        header_html="$header_html<div class=\"header-line\">$tracking_rev_line</div>"
+        
+        # Add draft marker if revision contains ~
+        if echo "$rev2_revision" | grep -q "~"; then
+            header_html="$header_html<div class=\"header-line metadata-line draft-line\"><span class=\"draft-status\">[DRAFT Generated at $(date '+%B %d, %Y at %I:%M:%S %p %Z')]</span></div>"
+        fi
+        
+        echo "$header_html"
+    }
+    
+    DIFF_HEADER_HTML=$(generate_diff_header)
+    
+    # Generate timestamp for conversion
+    GENERATION_TIME=$(date '+%B %d, %Y at %I:%M:%S %p %Z')
+    
+    # Set resource path to second file directory for resource resolution
+    FILE2_DIR=$(dirname "$FILE2")
+    
+    # Escape HTML for safe shell usage
+    ESCAPED_HEADER_HTML=$(printf '%s' "$DIFF_HEADER_HTML" | sed 's/"/\\"/g')
+    
+    # Build pandoc command as array (not string with eval)
+    PANDOC_ARGS=(
+        "pandoc" "$TEMP_DIFF" "-o" "$OUTPUT_FILE"
+        "--from" "html"
+        "--standalone"
+        "--template=$TEMPLATE_ABS"
+    )
+    
+    # Add TOC args if not disabled
+    if [ "$NO_TOC" != "true" ]; then
+        PANDOC_ARGS+=("--toc" "--toc-depth=3")
+    fi
+    
+    PANDOC_ARGS+=(
+        "--css=$SCRIPT_DIR/custom.css"
+        "--resource-path=$FILE2_DIR"
+        "--metadata" "title=$rev2_title"
+        "--metadata" "generation_time=$GENERATION_TIME"
+        "--metadata" "diff_mode=true"
+        "--metadata" "custom_header=$ESCAPED_HEADER_HTML"
+    )
+    
+    # Add ZDDC configuration variables from zddc.conf (only once)
+    if [ -n "$client" ]; then
+        PANDOC_ARGS+=("--variable" "client=$client")
+    fi
+    if [ -n "$project" ]; then
+        PANDOC_ARGS+=("--variable" "project=$project")
+    fi
+    if [ -n "$contractor" ]; then
+        PANDOC_ARGS+=("--variable" "contractor=$contractor")
+    fi
+    if [ -n "$project_number" ]; then
+        PANDOC_ARGS+=("--variable" "project_number=$project_number")
+    fi
+    
+    # Pass TOC status to template
+    if [ "$NO_TOC" = "true" ]; then
+        PANDOC_ARGS+=("--variable" "no-toc=true")
+    fi
+    
+    PANDOC_ARGS+=("--section-divs" "--id-prefix=" "--html-q-tags")
+    
+    # Execute pandoc via array (no eval)
+    if "${PANDOC_ARGS[@]}"; then
+        echo "  ✓ HTML generated successfully"
+        
+        echo "Stage 3: Adding diff view controls..."
+        inject_diff_controls "$OUTPUT_FILE"
+        
+        echo "  ✓ Successfully created diff HTML: $(basename "$OUTPUT_FILE")"
+        SUCCESSFUL=$((SUCCESSFUL + 1))
+    else
+        echo "  ✗ Failed to convert diff to HTML"
+        FAILED=$((FAILED + 1))
+    fi
+    
+    # Clean up temp file
+    rm -f "$TEMP_DIFF"
+done
+
+echo ""
+echo "=========================================="
+echo "DIFF CONVERSION SUMMARY"
+echo "=========================================="
+echo "Total pairs processed: $TOTAL_PAIRS"
+echo "Successful conversions: $SUCCESSFUL"
+echo "Failed conversions: $FAILED"
+echo "Skipped (existing files): $SKIPPED"
+echo "=========================================="
diff --git a/pandoc/custom.css b/pandoc/custom.css
new file mode 100644
index 0000000..a391f6a
--- /dev/null
+++ b/pandoc/custom.css
@@ -0,0 +1,163 @@
+/* 
+ * Legal-style heading numbering for ZDDC documents
+ * Adds hierarchical numbering like 1, 1.1, 1.1.1, etc.
+ */
+
+/* Reset counters at document level */
+.document-content {
+  counter-reset: h1-counter;
+}
+
+/* H1 counters */
+h1 {
+  counter-reset: h2-counter h3-counter h4-counter h5-counter h6-counter;
+  counter-increment: h1-counter;
+}
+
+h1::before {
+  content: counter(h1-counter) ". ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H2 counters */
+h2 {
+  counter-reset: h3-counter h4-counter h5-counter h6-counter;
+  counter-increment: h2-counter;
+}
+
+h2::before {
+  content: counter(h1-counter) "." counter(h2-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H3 counters */
+h3 {
+  counter-reset: h4-counter h5-counter h6-counter;
+  counter-increment: h3-counter;
+}
+
+h3::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H4 counters */
+h4 {
+  counter-reset: h5-counter h6-counter;
+  counter-increment: h4-counter;
+}
+
+h4::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) "." counter(h4-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H5 counters */
+h5 {
+  counter-reset: h6-counter;
+  counter-increment: h5-counter;
+}
+
+h5::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) "." counter(h4-counter) "." counter(h5-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H6 counters */
+h6 {
+  counter-increment: h6-counter;
+}
+
+h6::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) "." counter(h4-counter) "." counter(h5-counter) "." counter(h6-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* TOC numbering to match document headings */
+.toc {
+  counter-reset: toc-h1;
+}
+
+.toc ul {
+  list-style: none;
+}
+
+.toc > ul > li {
+  counter-increment: toc-h1;
+  counter-reset: toc-h2 toc-h3 toc-h4 toc-h5 toc-h6;
+}
+
+.toc > ul > li > a::before {
+  content: counter(toc-h1) ". ";
+  font-weight: bold;
+  color: var(--primary-color);
+  margin-right: 0.25em;
+}
+
+.toc > ul > li > ul > li {
+  counter-increment: toc-h2;
+  counter-reset: toc-h3 toc-h4 toc-h5 toc-h6;
+}
+
+.toc > ul > li > ul > li > a::before {
+  content: counter(toc-h1) "." counter(toc-h2) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+  margin-right: 0.25em;
+}
+
+.toc > ul > li > ul > li > ul > li {
+  counter-increment: toc-h3;
+  counter-reset: toc-h4 toc-h5 toc-h6;
+}
+
+.toc > ul > li > ul > li > ul > li > a::before {
+  content: counter(toc-h1) "." counter(toc-h2) "." counter(toc-h3) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+  margin-right: 0.25em;
+}
+
+/* Optional: Add some spacing after the numbers */
+h1::before, h2::before, h3::before, h4::before, h5::before, h6::before {
+  margin-right: 0.5em;
+}
+
+/* Print-specific adjustments */
+@media print {
+  h1::before, h2::before, h3::before, h4::before, h5::before, h6::before {
+    color: #000 !important; /* Ensure numbers print in black */
+  }
+}
+
+/* Optional: Style adjustments for better visual hierarchy */
+h1 {
+  border-bottom: 2px solid var(--primary-color);
+  padding-bottom: 0.3em;
+  margin-top: 1em;
+}
+
+/* Reduce margin for first heading */
+h1:first-of-type {
+  margin-top: 0.5em;
+}
+
+h2 {
+  border-bottom: 1px solid var(--border-color);
+  padding-bottom: 0.2em;
+  margin-top: 1.5em;
+}
+
+h3 {
+  margin-top: 1.2em;
+}
+
+h4, h5, h6 {
+  margin-top: 1em;
+}
diff --git a/pandoc/index.sh b/pandoc/index.sh
new file mode 100644
index 0000000..a42e60c
--- /dev/null
+++ b/pandoc/index.sh
@@ -0,0 +1,351 @@
+#!/bin/bash
+
+# Script to create symlinks and markdown table for ZDDC files
+# Usage: ./index.sh [-o output_dir] <folder1> [folder2] [...]
+# 
+# Creates three types of symlinks in output directory:
+# 1. Full filename symlink
+# 2. trackingNumber.ext (latest revision)  
+# 3. trackingNumber_revision.ext (specific revision)
+# 
+# Also generates index.html in each input folder with summary table
+# CSS and title can be customized via YAML frontmatter in existing index.md files
+
+set -e
+
+cleanup() {
+    unset latest_files
+}
+trap cleanup EXIT
+
+# Default output directory
+OUTPUT_DIR=".archive"
+
+# Parse command line options
+while getopts "o:" opt; do
+    case $opt in
+        o)
+            OUTPUT_DIR="$OPTARG"
+            ;;
+        \?)
+            echo "Invalid option: -$OPTARG" >&2
+            echo "Usage: $0 [-o output_dir] <folder1> [folder2] [...]"
+            exit 1
+            ;;
+    esac
+done
+
+# Shift past the options
+shift $((OPTIND-1))
+
+# Check if at least one folder is provided
+if [ $# -eq 0 ]; then
+    echo "Usage: $0 [-o output_dir] <folder1> [folder2] [...]"
+    echo "Creates symlinks and markdown table for ZDDC files"
+    echo "Options:"
+    echo "  -o output_dir    Output directory (default: .archive)"
+    exit 1
+fi
+
+# Validate all input directories exist
+for folder in "$@"; do
+    if [ ! -d "$folder" ]; then
+        echo "Error: Directory '$folder' does not exist"
+        exit 1
+    fi
+done
+
+# Create output directory
+mkdir -p "$OUTPUT_DIR"
+
+# Function to get relative path from $1 (base dir) to $2 (target path)
+# Uses Python for portability (works on both GNU and BSD systems)
+relative_path() {
+    local base_dir="$1"
+    local target_path="$2"
+    
+    if command -v python3 >/dev/null 2>&1; then
+        python3 -c "import os; print(os.path.relpath('$target_path', '$base_dir'))"
+    else
+        # Fallback: use absolute paths if python3 not available
+        realpath "$target_path"
+    fi
+}
+
+# Function to get revision from symlink target filename
+get_revision_from_target() {
+    local target="$1"
+    local basename_target=$(basename "$target")
+    
+    # Parse ZDDC filename to extract revision
+    if [[ "$basename_target" =~ ^([^_]+)_([^\ ]+)\ +\(([^\)]+)\)\ *-\ *(.+)\.([^.]+)$ ]]; then
+        echo "${BASH_REMATCH[2]}"
+    fi
+}
+
+# Function to check if revision A is greater than revision B
+is_revision_greater() {
+    local rev_a="$1"
+    local rev_b="$2"
+    
+    # Remove tilde prefix for comparison
+    local clean_a="${rev_a#~}"
+    local clean_b="${rev_b#~}"
+    
+    # Use version sort to compare
+    [ "$(printf '%s\n%s\n' "$clean_b" "$clean_a" | sort -V | tail -n1)" = "$clean_a" ] && [ "$clean_a" != "$clean_b" ]
+}
+
+echo "Processing ZDDC files from folders: $*"
+echo "Output directory: $OUTPUT_DIR"
+
+
+# Process each folder individually
+for folder in "$@"; do
+    echo "Processing folder: $folder"
+    
+    # Track latest revisions for each tracking number (per folder)
+    declare -A latest_files
+    
+    # Sequential counter for table rows (per folder)
+    row_counter=0
+    
+    # Set title for this folder
+    title="Document Index - $(basename "$folder")"
+    
+    # Initialize markdown file with CSS and title for this folder
+    index_md_file="$folder/index.md"
+    
+    # Check if index.md exists without sentinel comment
+    sentinel="<!-- Generated by zddc index.sh -->"
+    if [ -f "$index_md_file" ]; then
+        if ! grep -qF "$sentinel" "$index_md_file" 2>/dev/null; then
+            echo "  Warning: $index_md_file already exists and was not generated by this script"
+            echo "  Backing up to ${index_md_file}.bak"
+            mv "$index_md_file" "${index_md_file}.bak"
+        fi
+    fi
+    
+    cat > "$index_md_file" <<EOF
+<!-- Generated by zddc index.sh -->
+
+---
+title: "$title"
+---
+
+<style>
+body { 
+    max-width: none !important; 
+    margin: 20px !important; 
+    font-family: Arial, sans-serif !important;
+}
+table { 
+    width: 100% !important; 
+    border-collapse: collapse !important; 
+    table-layout: auto !important;
+    border: 1px solid #ccc !important;
+}
+th, td {
+    padding: 8px !important;
+    vertical-align: top !important;
+    border: 1px solid #ccc !important;
+    white-space: nowrap !important;
+}
+th {
+    background-color: #f0f0f0 !important;
+    font-weight: bold !important;
+}
+th:nth-child(1), td:nth-child(1) {
+    width: 1% !important;
+    text-align: center !important;
+}
+th:nth-child(3), td:nth-child(3) { 
+    white-space: normal !important;
+    width: 100% !important;
+}
+th:nth-child(4), td:nth-child(4) {
+    text-align: center !important;
+}
+th:nth-child(5), td:nth-child(5) {
+    text-align: center !important;
+}
+th:nth-child(6), td:nth-child(6) {
+    text-align: center !important;
+}
+</style>
+
+| # | TRACKING NO | TITLE | REV | STATUS | SHA256 |
+|---|---|---|---|---|---|
+EOF
+    
+    # Find all files in current folder
+    while IFS= read -r -d '' file; do
+        filename=$(basename "$file")
+        
+        # Skip index.md and index.html files
+        if [[ "$filename" == "index.md" || "$filename" == "index.html" ]]; then
+            continue
+        fi
+        
+        # Parse ZDDC filename: trackingNumber_revision (status) - title.extension
+        # Skip files that don't match ZDDC format
+        if [[ ! "$filename" =~ ^([^_]+)_([^\ ]+)\ +\(([^\)]+)\)\ *-\ *(.+)\.([^.]+)$ ]]; then
+            echo "  Skipping non-ZDDC file: $filename"
+            continue
+        fi
+        
+        tracking_number="${BASH_REMATCH[1]}"
+        revision="${BASH_REMATCH[2]}"
+        status="${BASH_REMATCH[3]}"
+        doc_title="${BASH_REMATCH[4]}"
+        extension="${BASH_REMATCH[5]}"
+        
+        # Remove tilde prefix from revision for comparison (draft indicator)
+        clean_revision="${revision#~}"
+        
+        # Calculate SHA256
+        sha256=$(sha256sum "$file" | cut -d' ' -f1)
+        
+        # Create full filename symlink (always safe to overwrite)
+        ln -sf "$(relative_path "$OUTPUT_DIR" "$file")" "$OUTPUT_DIR/$filename"
+        
+        # Handle specific revision symlink with conflict detection
+        specific_name="${tracking_number}_${revision}.${extension}"
+        specific_path="$OUTPUT_DIR/$specific_name"
+        
+        if [ -L "$specific_path" ]; then
+            # Symlink exists, check if it's the same file
+            existing_target=$(readlink "$specific_path")
+            existing_absolute=$(realpath "$OUTPUT_DIR/$existing_target" 2>/dev/null || echo "")
+            current_absolute=$(realpath "$file")
+            
+            if [ "$existing_absolute" != "$current_absolute" ]; then
+                # Different files claiming same revision - check SHA256
+                if [ -f "$existing_absolute" ]; then
+                    existing_sha256=$(sha256sum "$existing_absolute" | cut -d' ' -f1)
+                    if [ "$existing_sha256" != "$sha256" ]; then
+                        echo "  ERROR: Revision conflict for $specific_name"
+                        echo "    Existing: $existing_absolute (SHA256: $existing_sha256)"
+                        echo "    New:      $current_absolute (SHA256: $sha256)"
+                        echo "    Different files claim to be the same revision. Skipping."
+                        continue
+                    else
+                        echo "  Duplicate file detected for $specific_name (same SHA256), skipping symlink update"
+                    fi
+                else
+                    echo "  Warning: Existing symlink target not found, updating: $specific_name"
+                    ln -sf "$(relative_path "$OUTPUT_DIR" "$file")" "$specific_path"
+                fi
+            else
+                echo "  Symlink already points to same file: $specific_name"
+            fi
+        else
+            # No existing symlink, create it
+            ln -sf "$(relative_path "$OUTPUT_DIR" "$file")" "$specific_path"
+        fi
+        
+        # Track latest revision for each tracking number
+        current_latest="${latest_files[$tracking_number]}"
+        if [ -z "$current_latest" ]; then
+            latest_files["$tracking_number"]="$file|$clean_revision"
+        else
+            current_rev="${current_latest#*|}"
+            if is_revision_greater "$clean_revision" "$current_rev"; then
+                latest_files["$tracking_number"]="$file|$clean_revision"
+            fi
+        fi
+        
+        # Increment row counter
+        row_counter=$((row_counter + 1))
+        
+        # Create hyperlinks relative to output directory from this folder
+        rel_path_to_output=$(relative_path "$folder" "$OUTPUT_DIR")
+        tracking_link="[$tracking_number]($rel_path_to_output/$tracking_number.$extension)"
+        revision_link="[$revision]($rel_path_to_output/${tracking_number}_${revision}.$extension)"
+        
+        # Create truncated SHA256 for display
+        sha256_short="${sha256:0:6}...${sha256: -6}"
+        
+        # Add to markdown table
+        echo "| $row_counter | $tracking_link | $doc_title | $revision_link | $status | <span class=\"sha256\" title=\"$sha256\">$sha256_short</span> |" >> "$index_md_file"
+        
+        echo "  $filename -> symlinks created"
+    done < <(find "$folder" -maxdepth 1 \( -type f -o -type l \) -print0)
+    
+    # Create/update latest revision symlinks for this folder
+    echo "  Creating/updating latest revision symlinks..."
+    for tracking_number in "${!latest_files[@]}"; do
+        file_info="${latest_files[$tracking_number]}"
+        file="${file_info%|*}"
+        new_revision="${file_info#*|}"
+        filename=$(basename "$file")
+        
+        # Extract extension
+        extension="${filename##*.}"
+        
+        # Check latest symlink
+        latest_name="${tracking_number}.${extension}"
+        latest_path="$OUTPUT_DIR/$latest_name"
+        
+        should_update=true
+        
+        if [ -L "$latest_path" ]; then
+            # Existing latest symlink - check revision
+            existing_target=$(readlink "$latest_path")
+            existing_absolute=$(realpath "$OUTPUT_DIR/$existing_target" 2>/dev/null || echo "")
+            
+            if [ -f "$existing_absolute" ]; then
+                existing_revision=$(get_revision_from_target "$existing_absolute")
+                
+                if [ -n "$existing_revision" ]; then
+                    if is_revision_greater "$new_revision" "$existing_revision"; then
+                        echo "    Updating latest: $latest_name ($existing_revision -> $new_revision)"
+                    else
+                        echo "    Keeping existing latest: $latest_name (current: $existing_revision >= new: $new_revision)"
+                        should_update=false
+                    fi
+                else
+                    echo "    Warning: Could not parse revision from existing target, updating: $latest_name"
+                fi
+            else
+                echo "    Warning: Existing latest symlink target not found, updating: $latest_name"
+            fi
+        else
+            echo "    Creating new latest: $latest_name -> $filename"
+        fi
+        
+        if [ "$should_update" = true ]; then
+            ln -sf "$(relative_path "$OUTPUT_DIR" "$file")" "$latest_path"
+        fi
+    done
+
+    # Convert markdown to HTML with pandoc for this folder
+    echo "  Converting to HTML..."
+    if command -v pandoc >/dev/null 2>&1; then
+        pandoc "$index_md_file" -o "$folder/index.html" \
+            --standalone \
+            --embed-resources \
+            --from markdown+raw_html
+        
+        echo "    Markdown file: $folder/index.md"
+        echo "    HTML file: $folder/index.html"
+    else
+        echo "    Warning: pandoc not found, skipping HTML conversion"
+        echo "    Markdown file: $folder/index.md"
+    fi
+    
+    # Reset associative array for next folder
+    unset latest_files
+done
+
+# Count symlinks
+symlink_count=$(find "$OUTPUT_DIR" -type l | wc -l)
+
+echo ""
+echo "Summary:"
+echo "  Output directory: $OUTPUT_DIR"
+echo "  Symlinks created: $symlink_count"
+for folder in "$@"; do
+    echo "  Markdown file: $folder/index.md"
+    echo "  HTML file: $folder/index.html"
+done
diff --git a/pandoc/viewer-template.html b/pandoc/viewer-template.html
new file mode 100644
index 0000000..eaf5464
--- /dev/null
+++ b/pandoc/viewer-template.html
@@ -0,0 +1,1226 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>$if(title)$$title$$else$Document$endif$</title>
+  
+  <!-- Document metadata for JavaScript -->
+  $if(revision)$<meta name="revision" content="$revision$">$endif$
+  $if(generation_time)$<meta name="generation_time" content="$generation_time$">$endif$
+  
+  <!-- Embedded CSS -->
+  <style>
+/*
+* ZDDC Document Viewer Template
+* Enhanced responsive layout with TOC navigation
+*/
+
+/* CSS Variables for theming - Soft Light Theme */
+:root {
+  --primary-color: #2563eb;
+  --primary-color-dark: #1d4ed8;
+  --text-color: #4b5563;
+  --text-secondary: #6b7280;
+  --text-primary: #1f2937;
+  --bg-primary: #f8fafc;
+  --bg-secondary: #f1f5f9;
+  --border-color: #d1d5db;
+  --hover-bg: #e2e8f0;
+  --active-bg: rgba(37, 99, 235, 0.1);
+  --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+  --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+  --sidebar-width: 280px;
+  --header-height: 120px;
+  --content-max-width: 900px;
+}
+
+/* Dark mode variables - Standard Dark Theme */
+@media (prefers-color-scheme: dark) {
+  :root {
+    --primary-color: #60a5fa;
+    --primary-color-dark: #3b82f6;
+    --text-color: #d1d5db;
+    --text-secondary: #9ca3af;
+    --text-primary: #f9fafb;
+    --bg-primary: #111827;
+    --bg-secondary: #1f2937;
+    --border-color: #374151;
+    --hover-bg: #374151;
+    --active-bg: rgba(96, 165, 250, 0.2);
+    --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.3);
+    --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.4), 0 2px 4px -1px rgba(0, 0, 0, 0.3);
+  }
+}
+
+/* Reset and base styles */
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+  line-height: 1.6;
+  color: var(--text-color);
+  background: var(--bg-secondary);
+  height: 100vh;
+  overflow-x: hidden;
+}
+
+@media print {
+  body {
+    height: auto !important;
+    overflow: visible !important;
+  }
+}
+
+/* App Container - Modern CSS Grid Layout */
+.app-container {
+  height: 100vh;
+  display: grid;
+  grid-template-columns: var(--sidebar-width) 1fr;
+  grid-template-areas: "sidebar main";
+}
+
+@media (max-width: 768px) {
+  .app-container {
+    grid-template-columns: 1fr;
+    grid-template-areas: "main";
+  }
+}
+
+/* Content wrapper - Grid area */
+.content-wrapper {
+  grid-area: main;
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  max-width: min(900px, 100%);
+  margin: 0;
+  container-type: inline-size;
+}
+
+/* Content page simplified */
+.content-page {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+}
+
+.header-content {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-start;
+}
+
+/* Sidebar Navigation - Grid area */
+#sidebar {
+  grid-area: sidebar;
+  height: 100vh;
+  background: var(--bg-primary);
+  border-inline-end: 1px solid var(--border-color);
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+@media (max-width: 768px) {
+  #sidebar {
+    position: fixed;
+    inset: 0;
+    z-index: 1000;
+    transform: translateX(-100%);
+    transition: transform 0.3s ease;
+    box-shadow: 2px 0 10px rgba(0, 0, 0, 0.1);
+    background: var(--bg-primary);
+  }
+  
+  #sidebar.mobile-open {
+    transform: translateX(0);
+  }
+  
+  .content-wrapper {
+    max-width: none;
+  }
+  
+  /* Ensure mobile TOC uses light theme colors */
+  #sidebar .sidebar-header {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+  }
+  
+  #sidebar .toc a {
+    color: var(--text-primary);
+  }
+  
+  #sidebar .toc a:hover {
+    background: var(--hover-bg);
+  }
+}
+
+/* Document Header - Flex Row Layout */
+.document-header {
+  background: var(--bg-primary);
+  border-bottom: 1px solid var(--border-color);
+  padding: 1rem;
+  margin-bottom: 0;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  flex-shrink: 0;
+}
+
+.mobile-menu-container {
+  display: none;
+  flex-shrink: 0;
+}
+
+@media (max-width: 768px) {
+  .mobile-menu-container {
+    display: flex;
+    align-items: center;
+  }
+  
+  .mobile-menu-toggle {
+    background: var(--primary-color);
+    color: white;
+    border: none;
+    padding: 0.75rem;
+    border-radius: 0.5rem;
+    font-size: 1.2rem;
+    cursor: pointer;
+    transition: all 0.2s ease;
+    line-height: 1;
+  }
+  
+  .mobile-menu-toggle:hover {
+    background: var(--primary-color-dark);
+    transform: scale(1.05);
+    margin: 0;
+  }
+}
+
+.header-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.sidebar-title {
+  font-size: 1.1rem;
+  font-weight: 600;
+  color: var(--text-primary);
+  margin: 0;
+}
+
+.sidebar-header {
+  padding: 1.25rem 1.5rem;
+  border-bottom: 1px solid var(--border-color);
+  background: var(--bg-secondary);
+}
+
+.toc-header-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+}
+
+.toc-level-selector {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+
+
+.toc-level-selector select {
+  padding: 0.25rem 0.5rem;
+  border: 1px solid var(--border-color);
+  border-radius: 0.25rem;
+  background: var(--bg-primary);
+  color: var(--text-color);
+  font-size: 0.9rem;
+}
+
+/* TOC Container */
+.toc-container {
+  flex: 1;
+  overflow-y: auto;
+  padding: 1rem 0;
+  scrollbar-width: thin;
+  scrollbar-color: var(--border-color) transparent;
+  position: relative;
+}
+
+.toc-container::-webkit-scrollbar {
+  width: 6px;
+}
+
+.toc-container::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.toc-container::-webkit-scrollbar-thumb {
+  background: var(--border-color);
+  border-radius: 3px;
+}
+
+/* Scroll Progress Indicator */
+.scroll-progress {
+  width: 100%;
+  height: 3px;
+  background: var(--border-color);
+  margin-bottom: 20px;
+}
+
+.scroll-progress-bar {
+  height: 100%;
+  background: var(--primary-color);
+  width: 0%;
+  transition: width 0.1s ease;
+}
+
+/* TOC Styling */
+.toc ul {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.toc ul ul {
+  padding-left: 1.25rem;
+  margin-top: 0.25rem;
+  border-left: 2px solid var(--border-color);
+  margin-left: 0.5rem;
+}
+
+.toc li {
+  margin: 0;
+}
+
+.toc a {
+  display: block;
+  padding: 0.375rem 0.75rem;
+  color: var(--text-color);
+  text-decoration: none;
+  border-radius: 4px;
+  transition: all 0.2s ease;
+  font-size: 0.9rem;
+  line-height: 1.3;
+}
+
+.toc li li a {
+  border-left: none;
+}
+
+.toc a:hover {
+  background: var(--hover-bg);
+  color: var(--primary-color);
+}
+
+.toc a.active {
+  background: var(--active-bg);
+  color: var(--primary-color);
+  border-left-color: var(--primary-color);
+  font-weight: 500;
+}
+
+/* Content Page Container - Simplified */
+.content-page {
+  flex: 1;
+  background: var(--bg-primary);
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+}
+
+/* Document Content */
+.document-content {
+  flex: 1;
+  padding: 0.5rem 2rem 2rem 2rem;
+  max-width: var(--content-max-width);
+  margin: 0 auto;
+  overflow-y: auto;
+  position: relative;
+}
+
+/* Document Header */
+.document-header {
+  border-bottom: 1px solid var(--border-color);
+  padding: 0.75rem 2rem;
+  background: var(--bg-primary);
+}
+
+.header-content {
+  max-width: var(--content-max-width);
+  margin: 0 auto;
+}
+
+.header-line {
+  margin: 0;
+  line-height: 1.3;
+}
+
+/* Header line hierarchy */
+.client-project {
+  font-size: 1.2rem;
+  color: var(--text-color);
+  font-weight: 600;
+  margin-bottom: 0.5rem;
+}
+
+.document-title {
+  font-size: 2.2rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  margin-bottom: 0.5rem;
+}
+
+.metadata-line {
+  font-size: 0.9rem;
+  color: var(--text-secondary);
+  font-weight: 400;
+}
+
+.draft-status {
+  color: #dc3545;
+  font-weight: bold;
+  margin-left: 0.5rem;
+}
+
+/* Print-only elements - hidden on screen */
+.print-header,
+.print-footer {
+  display: none;
+}
+
+/* Mobile menu backdrop */
+@media (max-width: 768px) {
+  .mobile-menu-container {
+    display: flex;
+    align-items: center;
+  }
+
+  #sidebar.mobile-open::before {
+    content: '';
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: -1;
+  }
+}
+
+/* Typography */
+h1, h2, h3, h4, h5, h6 {
+  color: var(--text-primary);
+  font-weight: 600;
+  line-height: 1.25;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+}
+
+/* Remove top margin from first heading in content */
+.document-content h1:first-child,
+.document-content h2:first-child,
+.document-content h3:first-child,
+.document-content h4:first-child,
+.document-content h5:first-child,
+.document-content h6:first-child {
+  margin-top: 0;
+}
+
+h1 { font-size: 2rem; }
+h2 { font-size: 1.5rem; }
+h3 { font-size: 1.25rem; }
+h4 { font-size: 1.125rem; }
+h5 { font-size: 1rem; }
+h6 { font-size: 0.875rem; }
+
+p {
+  margin: 1rem 0;
+  color: var(--text-color);
+}
+
+/* Lists */
+ol, ul {
+  margin: 1rem 0;
+  padding-left: 2rem;
+}
+
+ol {
+  list-style-type: decimal;
+}
+
+ul {
+  list-style-type: disc;
+}
+
+li {
+  margin: 0.25rem 0;
+  color: var(--text-color);
+}
+
+/* Nested lists */
+ol ol, ul ul, ol ul, ul ol {
+  margin: 0.25rem 0;
+  padding-left: 1.5rem;
+}
+
+ul ul {
+  list-style-type: circle;
+}
+
+ul ul ul {
+  list-style-type: square;
+}
+
+/* Tables */
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin: 1.5rem 0;
+  font-size: 0.9rem;
+}
+
+th, td {
+  padding: 0.75rem;
+  text-align: left;
+  border-bottom: 1px solid var(--border-color);
+}
+
+/* Print styles */
+@media print {
+  /* Hide online-only elements */
+  .sidebar,
+  .mobile-menu-toggle,
+  .scroll-progress,
+  .document-header {
+    display: none !important;
+  }
+
+  /* Show print-only elements */
+  .print-header {
+    display: block !important;
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    background: white;
+    border-bottom: 1pt solid #000;
+    padding: 12pt 0.5in;
+    z-index: 1000;
+    margin: 0;
+  }
+
+  .print-footer {
+    display: flex !important;
+    position: fixed;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    background: white;
+    border-top: 1pt solid #000;
+    padding: 8pt 0.5in;
+    z-index: 1000;
+    justify-content: space-between;
+    align-items: center;
+    margin: 0;
+  }
+
+  /* Print header styling */
+  .print-header .client-project {
+    font-size: 12pt;
+    color: #333;
+    font-weight: 600;
+    margin: 0 0 4pt 0;
+    line-height: 1.2;
+  }
+
+  .print-header .document-title {
+    font-size: 16pt;
+    color: #000;
+    font-weight: 700;
+    margin: 0;
+    line-height: 1.2;
+  }
+
+  /* Print footer styling */
+  .print-footer .footer-left,
+  .print-footer .footer-right {
+    font-size: 10pt;
+    color: #666;
+    margin: 0;
+  }
+  
+  /* Page counter for print */
+  .print-footer .page-number::after {
+    content: counter(page);
+  }
+  
+  @page {
+    margin: 1in;
+    size: letter;
+    counter-increment: page;
+  }
+  
+  .draft-line {
+    margin-top: 4pt;
+    font-size: 10pt;
+  }
+
+  /* Layout adjustments */
+  .app-container {
+    display: block !important;
+  }
+  
+  .content-wrapper {
+    margin-left: 0 !important;
+    width: 100% !important;
+  }
+
+  .content-page {
+    max-width: none !important;
+    padding: 0 !important;
+  }
+
+  .document-content {
+    margin-top: 80pt !important;
+    margin-bottom: 50pt !important;
+    padding: 0 0.5in !important;
+    border-left: none !important;
+    min-height: calc(100vh - 130pt) !important;
+  }
+
+  /* Fix list formatting in print */
+  ol, ul {
+    padding-left: 2rem !important;
+  }
+
+  li {
+    margin: 0.25rem 0 !important;
+  }
+
+  /* Typography for print */
+  body {
+    font-size: 12pt !important;
+    line-height: 1.4 !important;
+    color: #000 !important;
+    background: white !important;
+  }
+
+  /* Page breaks */
+  h1, h2, h3, h4, h5, h6 {
+    page-break-after: avoid;
+    page-break-inside: avoid;
+    margin-top: 0.5em;
+  }
+
+  p, li {
+    orphans: 3;
+    widows: 3;
+    page-break-inside: avoid;
+  }
+  
+  /* Prevent content cutoff */
+  * {
+    box-sizing: border-box;
+  }
+  
+  /* Ensure proper spacing at page breaks */
+  h1:first-child, h2:first-child, h3:first-child {
+    margin-top: 0;
+    padding-top: 0.5em;
+  }
+  
+  /* Table print formatting */
+  table {
+    page-break-inside: avoid;
+  }
+
+  thead {
+    display: table-header-group;
+  }
+
+  tbody {
+    display: table-row-group;
+  }
+
+  tr {
+    page-break-inside: avoid;
+  }
+
+  th, td {
+    padding: 8pt 6pt !important;
+    vertical-align: top;
+  }
+
+  a {
+    color: #000 !important;
+    text-decoration: underline !important;
+  }
+}
+
+/* Diff styling for pandiff output */
+u {
+  background-color: #d4edda;
+  color: #155724;
+  text-decoration: none;
+  padding: 0.1em 0.2em;
+  border-radius: 0.2em;
+}
+
+/* 
+ * Legal-style heading numbering for ZDDC documents
+ * Adds hierarchical numbering like 1, 1.1, 1.1.1, etc.
+ */
+
+/* Reset counters at document level */
+.document-content {
+  counter-reset: h1-counter;
+}
+
+/* H1 counters */
+h1 {
+  counter-reset: h2-counter h3-counter h4-counter h5-counter h6-counter;
+  counter-increment: h1-counter;
+}
+
+h1::before {
+  content: counter(h1-counter) ". ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H2 counters */
+h2 {
+  counter-reset: h3-counter h4-counter h5-counter h6-counter;
+  counter-increment: h2-counter;
+}
+
+h2::before {
+  content: counter(h1-counter) "." counter(h2-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H3 counters */
+h3 {
+  counter-reset: h4-counter h5-counter h6-counter;
+  counter-increment: h3-counter;
+}
+
+h3::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H4 counters */
+h4 {
+  counter-reset: h5-counter h6-counter;
+  counter-increment: h4-counter;
+}
+
+h4::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) "." counter(h4-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H5 counters */
+h5 {
+  counter-reset: h6-counter;
+  counter-increment: h5-counter;
+}
+
+h5::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) "." counter(h4-counter) "." counter(h5-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* H6 counters */
+h6 {
+  counter-increment: h6-counter;
+}
+
+h6::before {
+  content: counter(h1-counter) "." counter(h2-counter) "." counter(h3-counter) "." counter(h4-counter) "." counter(h5-counter) "." counter(h6-counter) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+}
+
+/* TOC numbering to match document headings */
+.toc {
+  counter-reset: toc-h1;
+}
+
+.toc ul {
+  list-style: none;
+}
+
+.toc > ul > li {
+  counter-increment: toc-h1;
+  counter-reset: toc-h2 toc-h3 toc-h4 toc-h5 toc-h6;
+}
+
+.toc > ul > li > a::before {
+  content: counter(toc-h1) ". ";
+  font-weight: bold;
+  color: var(--primary-color);
+  margin-right: 0.25em;
+}
+
+.toc > ul > li > ul > li {
+  counter-increment: toc-h2;
+  counter-reset: toc-h3 toc-h4 toc-h5 toc-h6;
+}
+
+.toc > ul > li > ul > li > a::before {
+  content: counter(toc-h1) "." counter(toc-h2) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+  margin-right: 0.25em;
+}
+
+.toc > ul > li > ul > li > ul > li {
+  counter-increment: toc-h3;
+  counter-reset: toc-h4 toc-h5 toc-h6;
+}
+
+.toc > ul > li > ul > li > ul > li > a::before {
+  content: counter(toc-h1) "." counter(toc-h2) "." counter(toc-h3) " ";
+  font-weight: bold;
+  color: var(--primary-color);
+  margin-right: 0.25em;
+}
+
+/* Optional: Add some spacing after the numbers */
+h1::before, h2::before, h3::before, h4::before, h5::before, h6::before {
+  margin-right: 0.5em;
+}
+
+/* Print-specific adjustments */
+@media print {
+  h1::before, h2::before, h3::before, h4::before, h5::before, h6::before {
+    color: #000 !important; /* Ensure numbers print in black */
+  }
+}
+
+/* Optional: Style adjustments for better visual hierarchy */
+h1 {
+  border-bottom: 2px solid var(--primary-color);
+  padding-bottom: 0.3em;
+  margin-top: 1em;
+}
+
+/* Reduce margin for first heading */
+h1:first-of-type {
+  margin-top: 0.5em;
+}
+
+h2 {
+  border-bottom: 1px solid var(--border-color);
+  padding-bottom: 0.2em;
+  margin-top: 1.5em;
+}
+
+h3 {
+  margin-top: 1.2em;
+}
+
+h4, h5, h6 {
+  margin-top: 1em;
+}
+
+
+  </style>
+  
+  $for(header-includes)$
+  $header-includes$
+  $endfor$
+</head>
+
+<body>
+  <div class="app-container">
+    $if(toc)$
+    <!-- Sidebar Navigation -->
+    <aside id="sidebar" role="complementary" aria-label="Table of contents">
+      <header class="sidebar-header">
+        <div class="toc-header-row">
+          <div class="sidebar-title">Table Of Contents</div>
+          <div class="toc-level-selector">
+            <select id="toc-level" aria-label="Filter table of contents levels">
+              <option value="1">1</option>
+              <option value="2">2</option>
+              <option value="3" selected>3</option>
+              <option value="4">4</option>
+              <option value="5">5</option>
+              <option value="6">6</option>
+            </select>
+          </div>
+        </div>
+      </header>
+      
+      <div class="toc-container">
+        $if(toc)$
+        <nav class="toc" role="navigation" aria-label="Table of contents">
+          $toc$
+        </nav>
+        $endif$
+      </div>
+    </aside>
+    $endif$
+    <!-- Main Content Area -->
+    <main class="content-wrapper" role="main">
+      <div class="content-page">
+        <!-- Document Header -->
+        <header class="document-header">
+          $if(toc)$
+          <div class="mobile-menu-container">
+            <button class="mobile-menu-toggle" type="button" aria-label="Toggle navigation menu" aria-expanded="false">
+              <span aria-hidden="true">☰</span>
+            </button>
+          </div>
+          $endif$
+          <div class="header-content">
+            $if(client)$$if(project)$
+            <div class="header-line client-project">
+              $client$ - $project$$if(project_number)$ ($project_number$)$endif$
+            </div>
+            $endif$$endif$
+            $if(title)$
+            <div class="document-title">$title$</div>
+            $endif$
+            <div class="document-meta">
+              $if(tracking_number)$<span class="tracking-number">$tracking_number$</span>$endif$
+              $if(revision)$<span class="revision">Revision: $revision$</span>$endif$
+              $if(status)$<span class="status">Status: $status$</span>$endif$
+              $if(revision_comparison)$<span class="revision-comparison">$revision_comparison$</span>$endif$
+            </div>
+            $if(is_draft)$
+            $if(generation_time)$
+            <div class="draft-line">
+              <span class="draft-status">[DRAFT Generated at $generation_time$]</span>
+            </div>
+            $endif$
+            $endif$
+          </div>
+        </header>
+        
+        <!-- Scroll Progress Bar -->
+        <div class="scroll-progress" role="progressbar" aria-label="Reading progress">
+          <div class="scroll-progress-bar"></div>
+        </div>
+        
+        <!-- Print-only header -->
+        <div class="print-header">
+          $if(custom_header)$
+          $custom_header$
+          $else$
+          $if(client)$$if(project)$
+          <div class="header-line client-project">
+            $client$ - $project$$if(project_number)$ ($project_number$)$endif$
+          </div>
+          $endif$$endif$
+          $if(title)$
+          <div class="header-line document-title">$title$</div>
+          $endif$
+          $if(tracking_number)$<div class="header-line">$tracking_number$$if(revision)$ Revision: $revision$$endif$$if(status)$ Status: $status$$endif$</div>$endif$
+          $if(revision_comparison)$<div class="header-line revision-comparison">$revision_comparison$</div>$endif$
+          $endif$
+          $if(generation_time)$
+          <div class="header-line metadata-line draft-line">
+            <span class="draft-status">Generated: $generation_time$</span>
+          </div>
+          $endif$
+        </div>
+
+        <!-- Print-only footer -->
+        <div class="print-footer">
+          <div class="footer-left">
+            $if(tracking_number)$$tracking_number$$endif$$if(revision)$ Revision: $revision$$endif$$if(status)$ Status: $status$$endif$
+          </div>
+          <div class="footer-right">
+            Page <span class="page-number"></span>
+          </div>
+        </div>
+
+
+        <!-- Document Content -->
+        <article class="document-content">
+          $body$
+        </article>
+      </div>
+    </main>
+  </div>
+
+  <!-- Embedded JavaScript -->
+  <script>
+    'use strict';
+
+    // Modern initialization with arrow functions
+    document.addEventListener('DOMContentLoaded', function() {
+      // View mode toggle functionality
+      const buttons = document.querySelectorAll('.view-mode-btn');
+      const body = document.body;
+      
+      buttons.forEach(button => {
+        button.addEventListener('click', function() {
+          const mode = this.dataset.mode;
+          
+          // Remove all view mode classes
+          body.classList.remove('view-original', 'view-final');
+          
+          // Add the selected mode class (except for diff which is default)
+          if (mode === 'original') {
+            body.classList.add('view-original');
+          } else if (mode === 'final') {
+            body.classList.add('view-final');
+          }
+          
+          // Update button states
+          buttons.forEach(btn => btn.classList.remove('active'));
+          this.classList.add('active');
+        });
+      });
+
+      const sidebar = document.getElementById('sidebar');
+      if (sidebar) {
+        initTocNavigation();
+      }
+      
+      // Set default TOC level filtering
+      filterTocLevels('3');
+      
+      // Setup event listeners with delegation
+      setupEventListeners();
+      
+      // Initialize print functionality
+      initPrintSupport();
+    });
+
+    // Modern TOC Navigation with ES6+ patterns
+    function initTocNavigation() {
+      const tocLinks = document.querySelectorAll('.toc a');
+      const contentArea = document.querySelector('.document-content');
+      
+      if (!tocLinks.length || !contentArea) return;
+      
+      // Smooth scroll with event delegation (better performance)
+      function handleTocClick(e) {
+        if (!e.target.matches('.toc a')) return;
+        
+        e.preventDefault();
+        const href = e.target.getAttribute('href');
+        const targetId = href ? href.slice(1) : null;
+        const targetElement = targetId ? document.getElementById(targetId) : null;
+        
+        if (!targetElement) return;
+        
+        targetElement.scrollIntoView({ behavior: 'smooth', block: 'start' });
+        
+        // Update URL hash without adding to browser history
+        window.location.replace(window.location.pathname + window.location.search + href);
+        
+        // Update active state
+        tocLinks.forEach(link => link.classList.remove('active'));
+        e.target.classList.add('active');
+        
+        // Close mobile menu if open
+        const sidebar = document.getElementById('sidebar');
+        if (sidebar && sidebar.classList.contains('mobile-open')) toggleMobileMenu();
+      };
+      
+      document.addEventListener('click', handleTocClick);
+      
+      // TOC scroll tracking using Intersection Observer API
+      // NOTE: Intersection Observer is the industry-standard, recommended approach for scroll spy
+      // implementations as of 2024. It provides better performance (runs off main thread),
+      // cleaner code, and is supported by all modern browsers. Avoid scroll event listeners
+      // for this use case as they are performance-intensive and require complex calculations.
+      // Find all sections with IDs - much simpler approach
+      const sections = Array.from(contentArea.querySelectorAll('section[id]'));
+      
+      
+      if (sections.length === 0) {
+        return;
+      }
+      
+      function updateActiveTocItem(activeSection) {
+        if (!activeSection || !activeSection.id) return;
+        
+        // Clear all active states
+        tocLinks.forEach(link => link.classList.remove('active'));
+        
+        // Find and activate the matching TOC link
+        const activeLink = document.querySelector('.toc a[href="#' + activeSection.id + '"]');
+        if (!activeLink) return;
+        
+        activeLink.classList.add('active');
+        
+        // Auto-scroll TOC to keep active item visible
+        activeLink.scrollIntoView({
+          behavior: 'smooth',
+          block: 'nearest',
+          inline: 'nearest'
+        });
+      };
+      
+      // Create Intersection Observer with industry-standard configuration
+      const observer = new IntersectionObserver(function(entries) {
+        // Find visible sections and update active TOC item
+        const visibleSections = entries.filter(function(entry) { return entry.isIntersecting; });
+        if (visibleSections.length > 0) {
+          // Sort by position in viewport (topmost first)
+          visibleSections.sort(function(a, b) { return a.boundingClientRect.top - b.boundingClientRect.top; });
+          const activeSection = visibleSections[0].target;
+          updateActiveTocItem(activeSection);
+        }
+      }, {
+        root: contentArea,
+        rootMargin: '-20% 0px -60% 0px', // Only consider sections in the middle 20% of viewport
+        threshold: 0.1
+      });
+      
+      // Observe all sections
+      sections.forEach(function(section) { observer.observe(section); });
+      
+      // Scroll progress bar with throttling for better performance
+      const progressBar = document.querySelector('.scroll-progress-bar');
+      if (progressBar) {
+        let ticking = false;
+        
+        function updateScrollProgress() {
+          const scrollTop = contentArea.scrollTop;
+          const scrollHeight = contentArea.scrollHeight;
+          const clientHeight = contentArea.clientHeight;
+          const scrollPercent = scrollHeight > clientHeight 
+            ? (scrollTop / (scrollHeight - clientHeight)) * 100 
+            : 0;
+          progressBar.style.width = Math.min(100, Math.max(0, scrollPercent)) + '%';
+          ticking = false;
+        };
+        
+        function onScroll() {
+          if (!ticking) {
+            requestAnimationFrame(updateScrollProgress);
+            ticking = true;
+          }
+        };
+        
+        contentArea.addEventListener('scroll', onScroll, { passive: true });
+        updateScrollProgress(); // Initial call
+      }
+    };
+
+    // Toggle mobile menu with ARIA support
+    function toggleMobileMenu() {
+      const sidebar = document.getElementById('sidebar');
+      const menuToggle = document.querySelector('.mobile-menu-toggle');
+      
+      if (!sidebar || !menuToggle) return;
+      
+      const isOpen = sidebar.classList.toggle('mobile-open');
+      menuToggle.setAttribute('aria-expanded', isOpen.toString());
+    };
+
+    // Filter TOC levels with modern patterns
+    function filterTocLevels(maxLevel) {
+      const toc = document.querySelector('.toc');
+      if (!toc) return;
+      
+      const allItems = toc.querySelectorAll('li');
+      const maxLevelNum = parseInt(maxLevel);
+      const showAll = maxLevel === '6';
+      
+      allItems.forEach(function(item) {
+        const link = item.querySelector('a');
+        if (!link) return;
+        
+        if (showAll) {
+          item.style.display = '';
+          return;
+        }
+        
+        // Calculate nesting level more efficiently
+        let level = 1;
+        let parent = item.parentElement;
+        while (parent && !parent.classList.contains('toc')) {
+          if (parent.tagName === 'LI') level++;
+          parent = parent.parentElement;
+        }
+        
+        item.style.display = level <= maxLevelNum ? '' : 'none';
+      });
+    };
+
+
+    // Setup event listeners with delegation
+    function setupEventListeners() {
+      // TOC level selector
+      const tocLevelSelect = document.getElementById('toc-level');
+      if (tocLevelSelect) tocLevelSelect.addEventListener('change', function(e) {
+        filterTocLevels(e.target.value);
+      });
+      
+      // Mobile menu toggle
+      const menuToggle = document.querySelector('.mobile-menu-toggle');
+      if (menuToggle) menuToggle.addEventListener('click', toggleMobileMenu);
+      
+      // Close mobile menu on outside click
+      document.addEventListener('click', function(e) {
+        const sidebar = document.getElementById('sidebar');
+        const menuToggle = document.querySelector('.mobile-menu-toggle');
+        
+        if (sidebar && sidebar.classList.contains('mobile-open') && 
+            !sidebar.contains(e.target) && 
+            (!menuToggle || !menuToggle.contains(e.target))) {
+          toggleMobileMenu();
+        }
+      });
+      
+      // Handle escape key to close mobile menu
+      document.addEventListener('keydown', function(e) {
+        if (e.key === 'Escape') {
+          const sidebar = document.getElementById('sidebar');
+          if (sidebar && sidebar.classList.contains('mobile-open')) {
+            toggleMobileMenu();
+          }
+        }
+      });
+    };
+
+    // Initialize print support and draft status
+    function initPrintSupport() {
+      // Handle draft status for revisions containing tilde (~)
+      const revision = document.querySelector('meta[name="revision"]');
+      const generationTime = document.querySelector('meta[name="generation_time"]');
+      
+      if (revision && generationTime) {
+        const revisionValue = revision.getAttribute('content');
+        const timeValue = generationTime.getAttribute('content');
+        
+        if (revisionValue && revisionValue.includes('~') && timeValue) {
+          const draftElements = document.querySelectorAll('.draft-status');
+          draftElements.forEach(function(element) {
+            element.textContent = ' [DRAFT Generated at ' + timeValue + ']';
+          });
+        }
+      }
+    }
+
+    // Export functions for global access (maintaining backward compatibility)
+    window.toggleMobileMenu = toggleMobileMenu;
+    window.filterTocLevels = filterTocLevels;
+  </script>
+</body>
+</html>
diff --git a/pandoc/zddc.conf b/pandoc/zddc.conf
new file mode 100644
index 0000000..e1c4e2b
--- /dev/null
+++ b/pandoc/zddc.conf
@@ -0,0 +1,18 @@
+# zddc.conf - ZDDC project configuration
+# Place this file in your project directory. It is sourced by the convert and
+# convert-diff scripts to inject project-level metadata into the document header.
+#
+# Variables defined here are passed to pandoc as --variable arguments and
+# are available in the viewer template as $client$, $project$, etc.
+
+# Name of the contracting organization (appears in document header)
+contractor="Contractor Name"
+
+# Client organization name (appears in document header as "Client - Project")
+client="Client Name"
+
+# Full project name (appears in document header paired with client)
+project="Project Name"
+
+# Project number or identifier (appears in parentheses after project name)
+project_number="Project Number"
diff --git a/playwright.config.js b/playwright.config.js
new file mode 100644
index 0000000..928eee1
--- /dev/null
+++ b/playwright.config.js
@@ -0,0 +1,59 @@
+import { defineConfig } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './tests',
+  timeout: 30000,
+  retries: 0,
+  reporter: [['line'], ['html', { open: 'never' }]],
+
+  use: {
+    // Chromium only -- File System Access API requires it,
+    // and the ZDDC tools target "any modern Chromium-based browser"
+    browserName: 'chromium',
+    screenshot: 'only-on-failure',
+    trace: 'retain-on-failure',
+  },
+
+  projects: [
+    {
+      name: 'archive',
+      testMatch: 'archive.spec.js',
+    },
+    {
+      name: 'transmittal',
+      testMatch: 'transmittal.spec.js',
+    },
+    {
+      name: 'transmittal-init',
+      testMatch: 'transmittal-init-check.spec.js',
+    },
+    {
+      name: 'transmittal-drag-drop',
+      testMatch: 'transmittal-drag-drop.spec.js',
+    },
+    {
+      name: 'classifier',
+      testMatch: 'classifier.spec.js',
+    },
+    {
+      name: 'mdedit',
+      testMatch: 'mdedit.spec.js',
+    },
+    {
+      name: 'zddc',
+      testMatch: 'zddc.spec.js',
+    },
+    {
+      name: 'zddc-filter',
+      testMatch: 'zddc-filter.spec.js',
+    },
+    {
+      name: 'build-label',
+      testMatch: 'build-label.spec.js',
+    },
+    {
+      name: 'schema',
+      testMatch: 'schema.spec.js',
+    },
+  ],
+});
diff --git a/shared/base.css b/shared/base.css
new file mode 100644
index 0000000..a0e0aa1
--- /dev/null
+++ b/shared/base.css
@@ -0,0 +1,490 @@
+/* ==========================================================================
+   ZDDC Shared Base — single source of truth for tokens and primitives
+   Included first by every tool's build.sh via ../shared/base.css
+   ========================================================================== */
+
+/* ── CSS custom properties ────────────────────────────────────────────────── */
+:root {
+    /* Brand / accent (matches zddc.varasys.io website --accent) */
+    --primary:        #2a5a8a;
+    --primary-hover:  #1d4060;
+    --primary-active: #163352;
+    --primary-light:  #e8f0f7;
+
+    /* Semantic colours */
+    --success: #28a745;
+    --warning: #d97706;
+    --danger:  #dc3545;
+    --info:    #17a2b8;
+
+    /* Backgrounds */
+    --bg:           #ffffff;
+    --bg-secondary: #f8f9fa;
+    --bg-hover:     #f0f4f8;
+    --bg-selected:  var(--primary-light);
+
+    /* Text */
+    --text:       #212529;
+    --text-muted: #6c757d;
+    --text-light: #ffffff;
+
+    /* Borders */
+    --border:      #dee2e6;
+    --border-dark: #adb5bd;
+
+    /* Shape */
+    --radius: 4px;
+
+    /* Typography */
+    --font:      -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    --font-mono: 'SF Mono', 'Fira Code', 'Consolas', 'Courier New', monospace;
+}
+
+/* ── Dark mode tokens ─────────────────────────────────────────────────────── */
+/* Applied via: OS preference (auto) or [data-theme="dark"] on <html>          */
+/* The [data-theme="light"] selector locks light mode regardless of OS pref.   */
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+        --primary:        #4a90c4;
+        --primary-hover:  #5ba3d9;
+        --primary-active: #6ab5e8;
+        --primary-light:  #1a3550;
+
+        --bg:           #1e1e1e;
+        --bg-secondary: #252526;
+        --bg-hover:     #2d2d30;
+        --bg-selected:  #1a3550;
+
+        --text:       #d4d4d4;
+        --text-muted: #9d9d9d;
+        --text-light: #ffffff;
+
+        --border:      #3e3e42;
+        --border-dark: #6e6e72;
+    }
+}
+
+/* Manual dark override — wins over media query */
+[data-theme="dark"] {
+    --primary:        #4a90c4;
+    --primary-hover:  #5ba3d9;
+    --primary-active: #6ab5e8;
+    --primary-light:  #1a3550;
+
+    --bg:           #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover:     #2d2d30;
+    --bg-selected:  #1a3550;
+
+    --text:       #d4d4d4;
+    --text-muted: #9d9d9d;
+    --text-light: #ffffff;
+
+    --border:      #3e3e42;
+    --border-dark: #6e6e72;
+}
+
+/* ── Reset ────────────────────────────────────────────────────────────────── */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* ── Base document ────────────────────────────────────────────────────────── */
+html, body {
+    height: 100%;
+    font-family: var(--font);
+    font-size: 16px;
+    line-height: 1.5;
+    color: var(--text);
+    background-color: var(--bg-secondary);
+}
+
+/* ── Typography ───────────────────────────────────────────────────────────── */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 600;
+    line-height: 1.2;
+}
+
+a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+/* ── Utility ──────────────────────────────────────────────────────────────── */
+.hidden {
+    display: none !important;
+}
+
+.truncate {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* ── Scrollbars (webkit) ──────────────────────────────────────────────────── */
+::-webkit-scrollbar {
+    width: 7px;
+    height: 7px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a0a0a0;
+}
+
+/* ── Button primitive ─────────────────────────────────────────────────────── */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.4rem 0.85rem;
+    font-family: var(--font);
+    font-size: 0.875rem;
+    font-weight: 500;
+    line-height: 1.4;
+    text-align: center;
+    text-decoration: none;
+    white-space: nowrap;
+    vertical-align: middle;
+    cursor: pointer;
+    border: 1px solid transparent;
+    border-radius: var(--radius);
+    transition: background 0.15s, box-shadow 0.15s, border-color 0.15s, color 0.15s;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.btn:disabled,
+.btn[disabled] {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:not(:disabled):hover {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.12);
+}
+
+.btn:not(:disabled):active {
+    box-shadow: none;
+}
+
+/* Variants */
+.btn-primary {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-primary:not(:disabled):hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+    color: var(--text-light);
+}
+
+.btn-primary:not(:disabled):active {
+    background: var(--primary-active);
+    border-color: var(--primary-active);
+}
+
+.btn-secondary {
+    background: var(--bg);
+    color: var(--text);
+    border-color: var(--border);
+}
+
+.btn-secondary:not(:disabled):hover {
+    background: var(--bg-secondary);
+}
+
+.btn-success {
+    background: var(--success);
+    color: var(--text-light);
+    border-color: var(--success);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: var(--text-light);
+    border-color: var(--danger);
+}
+
+/* Sizes */
+.btn-sm {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.75rem;
+}
+
+.btn-lg {
+    padding: 0.6rem 1.4rem;
+    font-size: 1rem;
+}
+
+.btn-link {
+    background: transparent;
+    border-color: transparent;
+    color: var(--primary);
+    padding-left: 0;
+    padding-right: 0;
+}
+
+.btn-link:not(:disabled):hover {
+    text-decoration: underline;
+    box-shadow: none;
+}
+
+/* ── App header chrome ────────────────────────────────────────────────────── */
+.app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.35rem 1rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+/* Tool name inside the header */
+.app-header__title {
+    font-size: 17px;
+    font-weight: 600;
+    color: var(--text);
+    letter-spacing: 0.01em;
+    white-space: nowrap;
+}
+
+/* ── Build timestamp ──────────────────────────────────────────────────────── */
+.build-timestamp {
+    font-size: 0.55rem;
+    color: var(--text-muted);
+    opacity: 0.7;
+    font-weight: 300;
+    white-space: nowrap;
+    padding-top: 0.15rem;
+}
+
+/* Title + timestamp stacked vertically on the left side of the header */
+.header-title-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    line-height: 1;
+}
+
+/* ── Icon buttons (help, theme, refresh) ─────────────────────────────────── */
+/* Square, centered — overrides the asymmetric text-button padding/line-height */
+#help-btn,
+#theme-btn,
+#refreshHeaderBtn {
+    width: 2rem;
+    height: 2rem;
+    padding: 0;
+    line-height: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1rem;
+}
+
+/* Toast CSS lives in classifier/css/base.css — only that tool uses toasts. */
+
+/* ── Theme and help icon buttons ─────────────────────────────────────────── */
+#theme-btn,
+#help-btn {
+    font-size: 1rem;
+}
+
+/* ── Help panel (shared slide-out drawer) ─────────────────────────────────── */
+/* Used by all four tools. Toggle open/close via shared/help.js.               */
+
+.help-panel {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: min(420px, 85vw);
+    height: 100vh;
+    z-index: 1000;
+    background: var(--bg);
+    border-left: 1px solid var(--border);
+    box-shadow: -2px 0 12px rgba(0, 0, 0, 0.08);
+    display: flex;
+    flex-direction: column;
+    transform: translateX(100%);
+    transition: transform 0.25s ease;
+}
+
+.help-panel:not([hidden]) {
+    transform: translateX(0);
+}
+
+.help-panel[hidden] {
+    display: flex;
+    transform: translateX(100%);
+    pointer-events: none;
+}
+
+.help-panel__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+    background: var(--bg);
+}
+
+.help-panel__title {
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.help-panel__close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1.35rem;
+    cursor: pointer;
+    padding: 0.25rem 0.5rem;
+    border-radius: var(--radius);
+    line-height: 1;
+    transition: background 0.15s, color 0.15s;
+}
+
+.help-panel__close:hover {
+    color: var(--text);
+    background: var(--bg-secondary);
+}
+
+.help-panel__body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem 1rem 2rem;
+    font-size: 0.85rem;
+    line-height: 1.6;
+    color: var(--text);
+}
+
+.help-panel__body h3 {
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin: 1.25rem 0 0.35rem;
+    color: var(--text);
+    border-bottom: 1px solid var(--border);
+    padding-bottom: 0.15rem;
+}
+
+.help-panel__body h3:first-child {
+    margin-top: 0;
+}
+
+.help-panel__body h4 {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    margin: 1.25rem 0 0.3rem;
+    padding-left: 0.5rem;
+    border-left: 3px solid var(--border-dark);
+    color: var(--text-muted);
+}
+
+.help-panel__body p {
+    margin: 0 0 0.5rem;
+}
+
+.help-panel__body ol,
+.help-panel__body ul {
+    padding-left: 1.5rem;
+    margin: 0.3rem 0 0.5rem;
+}
+
+.help-panel__body li {
+    margin-bottom: 0.3rem;
+}
+
+.help-panel__body dl {
+    margin: 0.3rem 0;
+}
+
+.help-panel__body dt {
+    font-weight: 600;
+    color: var(--text);
+}
+
+.help-panel__body dd {
+    margin: 0 0 0.5rem 1rem;
+    color: var(--text-muted);
+}
+
+.help-panel__body code {
+    font-family: var(--font-mono);
+    font-size: 0.8em;
+    background: var(--bg-secondary);
+    padding: 0.1em 0.3em;
+    border-radius: 3px;
+}
+
+.help-badge {
+    font-size: 0.7rem;
+    font-weight: 600;
+    padding: 0.1rem 0.35rem;
+    border-radius: var(--radius);
+    vertical-align: middle;
+    letter-spacing: 0.02em;
+}
+
+.help-badge--draft {
+    color: #2563eb;
+    background: #eff6ff;
+}
+
+.help-badge--published {
+    color: #7c3aed;
+    background: #f5f3ff;
+}
+
+/* Shrink main content when help panel is open */
+body.help-open .app-header {
+    margin-right: min(420px, 85vw);
+}
+
+/* ── Column filter inputs (shared across archive, classifier, transmittal) ─── */
+.column-filter {
+    display: block;
+    width: 100%;
+    box-sizing: border-box;
+    margin-top: 0.25rem;
+    padding: 0.2rem 0.4rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.15s;
+}
+
+.column-filter:focus {
+    border-color: var(--primary);
+    outline: none;
+    box-shadow: 0 0 0 1px rgba(42, 90, 138, 0.35);
+}
+
+.column-filter::placeholder {
+    color: var(--text-muted);
+}
diff --git a/shared/build-lib.sh b/shared/build-lib.sh
new file mode 100755
index 0000000..5650437
--- /dev/null
+++ b/shared/build-lib.sh
@@ -0,0 +1,198 @@
+#!/bin/sh
+# =============================================================================
+# ZDDC shared build helpers — sourced by each tool's build.sh
+#
+# Usage in a tool build.sh:
+#   root_dir=$(cd "$(dirname "$0")" && pwd)
+#   . "$root_dir/../shared/build-lib.sh"
+#
+# Provides:
+#   ensure_exists <path>          — abort with error if file missing
+#   concat_files  <file ...>      — cat each relative path under $root_dir
+#   build_timestamp               — ISO UTC timestamp string, set at source time;
+#                                   used as build_label for dev builds
+#   escape_js_close_tags <in> <out>
+#                                 — copy <in> to <out> with all '</' rewritten as
+#                                   '<\/' so the HTML parser cannot misread the
+#                                   inlined JS as containing a closing </script>.
+#                                   The JS engine treats \/ as a regular slash,
+#                                   so runtime behaviour is unchanged.
+#   compute_build_label <tool> [--release [<channel-or-version>]]
+#                                 — sets globals: build_label, build_version,
+#                                   is_release, is_red, channel.
+#                                   See "Channels and release args" below.
+#   promote_release <tool>        — write to website/releases/ in the layout
+#                                   driven by $channel and $build_version. For
+#                                   stable, also update the _latest.html
+#                                   symlink and create the git tag.
+#
+# Channels and release args:
+#   <none>            dev build, dist/ only, label "Built: <ts> BETA" (red).
+#   --release         stable, auto-bump patch from latest tag (or 0.0.1).
+#   --release X.Y.Z   stable, explicit version.
+#   --release alpha   alpha channel; mutable file, no tag, label "alpha · <date> · <sha>" (red).
+#   --release beta    beta channel; analogous to alpha.
+#   --release <other> error.
+# =============================================================================
+
+# Abort if root_dir is not set by the caller
+if [ -z "${root_dir:-}" ]; then
+    echo "build-lib.sh: root_dir must be set before sourcing this file" >&2
+    exit 1
+fi
+
+# Fail hard on any missing source file
+ensure_exists() {
+    _path="$1"
+    if [ ! -f "$_path" ]; then
+        echo "error: missing file: $_path" >&2
+        exit 1
+    fi
+}
+
+# Concatenate files listed as positional args, each relative to root_dir
+concat_files() {
+    for _rel do
+        ensure_exists "$root_dir/$_rel"
+        cat "$root_dir/$_rel"
+        printf '\n'
+    done
+}
+
+# ISO UTC build timestamp — set once when this file is sourced
+build_timestamp=$(date -u +"%Y-%m-%d %H:%M:%S")
+
+# Rewrite '</script' (case-insensitive) in JS as '<\/script' so the HTML parser
+# cannot mistake string contents for a closing </script> tag. Per the HTML5 spec
+# only </script terminates a <script> block — other tags like </div> are safe
+# inside a script's text content. Narrowly targeting </script avoids corrupting
+# regex literals like /</g whose trailing letter is a flag, not a tag name.
+# The JS engine treats '\/' the same as '/' inside a string, so behaviour is
+# unchanged. See ARCHITECTURE.md "HTML Embedding Safety".
+escape_js_close_tags() {
+    sed 's#</\([sS][cC][rR][iI][pP][tT]\)#<\\/\1#g' "$1" > "$2"
+}
+
+# Validate that $1 is a strict X.Y.Z numeric version, where each component
+# is a non-empty numeric string. Exits with an error if not.
+_validate_semver() {
+    _v="$1"
+    _bad() {
+        echo "error: invalid release argument: '$_v' (expected: alpha, beta, or X.Y.Z stable version)" >&2
+        exit 1
+    }
+    _v1="${_v%%.*}"
+    _rest="${_v#*.}"
+    [ "$_rest" = "$_v" ] && _bad
+    _v2="${_rest%%.*}"
+    _v3="${_rest#*.}"
+    { [ "$_v3" = "$_rest" ] || [ "$_v3" != "${_v3%.*}" ]; } && _bad
+    case "$_v1" in '' | *[!0-9]*) _bad ;; esac
+    case "$_v2" in '' | *[!0-9]*) _bad ;; esac
+    case "$_v3" in '' | *[!0-9]*) _bad ;; esac
+}
+
+# Compute build label and channel. Reads positional args:
+#   compute_build_label <tool_name> [--release [<channel-or-version>]]
+# Sets global variables:
+#   build_label    — text rendered into the page's {{BUILD_LABEL}} slot
+#   build_version  — bare semver string (stable releases only)
+#   is_release     — "1" for any --release invocation, else "0"
+#   is_red         — "1" if the label should render red+bold (dev/alpha/beta), else "0"
+#   channel        — "stable" / "alpha" / "beta" / "" (dev)
+compute_build_label() {
+    _tool="$1"
+    _flag="${2:-}"
+    _arg="${3:-}"
+
+    is_release=0
+    is_red=1
+    channel=""
+    build_version=""
+
+    if [ "$_flag" != "--release" ]; then
+        build_label="Built: ${build_timestamp} BETA"
+        return 0
+    fi
+
+    is_release=1
+
+    case "$_arg" in
+        alpha | beta)
+            channel="$_arg"
+            _date=$(date -u +"%Y-%m-%d")
+            _sha=$(git -C "$root_dir" rev-parse --short=7 HEAD 2>/dev/null || echo "unknown")
+            build_label="${channel} · ${_date} · ${_sha}"
+            return 0
+            ;;
+        '')
+            # Auto-bump patch from latest stable tag for this tool.
+            _latest=$(git -C "$root_dir" tag --list "${_tool}-v*" --sort=-v:refname 2>/dev/null | head -1)
+            if [ -z "$_latest" ]; then
+                build_version="0.0.1"
+            else
+                _ver="${_latest#${_tool}-v}"
+                _major="${_ver%%.*}"
+                _rest="${_ver#*.}"
+                _minor="${_rest%%.*}"
+                _patch="${_rest#*.}"
+                _patch=$((_patch + 1))
+                build_version="${_major}.${_minor}.${_patch}"
+            fi
+            ;;
+        *)
+            _validate_semver "$_arg"
+            build_version="$_arg"
+            ;;
+    esac
+
+    channel="stable"
+    is_red=0
+    build_label="v${build_version}"
+}
+
+# Promote a built dist file to the appropriate slot under website/releases/.
+# Reads from caller scope: $channel, $build_version, $output_html, $root_dir.
+#
+# Stable releases write website/releases/<tool>_v<version>.html, refresh the
+# website/releases/<tool>_latest.html symlink, and tag <tool>-v<version> in
+# git. Skips silently when the source has not changed since the latest tag.
+#
+# Alpha and beta channel releases overwrite website/releases/<tool>_<channel>.html
+# in place with no tag (the embedded label carries date + commit SHA, so the
+# source is recoverable from git directly).
+promote_release() {
+    _tool="$1"
+    _releases_dir="$root_dir/../website/releases"
+    mkdir -p "$_releases_dir"
+
+    if [ "$channel" = "alpha" ] || [ "$channel" = "beta" ]; then
+        _dest="${_releases_dir}/${_tool}_${channel}.html"
+        cp "$output_html" "$_dest"
+        echo "Released $channel to $_dest"
+        return 0
+    fi
+
+    if [ "$channel" != "stable" ] || [ -z "$build_version" ]; then
+        echo "promote_release: refusing to promote — channel=$channel build_version=$build_version" >&2
+        exit 1
+    fi
+
+    _latest=$(git -C "$root_dir" tag --list "${_tool}-v*" --sort=-v:refname 2>/dev/null | head -1)
+    if [ -n "$_latest" ] && git -C "$root_dir" diff --quiet "$_latest" HEAD -- . ../shared 2>/dev/null; then
+        echo "${_tool}: no source changes since $_latest — skipping"
+        return 0
+    fi
+
+    _versioned="${_releases_dir}/${_tool}_v${build_version}.html"
+    cp "$output_html" "$_versioned"
+    echo "Released $_versioned"
+
+    # Symlink target is relative to its own directory so the link survives
+    # path moves and works regardless of where the website is mounted.
+    (cd "$_releases_dir" && ln -sfn "${_tool}_v${build_version}.html" "${_tool}_latest.html")
+    echo "Updated ${_tool}_latest.html -> ${_tool}_v${build_version}.html"
+
+    git -C "$root_dir" tag "${_tool}-v${build_version}"
+    echo "Tagged ${_tool}-v${build_version} — run: git push --tags"
+}
diff --git a/shared/hash.js b/shared/hash.js
new file mode 100644
index 0000000..28277ca
--- /dev/null
+++ b/shared/hash.js
@@ -0,0 +1,94 @@
+/**
+ * ZDDC — shared SHA-256 helpers
+ *
+ * Attaches to window.zddc.crypto. Must load AFTER shared/zddc.js (which creates
+ * the window.zddc object).
+ *
+ * Exports:
+ *   zddc.crypto.sha256Hex(buffer)       → Promise<string>  hex digest of ArrayBuffer/Uint8Array
+ *   zddc.crypto.sha256String(str)       → Promise<string>  hex digest of UTF-8 encoded string
+ *   zddc.crypto.sha256File(file, onProgress?) → Promise<string>
+ *       chunked streaming digest for File/Blob; for files >= 4 MB, streams 2 MB chunks
+ *       and invokes onProgress(loaded, total) every ~8 MB.
+ *   zddc.crypto.bytesToHex(buffer)      → string  (hex of ArrayBuffer/Uint8Array, no digest)
+ *
+ * Throws if Web Crypto SubtleCrypto is not available.
+ */
+(function (root) {
+    'use strict';
+
+    if (!root.zddc) {
+        throw new Error('shared/hash.js: window.zddc must be loaded first');
+    }
+
+    var HASH_CHUNK_SIZE = 2 * 1024 * 1024; // 2 MB
+
+    function requireSubtle() {
+        if (!root.crypto || !root.crypto.subtle || typeof root.crypto.subtle.digest !== 'function') {
+            throw new Error('Web Crypto SubtleCrypto is required');
+        }
+    }
+
+    function bytesToHex(buffer) {
+        return Array.from(new Uint8Array(buffer), function (byte) {
+            return byte.toString(16).padStart(2, '0');
+        }).join('');
+    }
+
+    async function sha256Hex(buffer) {
+        requireSubtle();
+        var input = (buffer instanceof Uint8Array) ? buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength) : buffer;
+        var hash = await root.crypto.subtle.digest('SHA-256', input);
+        return bytesToHex(hash);
+    }
+
+    async function sha256String(str) {
+        requireSubtle();
+        var bytes = new TextEncoder().encode(str);
+        var hash = await root.crypto.subtle.digest('SHA-256', bytes);
+        return bytesToHex(hash);
+    }
+
+    async function sha256File(file, onProgress) {
+        requireSubtle();
+        // Single-shot for small files or environments without ReadableStream
+        if (file.size < HASH_CHUNK_SIZE * 2 || typeof file.stream !== 'function') {
+            if (onProgress) { onProgress(file.size, file.size); }
+            var buf = await file.arrayBuffer();
+            var hash = await root.crypto.subtle.digest('SHA-256', buf);
+            return bytesToHex(hash);
+        }
+        // Chunked streaming for large files
+        var reader = file.stream().getReader();
+        var loaded = 0;
+        var chunks = [];
+        var yieldCounter = 0;
+        while (true) {
+            var result = await reader.read();
+            if (result.done) { break; }
+            chunks.push(result.value);
+            loaded += result.value.byteLength;
+            yieldCounter++;
+            if (onProgress && yieldCounter % 4 === 0) {
+                onProgress(loaded, file.size);
+                await new Promise(function (r) { setTimeout(r, 0); });
+            }
+        }
+        var total = new Uint8Array(loaded);
+        var offset = 0;
+        for (var i = 0; i < chunks.length; i++) {
+            total.set(chunks[i], offset);
+            offset += chunks[i].byteLength;
+        }
+        var digest = await root.crypto.subtle.digest('SHA-256', total.buffer);
+        if (onProgress) { onProgress(file.size, file.size); }
+        return bytesToHex(digest);
+    }
+
+    root.zddc.crypto = {
+        sha256Hex:    sha256Hex,
+        sha256String: sha256String,
+        sha256File:   sha256File,
+        bytesToHex:   bytesToHex,
+    };
+})(typeof window !== 'undefined' ? window : globalThis);
diff --git a/shared/help.js b/shared/help.js
new file mode 100644
index 0000000..202388b
--- /dev/null
+++ b/shared/help.js
@@ -0,0 +1,46 @@
+/**
+ * ZDDC shared help panel — open/close logic.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #help-btn, #help-panel, #help-panel-close in the DOM.
+ */
+(function () {
+    'use strict';
+
+    function init() {
+        var helpBtn   = document.getElementById('help-btn');
+        var panel     = document.getElementById('help-panel');
+        var closeBtn  = document.getElementById('help-panel-close');
+
+        if (!helpBtn || !panel) { return; }
+
+        function isOpen() { return !panel.hidden; }
+
+        function openPanel() {
+            panel.hidden = false;
+            document.body.classList.add('help-open');
+        }
+
+        function closePanel() {
+            panel.hidden = true;
+            document.body.classList.remove('help-open');
+        }
+
+        helpBtn.addEventListener('click', function () {
+            if (isOpen()) { closePanel(); } else { openPanel(); }
+        });
+
+        if (closeBtn) {
+            closeBtn.addEventListener('click', closePanel);
+        }
+
+        document.addEventListener('keydown', function (e) {
+            if (e.key === 'Escape' && isOpen()) { closePanel(); }
+        });
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
diff --git a/shared/theme.js b/shared/theme.js
new file mode 100644
index 0000000..44ecff7
--- /dev/null
+++ b/shared/theme.js
@@ -0,0 +1,84 @@
+/**
+ * ZDDC shared theme toggle — light / dark / auto.
+ * Persists choice to localStorage under 'zddc-theme'.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #theme-btn in the DOM (optional — skips gracefully if absent).
+ *
+ * Theme cycle: auto → light → dark → auto …
+ * 'auto' honours the OS prefers-color-scheme media query (CSS handles it).
+ * 'light' sets data-theme="light" on <html> (overrides dark media query).
+ * 'dark'  sets data-theme="dark"  on <html>.
+ */
+(function () {
+    'use strict';
+
+    var STORAGE_KEY = 'zddc-theme';
+    var THEMES = ['auto', 'light', 'dark'];
+
+    var LABELS = {
+        auto:  '◐',
+        light: '☀',
+        dark:  '☾'
+    };
+
+    var TITLES = {
+        auto:  'Theme: auto (follows OS)',
+        light: 'Theme: light',
+        dark:  'Theme: dark'
+    };
+
+    function load() {
+        var stored = localStorage.getItem(STORAGE_KEY);
+        return THEMES.indexOf(stored) !== -1 ? stored : 'auto';
+    }
+
+    function apply(theme) {
+        if (theme === 'dark') {
+            document.documentElement.setAttribute('data-theme', 'dark');
+        } else if (theme === 'light') {
+            document.documentElement.setAttribute('data-theme', 'light');
+        } else {
+            document.documentElement.removeAttribute('data-theme');
+        }
+    }
+
+    function save(theme) {
+        try { localStorage.setItem(STORAGE_KEY, theme); } catch (e) {}
+    }
+
+    function updateButton(btn, theme) {
+        btn.textContent = LABELS[theme];
+        btn.title = TITLES[theme];
+        btn.setAttribute('aria-label', TITLES[theme]);
+    }
+
+    function next(theme) {
+        return THEMES[(THEMES.indexOf(theme) + 1) % THEMES.length];
+    }
+
+    function init() {
+        var current = load();
+        apply(current);
+
+        var btn = document.getElementById('theme-btn');
+        if (!btn) { return; }
+
+        updateButton(btn, current);
+
+        btn.addEventListener('click', function () {
+            current = next(current);
+            apply(current);
+            save(current);
+            updateButton(btn, current);
+        });
+    }
+
+    /* Apply theme immediately (before DOM ready) to avoid flash */
+    apply(load());
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
diff --git a/shared/zddc-filter-test.html b/shared/zddc-filter-test.html
new file mode 100644
index 0000000..c2b2d7a
--- /dev/null
+++ b/shared/zddc-filter-test.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="utf-8"><title>zddc.filter test shim</title></head>
+<body>
+<!-- Loads shared/zddc.js then shared/zddc-filter.js so Playwright tests can call window.zddc.filter.* -->
+<script src="zddc.js"></script>
+<script src="zddc-filter.js"></script>
+</body>
+</html>
diff --git a/shared/zddc-filter.js b/shared/zddc-filter.js
new file mode 100644
index 0000000..4989e26
--- /dev/null
+++ b/shared/zddc-filter.js
@@ -0,0 +1,160 @@
+(function() {
+    'use strict';
+
+    // Escape a string for use in a RegExp (literal match)
+    function escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
+    // Build regex pattern at parse time based on anchors
+    function compilePattern(raw, anchorStart, anchorEnd) {
+        var src = (anchorStart ? '^' : '') + raw + (anchorEnd ? '$' : '');
+        try {
+            return new RegExp(src, 'i');
+        } catch (e) {
+            // Invalid regex — escape and retry (always succeeds)
+            var safe = (anchorStart ? '^' : '') + escapeRegex(raw) + (anchorEnd ? '$' : '');
+            return new RegExp(safe, 'i');
+        }
+    }
+
+    // Parse a single token string into a node
+    function parseToken(token) {
+        var s = token;
+        var negate = false;
+        var anchorStart = false;
+        var anchorEnd = false;
+
+        if (s.charAt(0) === '!') {
+            negate = true;
+            s = s.slice(1);
+        }
+        if (s.charAt(0) === '^') {
+            anchorStart = true;
+            s = s.slice(1);
+        }
+        if (s.length > 0 && s.charAt(s.length - 1) === '$') {
+            anchorEnd = true;
+            s = s.slice(0, -1);
+        }
+
+        if (s === '') return null;
+
+        // bare * (possibly after stripping !) → wildcard-all or wildcard-none
+        if (s === '*' && !anchorStart && !anchorEnd) {
+            return negate ? null : { type: 'wildcard-all' };
+        }
+
+        var re = compilePattern(s, anchorStart, anchorEnd);
+        return { type: negate ? 'no-match' : 'match', re: re };
+    }
+
+    // Parse expression string into AST array
+    function parse(expression) {
+        if (!expression || typeof expression !== 'string') return [];
+        var trimmed = expression.trim();
+        if (trimmed === '') return [];
+        if (trimmed === '*') return [{ type: 'wildcard-all' }];
+
+        var ast = [];
+        var i = 0;
+        var len = trimmed.length;
+
+        while (i < len) {
+            var ch = trimmed.charAt(i);
+
+            if (ch === '(') {
+                var depth = 1;
+                var j = i + 1;
+                while (j < len && depth > 0) {
+                    if (trimmed.charAt(j) === '(') depth++;
+                    else if (trimmed.charAt(j) === ')') depth--;
+                    j++;
+                }
+                var innerAst = parse(trimmed.slice(i + 1, j - 1));
+                if (innerAst.length === 1) {
+                    ast.push(innerAst[0]);
+                } else if (innerAst.length > 1) {
+                    for (var k = 0; k < innerAst.length; k++) ast.push(innerAst[k]);
+                }
+                i = j;
+            } else if (ch === '|') {
+                ast.push({ type: 'pipe' });
+                i++;
+            } else if (ch === ' ') {
+                i++;
+            } else {
+                var j = i;
+                while (j < len) {
+                    var c = trimmed.charAt(j);
+                    if (c === ' ' || c === '(' || c === '|' || c === ')') break;
+                    j++;
+                }
+                var token = trimmed.slice(i, j);
+                if (token.length > 0) {
+                    var node = parseToken(token);
+                    if (node !== null) ast.push(node);
+                }
+                i = j;
+            }
+        }
+
+        // Group pipes into OR nodes
+        var hasPipe = false;
+        var branches = [[]];
+        for (var l = 0; l < ast.length; l++) {
+            if (ast[l].type === 'pipe') {
+                hasPipe = true;
+                branches.push([]);
+            } else {
+                branches[branches.length - 1].push(ast[l]);
+            }
+        }
+        branches = branches.filter(function(b) { return b.length > 0; });
+
+        if (!hasPipe) {
+            return ast.filter(function(n) { return n.type !== 'pipe'; });
+        }
+
+        var orNodes = branches.map(function(branch) {
+            if (branch.length === 1) return branch[0];
+            return { type: 'and', nodes: branch };
+        });
+        return [{ type: 'or', nodes: orNodes }];
+    }
+
+    // Check if a single node matches the value
+    function nodeMatches(node, value) {
+        switch (node.type) {
+            case 'wildcard-all': return true;
+            case 'match':    return node.re.test(value);
+            case 'no-match': return !node.re.test(value);
+            case 'or':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (nodeMatches(node.nodes[i], value)) return true;
+                }
+                return false;
+            case 'and':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (!nodeMatches(node.nodes[i], value)) return false;
+                }
+                return true;
+            default: return false;
+        }
+    }
+
+    // Evaluate AST against value
+    function matches(value, ast) {
+        if (!ast || ast.length === 0) return true;
+        var v = String(value); // no forced lowercase — regex has 'i' flag
+        for (var i = 0; i < ast.length; i++) {
+            if (!nodeMatches(ast[i], v)) return false;
+        }
+        return true;
+    }
+
+    if (!window.zddc) {
+        throw new Error('shared/zddc-filter.js: window.zddc must be loaded first');
+    }
+    window.zddc.filter = { parse: parse, matches: matches };
+})();
diff --git a/shared/zddc-test.html b/shared/zddc-test.html
new file mode 100644
index 0000000..bdd6c5f
--- /dev/null
+++ b/shared/zddc-test.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html lang="en">
+<head><meta charset="utf-8"><title>ZDDC library test shim</title></head>
+<body>
+<!-- Loads shared/zddc.js + shared/hash.js so Playwright tests can call window.zddc.* -->
+<script src="zddc.js"></script>
+<script src="hash.js"></script>
+</body>
+</html>
diff --git a/shared/zddc.js b/shared/zddc.js
new file mode 100644
index 0000000..1166b4d
--- /dev/null
+++ b/shared/zddc.js
@@ -0,0 +1,380 @@
+/**
+ * ZDDC — shared naming convention library
+ *
+ * Canonical implementation of all ZDDC filename, folder name, tracking number,
+ * revision, and status logic.  Included in every tool's build via shared/zddc.js.
+ *
+ * Exposed as window.zddc (plain global) so it works with every tool's module
+ * pattern (archive globals, classifier IIFE, transmittal IIFE, mdedit globals).
+ *
+ * Public API
+ * ----------
+ *   zddc.parseFilename(str)        → ParsedFile | null
+ *   zddc.parseFolder(str)          → ParsedFolder | null
+ *   zddc.parseRevision(str)        → ParsedRevision
+ *   zddc.formatFilename(parts)     → string
+ *   zddc.formatFolder(parts)       → string
+ *   zddc.compareRevisions(a, b)    → number  (-1 | 0 | 1)
+ *   zddc.isValidStatus(str)        → boolean
+ *   zddc.STATUSES                  → string[]
+ *
+ * ParsedFile   { trackingNumber, revision, status, title, extension }
+ * ParsedFolder { date, trackingNumber, status, title }
+ * ParsedRevision { base, modifier, modifierType, modifierNumber, isDraft, full }
+ */
+
+(function (root) {
+    'use strict';
+
+    // ── Valid status codes ───────────────────────────────────────────────────
+
+    /**
+     * Complete list of valid ZDDC document status codes.
+     * '---' denotes an unknown or not-yet-assigned status.
+     */
+    var STATUSES = [
+        '---',
+        'IFA', 'IFB', 'IFC', 'IFD', 'IFI', 'IFP', 'IFR', 'IFU',
+        'REC',
+        'RSA', 'RSB', 'RSC', 'RSD', 'RSI',
+    ];
+
+    var STATUS_SET = {};
+    for (var _i = 0; _i < STATUSES.length; _i++) {
+        STATUS_SET[STATUSES[_i]] = true;
+    }
+
+    function isValidStatus(str) {
+        return !!STATUS_SET[str];
+    }
+
+    // ── Filename parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Canonical file regex.
+     * Matches: TRACKING_REVISION (STATUS) - TITLE.EXT
+     *
+     * Tracking number: no underscores, no whitespace.
+     * Revision:        no whitespace, no parentheses.
+     * Status:          anything inside parentheses (validated separately).
+     * Title:           everything up to the last dot.
+     * Extension:       after the last dot (lowercased by parseFilename).
+     */
+    var FILE_RE = /^([^_\s]+)_([^\s()_]+)\s*\(([^)]+)\)\s*-\s*(\S.*\S|\S)\.\s*([^\s.]+)$/;
+
+    /**
+     * Parse a ZDDC filename.
+     *
+     * @param {string} filename
+     * @returns {{ trackingNumber: string, revision: string, status: string,
+     *             title: string, extension: string, valid: boolean } | null}
+     *   null only if filename is falsy.
+     *   `valid` is true when all fields matched the ZDDC pattern.
+     */
+    function parseFilename(filename) {
+        if (!filename) { return null; }
+
+        var match = filename.match(FILE_RE);
+
+        if (!match) {
+            var lastDot = filename.lastIndexOf('.');
+            return {
+                trackingNumber: '',
+                revision:       '',
+                status:         '',
+                title:          lastDot > 0 ? filename.substring(0, lastDot) : filename,
+                extension:      lastDot > 0 ? filename.substring(lastDot + 1).toLowerCase() : '',
+                valid:          false,
+            };
+        }
+
+        return {
+            trackingNumber: match[1].trim(),
+            revision:       match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            extension:      match[5].toLowerCase(),
+            valid:          true,
+        };
+    }
+
+    // ── Folder name parsing ──────────────────────────────────────────────────
+
+    /**
+     * Transmittal folder regex.
+     * Matches: YYYY-MM-DD_TRACKING (STATUS) - TITLE
+     */
+    var FOLDER_RE = /^(\d{4}-\d{2}-\d{2})_([^_\s(]+)\s*\(([^)]+)\)\s*-\s*(.+)$/;
+
+    /**
+     * Parse a ZDDC transmittal folder name.
+     *
+     * @param {string} foldername
+     * @returns {{ date: string, trackingNumber: string, status: string,
+     *             title: string, valid: boolean } | null}
+     *   null only if foldername is falsy.
+     */
+    function parseFolder(foldername) {
+        if (!foldername) { return null; }
+
+        var match = foldername.match(FOLDER_RE);
+
+        if (!match) {
+            return {
+                date:            '',
+                trackingNumber:  '',
+                status:          '',
+                title:           foldername,
+                valid:           false,
+            };
+        }
+
+        return {
+            date:           match[1],
+            trackingNumber: match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            valid:          true,
+        };
+    }
+
+    // ── Revision parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Modifier sub-regex: +LETTER DIGITS  e.g. +C1, +B2, +N1, +Q1
+     * The draft prefix (~) may appear inside the modifier: A+~C1
+     */
+    var MODIFIER_RE = /^\+(~?)([A-Za-z])(\d+)$/;
+
+    /**
+     * Parse a ZDDC revision string.
+     *
+     * Revision grammar:
+     *   revision     = ['~'] base ['+' ['~'] modifier_letter modifier_number]
+     *   base         = letter(s) | digit(s) | date(YYYY-MM-DD)
+     *   modifier     = letter + digits   e.g. C1, B2, N1, Q1
+     *
+     * @param {string} revision
+     * @returns {{
+     *   base: string,
+     *   modifier: string,       full modifier string e.g. '+C1', '' if none
+     *   modifierType: string,   modifier letter e.g. 'C', '' if none
+     *   modifierNumber: number, modifier number e.g. 1, 0 if none
+     *   modifierIsDraft: boolean,
+     *   isDraft: boolean,       true if base revision starts with ~
+     *   full: string,           original input
+     * }}
+     */
+    function parseRevision(revision) {
+        var raw = (revision || '').toString();
+
+        // Split on '+' to separate base from optional modifier
+        var plusIdx = raw.indexOf('+');
+        var basePart     = plusIdx === -1 ? raw : raw.substring(0, plusIdx);
+        var modifierPart = plusIdx === -1 ? ''  : raw.substring(plusIdx);
+
+        // Draft flag on the base part
+        var isDraft = basePart.startsWith('~');
+        var base    = isDraft ? basePart.substring(1) : basePart;
+
+        // Parse modifier
+        var modifier        = '';
+        var modifierType    = '';
+        var modifierNumber  = 0;
+        var modifierIsDraft = false;
+
+        if (modifierPart) {
+            var mMatch = modifierPart.match(MODIFIER_RE);
+            if (mMatch) {
+                modifierIsDraft = mMatch[1] === '~';
+                modifierType    = mMatch[2].toUpperCase();
+                modifierNumber  = parseInt(mMatch[3], 10);
+                modifier        = modifierPart;
+            } else {
+                // Unrecognised modifier — preserve as-is
+                modifier = modifierPart;
+            }
+        }
+
+        return {
+            base:           base,
+            modifier:       modifier,
+            modifierType:   modifierType,
+            modifierNumber: modifierNumber,
+            modifierIsDraft: modifierIsDraft,
+            isDraft:        isDraft,
+            full:           raw,
+        };
+    }
+
+    // ── Revision comparison ──────────────────────────────────────────────────
+
+    /**
+     * Classify a base revision string into a sort tier:
+     *   0 = date (YYYY-MM-DD)
+     *   1 = letter(s)   A, B, AA …
+     *   2 = number(s)   0, 1, 2, 1.5 …
+     *   3 = other
+     */
+    function _baseTier(base) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(base)) { return 0; }
+        if (/^[A-Za-z]+$/.test(base))          { return 1; }
+        if (/^\d+(\.\d+)?$/.test(base))         { return 2; }
+        return 3;
+    }
+
+    /**
+     * Compare two base revision strings.
+     * Sort order: dates < letters < numbers < other.
+     */
+    function _compareBase(a, b) {
+        var ta = _baseTier(a);
+        var tb = _baseTier(b);
+        if (ta !== tb) { return ta - tb; }
+
+        if (ta === 0) { return a < b ? -1 : a > b ? 1 : 0; }       // date lexicographic = chronological
+        if (ta === 1) { return a.toUpperCase() < b.toUpperCase() ? -1 : a.toUpperCase() > b.toUpperCase() ? 1 : 0; }
+        if (ta === 2) { return parseFloat(a) - parseFloat(b); }
+        return a.localeCompare(b);
+    }
+
+    /**
+     * Compare two ZDDC revision strings for sort ordering.
+     *
+     * Canonical order (ascending = older → newer):
+     *   ~A  <  A  <  A+B1  <  A+C1  <  A+~C2  <  A+C2  <  A+N1  <  A+Q1
+     *   <  ~B  <  B  < … < 0 < 1 < 2
+     *
+     * Rules:
+     *   1. Compare base revisions first (dates < letters < numbers).
+     *   2. For equal bases, draft (isDraft=true) comes before final.
+     *   3. For equal base+draft, no-modifier < has-modifier.
+     *   4. For equal base+draft+modifier presence:
+     *      a. modifier draft comes before modifier final (modifierIsDraft).
+     *      b. Sort modifier by type letter then by number.
+     *
+     * @param {string} a
+     * @param {string} b
+     * @returns {number}  negative if a < b, 0 if equal, positive if a > b
+     */
+    function compareRevisions(a, b) {
+        var pa = parseRevision(a);
+        var pb = parseRevision(b);
+
+        // 1. Base revision
+        var baseCmp = _compareBase(pa.base, pb.base);
+        if (baseCmp !== 0) { return baseCmp; }
+
+        // 2. Draft before final (for same base)
+        if (pa.isDraft !== pb.isDraft) { return pa.isDraft ? -1 : 1; }
+
+        // 3. No modifier before any modifier
+        var aHasMod = pa.modifier !== '';
+        var bHasMod = pb.modifier !== '';
+        if (aHasMod !== bHasMod) { return aHasMod ? 1 : -1; }
+
+        if (!aHasMod) { return 0; } // both have no modifier
+
+        // 4. Compare modifiers: type → number → draft (draft is a tie-breaker only)
+        // 4a. Modifier type letter (B < C < N < Q …)
+        if (pa.modifierType !== pb.modifierType) {
+            return pa.modifierType < pb.modifierType ? -1 : 1;
+        }
+
+        // 4b. Modifier number (1 < 2 …)
+        if (pa.modifierNumber !== pb.modifierNumber) {
+            return pa.modifierNumber - pb.modifierNumber;
+        }
+
+        // 4c. Draft of a modifier comes before the final modifier (same type+number)
+        if (pa.modifierIsDraft !== pb.modifierIsDraft) {
+            return pa.modifierIsDraft ? -1 : 1;
+        }
+
+        return 0;
+    }
+
+    // ── Filename / folder formatting ─────────────────────────────────────────
+
+    /**
+     * Build a ZDDC filename from its components.
+     *
+     * @param {{ trackingNumber: string, revision: string, status: string,
+     *           title: string, extension: string }} parts
+     * @returns {string}  e.g. "123456-EL-SPC-2623_A (IFR) - Specification.pdf"
+     */
+    function formatFilename(parts) {
+        var tn  = (parts.trackingNumber || '').trim();
+        var rev = (parts.revision       || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+        var ext = (parts.extension      || '').replace(/^\./, '');
+
+        if (!tn || !rev || !st || !ttl) { return ''; }
+
+        var name = tn + '_' + rev + ' (' + st + ') - ' + ttl;
+        return ext ? name + '.' + ext : name;
+    }
+
+    /**
+     * Build a ZDDC transmittal folder name from its components.
+     *
+     * @param {{ date: string, trackingNumber: string, status: string,
+     *           title: string }} parts
+     * @returns {string}  e.g. "2025-10-31_123456-EM-SUB-0001 (IFR) - Title"
+     */
+    function formatFolder(parts) {
+        var dt  = (parts.date           || '').trim();
+        var tn  = (parts.trackingNumber || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+
+        if (!dt || !tn || !st || !ttl) { return ''; }
+
+        return dt + '_' + tn + ' (' + st + ') - ' + ttl;
+    }
+
+    // ── Filename / extension splitting ───────────────────────────────────────
+
+    /**
+     * Split a filename into its base name and extension (no leading dot).
+     * Treats leading dot ('.gitignore') as no extension.
+     *
+     * @param {string} filename
+     * @returns {{ name: string, extension: string }}
+     */
+    function splitExtension(filename) {
+        if (!filename) { return { name: '', extension: '' }; }
+        var lastDot = filename.lastIndexOf('.');
+        if (lastDot <= 0) { return { name: filename, extension: '' }; }
+        return {
+            name:      filename.substring(0, lastDot),
+            extension: filename.substring(lastDot + 1).toLowerCase(),
+        };
+    }
+
+    /**
+     * Join a base name and extension. Tolerant of either form ('pdf' or '.pdf').
+     * Returns just the name when extension is empty.
+     */
+    function joinExtension(name, extension) {
+        var ext = (extension || '').replace(/^\./, '');
+        return ext ? name + '.' + ext : name;
+    }
+
+    // ── Public API ───────────────────────────────────────────────────────────
+
+    root.zddc = {
+        STATUSES:         STATUSES,
+        isValidStatus:    isValidStatus,
+        parseFilename:    parseFilename,
+        parseFolder:      parseFolder,
+        parseRevision:    parseRevision,
+        formatFilename:   formatFilename,
+        formatFolder:     formatFolder,
+        compareRevisions: compareRevisions,
+        splitExtension:   splitExtension,
+        joinExtension:    joinExtension,
+    };
+
+}(typeof window !== 'undefined' ? window : this));
diff --git a/tests/archive.spec.js b/tests/archive.spec.js
new file mode 100644
index 0000000..8009a07
--- /dev/null
+++ b/tests/archive.spec.js
@@ -0,0 +1,113 @@
+import { test, expect } from '@playwright/test';
+import { MOCK_FS_INIT_SCRIPT } from './fixtures/mock-fs-api.js';
+import * as path from 'path';
+
+const HTML_PATH = path.resolve('archive/dist/archive.html');
+
+test.describe('Archive Browser', () => {
+    test.beforeEach(async ({ page }) => {
+        await page.addInitScript(MOCK_FS_INIT_SCRIPT);
+    });
+
+    test('loads without errors', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'domcontentloaded' });
+        await page.waitForSelector('#appContainer', { timeout: 15000 });
+
+        // Page title contains "Archive"
+        await expect(page).toHaveTitle(/Archive/i);
+
+        // No-directory message is shown before any directory is opened
+        await expect(page.locator('#noDirectoryMessage')).toBeVisible();
+
+        // The open-directory button is present
+        await expect(page.locator('#addDirectoryBtn')).toBeVisible();
+    });
+
+    test('scans a mock directory tree and displays files', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'domcontentloaded' });
+        await page.waitForSelector('#addDirectoryBtn', { timeout: 15000 });
+
+        // Log to see if the scan is working
+        page.on('console', msg => {
+            console.log('Browser console:', msg.text());
+        });
+        page.on('pageerror', err => {
+            console.log('Page error:', err.message);
+        });
+
+        // The archive expects a two-level structure: root → transmittal-folder → files.
+        // Flat files at the root are not counted — they must be inside subdirectories.
+        await page.evaluate(() => {
+            window.__setMockDirectoryTree('test-project', {
+                '2025-01-15_123456-EM-TRN-0001 (IFC) - First Transmittal': {
+                    '123456-EL-SPC-2623_A (IFC) - Specification.pdf': '%PDF',
+                    '123456-EL-DRW-0001_B (IFR) - Drawing.dwg':        'DWG',
+                },
+                '2025-02-10_123456-EM-TRN-0002 (IFC) - Second Transmittal': {
+                    '789012-ME-CAL-0001_A (IFA) - Calculation.pdf': '%PDF',
+                },
+            });
+            console.log('Mock directory set up');
+        });
+
+        await page.locator('#addDirectoryBtn').click();
+        
+        // Wait for scanning to complete
+        await page.waitForTimeout(2000);
+
+        // Log state for debugging
+        await page.evaluate(() => {
+            console.log('After scanning:');
+            console.log('  window.app exists:', typeof window.app !== 'undefined');
+            if (typeof window.app !== 'undefined') {
+                console.log('  window.app type:', typeof window.app);
+                console.log('  window.app constructor:', window.app.constructor.name);
+                console.log('  window.app.directories:', Array.isArray(window.app.directories) ? window.app.directories.length : window.app.directories);
+                console.log('  window.app.files:', Array.isArray(window.app.files) ? window.app.files.length : window.app.files);
+                console.log('  window.app.filteredFiles:', Array.isArray(window.app.filteredFiles) ? window.app.filteredFiles.length : window.app.filteredFiles);
+                console.log('  window.app modules:', Object.keys(window.app || {}).filter(k => k.startsWith('modules')));
+            } else {
+                console.log('  window.app is undefined!');
+            }
+        });
+
+        // Select all grouping folders so files are included in the file list
+        await page.evaluate(() => {
+            const cb = document.getElementById('selectAllGroupingCheckbox');
+            if (cb && !cb.checked) cb.click();
+        });
+        await page.waitForTimeout(500);
+
+        // The files table should have at least one data row
+        const rowCount = await page.locator('#filesTableBody tr').count();
+        expect(rowCount).toBeGreaterThanOrEqual(1);
+
+        // Status bar should show files were found (any non-empty text is fine)
+        const fileCountText = await page.locator('#fileCount').textContent();
+        expect(fileCountText).toBeTruthy();
+    });
+
+    test('parser module uses shared zddc helpers (not its own wrappers)', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'domcontentloaded' });
+        await page.waitForSelector('#appContainer', { timeout: 15000 });
+
+        const probe = await page.evaluate(() => ({
+            // archive's parser module should NOT re-export wrappers we removed
+            hasParseFileNameWrapper: typeof window.app.modules.parser?.parseFileName === 'function',
+            hasParseRevisionWrapper: typeof window.app.modules.parser?.parseRevision === 'function',
+            // but should still expose archive-specific helpers
+            hasIsTransmittalFolder:  typeof window.app.modules.parser?.isTransmittalFolder === 'function',
+            hasGroupFiles:           typeof window.app.modules.parser?.groupFilesByTrackingNumber === 'function',
+            // and isTransmittalFolder should agree with shared zddc.parseFolder
+            validFolder:   window.app.modules.parser.isTransmittalFolder('2025-10-31_123456-EM-SUB-0001 (IFR) - General Arrangement'),
+            invalidFolder: window.app.modules.parser.isTransmittalFolder('not-a-zddc-folder'),
+        }));
+
+        expect(probe.hasParseFileNameWrapper).toBe(false);
+        expect(probe.hasParseRevisionWrapper).toBe(false);
+        expect(probe.hasIsTransmittalFolder).toBe(true);
+        expect(probe.hasGroupFiles).toBe(true);
+        expect(probe.validFolder).toBe(true);
+        expect(probe.invalidFolder).toBe(false);
+    });
+});
diff --git a/tests/build-label.spec.js b/tests/build-label.spec.js
new file mode 100644
index 0000000..b653177
--- /dev/null
+++ b/tests/build-label.spec.js
@@ -0,0 +1,64 @@
+/**
+ * build-label.spec.js
+ *
+ * Verifies that the {{BUILD_LABEL}} placeholder is correctly substituted in all
+ * four tool dist and website files:
+ *
+ *   - No placeholder text leaks through
+ *   - The .build-timestamp element is present and visible in the browser
+ *   - The label content is either a timestamp ("Built: 20...") or a version ("v...")
+ *   - website/ files (when present) always show the version format
+ *
+ * Note: dist/ files may show either format depending on whether the last build
+ * was a dev build (timestamp) or a release build (version). Both are valid.
+ */
+import { test, expect } from '@playwright/test';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const tools = ['archive', 'transmittal', 'classifier', 'mdedit'];
+
+for (const tool of tools) {
+    const distPath    = path.resolve(`${tool}/dist/${tool}.html`);
+    const websitePath = path.resolve(`website/${tool}.html`);
+
+    test.describe(`${tool}: build-label`, () => {
+
+        test(`dist file: no placeholder text leaks through`, async () => {
+            const html = fs.readFileSync(distPath, 'utf8');
+            expect(html).not.toContain('{{BUILD_LABEL}}');
+            expect(html).not.toContain('{{BUILD_TIMESTAMP}}');
+        });
+
+        test(`dist file: .build-timestamp element is visible in browser`, async ({ page }) => {
+            const waitUntil = tool === 'mdedit' ? 'load' : 'domcontentloaded';
+            await page.goto(`file://${distPath}`, { waitUntil });
+            const el = page.locator('.build-timestamp');
+            await expect(el).toBeVisible({ timeout: 10000 });
+        });
+
+        test(`dist file: label is a valid timestamp or version string`, async () => {
+            const html = fs.readFileSync(distPath, 'utf8');
+            // BETA labels are wrapped in an inner <span style="color:red...">; non-BETA are bare text.
+            const match = html.match(/class="build-timestamp">(?:<span[^>]*>)?([^<]+?)(?:<\/span>)?</);
+            expect(match, 'build-timestamp element must have text content').toBeTruthy();
+            const label = match[1];
+            const isTimestamp = /^Built: 20\d\d-\d\d-\d\d \d\d:\d\d:\d\d( BETA)?$/.test(label);
+            const isVersion   = /^v\d+\.\d+\.\d+( BETA)?$/.test(label);
+            expect(isTimestamp || isVersion,
+                `Expected timestamp or version, got: "${label}"`
+            ).toBe(true);
+        });
+
+        test(`website file: label shows version format (release build)`, async () => {
+            if (!fs.existsSync(websitePath)) {
+                test.skip(true, `website/${tool}.html not present — run sh ${tool}/build.sh --release first`);
+                return;
+            }
+            const html = fs.readFileSync(websitePath, 'utf8');
+            expect(html).not.toContain('{{BUILD_LABEL}}');
+            expect(html).not.toContain('{{BUILD_TIMESTAMP}}');
+            expect(html).toMatch(/class="build-timestamp">(?:<span[^>]*>)?v\d+\.\d+\.\d+( BETA)?(?:<\/span>)?</);
+        });
+    });
+}
diff --git a/tests/classifier.spec.js b/tests/classifier.spec.js
new file mode 100644
index 0000000..d88b265
--- /dev/null
+++ b/tests/classifier.spec.js
@@ -0,0 +1,112 @@
+import { test, expect } from '@playwright/test';
+import * as path from 'path';
+
+const HTML_PATH = path.resolve('classifier/dist/classifier.html');
+
+test.describe('Classifier', () => {
+
+    test('loads without errors', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'domcontentloaded' });
+
+        // Wait for app initialisation
+        await page.waitForFunction(() => typeof window.app !== 'undefined' && window.app.modules, { timeout: 15000 });
+
+        // Core modules should be registered
+        const moduleNames = await page.evaluate(() => Object.keys(window.app.modules));
+        expect(moduleNames).toContain('store');
+        expect(moduleNames).toContain('spreadsheet');
+        expect(moduleNames).toContain('validator');
+    });
+
+    test('files injected into store are parsed and produce valid computed filenames', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'domcontentloaded' });
+        await page.waitForFunction(() => typeof window.app !== 'undefined' && window.app.modules?.store, { timeout: 15000 });
+
+        // Inject files via the store API. The main app panel stays hidden until a real
+        // directory is opened via showDirectoryPicker, so we verify through the store
+        // and spreadsheet module APIs rather than the DOM table.
+        const result = await page.evaluate(() => {
+            // File objects must match the shape the scanner produces:
+            // `trackingNumber`, `originalFilename`, `extension` (with dot)
+            const files = [
+                { trackingNumber: '123456-EL-SPC-2623', title: 'Specification For Switchgear',
+                  revision: 'A', status: 'IFC', extension: '.pdf',
+                  originalFilename: '123456-EL-SPC-2623_A (IFC) - Specification For Switchgear',
+                  name: '123456-EL-SPC-2623_A (IFC) - Specification For Switchgear.pdf',
+                  path: 'test-project/123456-EL-SPC-2623_A (IFC) - Specification For Switchgear.pdf',
+                  size: 45000, isDirectory: false },
+                { trackingNumber: '123456-EL-DRW-0001', title: 'Electrical Arrangement',
+                  revision: 'B', status: 'IFR', extension: '.dwg',
+                  originalFilename: '123456-EL-DRW-0001_B (IFR) - Electrical Arrangement',
+                  name: '123456-EL-DRW-0001_B (IFR) - Electrical Arrangement.dwg',
+                  path: 'test-project/123456-EL-DRW-0001_B (IFR) - Electrical Arrangement.dwg',
+                  size: 120000, isDirectory: false },
+            ];
+            const tree = [{ path: 'test-project', name: 'test-project', files, children: [] }];
+            window.app.modules.store.setFolderTree(tree);
+            window.app.modules.store.setSelectedFolders(['test-project']);
+
+            const displayFiles = window.app.modules.store.getDisplayFiles();
+            const computed = displayFiles.map(f =>
+                window.app.modules.spreadsheet.computeNewFilename(f, 0) || ''
+            );
+            return { count: displayFiles.length, computed };
+        });
+
+        // Both files should be in the store
+        expect(result.count).toBe(2);
+
+        // Each computed filename should contain its tracking number
+        // (sort order may vary, so check both filenames contain a tracking number)
+        const allFilenames = result.computed.join('\n');
+        expect(allFilenames).toContain('123456-EL-SPC-2623');
+        expect(allFilenames).toContain('123456-EL-DRW-0001');
+    });
+
+    test('extension is stored without leading dot, joined back with one', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'domcontentloaded' });
+        await page.waitForFunction(() => typeof window.app !== 'undefined' && window.app.modules?.utils, { timeout: 15000 });
+
+        const probe = await page.evaluate(() => {
+            const split = window.zddc.splitExtension('test.pdf');
+            const joined = window.zddc.joinExtension('test', 'pdf');
+            const file = {
+                originalFilename: '123456-EL-SPC-2623_A (IFC) - Spec',
+                extension: split.extension,
+                trackingNumber: '123456-EL-SPC-2623',
+                revision: 'A',
+                status: 'IFC',
+                title: 'Spec',
+            };
+            return {
+                splitExt: split.extension,
+                joined: joined,
+                computedFilename: window.app.modules.utils.computeNewFilename(file),
+            };
+        });
+
+        expect(probe.splitExt).toBe('pdf');               // no leading dot stored
+        expect(probe.joined).toBe('test.pdf');             // joinExtension adds the dot
+        expect(probe.computedFilename).toBe('123456-EL-SPC-2623_A (IFC) - Spec.pdf');
+    });
+
+    test('zddc.filter is exposed as a sub-namespace of zddc', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'domcontentloaded' });
+        await page.waitForFunction(() => typeof window.zddc?.filter === 'object', { timeout: 15000 });
+
+        const result = await page.evaluate(() => {
+            const ast = window.zddc.filter.parse('foo');
+            return {
+                hasParse:   typeof window.zddc.filter.parse === 'function',
+                hasMatches: typeof window.zddc.filter.matches === 'function',
+                noLegacyGlobal: typeof window.ZDDCFilter === 'undefined',
+                matches:    window.zddc.filter.matches('foobar', ast),
+            };
+        });
+
+        expect(result.hasParse).toBe(true);
+        expect(result.hasMatches).toBe(true);
+        expect(result.noLegacyGlobal).toBe(true);
+        expect(result.matches).toBe(true);
+    });
+});
diff --git a/tests/fixtures/mock-fs-api.js b/tests/fixtures/mock-fs-api.js
new file mode 100644
index 0000000..3a4a674
--- /dev/null
+++ b/tests/fixtures/mock-fs-api.js
@@ -0,0 +1,196 @@
+/**
+ * Reusable File System Access API mock for Playwright tests.
+ *
+ * Usage in a Playwright test:
+ *
+ *   import { MOCK_FS_INIT_SCRIPT, buildMockDirectory } from './fixtures/mock-fs-api.js';
+ *
+ *   test.beforeEach(async ({ page }) => {
+ *     await page.addInitScript(MOCK_FS_INIT_SCRIPT);
+ *   });
+ *
+ *   test('loads files', async ({ page }) => {
+ *     const files = [
+ *       { name: '123456-EL-SPC-2623_A (IFR) - Spec.pdf', content: 'pdf-bytes', size: 45000 },
+ *     ];
+ *     await page.evaluate((files) => {
+ *       window.__setMockDirectory('test-project', files);
+ *     }, files);
+ *     await page.goto(`file://${htmlPath}`);
+ *   });
+ */
+
+/**
+ * Init script string to inject via page.addInitScript().
+ * Defines MockFileHandle, MockDirectoryHandle, and overrides the
+ * showDirectoryPicker / showOpenFilePicker / showSaveFilePicker APIs.
+ */
+export const MOCK_FS_INIT_SCRIPT = `
+  class MockFileHandle {
+    constructor(name, content, size) {
+      this.kind = 'file';
+      this.name = name;
+      this._content = content || '';
+      this._size = size || (content ? content.length : 0);
+    }
+
+    async getFile() {
+      const blob = new File([this._content], this.name, {
+        lastModified: Date.now(),
+        type: this._guessMimeType(),
+      });
+      if (this._size && this._size !== blob.size) {
+        Object.defineProperty(blob, 'size', { value: this._size, writable: false });
+      }
+      return blob;
+    }
+
+    async createWritable() {
+      const name = this.name;
+      const chunks = [];
+      return {
+        write(data) { chunks.push(data); },
+        close() {
+          window.__writtenFiles = window.__writtenFiles || {};
+          window.__writtenFiles[name] = chunks;
+        },
+      };
+    }
+
+    _guessMimeType() {
+      const ext = this.name.split('.').pop().toLowerCase();
+      const types = {
+        pdf: 'application/pdf',
+        html: 'text/html',
+        json: 'application/json',
+        txt: 'text/plain',
+        dwg: 'application/acad',
+        md: 'text/markdown',
+      };
+      return types[ext] || 'application/octet-stream';
+    }
+  }
+
+  class MockDirectoryHandle {
+    constructor(name, entries) {
+      this.kind = 'directory';
+      this.name = name;
+      this._entries = entries || [];
+    }
+
+    async *values() {
+      for (const entry of this._entries) {
+        yield entry;
+      }
+    }
+
+    async *entries() {
+      for (const entry of this._entries) {
+        yield [entry.name, entry];
+      }
+    }
+
+    async *keys() {
+      for (const entry of this._entries) {
+        yield entry.name;
+      }
+    }
+
+    async getFileHandle(name, opts) {
+      const found = this._entries.find(e => e.kind === 'file' && e.name === name);
+      if (found) return found;
+      if (opts && opts.create) {
+        const handle = new MockFileHandle(name, '');
+        this._entries.push(handle);
+        return handle;
+      }
+      throw new DOMException('A requested file or directory could not be found.', 'NotFoundError');
+    }
+
+    async getDirectoryHandle(name, opts) {
+      const found = this._entries.find(e => e.kind === 'directory' && e.name === name);
+      if (found) return found;
+      if (opts && opts.create) {
+        const handle = new MockDirectoryHandle(name, []);
+        this._entries.push(handle);
+        return handle;
+      }
+      throw new DOMException('A requested file or directory could not be found.', 'NotFoundError');
+    }
+
+    async queryPermission() { return 'granted'; }
+    async requestPermission() { return 'granted'; }
+    async resolve(child) { return child ? [child.name] : null; }
+  }
+
+  // Expose constructors globally for per-test customization
+  window.__MockFileHandle = MockFileHandle;
+  window.__MockDirectoryHandle = MockDirectoryHandle;
+  window.__writtenFiles = {};
+
+  /**
+   * Helper to build a mock directory from a flat file list.
+   * @param {string} dirName - Root directory name
+   * @param {Array<{name: string, content?: string, size?: number}>} files - Flat file list
+   */
+  window.__setMockDirectory = function(dirName, files) {
+    const entries = (files || []).map(f =>
+      new MockFileHandle(f.name, f.content || '', f.size || 0)
+    );
+    window.__mockRootDirectory = new MockDirectoryHandle(dirName, entries);
+  };
+
+  /**
+   * Helper to build nested mock directories.
+   * @param {string} dirName - Root directory name
+   * @param {Object} tree - Nested structure: { 'subdir': { 'file.txt': 'content' }, 'root.pdf': 'content' }
+   */
+  window.__setMockDirectoryTree = function(dirName, tree) {
+    function buildEntries(obj) {
+      const entries = [];
+      for (const [name, value] of Object.entries(obj)) {
+        if (typeof value === 'object' && value !== null && !ArrayBuffer.isView(value)) {
+          entries.push(new MockDirectoryHandle(name, buildEntries(value)));
+        } else {
+          entries.push(new MockFileHandle(name, String(value), String(value).length));
+        }
+      }
+      return entries;
+    }
+    window.__mockRootDirectory = new MockDirectoryHandle(dirName, buildEntries(tree));
+  };
+
+  // Override File System Access API pickers
+  window.showDirectoryPicker = async function(opts) {
+    if (!window.__mockRootDirectory) {
+      throw new DOMException('The user aborted a request.', 'AbortError');
+    }
+    return window.__mockRootDirectory;
+  };
+
+  window.showOpenFilePicker = async function(opts) {
+    if (!window.__mockOpenFiles || window.__mockOpenFiles.length === 0) {
+      throw new DOMException('The user aborted a request.', 'AbortError');
+    }
+    return window.__mockOpenFiles;
+  };
+
+  window.showSaveFilePicker = async function(opts) {
+    const name = (opts && opts.suggestedName) || 'untitled';
+    const handle = new MockFileHandle(name, '');
+    window.__lastSaveHandle = handle;
+    return handle;
+  };
+`;
+
+/**
+ * Helper to build a mock directory structure for page.evaluate().
+ * Call this in test code (Node-side), then pass to page.evaluate().
+ *
+ * @param {string} name - Directory name
+ * @param {Array<{name: string, content?: string, size?: number}>} files
+ * @returns {Object} Serializable directory description
+ */
+export function buildMockDirectory(name, files) {
+  return { name, files };
+}
diff --git a/tests/fixtures/transmittal-data.js b/tests/fixtures/transmittal-data.js
new file mode 100644
index 0000000..1a4f7f6
--- /dev/null
+++ b/tests/fixtures/transmittal-data.js
@@ -0,0 +1,163 @@
+/**
+ * Transmittal JSON test fixtures.
+ * Matches transmittal/transmittal.schema.json (JSON Schema draft 2020-12).
+ */
+
+/** Minimal valid transmittal (required fields only) */
+export const MINIMAL_TRANSMITTAL = {
+  payload: {
+    version: 1,
+    type: 'Transmittal',
+    date: '2025-10-31',
+    trackingNumber: '123456-EL-TRN-0001',
+    files: [
+      {
+        filename: '123456-EL-SPC-2623_A (IFR) - Specification For Switchgear.pdf',
+        sha256: 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2',
+      },
+    ],
+  },
+  envelope: {
+    version: 1,
+    digestAlgorithm: 'SHA-256',
+    digest: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    digestedAt: '2025-10-31T12:00:00.000Z',
+    signatureAlgorithm: 'ECDSA-P256-SHA256',
+  },
+};
+
+/** Full transmittal with all optional fields populated */
+export const FULL_TRANSMITTAL = {
+  payload: {
+    version: 1,
+    type: 'Transmittal',
+    title: 'Electrical Design Package',
+    client: 'ACME Corporation',
+    project: 'New Substation',
+    projectNumber: '123456',
+    date: '2025-10-31',
+    trackingNumber: '123456-EL-TRN-0043',
+    from: 'Engineering Team',
+    to: 'Construction Team',
+    purpose: 'IFC',
+    responseDue: '2025-11-15',
+    subject: 'Electrical Design Issued For Construction',
+    remarks: '## Notes\n\nPlease review the attached specifications and drawings.\n\n- Item 1\n- Item 2',
+    files: [
+      {
+        trackingNumber: '123456-EL-SPC-2623',
+        revision: 'A',
+        status: 'IFC',
+        title: 'Specification For Switchgear',
+        path: '',
+        filename: '123456-EL-SPC-2623_A (IFC) - Specification For Switchgear.pdf',
+        sha256: 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2',
+        fileSize: 45000,
+      },
+      {
+        trackingNumber: '123456-EL-ARR-0003',
+        revision: '0',
+        status: 'IFC',
+        title: 'Electrical Room Equipment Arrangement',
+        path: 'drawings',
+        filename: '123456-EL-ARR-0003_0 (IFC) - Electrical Room Equipment Arrangement.pdf',
+        sha256: 'b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3',
+        fileSize: 500000,
+      },
+      {
+        trackingNumber: '123456-EL-DWG-0010',
+        revision: 'A',
+        status: 'IFC',
+        title: 'Single Line Diagram',
+        path: 'drawings',
+        filename: '123456-EL-DWG-0010_A (IFC) - Single Line Diagram.pdf',
+        sha256: 'c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4',
+        fileSize: 250000,
+      },
+    ],
+  },
+  envelope: {
+    version: 1,
+    digestAlgorithm: 'SHA-256',
+    digest: 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef',
+    digestedAt: '2025-10-31T14:30:00.000Z',
+    signatureAlgorithm: 'ECDSA-P256-SHA256',
+    signatures: [],
+  },
+  presentation: {
+    theme: 'default',
+    customCss: '',
+  },
+};
+
+/** Submittal type (shows responseDue field) */
+export const SUBMITTAL = {
+  payload: {
+    version: 1,
+    type: 'Submittal',
+    date: '2025-10-31',
+    trackingNumber: '123456-EL-SUB-0001',
+    from: 'Contractor',
+    to: 'Engineer',
+    purpose: 'IFA',
+    responseDue: '2025-11-14',
+    subject: 'Switchgear Submittal',
+    files: [
+      {
+        trackingNumber: '123456-EL-SPC-2623',
+        revision: 'A',
+        status: 'IFA',
+        title: 'Specification For Switchgear',
+        filename: '123456-EL-SPC-2623_A (IFA) - Specification For Switchgear.pdf',
+        sha256: 'f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1',
+        fileSize: 45000,
+      },
+    ],
+  },
+  envelope: {
+    version: 1,
+    digestAlgorithm: 'SHA-256',
+    digest: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+    digestedAt: '2025-10-31T10:00:00.000Z',
+    signatureAlgorithm: 'ECDSA-P256-SHA256',
+  },
+};
+
+/** Invalid transmittal payloads for negative testing */
+export const INVALID_TRANSMITTALS = [
+  {
+    description: 'Missing required payload.version',
+    data: {
+      payload: { type: 'Transmittal', date: '2025-10-31', trackingNumber: '123456-EL-TRN-0001', files: [] },
+      envelope: { version: 1, digestAlgorithm: 'SHA-256', digest: 'a'.repeat(64), digestedAt: '2025-10-31T12:00:00.000Z', signatureAlgorithm: 'ECDSA-P256-SHA256' },
+    },
+  },
+  {
+    description: 'Invalid date format',
+    data: {
+      payload: { version: 1, type: 'Transmittal', date: '31-10-2025', trackingNumber: '123456-EL-TRN-0001', files: [] },
+      envelope: { version: 1, digestAlgorithm: 'SHA-256', digest: 'a'.repeat(64), digestedAt: '2025-10-31T12:00:00.000Z', signatureAlgorithm: 'ECDSA-P256-SHA256' },
+    },
+  },
+  {
+    description: 'Tracking number with underscore',
+    data: {
+      payload: { version: 1, type: 'Transmittal', date: '2025-10-31', trackingNumber: '123456_EL_TRN_0001', files: [] },
+      envelope: { version: 1, digestAlgorithm: 'SHA-256', digest: 'a'.repeat(64), digestedAt: '2025-10-31T12:00:00.000Z', signatureAlgorithm: 'ECDSA-P256-SHA256' },
+    },
+  },
+  {
+    description: 'Invalid SHA-256 hash (wrong length)',
+    data: {
+      payload: { version: 1, type: 'Transmittal', date: '2025-10-31', trackingNumber: '123456-EL-TRN-0001', files: [{ filename: 'test.pdf', sha256: 'abc123' }] },
+      envelope: { version: 1, digestAlgorithm: 'SHA-256', digest: 'a'.repeat(64), digestedAt: '2025-10-31T12:00:00.000Z', signatureAlgorithm: 'ECDSA-P256-SHA256' },
+    },
+  },
+  {
+    description: 'File with additional unexpected property',
+    data: {
+      payload: { version: 1, type: 'Transmittal', date: '2025-10-31', trackingNumber: '123456-EL-TRN-0001', files: [{ filename: 'test.pdf', sha256: 'a'.repeat(64), unexpected: true }] },
+      envelope: { version: 1, digestAlgorithm: 'SHA-256', digest: 'a'.repeat(64), digestedAt: '2025-10-31T12:00:00.000Z', signatureAlgorithm: 'ECDSA-P256-SHA256' },
+    },
+  },
+];
diff --git a/tests/fixtures/zddc-filenames.js b/tests/fixtures/zddc-filenames.js
new file mode 100644
index 0000000..9e95647
--- /dev/null
+++ b/tests/fixtures/zddc-filenames.js
@@ -0,0 +1,191 @@
+/**
+ * ZDDC filename test fixtures.
+ *
+ * Covers the full naming convention from README.md:
+ *   trackingNumber_revision (status) - title.extension
+ *
+ * These fixtures are shared across tool tests to ensure consistent
+ * parsing behavior (archive, transmittal, classifier all parse filenames).
+ */
+
+/** Valid ZDDC filenames with expected parsed components */
+export const VALID_FILES = [
+  // --- Standard letter revisions ---
+  {
+    filename: '123456-EL-SPC-2623_A (IFR) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'A', status: 'IFR', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 45000,
+  },
+  {
+    filename: '123456-EL-SPC-2623_B (IFR) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'B', status: 'IFR', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 46000,
+  },
+
+  // --- Standard number revisions (issued for construction) ---
+  {
+    filename: '123456-EL-SPC-2623_0 (IFC) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: '0', status: 'IFC', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 47000,
+  },
+  {
+    filename: '123456-EL-SPC-2623_1 (IFC) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: '1', status: 'IFC', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 48000,
+  },
+
+  // --- Revision modifiers ---
+  {
+    filename: '123456-EL-SPC-2623_A+C1 (RSB) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'A+C1', status: 'RSB', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 12000,
+    description: 'Comments to Rev A',
+  },
+  {
+    filename: '123456-EL-SPC-2623_A+C2 (RSA) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'A+C2', status: 'RSA', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 13000,
+    description: 'Second set of comments to Rev A',
+  },
+  {
+    filename: '123456-EL-SPC-2623_A+B1 (IFI) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'A+B1', status: 'IFI', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 8000,
+    description: 'Backup material for Rev A',
+  },
+  {
+    filename: '123456-EL-SPC-2623_A+N1 (IFI) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'A+N1', status: 'IFI', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 5000,
+    description: 'Notes for Rev A',
+  },
+  {
+    filename: '123456-EL-SPC-2623_A+Q1 (RSA) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'A+Q1', status: 'RSA', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 3000,
+    description: 'Quality check record for Rev A',
+  },
+
+  // --- Draft indicators ---
+  {
+    filename: '123456-EL-SPC-2623_~B (IFR) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: '~B', status: 'IFR', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 44000,
+    description: 'Working draft of Rev B',
+  },
+  {
+    filename: '123456-EL-SPC-2623_A+~C1 (---) - Specification For Switchgear.pdf',
+    parsed: { trackingNumber: '123456-EL-SPC-2623', revision: 'A+~C1', status: '---', title: 'Specification For Switchgear', extension: 'pdf' },
+    size: 11000,
+    description: 'Working draft of comments to Rev A, status unknown',
+  },
+
+  // --- Multiple disciplines ---
+  {
+    filename: '123456-EM-MDL-0001_A (IFR) - Master Deliverables List.pdf',
+    parsed: { trackingNumber: '123456-EM-MDL-0001', revision: 'A', status: 'IFR', title: 'Master Deliverables List', extension: 'pdf' },
+    size: 120000,
+  },
+  {
+    filename: '123456-EL-ARR-0003_A (IFR) - Electrical Room Equipment Arrangement.dwg',
+    parsed: { trackingNumber: '123456-EL-ARR-0003', revision: 'A', status: 'IFR', title: 'Electrical Room Equipment Arrangement', extension: 'dwg' },
+    size: 500000,
+  },
+  {
+    filename: '123456-ME-RFI-0024_A (IFR) - Mechanical Room Size RFI.pdf',
+    parsed: { trackingNumber: '123456-ME-RFI-0024', revision: 'A', status: 'IFR', title: 'Mechanical Room Size RFI', extension: 'pdf' },
+    size: 25000,
+  },
+
+  // --- Issued status codes (no DFT — drafts use ~rev prefix) ---
+  { filename: '123456-EL-DWG-0002_A (IFA) - Approval Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0002', revision: 'A', status: 'IFA', title: 'Approval Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0003_A (IFB) - Bid Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0003', revision: 'A', status: 'IFB', title: 'Bid Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0004_A (IFC) - Construction Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0004', revision: 'A', status: 'IFC', title: 'Construction Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0005_A (IFD) - Design Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0005', revision: 'A', status: 'IFD', title: 'Design Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0006_A (IFI) - Information Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0006', revision: 'A', status: 'IFI', title: 'Information Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0007_A (IFP) - Purchase Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0007', revision: 'A', status: 'IFP', title: 'Purchase Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0008_A (IFR) - Review Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0008', revision: 'A', status: 'IFR', title: 'Review Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0009_A (IFU) - Use Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0009', revision: 'A', status: 'IFU', title: 'Use Drawing', extension: 'pdf' }, size: 10000 },
+  { filename: '123456-EL-DWG-0010_A (REC) - Record Drawing.pdf', parsed: { trackingNumber: '123456-EL-DWG-0010', revision: 'A', status: 'REC', title: 'Record Drawing', extension: 'pdf' }, size: 10000 },
+
+  // --- Review status codes (used with modifiers) ---
+  { filename: '123456-EL-DWG-0001_A+C1 (RSA) - No Comments.pdf', parsed: { trackingNumber: '123456-EL-DWG-0001', revision: 'A+C1', status: 'RSA', title: 'No Comments', extension: 'pdf' }, size: 5000 },
+  { filename: '123456-EL-DWG-0001_A+C1 (RSB) - Incorporate and Resubmit.pdf', parsed: { trackingNumber: '123456-EL-DWG-0001', revision: 'A+C1', status: 'RSB', title: 'Incorporate and Resubmit', extension: 'pdf' }, size: 5000 },
+  { filename: '123456-EL-DWG-0001_A+C1 (RSC) - Revise and Resubmit.pdf', parsed: { trackingNumber: '123456-EL-DWG-0001', revision: 'A+C1', status: 'RSC', title: 'Revise and Resubmit', extension: 'pdf' }, size: 5000 },
+  { filename: '123456-EL-DWG-0001_A+C1 (RSD) - Rejected.pdf', parsed: { trackingNumber: '123456-EL-DWG-0001', revision: 'A+C1', status: 'RSD', title: 'Rejected', extension: 'pdf' }, size: 5000 },
+  { filename: '123456-EL-DWG-0001_A+B1 (RSI) - Supplemental Info.pdf', parsed: { trackingNumber: '123456-EL-DWG-0001', revision: 'A+B1', status: 'RSI', title: 'Supplemental Info', extension: 'pdf' }, size: 5000 },
+
+  // --- Record/construction lifecycle ---
+  {
+    filename: '123456-EL-ARR-0003_0 (IFC) - Electrical Room Equipment Arrangement.pdf',
+    parsed: { trackingNumber: '123456-EL-ARR-0003', revision: '0', status: 'IFC', title: 'Electrical Room Equipment Arrangement', extension: 'pdf' },
+    size: 50000,
+    description: 'First construction issue',
+  },
+  {
+    filename: '123456-EL-ARR-0003_1 (IFC) - Electrical Room Equipment Arrangement.pdf',
+    parsed: { trackingNumber: '123456-EL-ARR-0003', revision: '1', status: 'IFC', title: 'Electrical Room Equipment Arrangement', extension: 'pdf' },
+    size: 51000,
+    description: 'Construction revision',
+  },
+  {
+    filename: '123456-EL-ARR-0003_2 (REC) - Electrical Room Equipment Arrangement.pdf',
+    parsed: { trackingNumber: '123456-EL-ARR-0003', revision: '2', status: 'REC', title: 'Electrical Room Equipment Arrangement', extension: 'pdf' },
+    size: 52000,
+    description: 'For record',
+  },
+];
+
+/** Invalid filenames for negative testing */
+export const INVALID_FILES = [
+  { filename: 'random-document.pdf', reason: 'No ZDDC naming convention' },
+  { filename: 'has spaces in tracking_A (IFR) - Title.pdf', reason: 'Spaces in tracking number' },
+  { filename: '123456_EL_SPC_2623_A (IFR) - Title.pdf', reason: 'Underscores in tracking number' },
+  { filename: '123456-EL-SPC-2623_A (IFR).pdf', reason: 'Missing title separator' },
+  { filename: '123456-EL-SPC-2623_A - Title.pdf', reason: 'Missing status' },
+  { filename: '123456-EL-SPC-2623 (IFR) - Title.pdf', reason: 'Missing revision' },
+  { filename: '123456-EL-SPC-2623_ (IFR) - Title.pdf', reason: 'Empty revision' },
+  { filename: '123456-EL-SPC-2623_A () - Title.pdf', reason: 'Empty status' },
+  { filename: '123456-EL-SPC-2623_A (IFR) - .pdf', reason: 'Empty title' },
+];
+
+/** Transmittal folder names */
+export const VALID_FOLDERS = [
+  {
+    foldername: '2025-10-31_123456-EM-SUB-0001 (IFR) - General Arrangement for Review',
+    parsed: { date: '2025-10-31', trackingNumber: '123456-EM-SUB-0001', status: 'IFR', title: 'General Arrangement for Review' },
+  },
+  {
+    foldername: '2025-10-31_123456-EL-TRN-0043 (IFC) - Electrical Design Issued For Construction',
+    parsed: { date: '2025-10-31', trackingNumber: '123456-EL-TRN-0043', status: 'IFC', title: 'Electrical Design Issued For Construction' },
+  },
+  {
+    foldername: '2025-10-31_123456-ME-RFI-0024 (IFR) - Mechanical Room Size RFI',
+    parsed: { date: '2025-10-31', trackingNumber: '123456-ME-RFI-0024', status: 'IFR', title: 'Mechanical Room Size RFI' },
+  },
+  {
+    foldername: '2025-11-12_123456-ME-RFI-0024 (IFU) - Mechanical Room Size RFI',
+    parsed: { date: '2025-11-12', trackingNumber: '123456-ME-RFI-0024', status: 'IFU', title: 'Mechanical Room Size RFI' },
+  },
+];
+
+/**
+ * Expected revision sort order (letters before numbers, drafts before finals).
+ * This documents the canonical behavior -- tests should verify each tool's
+ * compareRevisions() matches this order.
+ */
+export const REVISION_SORT_ORDER = [
+  '~A',       // draft of A
+  'A',        // final A
+  'A+B1',     // backup material for A
+  'A+C1',     // comments to A
+  'A+~C2',    // draft of second comments to A
+  'A+C2',     // second comments to A
+  'A+N1',     // notes for A
+  'A+Q1',     // quality check for A
+  '~B',       // draft of B
+  'B',        // final B
+  '0',        // first construction issue
+  '1',        // construction revision
+  '2',        // for record
+];
diff --git a/tests/mdedit.spec.js b/tests/mdedit.spec.js
new file mode 100644
index 0000000..f55e100
--- /dev/null
+++ b/tests/mdedit.spec.js
@@ -0,0 +1,76 @@
+import { test, expect } from '@playwright/test';
+import { MOCK_FS_INIT_SCRIPT } from './fixtures/mock-fs-api.js';
+import * as path from 'path';
+
+const HTML_PATH = path.resolve('mdedit/dist/mdedit.html');
+
+test.describe('Markdown Editor', () => {
+    test.beforeEach(async ({ page }) => {
+        await page.addInitScript(MOCK_FS_INIT_SCRIPT);
+    });
+
+    test('loads without errors', async ({ page }) => {
+        // Use 'load' rather than 'networkidle' — the bundled Toast UI/Tailwind
+        // scripts run inline so there is no external network activity to wait for.
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'load' });
+        await page.waitForSelector('#app', { timeout: 15000 });
+
+        // Welcome screen is shown before any directory is opened
+        await expect(page.locator('#welcome-screen')).toBeVisible();
+
+        // Select Directory button is present and enabled
+        const selectDirBtn = page.locator('#select-directory');
+        await expect(selectDirBtn).toBeVisible();
+        await expect(selectDirBtn).not.toBeDisabled();
+    });
+
+    test('renders a file tree from a mock directory', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'load' });
+        await page.waitForSelector('#select-directory', { timeout: 15000 });
+
+        // Set up mock directory before triggering the picker
+        await page.evaluate(() => {
+            window.__setMockDirectory('notes', [
+                { name: 'readme.md', content: '# Hello\n\nWelcome.', size: 30 },
+                { name: 'notes.md', content: '# Notes\n\nSome notes.', size: 25 },
+            ]);
+        });
+
+        await page.locator('#select-directory').click();
+
+        // File tree should populate with the two files
+        await page.waitForFunction(
+            () => document.querySelector('#file-tree')?.children.length > 0,
+            { timeout: 10000 }
+        );
+
+        const items = await page.locator('#file-tree *').count();
+        expect(items).toBeGreaterThanOrEqual(2);
+    });
+
+    test('DEBUG flag is defined and console.log calls are gated', async ({ page }) => {
+        const logs = [];
+        page.on('console', msg => msg.type() === 'log' && logs.push(msg.text()));
+
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'load' });
+        await page.waitForSelector('#select-directory', { timeout: 15000 });
+
+        const probe = await page.evaluate(() => ({
+            debugDefined: typeof DEBUG !== 'undefined',
+            debugValue:   typeof DEBUG !== 'undefined' ? DEBUG : null,
+        }));
+
+        expect(probe.debugDefined).toBe(true);
+        expect(probe.debugValue).toBe(false);
+
+        // With DEBUG=false, no console.log should fire from app code on load.
+        // (Browser/Toast-UI may still log; we only check none of the gated lines fired.)
+        const ourLogs = logs.filter(l =>
+            l.startsWith('Opened scratchpad') ||
+            l.startsWith('Directory selected') ||
+            l.startsWith('File ') ||
+            l.startsWith('Created new file')
+        );
+        expect(ourLogs).toEqual([]);
+    });
+});
diff --git a/tests/schema.spec.js b/tests/schema.spec.js
new file mode 100644
index 0000000..8c34cef
--- /dev/null
+++ b/tests/schema.spec.js
@@ -0,0 +1,44 @@
+import { test, expect } from '@playwright/test';
+import * as fs from 'fs';
+import * as path from 'path';
+import Ajv from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import {
+    MINIMAL_TRANSMITTAL,
+    FULL_TRANSMITTAL,
+    SUBMITTAL,
+    INVALID_TRANSMITTALS,
+} from './fixtures/transmittal-data.js';
+
+const SCHEMA_PATH = path.resolve('transmittal/transmittal.schema.json');
+const schema = JSON.parse(fs.readFileSync(SCHEMA_PATH, 'utf8'));
+
+const ajv = new Ajv({ strict: false, allErrors: true });
+addFormats(ajv);
+const validate = ajv.compile(schema);
+
+test.describe('transmittal.schema.json', () => {
+    test('schema is syntactically valid JSON Schema', () => {
+        expect(() => ajv.compile(schema)).not.toThrow();
+    });
+
+    for (const [name, data] of [
+        ['MINIMAL_TRANSMITTAL', MINIMAL_TRANSMITTAL],
+        ['FULL_TRANSMITTAL', FULL_TRANSMITTAL],
+        ['SUBMITTAL', SUBMITTAL],
+    ]) {
+        test(`accepts canonical fixture: ${name}`, () => {
+            const ok = validate(data);
+            if (!ok) {
+                console.error(`Validation errors for ${name}:`, JSON.stringify(validate.errors, null, 2));
+            }
+            expect(ok).toBe(true);
+        });
+    }
+
+    for (const { description, data } of INVALID_TRANSMITTALS) {
+        test(`rejects: ${description}`, () => {
+            expect(validate(data)).toBe(false);
+        });
+    }
+});
diff --git a/tests/transmittal-drag-drop.spec.js b/tests/transmittal-drag-drop.spec.js
new file mode 100644
index 0000000..4d5b290
--- /dev/null
+++ b/tests/transmittal-drag-drop.spec.js
@@ -0,0 +1,109 @@
+import { test, expect } from '@playwright/test';
+import { MOCK_FS_INIT_SCRIPT } from './fixtures/mock-fs-api.js';
+
+const HTML_PATH = '/home/user/src/zddc/transmittal/dist/transmittal.html';
+
+test.describe('drag-drop zones', () => {
+    test.beforeEach(async ({ page }) => {
+        await page.addInitScript(MOCK_FS_INIT_SCRIPT);
+    });
+
+    test('dragenter with directory MIME (empty type) makes file-table eligible', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'networkidle' });
+        await page.waitForTimeout(300);
+
+        // Dispatch dragenter with relatedTarget: null and directory MIME (empty string)
+        await page.evaluate(() => {
+            const dt = {
+                items: [{ kind: 'file', type: '' }],
+                files: [],
+                types: ['Files']
+            };
+            const event = new Event('dragenter', { bubbles: true });
+            Object.defineProperty(event, 'dataTransfer', { value: dt, writable: false });
+            Object.defineProperty(event, 'relatedTarget', { value: null, writable: false });
+            document.dispatchEvent(event);
+        });
+
+        await page.waitForTimeout(300);
+
+        // Verify file-table zone is visible and eligible
+        const fileTableZone = page.locator('[data-drop-zone="file-table"]');
+        await expect(fileTableZone).toHaveClass(/dz-visible/);
+        await expect(fileTableZone).toHaveClass(/dz-eligible/);
+
+        // Verify logo-left zone is NOT eligible (image-only zone, no image dropped)
+        const logoLeftZone = page.locator('[data-drop-zone="logo-left"]');
+        await expect(logoLeftZone).not.toHaveClass(/dz-eligible/);
+    });
+
+    test('dragleave with relatedTarget: null removes dz-visible from zones', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'networkidle' });
+        await page.waitForTimeout(300);
+
+        // First show zones with dragenter
+        await page.evaluate(() => {
+            const dt = {
+                items: [{ kind: 'file', type: '' }],
+                files: [],
+                types: ['Files']
+            };
+            const event = new Event('dragenter', { bubbles: true });
+            Object.defineProperty(event, 'dataTransfer', { value: dt, writable: false });
+            Object.defineProperty(event, 'relatedTarget', { value: null, writable: false });
+            document.dispatchEvent(event);
+        });
+
+        await page.waitForTimeout(300);
+
+        // Verify zones are visible
+        const fileTableZone = page.locator('[data-drop-zone="file-table"]');
+        await expect(fileTableZone).toHaveClass(/dz-visible/);
+
+        // Now dispatch dragleave with relatedTarget: null
+        await page.evaluate(() => {
+            const dt = {
+                items: [{ kind: 'file', type: '' }],
+                files: [],
+                types: ['Files']
+            };
+            const event = new Event('dragleave', { bubbles: true });
+            Object.defineProperty(event, 'dataTransfer', { value: dt, writable: false });
+            Object.defineProperty(event, 'relatedTarget', { value: null, writable: false });
+            document.dispatchEvent(event);
+        });
+
+        await page.waitForTimeout(300);
+
+        // Verify zones no longer have dz-visible class
+        await expect(fileTableZone).not.toHaveClass(/dz-visible/);
+    });
+
+    test('dragenter with image MIME makes logo zones eligible and file-table ineligible', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'networkidle' });
+        await page.waitForTimeout(300);
+
+        // Dispatch dragenter with image MIME
+        await page.evaluate(() => {
+            const dt = {
+                items: [{ kind: 'file', type: 'image/png' }],
+                files: [],
+                types: ['Files']
+            };
+            const event = new Event('dragenter', { bubbles: true });
+            Object.defineProperty(event, 'dataTransfer', { value: dt, writable: false });
+            Object.defineProperty(event, 'relatedTarget', { value: null, writable: false });
+            document.dispatchEvent(event);
+        });
+
+        await page.waitForTimeout(300);
+
+        // App starts in edit mode — logo zones accept image drops and should be eligible
+        const logoLeftZone = page.locator('[data-drop-zone="logo-left"]');
+        await expect(logoLeftZone).toHaveClass(/dz-eligible/);
+
+        // File-table zone does not accept pure-image drops — should be ineligible
+        const fileTableZone = page.locator('[data-drop-zone="file-table"]');
+        await expect(fileTableZone).toHaveClass(/dz-ineligible/);
+    });
+});
diff --git a/tests/transmittal-init-check.spec.js b/tests/transmittal-init-check.spec.js
new file mode 100644
index 0000000..7dee013
--- /dev/null
+++ b/tests/transmittal-init-check.spec.js
@@ -0,0 +1,66 @@
+import { test, expect } from '@playwright/test';
+import { MOCK_FS_INIT_SCRIPT } from './fixtures/mock-fs-api.js';
+
+const HTML_PATH = '/home/user/src/zddc/transmittal/dist/transmittal.html';
+
+test.describe('Transmittal – initial state validation (detailed check)', () => {
+    test.beforeEach(async ({ page }) => {
+        await page.addInitScript(MOCK_FS_INIT_SCRIPT);
+    });
+
+    test('should show NOT VALIDATED warning and check signature/digest elements', async ({ page }) => {
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'networkidle' });
+        
+        // Collect console errors
+        const errors = [];
+        page.on('console', msg => {
+            if (msg.type() === 'error') {
+                errors.push(msg.text());
+            }
+        });
+        
+        // Wait for page to stabilize
+        await page.waitForTimeout(500);
+        
+        // 1. Check if "Not Validated (requires JavaScript)" warning is visible
+        // With the CSS fix, the static warning is now hidden by default when JS is available
+        const warningLocator = page.locator('text=Not Validated (requires JavaScript)');
+        const warningIsVisible = await warningLocator.isVisible();
+        
+        // 2. Check signature-status-static element state
+        // The element has display:none from CSS, not hidden property (JS may set that too)
+        const signatureStatus = page.locator('#signature-status-static');
+        const signatureHiddenAttr = await signatureStatus.getAttribute('hidden');
+        const signatureHiddenProp = await signatureStatus.evaluate(el => el.hidden);
+        const signatureVisibility = await signatureStatus.evaluate(el => getComputedStyle(el).visibility);
+        const signatureDisplay = await signatureStatus.evaluate(el => getComputedStyle(el).display);
+        
+        // 3. Check digest-display element content
+        const digestContent = await page.locator('#digest-display').textContent();
+        const digestComputedStyle = await page.locator('#digest-display').evaluate(el => getComputedStyle(el));
+        const digestDisplay = digestComputedStyle.display;
+        const digestVisibility = digestComputedStyle.visibility;
+        
+        // 4. Check if there are any other visible elements we should report
+        const signatureStatusText = await signatureStatus.textContent();
+        const digestHasChildren = await page.locator('#digest-display').evaluate(el => el.children.length);
+        
+        // Report all findings
+        console.log('=== INITIAL STATE CHECK ===');
+        console.log('Warning visible:', warningIsVisible);
+        console.log('signature-status-static display:', signatureDisplay);
+        console.log('signature-status-static visibility:', signatureVisibility);
+        console.log('signature-status-basic text:', signatureStatusText);
+        console.log('digest-display content:', JSON.stringify(digestContent));
+        console.log('digest-display display:', digestDisplay);
+        console.log('digest-display visibility:', digestVisibility);
+        console.log('digest-display children count:', digestHasChildren);
+        console.log('console errors:', errors);
+        
+        // Assertions - with CSS fix, static warning should be hidden
+        expect(warningIsVisible).toBe(false); // Hidden by CSS [data-hydrate-hide="true"]
+        expect(signatureDisplay).toBe('none');
+        // digest-display may be populated by the security module on load — don't assert empty
+        expect(errors).toHaveLength(0);
+    });
+});
diff --git a/tests/transmittal.spec.js b/tests/transmittal.spec.js
new file mode 100644
index 0000000..2a36895
--- /dev/null
+++ b/tests/transmittal.spec.js
@@ -0,0 +1,174 @@
+import { test, expect } from '@playwright/test';
+import { MOCK_FS_INIT_SCRIPT } from './fixtures/mock-fs-api.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+const HTML_PATH = path.resolve('transmittal/dist/transmittal.html');
+
+// Tab-separated clipboard data simulating a paste from a document register
+const PASTED_FILE_TEXT = [
+    '123456-EL-SPC-2623\tMaterial Specification\tA\tIFC\tpdf',
+    '123456-EL-SPC-2624\tInstallation Drawing\tB\tIFR\tdwg',
+].join('\n');
+
+test.describe('Transmittal – pasted files survive a save/load cycle', () => {
+    test.beforeEach(async ({ page }) => {
+        await page.addInitScript(MOCK_FS_INIT_SCRIPT);
+    });
+
+    test('files pasted from clipboard appear after opening the saved draft', async ({ page }) => {
+        // ── 1. Load the app ──────────────────────────────────────────────────
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'networkidle' });
+
+        // ── Wait for table tbody ──────────────────────────────────────────────
+        await page.waitForSelector('table tbody', { timeout: 30000 });
+
+        // ── 2. Inject pasted files directly into app state ───────────────────
+        // Simulates what "Paste Append Rows" does without needing real clipboard.
+        await page.evaluate((clipText) => {
+            const app = window.transmittalApp;
+            // Parse through the app's own paste parser
+            const result = app.modules.files._parseClipboardTextForTest
+                ? app.modules.files._parseClipboardTextForTest(clipText)
+                : null;
+
+            // Direct injection: build the same structure columnsToFileRow produces
+            const rows = clipText.trim().split('\n').map(line => {
+                const cols = line.split('\t');
+                return {
+                    trackingNumber: cols[0] || '',
+                    title: cols[1] || '',
+                    revision: cols[2] || '',
+                    status: cols[3] || '',
+                    extension: (cols[4] || '').toLowerCase(),
+                    path: '', name: '', size: 0, fileSize: 0, sha256: ''
+                };
+            });
+            app.data.files = rows;
+            app.modules.files.updateFilesInJson(app.data.files);
+            app.modules.files.render();
+        }, PASTED_FILE_TEXT);
+
+        // Verify the files are visible in the table
+        const rowsBefore = await page.locator('table tbody tr').count();
+        // Self-entry row (row 0) + 2 pasted files
+        expect(rowsBefore).toBeGreaterThanOrEqual(3);
+
+        // ── 3. Sync UI to JSON and build the draft HTML ──────────────────────
+        const draftHtml = await page.evaluate(async () => {
+            const pub = window.transmittalApp.modules.publish;
+            await pub.syncUiToJson({ sign: false, computeDigest: false });
+            return pub.buildHtmlString();
+        });
+
+        expect(typeof draftHtml).toBe('string');
+        expect(draftHtml.length).toBeGreaterThan(1000);
+
+        // The draft HTML must contain the tracking numbers in the JSON block
+        expect(draftHtml).toContain('123456-EL-SPC-2623');
+        expect(draftHtml).toContain('123456-EL-SPC-2624');
+
+        // ── 4. Write the draft to a temp file and open it in a new page ──────
+        const tmp = path.join(os.tmpdir(), `transmittal-draft-test-${Date.now()}.html`);
+        fs.writeFileSync(tmp, draftHtml, 'utf8');
+        try {
+            const draftPage = await page.context().newPage();
+            await draftPage.addInitScript(MOCK_FS_INIT_SCRIPT);
+            await draftPage.goto(`file://${tmp}`);
+            await draftPage.waitForSelector('table tbody');
+
+            // ── 5. Assert files survived the round-trip ───────────────────────
+            const rowsAfter = await draftPage.locator('table tbody tr').count();
+            // Self-entry + 2 pasted files
+            expect(rowsAfter).toBeGreaterThanOrEqual(3);
+
+            // Check that the tracking numbers are visible in the table
+            await expect(draftPage.locator('table tbody')).toContainText('123456-EL-SPC-2623');
+            await expect(draftPage.locator('table tbody')).toContainText('123456-EL-SPC-2624');
+
+            // Check the in-memory data too
+            const appFiles = await draftPage.evaluate(() => window.transmittalApp.data.files);
+            expect(appFiles.length).toBe(2);
+            expect(appFiles[0].trackingNumber).toBe('123456-EL-SPC-2623');
+            expect(appFiles[1].trackingNumber).toBe('123456-EL-SPC-2624');
+
+            // Files must have usable names even though path/filename are empty
+            expect(appFiles[0].name).toBeTruthy();
+            expect(appFiles[1].name).toBeTruthy();
+
+            await draftPage.close();
+        } finally {
+            fs.unlinkSync(tmp);
+        }
+    });
+
+    test('files selected from filesystem survive a save/load cycle', async ({ page }) => {
+        // ── 1. Load the app ──────────────────────────────────────────────────
+        await page.goto(`file://${HTML_PATH}`, { waitUntil: 'networkidle' });
+        await page.waitForSelector('table tbody', { state: 'attached' });
+        await page.waitForTimeout(300);
+
+        // ── 2. Inject filesystem-style files (have real path + sha256) ───────
+        await page.evaluate(() => {
+            const app = window.transmittalApp;
+            app.data.files = [
+                {
+                    trackingNumber: '123456-EL-SPC-0001', title: 'Spec One',
+                    revision: 'A', status: 'IFC', extension: 'pdf',
+                    path: 'project-dir/123456-EL-SPC-0001_A (IFC) - Spec One.pdf',
+                    name: '123456-EL-SPC-0001_A (IFC) - Spec One.pdf',
+                    size: 10000, fileSize: 10000,
+                    sha256: 'aabbccddeeff001122334455667788990011223344556677889900aabbccddee'
+                },
+                {
+                    trackingNumber: '123456-EL-DRW-0002', title: 'Drawing Two',
+                    revision: 'B', status: 'IFR', extension: 'dwg',
+                    path: 'project-dir/123456-EL-DRW-0002_B (IFR) - Drawing Two.dwg',
+                    name: '123456-EL-DRW-0002_B (IFR) - Drawing Two.dwg',
+                    size: 20000, fileSize: 20000,
+                    sha256: 'ffeeddccbbaa998877665544332211ffeeddccbbaa998877665544332211ffee'
+                },
+            ];
+            app.modules.files.updateFilesInJson(app.data.files);
+            app.modules.files.render();
+        });
+        await page.waitForTimeout(300);
+
+        const rowsBefore = await page.locator('table tbody tr').count();
+        expect(rowsBefore).toBeGreaterThanOrEqual(3);
+
+        // ── 3. Build the draft HTML ──────────────────────────────────────────
+        const draftHtml = await page.evaluate(async () => {
+            const pub = window.transmittalApp.modules.publish;
+            await pub.syncUiToJson({ sign: false, computeDigest: false });
+            return pub.buildHtmlString();
+        });
+
+        expect(draftHtml).toContain('123456-EL-SPC-0001');
+        expect(draftHtml).toContain('123456-EL-DRW-0002');
+
+        // ── 4. Open draft and verify ─────────────────────────────────────────
+        const tmp = path.join(os.tmpdir(), `transmittal-draft-fs-${Date.now()}.html`);
+        fs.writeFileSync(tmp, draftHtml, 'utf8');
+        try {
+            const draftPage = await page.context().newPage();
+            await draftPage.addInitScript(MOCK_FS_INIT_SCRIPT);
+            await draftPage.goto(`file://${tmp}`);
+            await draftPage.waitForSelector('table tbody');
+
+            const rowsAfter = await draftPage.locator('table tbody tr').count();
+            expect(rowsAfter).toBeGreaterThanOrEqual(3);
+
+            await expect(draftPage.locator('table tbody')).toContainText('123456-EL-SPC-0001');
+            await expect(draftPage.locator('table tbody')).toContainText('123456-EL-DRW-0002');
+
+            const appFiles = await draftPage.evaluate(() => window.transmittalApp.data.files);
+            expect(appFiles.length).toBe(2);
+
+            await draftPage.close();
+        } finally {
+            fs.unlinkSync(tmp);
+        }
+    });
+});
diff --git a/tests/zddc-filter.spec.js b/tests/zddc-filter.spec.js
new file mode 100644
index 0000000..e9f8c23
--- /dev/null
+++ b/tests/zddc-filter.spec.js
@@ -0,0 +1,177 @@
+/**
+ * Tests for shared/zddc-filter.js — standardised filter expression engine.
+ *
+ * Runs against shared/zddc-filter-test.html which loads the parser as a
+ * standalone script and exposes window.zddc.filter.
+ */
+
+import { test, expect } from '@playwright/test';
+import * as path from 'path';
+
+const SHIM_PATH = 'file://' + path.resolve('shared/zddc-filter-test.html');
+
+// Helper: parse then matches
+async function fm(page, expr, value) {
+    return page.evaluate(
+        ([expr, value]) => {
+            const ast = window.zddc.filter.parse(expr);
+            return window.zddc.filter.matches(value, ast);
+        },
+        [expr, value]
+    );
+}
+
+test.beforeEach(async ({ page }) => {
+    await page.goto(SHIM_PATH, { waitUntil: 'load' });
+    const ok = await page.evaluate(() => typeof window.zddc.filter === 'object');
+    expect(ok).toBe(true);
+});
+
+// ── empty / wildcard-all ──────────────────────────────────────────────────────
+
+test('empty string matches everything', async ({ page }) => {
+    expect(await fm(page, '', 'anything')).toBe(true);
+    expect(await fm(page, '', '')).toBe(true);
+});
+
+test('whitespace-only matches everything', async ({ page }) => {
+    expect(await fm(page, '   ', 'anything')).toBe(true);
+});
+
+test('bare * matches everything', async ({ page }) => {
+    expect(await fm(page, '*', 'hello world')).toBe(true);
+    expect(await fm(page, '*', '')).toBe(true);
+});
+
+// ── plain term (substring, case-insensitive) ──────────────────────────────────
+
+test('plain term: case-insensitive substring match', async ({ page }) => {
+    expect(await fm(page, 'IFA', 'status IFA rev')).toBe(true);
+    expect(await fm(page, 'ifa', 'status IFA rev')).toBe(true);
+    expect(await fm(page, 'IFA', 'status IFB rev')).toBe(false);
+});
+
+test('plain term: substring anywhere in value', async ({ page }) => {
+    expect(await fm(page, 'el', '123456-el-spc-2623')).toBe(true);
+    expect(await fm(page, 'spc', '123456-el-spc-2623')).toBe(true);
+});
+
+// ── ! negation ────────────────────────────────────────────────────────────────
+
+test('!term: excludes values containing term', async ({ page }) => {
+    expect(await fm(page, '!draft', 'final document')).toBe(true);
+    expect(await fm(page, '!draft', 'draft document')).toBe(false);
+});
+
+// ── ^ prefix anchor ───────────────────────────────────────────────────────────
+
+test('^term: only matches at start', async ({ page }) => {
+    expect(await fm(page, '^IFA', 'IFA document')).toBe(true);
+    expect(await fm(page, '^IFA', 'revision IFA')).toBe(false);
+});
+
+// ── $ suffix anchor ───────────────────────────────────────────────────────────
+
+test('term$: only matches at end', async ({ page }) => {
+    expect(await fm(page, 'pdf$', 'document.pdf')).toBe(true);
+    expect(await fm(page, 'pdf$', 'document.docx')).toBe(false);
+});
+
+// ── !^ not-prefix ─────────────────────────────────────────────────────────────
+
+test('!^term: excludes values starting with term', async ({ page }) => {
+    expect(await fm(page, '!^~', 'A (IFA) title')).toBe(true);
+    expect(await fm(page, '!^~', '~A (IFR) title')).toBe(false);
+});
+
+// ── !$ not-suffix ─────────────────────────────────────────────────────────────
+
+test('!term$: excludes values ending with term', async ({ page }) => {
+    expect(await fm(page, '!pdf$', 'document.docx')).toBe(true);
+    expect(await fm(page, '!pdf$', 'document.pdf')).toBe(false);
+});
+
+// ── AND (space-separated) ─────────────────────────────────────────────────────
+
+test('a b: both must match (AND)', async ({ page }) => {
+    expect(await fm(page, 'pdf spc', 'spc document.pdf')).toBe(true);
+    expect(await fm(page, 'pdf spc', 'spc document.docx')).toBe(false);
+    expect(await fm(page, 'pdf spc', 'other document.pdf')).toBe(false);
+});
+
+// ── OR ────────────────────────────────────────────────────────────────────────
+
+test('a | b: either matches (OR)', async ({ page }) => {
+    expect(await fm(page, 'IFA | IFB', 'status IFA')).toBe(true);
+    expect(await fm(page, 'IFA | IFB', 'status IFB')).toBe(true);
+    expect(await fm(page, 'IFA | IFB', 'status IFC')).toBe(false);
+});
+
+test('(a | b): grouped OR', async ({ page }) => {
+    expect(await fm(page, '(IFA | IFB)', 'status IFA')).toBe(true);
+    expect(await fm(page, '(IFA | IFB)', 'status IFB')).toBe(true);
+    expect(await fm(page, '(IFA | IFB)', 'status IFC')).toBe(false);
+});
+
+test('^IFA | ^IFB: prefix OR', async ({ page }) => {
+    expect(await fm(page, '^IFA | ^IFB', 'IFA document')).toBe(true);
+    expect(await fm(page, '^IFA | ^IFB', 'IFB document')).toBe(true);
+    expect(await fm(page, '^IFA | ^IFB', 'IFC document')).toBe(false);
+});
+
+// ── regex patterns (the new capability replacing glob) ────────────────────────
+
+test('regex: .* spans characters within a term', async ({ page }) => {
+    // el.*spc matches "123456-el-spc-2623" because it's a substring regex
+    expect(await fm(page, 'el.*spc', '123456-el-spc-2623')).toBe(true);
+    expect(await fm(page, 'el.*spc', '123456-me-spc-2623')).toBe(false);
+});
+
+test('regex: ^el.*spc anchored to start', async ({ page }) => {
+    expect(await fm(page, '^el.*spc', 'el-spc-2623')).toBe(true);
+    expect(await fm(page, '^el.*spc', '123456-el-spc-2623')).toBe(false);
+});
+
+test('regex: character class [ei]fa', async ({ page }) => {
+    expect(await fm(page, '[ei]fa', 'status efa')).toBe(true);
+    expect(await fm(page, '[ei]fa', 'status ifa')).toBe(true);
+    expect(await fm(page, '[ei]fa', 'status ofa')).toBe(false);
+});
+
+test('regex: invalid regex falls back to literal match', async ({ page }) => {
+    // "[unclosed" is invalid regex — should fall back and treat as literal
+    // It won't crash, just won't match normally
+    const result = await page.evaluate(() => {
+        try {
+            const ast = window.zddc.filter.parse('[unclosed');
+            window.zddc.filter.matches('test', ast);
+            return 'no-crash';
+        } catch (e) {
+            return 'crashed: ' + e.message;
+        }
+    });
+    expect(result).toBe('no-crash');
+});
+
+// ── regression: hyphen in tracking number is literal ─────────────────────────
+
+test('hyphen in tracking number is literal (not an operator)', async ({ page }) => {
+    expect(await fm(page, '123456-EL-SPC', '123456-EL-SPC-2623')).toBe(true);
+    expect(await fm(page, '123456-EL-SPC', '654321-EL-SPC-9999')).toBe(false);
+});
+
+// ── AND + NOT combined ────────────────────────────────────────────────────────
+
+test('pdf !draft: AND with exclusion', async ({ page }) => {
+    expect(await fm(page, 'pdf !draft', 'final.pdf')).toBe(true);
+    expect(await fm(page, 'pdf !draft', 'draft.pdf')).toBe(false);
+    expect(await fm(page, 'pdf !draft', 'final.docx')).toBe(false);
+});
+
+// ── complex real-world expressions ───────────────────────────────────────────
+
+test('!^~ !^[0-9]: excludes drafts and numeric revisions', async ({ page }) => {
+    expect(await fm(page, '!^~ !^[0-9]', 'A (IFA) title')).toBe(true);
+    expect(await fm(page, '!^~ !^[0-9]', '~A (IFR) title')).toBe(false);
+    expect(await fm(page, '!^~ !^[0-9]', '0 (IFC) title')).toBe(false);
+});
diff --git a/tests/zddc.spec.js b/tests/zddc.spec.js
new file mode 100644
index 0000000..711e732
--- /dev/null
+++ b/tests/zddc.spec.js
@@ -0,0 +1,365 @@
+/**
+ * Tests for shared/zddc.js — canonical ZDDC naming library.
+ *
+ * Runs against the compiled dist/zddc-test.html shim (a minimal HTML page
+ * that loads shared/zddc.js and exposes window.zddc to the test harness).
+ *
+ * Fixtures from tests/fixtures/zddc-filenames.js define the canonical
+ * expected behaviour for all tools.
+ */
+
+import { test, expect } from '@playwright/test';
+import { VALID_FILES, INVALID_FILES, VALID_FOLDERS, REVISION_SORT_ORDER }
+    from './fixtures/zddc-filenames.js';
+import * as path from 'path';
+
+const SHIM_PATH = 'file://' + path.resolve('shared/zddc-test.html');
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+async function zddc(page, fn, ...args) {
+    return page.evaluate(
+        ([fn, args]) => window.zddc[fn](...args),
+        [fn, args]
+    );
+}
+
+// ── setup ─────────────────────────────────────────────────────────────────────
+
+test.beforeEach(async ({ page }) => {
+    await page.goto(SHIM_PATH, { waitUntil: 'load' });
+    // Confirm the library loaded
+    const ok = await page.evaluate(() => typeof window.zddc === 'object');
+    expect(ok).toBe(true);
+});
+
+// ── parseFilename — valid files ───────────────────────────────────────────────
+
+for (const fixture of VALID_FILES) {
+    test(`parseFilename: ${fixture.filename}`, async ({ page }) => {
+        const result = await zddc(page, 'parseFilename', fixture.filename);
+        expect(result).not.toBeNull();
+        expect(result.valid).toBe(true);
+        expect(result.trackingNumber).toBe(fixture.parsed.trackingNumber);
+        expect(result.revision).toBe(fixture.parsed.revision);
+        expect(result.status).toBe(fixture.parsed.status);
+        expect(result.title).toBe(fixture.parsed.title);
+        expect(result.extension).toBe(fixture.parsed.extension);
+    });
+}
+
+// ── parseFilename — invalid files ─────────────────────────────────────────────
+
+for (const fixture of INVALID_FILES) {
+    test(`parseFilename invalid: ${fixture.filename}`, async ({ page }) => {
+        const result = await zddc(page, 'parseFilename', fixture.filename);
+        expect(result).not.toBeNull();
+        expect(result.valid).toBe(false);
+        // Should never throw — returns degraded object
+        expect(typeof result.trackingNumber).toBe('string');
+        expect(typeof result.extension).toBe('string');
+    });
+}
+
+// ── parseFilename — edge cases ────────────────────────────────────────────────
+
+test('parseFilename: null returns null', async ({ page }) => {
+    const result = await zddc(page, 'parseFilename', null);
+    expect(result).toBeNull();
+});
+
+test('parseFilename: empty string returns null', async ({ page }) => {
+    const result = await zddc(page, 'parseFilename', '');
+    expect(result).toBeNull();
+});
+
+test('parseFilename: no extension', async ({ page }) => {
+    const result = await zddc(page, 'parseFilename', 'just-a-name');
+    expect(result.valid).toBe(false);
+    expect(result.extension).toBe('');
+});
+
+// ── parseFolder — valid folders ───────────────────────────────────────────────
+
+for (const fixture of VALID_FOLDERS) {
+    test(`parseFolder: ${fixture.foldername}`, async ({ page }) => {
+        const result = await zddc(page, 'parseFolder', fixture.foldername);
+        expect(result).not.toBeNull();
+        expect(result.valid).toBe(true);
+        expect(result.date).toBe(fixture.parsed.date);
+        expect(result.trackingNumber).toBe(fixture.parsed.trackingNumber);
+        expect(result.status).toBe(fixture.parsed.status);
+        expect(result.title).toBe(fixture.parsed.title);
+    });
+}
+
+test('parseFolder: null returns null', async ({ page }) => {
+    const result = await zddc(page, 'parseFolder', null);
+    expect(result).toBeNull();
+});
+
+test('parseFolder: non-ZDDC name returns valid=false', async ({ page }) => {
+    const result = await zddc(page, 'parseFolder', 'random folder name');
+    expect(result.valid).toBe(false);
+    expect(result.title).toBe('random folder name');
+});
+
+// ── formatFilename ────────────────────────────────────────────────────────────
+
+test('formatFilename: round-trips all valid files', async ({ page }) => {
+    for (const fixture of VALID_FILES) {
+        const ext = fixture.parsed.extension;
+        const formatted = await zddc(page, 'formatFilename', {
+            trackingNumber: fixture.parsed.trackingNumber,
+            revision:       fixture.parsed.revision,
+            status:         fixture.parsed.status,
+            title:          fixture.parsed.title,
+            extension:      ext,
+        });
+        expect(formatted).toBe(fixture.filename);
+    }
+});
+
+test('formatFilename: empty required field returns empty string', async ({ page }) => {
+    expect(await zddc(page, 'formatFilename', { trackingNumber: '', revision: 'A', status: 'IFR', title: 'T', extension: 'pdf' })).toBe('');
+    expect(await zddc(page, 'formatFilename', { trackingNumber: '123', revision: '',  status: 'IFR', title: 'T', extension: 'pdf' })).toBe('');
+    expect(await zddc(page, 'formatFilename', { trackingNumber: '123', revision: 'A', status: '',    title: 'T', extension: 'pdf' })).toBe('');
+    expect(await zddc(page, 'formatFilename', { trackingNumber: '123', revision: 'A', status: 'IFR', title: '',  extension: 'pdf' })).toBe('');
+});
+
+test('formatFilename: extension with leading dot is handled', async ({ page }) => {
+    const result = await zddc(page, 'formatFilename', {
+        trackingNumber: '123-EL-SPC-0001', revision: 'A', status: 'IFR',
+        title: 'Test Title', extension: '.pdf',
+    });
+    expect(result).toBe('123-EL-SPC-0001_A (IFR) - Test Title.pdf');
+});
+
+// ── formatFolder ──────────────────────────────────────────────────────────────
+
+test('formatFolder: round-trips all valid folders', async ({ page }) => {
+    for (const fixture of VALID_FOLDERS) {
+        const formatted = await zddc(page, 'formatFolder', fixture.parsed);
+        expect(formatted).toBe(fixture.foldername);
+    }
+});
+
+test('formatFolder: empty required field returns empty string', async ({ page }) => {
+    expect(await zddc(page, 'formatFolder', { date: '', trackingNumber: '123', status: 'IFR', title: 'T' })).toBe('');
+    expect(await zddc(page, 'formatFolder', { date: '2025-01-01', trackingNumber: '',  status: 'IFR', title: 'T' })).toBe('');
+    expect(await zddc(page, 'formatFolder', { date: '2025-01-01', trackingNumber: '123', status: '', title: 'T' })).toBe('');
+    expect(await zddc(page, 'formatFolder', { date: '2025-01-01', trackingNumber: '123', status: 'IFR', title: '' })).toBe('');
+});
+
+// ── parseRevision ─────────────────────────────────────────────────────────────
+
+test('parseRevision: plain letter revision', async ({ page }) => {
+    const r = await zddc(page, 'parseRevision', 'A');
+    expect(r.base).toBe('A');
+    expect(r.isDraft).toBe(false);
+    expect(r.modifier).toBe('');
+    expect(r.modifierType).toBe('');
+    expect(r.modifierNumber).toBe(0);
+    expect(r.full).toBe('A');
+});
+
+test('parseRevision: draft revision ~A', async ({ page }) => {
+    const r = await zddc(page, 'parseRevision', '~A');
+    expect(r.base).toBe('A');
+    expect(r.isDraft).toBe(true);
+    expect(r.modifier).toBe('');
+});
+
+test('parseRevision: revision with modifier A+C1', async ({ page }) => {
+    const r = await zddc(page, 'parseRevision', 'A+C1');
+    expect(r.base).toBe('A');
+    expect(r.isDraft).toBe(false);
+    expect(r.modifier).toBe('+C1');
+    expect(r.modifierType).toBe('C');
+    expect(r.modifierNumber).toBe(1);
+    expect(r.modifierIsDraft).toBe(false);
+});
+
+test('parseRevision: draft modifier A+~C1', async ({ page }) => {
+    const r = await zddc(page, 'parseRevision', 'A+~C1');
+    expect(r.base).toBe('A');
+    expect(r.isDraft).toBe(false);
+    expect(r.modifier).toBe('+~C1');
+    expect(r.modifierType).toBe('C');
+    expect(r.modifierNumber).toBe(1);
+    expect(r.modifierIsDraft).toBe(true);
+});
+
+test('parseRevision: numeric base 0', async ({ page }) => {
+    const r = await zddc(page, 'parseRevision', '0');
+    expect(r.base).toBe('0');
+    expect(r.isDraft).toBe(false);
+    expect(r.modifier).toBe('');
+});
+
+test('parseRevision: all modifier types', async ({ page }) => {
+    const cases = [
+        ['A+B1', 'B', 1],
+        ['A+C2', 'C', 2],
+        ['A+N1', 'N', 1],
+        ['A+Q1', 'Q', 1],
+    ];
+    for (const [rev, type, num] of cases) {
+        const r = await zddc(page, 'parseRevision', rev);
+        expect(r.modifierType).toBe(type);
+        expect(r.modifierNumber).toBe(num);
+    }
+});
+
+// ── compareRevisions — canonical REVISION_SORT_ORDER ─────────────────────────
+
+test('compareRevisions: canonical sort order matches fixture', async ({ page }) => {
+    // For every adjacent pair in the expected order, a < b
+    for (let i = 0; i < REVISION_SORT_ORDER.length - 1; i++) {
+        const a = REVISION_SORT_ORDER[i];
+        const b = REVISION_SORT_ORDER[i + 1];
+        const cmp = await zddc(page, 'compareRevisions', a, b);
+        expect(cmp).toBeLessThan(0);
+    }
+});
+
+test('compareRevisions: equal revisions return 0', async ({ page }) => {
+    for (const rev of REVISION_SORT_ORDER) {
+        const cmp = await zddc(page, 'compareRevisions', rev, rev);
+        expect(cmp).toBe(0);
+    }
+});
+
+test('compareRevisions: reverse order is > 0', async ({ page }) => {
+    for (let i = 0; i < REVISION_SORT_ORDER.length - 1; i++) {
+        const a = REVISION_SORT_ORDER[i];
+        const b = REVISION_SORT_ORDER[i + 1];
+        const cmp = await zddc(page, 'compareRevisions', b, a);
+        expect(cmp).toBeGreaterThan(0);
+    }
+});
+
+test('compareRevisions: sort() produces canonical order', async ({ page }) => {
+    // Shuffle the order and sort with zddc.compareRevisions, expect canonical result
+    const shuffled = [...REVISION_SORT_ORDER].reverse();
+    const sorted = await page.evaluate((revisions) => {
+        return revisions.slice().sort((a, b) => window.zddc.compareRevisions(a, b));
+    }, shuffled);
+    expect(sorted).toEqual(REVISION_SORT_ORDER);
+});
+
+// ── isValidStatus ─────────────────────────────────────────────────────────────
+
+test('isValidStatus: accepts all known statuses', async ({ page }) => {
+    const statuses = await page.evaluate(() => window.zddc.STATUSES);
+    for (const s of statuses) {
+        const ok = await zddc(page, 'isValidStatus', s);
+        expect(ok).toBe(true);
+    }
+});
+
+test('isValidStatus: rejects unknown codes', async ({ page }) => {
+    const bad = ['IFX', 'ABC', '', 'ifr', 'rsa'];
+    for (const s of bad) {
+        const ok = await zddc(page, 'isValidStatus', s);
+        expect(ok).toBe(false);
+    }
+});
+
+test('isValidStatus: --- is valid (unknown status)', async ({ page }) => {
+    const ok = await zddc(page, 'isValidStatus', '---');
+    expect(ok).toBe(true);
+});
+
+// ── splitExtension / joinExtension ────────────────────────────────────────────
+
+test('splitExtension: standard filename', async ({ page }) => {
+    const r = await zddc(page, 'splitExtension', '123456-EL-SPC-2623_A (IFR) - Spec.pdf');
+    expect(r).toEqual({ name: '123456-EL-SPC-2623_A (IFR) - Spec', extension: 'pdf' });
+});
+
+test('splitExtension: no extension', async ({ page }) => {
+    const r = await zddc(page, 'splitExtension', 'README');
+    expect(r).toEqual({ name: 'README', extension: '' });
+});
+
+test('splitExtension: dotfile (leading dot is not an extension)', async ({ page }) => {
+    const r = await zddc(page, 'splitExtension', '.gitignore');
+    expect(r).toEqual({ name: '.gitignore', extension: '' });
+});
+
+test('splitExtension: multiple dots — last wins, lowercased', async ({ page }) => {
+    const r = await zddc(page, 'splitExtension', 'archive.tar.GZ');
+    expect(r).toEqual({ name: 'archive.tar', extension: 'gz' });
+});
+
+test('splitExtension: empty string', async ({ page }) => {
+    const r = await zddc(page, 'splitExtension', '');
+    expect(r).toEqual({ name: '', extension: '' });
+});
+
+test('joinExtension: with extension', async ({ page }) => {
+    const r = await zddc(page, 'joinExtension', 'foo', 'pdf');
+    expect(r).toBe('foo.pdf');
+});
+
+test('joinExtension: tolerates leading dot in extension', async ({ page }) => {
+    const r = await zddc(page, 'joinExtension', 'foo', '.pdf');
+    expect(r).toBe('foo.pdf');
+});
+
+test('joinExtension: empty extension returns name unchanged', async ({ page }) => {
+    const r = await zddc(page, 'joinExtension', 'foo', '');
+    expect(r).toBe('foo');
+});
+
+test('split / join round-trip', async ({ page }) => {
+    const filenames = ['foo.pdf', 'archive.tar.gz', 'README', '.gitignore', 'no-ext'];
+    for (const fn of filenames) {
+        const split = await zddc(page, 'splitExtension', fn);
+        const joined = await zddc(page, 'joinExtension', split.name, split.extension);
+        expect(joined.toLowerCase()).toBe(fn.toLowerCase());
+    }
+});
+
+// ── crypto helpers (shared/hash.js) ──────────────────────────────────────────
+
+test('sha256String: known vector', async ({ page }) => {
+    // SHA-256 of empty string
+    const empty = await page.evaluate(() => window.zddc.crypto.sha256String(''));
+    expect(empty).toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+    // SHA-256 of "abc"
+    const abc = await page.evaluate(() => window.zddc.crypto.sha256String('abc'));
+    expect(abc).toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
+});
+
+test('sha256Hex: ArrayBuffer input', async ({ page }) => {
+    const hex = await page.evaluate(() => {
+        const bytes = new Uint8Array([0x61, 0x62, 0x63]); // 'abc'
+        return window.zddc.crypto.sha256Hex(bytes.buffer);
+    });
+    expect(hex).toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
+});
+
+test('sha256Hex: Uint8Array input', async ({ page }) => {
+    const hex = await page.evaluate(() => {
+        const bytes = new Uint8Array([0x61, 0x62, 0x63]); // 'abc'
+        return window.zddc.crypto.sha256Hex(bytes);
+    });
+    expect(hex).toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
+});
+
+test('sha256File: small File goes through single-shot path', async ({ page }) => {
+    const hex = await page.evaluate(() => {
+        const blob = new File(['abc'], 'test.txt');
+        return window.zddc.crypto.sha256File(blob);
+    });
+    expect(hex).toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad');
+});
+
+test('bytesToHex: byte array → padded hex', async ({ page }) => {
+    const hex = await page.evaluate(() => {
+        return window.zddc.crypto.bytesToHex(new Uint8Array([0x00, 0x0f, 0xff]));
+    });
+    expect(hex).toBe('000fff');
+});
diff --git a/training-data/.gitignore b/training-data/.gitignore
new file mode 100644
index 0000000..ff95d24
--- /dev/null
+++ b/training-data/.gitignore
@@ -0,0 +1,6 @@
+# Training data — never commit actual data to the repo
+raw/
+processed/
+validation/
+adapters/
+snapshots/
diff --git a/training-data/README.md b/training-data/README.md
new file mode 100644
index 0000000..f7c0324
--- /dev/null
+++ b/training-data/README.md
@@ -0,0 +1,167 @@
+# ZDDC Training Data Pipeline
+
+Adaptive LoRA fine-tuning for **Qwen3-Coder-Next** (`vllm/RedHatAI/Qwen3-Coder-Next-NVFP4`).
+
+Training data is collected reactively: when Qwen struggles on a task and a stronger model (Sonnet/Opus) is consulted, that interaction is captured as a training example. Over time, domain-specific LoRA adapters are trained to patch Qwen's weak spots.
+
+---
+
+## Directory Layout
+
+```
+training-data/
+├── raw/
+│   └── interactions.jsonl      # All captured weak-spot interactions
+├── processed/
+│   ├── all.jsonl               # Deduplicated, combined dataset
+│   ├── multi-domain.jsonl      # All domains merged
+│   └── <domain>.jsonl          # Per-domain splits (auto-generated)
+├── validation/
+│   ├── train.jsonl             # 80% split
+│   ├── val.jsonl               # 10% split
+│   └── test.jsonl              # 10% split (never used during training)
+├── adapters/
+│   └── <domain>-lora-v1/       # Trained LoRA adapter
+│   └── <domain>-lora-v1-merged/ # Merged standalone model
+├── snapshots/
+│   └── v<date>/                # Versioned dataset snapshots
+├── collect-interaction.js      # Capture a weak-spot interaction
+├── process.sh                  # Cluster raw data into domain splits
+├── validate.sh                 # Check data quality before training
+├── train.sh                    # Train a LoRA adapter
+└── deploy.sh                   # Merge adapter into standalone model
+```
+
+---
+
+## Workflow
+
+### Step 1 — Collect a weak-spot interaction
+
+When Qwen gets stuck or you ask it to consult Sonnet/Opus:
+
+```bash
+node collect-interaction.js \
+  --query  "How do I parse ZDDC filenames?" \
+  --qwen   "[Qwen's suboptimal answer]" \
+  --expert "[Sonnet's correct answer]"
+```
+
+Optionally specify domain explicitly (otherwise auto-detected):
+
+```bash
+node collect-interaction.js \
+  --query  "..." \
+  --qwen   "..." \
+  --expert "..." \
+  --domain zddc-naming
+```
+
+Raw interaction is appended to `raw/interactions.jsonl`.
+
+### Step 2 — Process (after ~50 new interactions)
+
+```bash
+bash process.sh
+```
+
+Deduplicates, clusters by domain, creates train/val/test splits.
+
+### Step 3 — Validate
+
+```bash
+bash validate.sh
+```
+
+Checks JSONL validity, domain balance, and split sizes.
+
+### Step 4 — Train
+
+```bash
+bash train.sh              # train multi-domain adapter
+bash train.sh zddc-naming  # train domain-specific adapter
+```
+
+Outputs LoRA adapter to `adapters/<domain>-lora-v1/`.
+
+### Step 5 — Deploy (optional)
+
+```bash
+bash deploy.sh             # merge multi-domain adapter
+bash deploy.sh zddc-naming # merge specific adapter
+```
+
+Merges the LoRA weights into the base model and saves a standalone model.
+
+---
+
+## Training Data Format
+
+Each line in a `.jsonl` file is one training example:
+
+```json
+{
+  "messages": [
+    {"role": "user",      "content": "Query that exposed weakness"},
+    {"role": "assistant", "content": "Qwen's original response"},
+    {"role": "user",      "content": "consult Sonnet"},
+    {"role": "assistant", "content": "Expert's correct response"}
+  ],
+  "metadata": {
+    "domain":         "zddc-naming",
+    "adapter":        "lora-v1-zddc_naming",
+    "timestamp":      "2025-10-31T14:30:00.000Z",
+    "interaction_id": "int_1735648200000_abc123",
+    "source":         "manual-expert-consultation"
+  }
+}
+```
+
+---
+
+## Auto-Detected Domains
+
+| Domain | Trigger keywords |
+|--------|----------------|
+| `zddc-naming` | zddc, trackingnumber, revision, status code |
+| `html-architecture` | html, spa, single-file, es module, vanilla js |
+| `build-system` | build.sh, dist/, template.html |
+| `coding-debugging` | debug, error, fix, console |
+| `reasoning-architecture` | reason, analyze, architecture, design |
+| `general-coding` | (default) |
+
+---
+
+## LoRA Configuration
+
+| Parameter | Value | Notes |
+|-----------|-------|-------|
+| Base model | `Qwen/Qwen2.5-7B-Instruct` | Replace with Qwen3 when available on HF |
+| Rank | 64 | Increase to 128 if underfitting |
+| Alpha | 64 | 1:1 with rank |
+| Target modules | q_proj, v_proj, k_proj, o_proj | All attention projections |
+| Dropout | 0.05 | Light regularisation |
+| Learning rate | 1e-4 | Cosine decay with 10% warmup |
+| Epochs | 3 | Monitor val loss to catch overfitting |
+| Batch size | 8 effective | 4 per-device × 2 gradient accumulation |
+| Precision | bfloat16 | Requires Ampere GPU or newer |
+
+---
+
+## Hardware Requirements
+
+| Setup | Min VRAM | Method | Notes |
+|-------|----------|--------|-------|
+| Qwen-7B LoRA | 24 GB | LoRA bf16 | Recommended |
+| Qwen-7B QLoRA | 16 GB | QLoRA 4-bit | Add `--load_in_4bit` flag |
+| Qwen-14B LoRA | 48 GB | LoRA bf16 | Better quality |
+
+Your system has 96 GB VRAM — full LoRA on Qwen-14B is feasible.
+
+---
+
+## When to Retrain
+
+- Every **50–100 new interactions** collected
+- When a new domain accumulates **200+ examples**
+- After a major project phase where Qwen struggled repeatedly
diff --git a/training-data/build-interaction-collector.sh b/training-data/build-interaction-collector.sh
new file mode 100755
index 0000000..d29bea1
--- /dev/null
+++ b/training-data/build-interaction-collector.sh
@@ -0,0 +1,55 @@
+#!/bin/bash
+# build-interaction-collector.sh
+# Install dependencies for the interaction collector
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "=== Installing Node.js Dependencies ==="
+
+# Check if Node.js is available
+if ! command -v node &> /dev/null; then
+    echo "Error: Node.js is not installed"
+    echo "Please install Node.js 18+ from https://nodejs.org/"
+    exit 1
+fi
+
+NODE_VERSION=$(node --version)
+echo "Node.js version: $NODE_VERSION"
+
+# Check minimal version
+NODE_MAJOR=$(echo $NODE_VERSION | cut -c2- | cut -d. -f1)
+if [ "$NODE_MAJOR" -lt 18 ]; then
+    echo "Error: Node.js 18+ is required"
+    exit 1
+fi
+
+echo "✓ Node.js version check passed"
+
+# Create package.json if it doesn't exist
+if [ ! -f package.json ]; then
+    cat > package.json << 'EOF'
+{
+  "name": "zddc-training-data",
+  "version": "1.0.0",
+  "description": "Training data collection for ZDDC fine-tuning",
+  "type": "module",
+  "main": "collect-interaction.js",
+  "scripts": {
+    "collect": "node collect-interaction.js"
+  },
+  "keywords": ["zddc", "training", "lora"],
+  "license": "MIT"
+}
+EOF
+fi
+
+echo "✓ Created/verified package.json"
+echo ""
+echo "=== Ready to use ==="
+echo "Usage: node collect-interaction.js --query \"...\" --qwen \"...\" --expert \"...\""
+echo "       node collect-interaction.js --query \"How do I...\" --qwen \"[Qwen answer]\" --expert \"[Expert answer]\""
+echo ""
+echo "To batch process interactions, use process.sh"
diff --git a/training-data/collect-interaction.js b/training-data/collect-interaction.js
new file mode 100755
index 0000000..40b1f42
--- /dev/null
+++ b/training-data/collect-interaction.js
@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+/**
+ * Training Data Collector for Qwen3-Coder-Next
+ * 
+ * Captures conversations where Qwen needs expert (Sonnet/Opus) assistance
+ * and stores them in a format suitable for LoRA fine-tuning
+ * 
+ * Usage:
+ *   node collect-interaction.js --query "..." --qwen "..." --expert "..." --domain "domain-name"
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get script directory
+const SCRIPT_DIR = __dirname;
+const RAW_FILE = path.join(SCRIPT_DIR, 'raw', 'interactions.jsonl');
+
+/**
+ * Generate unique interaction ID
+ */
+function generateInteractionId() {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 10);
+  return `int_${timestamp}_${random}`;
+}
+
+/**
+ * Detect domain from conversation content
+ */
+function detectDomain(messages) {
+  const text = JSON.stringify(messages).toLowerCase();
+  
+  // ZDDC naming patterns
+  if (text.includes('zddc') || 
+      text.includes('trackingnumber') || 
+      text.includes('revision') ||
+      text.includes('_a (ifr)') ||
+      text.includes('status code')) {
+    return 'zddc-naming';
+  }
+  
+  // HTML SPA patterns
+  if (text.includes('html') || 
+      text.includes('spa') || 
+      text.includes('single-file') ||
+      text.includes('es module') ||
+      text.includes('vanilla js')) {
+    return 'html-architecture';
+  }
+  
+  // Build system patterns
+  if (text.includes('build') || 
+      text.includes('build.sh') || 
+      text.includes('dist/') ||
+      text.includes('template.html')) {
+    return 'build-system';
+  }
+  
+  // Debugging patterns
+  if (text.includes('debug') || 
+      text.includes('error') || 
+      text.includes('fix') ||
+      text.includes('console')) {
+    return 'coding-debugging';
+  }
+  
+  // Reasoning patterns
+  if (text.includes('reason') || 
+      text.includes('analyze') || 
+      text.includes('architecture') ||
+      text.includes('design')) {
+    return 'reasoning-architecture';
+  }
+  
+  // Default to general coding
+  return 'general-coding';
+}
+
+/**
+ * Create training example object
+ */
+function createTrainingExample(userQuery, qwenResponse, expertResponse, options = {}) {
+  const domain = options.domain || detectDomain([userQuery, qwenResponse, expertResponse]);
+  
+  return {
+    messages: [
+      { role: 'user', content: userQuery },
+      { role: 'assistant', content: qwenResponse },
+      { role: 'user', content: 'consult Sonnet' },
+      { role: 'assistant', content: expertResponse }
+    ],
+    metadata: {
+      domain: domain,
+      adapter: `lora-v1-${domain.replace(/-/g, '_')}`,
+      timestamp: new Date().toISOString(),
+      interaction_id: generateInteractionId(),
+      source: 'manual-expert-consultation',
+      ...options.metadata
+    }
+  };
+}
+
+/**
+ * Append to JSONL file
+ */
+function appendToJSONL(filePath, data) {
+  const jsonLine = JSON.stringify(data);
+  fs.appendFileSync(filePath, jsonLine + '\n');
+}
+
+/**
+ * Format domain name from detected or provided
+ */
+function formatDomainName(domain) {
+  // Convert hyphens to underscores for adapter name
+  return domain.replace(/-/g, '_');
+}
+
+/**
+ * Collect a training example
+ */
+export function collect({
+  userQuery,
+  qwenResponse,
+  expertResponse,
+  domain = null,
+  metadata = {}
+}) {
+  if (!userQuery || !qwenResponse || !expertResponse) {
+    console.error('Error: Missing required parameters');
+    console.error('Usage: node collect-interaction.js --query "..." --qwen "..." --expert "..."');
+    process.exit(1);
+  }
+  
+  const trainingExample = createTrainingExample(
+    userQuery,
+    qwenResponse,
+    expertResponse,
+    { domain, metadata }
+  );
+  
+  // Ensure raw directory exists
+  fs.mkdirSync(path.dirname(RAW_FILE), { recursive: true });
+  
+  // Append to raw file
+  appendToJSONL(RAW_FILE, trainingExample);
+  
+  console.log('\n=== Training Example Captured ===');
+  console.log(`Domain: ${trainingExample.metadata.domain}`);
+  console.log(`Adapter: ${trainingExample.metadata.adapter}`);
+  console.log(`Interaction ID: ${trainingExample.metadata.interaction_id}`);
+  console.log(`Timestamp: ${trainingExample.metadata.timestamp}`);
+  console.log(`Raw file: ${RAW_FILE}`);
+  console.log('=================================\n');
+  
+  return trainingExample;
+}
+
+/**
+ * CLI interface
+ */
+function main() {
+  const args = process.argv.slice(2);
+  
+  // Parse arguments
+  const queryIdx = args.findIndex(arg => arg === '--query');
+  const qwenIdx = args.findIndex(arg => arg === '--qwen');
+  const expertIdx = args.findIndex(arg => arg === '--expert');
+  const domainIdx = args.findIndex(arg => arg === '--domain');
+  
+  if (queryIdx === -1 || qwenIdx === -1 || expertIdx === -1) {
+    console.error('Error: Missing required arguments');
+    console.error('Usage: node collect-interaction.js --query "..." --qwen "..." --expert "..." [--domain "domain"]');
+    console.error('       node collect-interaction.js --query "Query" --qwen "Qwen answer" --expert "Expert answer"');
+    process.exit(1);
+  }
+  
+  const userQuery = args[queryIdx + 1];
+  const qwenResponse = args[qwenIdx + 1];
+  const expertResponse = args[expertIdx + 1];
+  const domain = domainIdx !== -1 ? args[domainIdx + 1] : null;
+  
+  collect({ userQuery, qwenResponse, expertResponse, domain });
+}
+
+// Export for module usage
+export default { collect, createTrainingExample, detectDomain };
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
diff --git a/training-data/deploy.sh b/training-data/deploy.sh
new file mode 100755
index 0000000..46d3490
--- /dev/null
+++ b/training-data/deploy.sh
@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# deploy.sh — Merge a trained LoRA adapter into a standalone model
+# Usage:
+#   bash deploy.sh                  # deploy multi-domain adapter
+#   bash deploy.sh zddc-naming      # deploy specific domain adapter
+#
+# Output: adapters/<domain>-lora-v1-merged/
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+DOMAIN="${1:-multi-domain}"
+BASE_MODEL="Qwen/Qwen2.5-7B-Instruct"
+ADAPTER_DIR="adapters/${DOMAIN}-lora-v1"
+MERGED_DIR="adapters/${DOMAIN}-lora-v1-merged"
+
+echo "=== ZDDC LoRA Deployment ==="
+echo "Domain:     $DOMAIN"
+echo "Adapter:    $ADAPTER_DIR"
+echo "Output:     $MERGED_DIR"
+echo ""
+
+if [ ! -d "$ADAPTER_DIR" ]; then
+    echo "Error: adapter not found: $ADAPTER_DIR"
+    echo "Run: bash train.sh $DOMAIN"
+    exit 1
+fi
+if [ ! -f "$ADAPTER_DIR/adapter_config.json" ]; then
+    echo "Error: adapter incomplete (missing adapter_config.json)"
+    exit 1
+fi
+
+command -v python3 &>/dev/null || { echo "Error: python3 required"; exit 1; }
+python3 -c "import torch, transformers, peft" 2>/dev/null || \
+    pip install torch transformers peft --quiet
+
+mkdir -p "$MERGED_DIR"
+
+DEPLOY_PY=$(mktemp /tmp/deploy_lora_XXXXXX.py)
+trap 'rm -f "$DEPLOY_PY"' EXIT
+
+cat > "$DEPLOY_PY" << 'PYEOF'
+import sys, os, torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+
+base_model_name = sys.argv[1]
+adapter_dir     = sys.argv[2]
+merged_dir      = sys.argv[3]
+
+print(f"Loading base model: {base_model_name}")
+tok = AutoTokenizer.from_pretrained(base_model_name, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained(
+    base_model_name, torch_dtype=torch.bfloat16,
+    device_map="auto", trust_remote_code=True)
+
+print(f"Loading adapter: {adapter_dir}")
+model = PeftModel.from_pretrained(model, adapter_dir)
+
+print("Merging weights into base model...")
+model = model.merge_and_unload()
+
+print(f"Saving merged model to {merged_dir} ...")
+model.save_pretrained(merged_dir, safe_serialization=True)
+tok.save_pretrained(merged_dir)
+
+print("\nRunning test inference...")
+prompt = "<|im_start|>user\nWhat is the ZDDC file naming convention?<|im_end|>\n<|im_start|>assistant\n"
+inputs = tok(prompt, return_tensors="pt").to(model.device)
+with torch.no_grad():
+    out = model.generate(
+        **inputs, max_new_tokens=128, temperature=0.7,
+        do_sample=True, pad_token_id=tok.eos_token_id)
+response = tok.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
+print(f"Test prompt:    What is the ZDDC file naming convention?")
+print(f"Model response: {response}")
+
+size = sum(
+    os.path.getsize(os.path.join(merged_dir, f))
+    for f in os.listdir(merged_dir)
+    if os.path.isfile(os.path.join(merged_dir, f)))
+print(f"\nMerged model size: {size/(1024**3):.2f} GB")
+print(f"Saved to: {merged_dir}")
+PYEOF
+
+python3 "$DEPLOY_PY" "$BASE_MODEL" "$ADAPTER_DIR" "$MERGED_DIR"
+
+echo ""
+echo "=== Deployment Complete ==="
+echo "Merged model: $MERGED_DIR"
+echo ""
+echo "To use:"
+echo "  from transformers import AutoTokenizer, AutoModelForCausalLM"
+echo "  model = AutoModelForCausalLM.from_pretrained('$MERGED_DIR')"
+echo "  tokenizer = AutoTokenizer.from_pretrained('$MERGED_DIR')"
diff --git a/training-data/package.json b/training-data/package.json
new file mode 100644
index 0000000..ae67840
--- /dev/null
+++ b/training-data/package.json
@@ -0,0 +1,16 @@
+{
+  "name": "zddc-training-data",
+  "version": "1.0.0",
+  "description": "Training data collection and LoRA fine-tuning pipeline for Qwen3-Coder-Next",
+  "type": "module",
+  "main": "collect-interaction.js",
+  "scripts": {
+    "collect": "node collect-interaction.js",
+    "process": "bash process.sh",
+    "validate": "bash validate.sh",
+    "train": "bash train.sh",
+    "deploy": "bash deploy.sh"
+  },
+  "keywords": ["zddc", "training", "lora", "fine-tuning", "qwen"],
+  "license": "AGPL-3.0"
+}
diff --git a/training-data/process.sh b/training-data/process.sh
new file mode 100644
index 0000000..a38e74d
--- /dev/null
+++ b/training-data/process.sh
@@ -0,0 +1,94 @@
+#!/bin/bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+echo "=== ZDDC Training Data Processor ==="
+echo "Timestamp: $(date +%Y-%m-%d_%H-%M-%S)"
+
+# Step 1: Combine raw interactions
+echo "Step 1: Combining raw interactions..."
+cat raw/*.jsonl > raw/all-interactions.jsonl 2>/dev/null || echo "No raw interactions yet"
+
+# Step 2: Deduplicate by conversation content
+echo "Step 2: Deduplicating..."
+if [ -f raw/all-interactions.jsonl ]; then
+    jq -s 'unique_by(.messages | tojson)' raw/all-interactions.jsonl > processed/all.jsonl
+else
+    echo "Warning: No raw interactions to deduplicate"
+fi
+
+# Step 3: Categorize by domain
+echo "Step 3: Categorizing by domain..."
+
+# Check if we have data to process
+if [ -f processed/all.jsonl ]; then
+    # Extract unique domains
+    domains=$(jq -r '.metadata.domain' processed/all.jsonl | sort -u)
+    
+    for domain in $domains; do
+        if [ -n "$domain" ]; then
+            echo "  Processing domain: $domain"
+            jq -s "grep(.metadata.domain == \"$domain\")" processed/all.jsonl > "processed/${domain}.jsonl" 2>/dev/null || \
+                jq -s 'map(select(.metadata.domain == "'"$domain"'"))' processed/all.jsonl > "processed/${domain}.jsonl"
+        fi
+    done
+else
+    echo "Warning: No processed data found"
+fi
+
+# Step 4: Create multi-domain dataset
+echo "Step 4: Creating multi-domain dataset..."
+if [ -f processed/all.jsonl ]; then
+    cp processed/all.jsonl processed/multi-domain.jsonl
+fi
+
+# Step 5: Initialize validation split (empty until we have data)
+echo "Step 5: Splitting into train/val/test..."
+mkdir -p validation
+
+# Create empty placeholders if no data
+if [ ! -f validation/train.jsonl ]; then
+    touch validation/train.jsonl
+fi
+if [ ! -f validation/val.jsonl ]; then
+    touch validation/val.jsonl
+fi
+if [ ! -f validation/test.jsonl ]; then
+    touch validation/test.jsonl
+fi
+
+# Step 6: Create snapshot
+echo "Step 6: Creating snapshot..."
+SNAPSHOT_NAME="v$(date +%Y-%m-%d)"
+mkdir -p snapshots/$SNAPSHOT_NAME
+
+if [ -f processed/all.jsonl ]; then
+    cp processed/all.jsonl snapshots/$SNAPSHOT_NAME/dataset.jsonl
+    cp validation/*.jsonl snapshots/$SNAPSHOT_NAME/
+fi
+
+echo ""
+echo "=== Processing Complete ==="
+
+# Display summary
+if [ -f processed/all.jsonl ]; then
+    TOTAL=$(wc -l < processed/all.jsonl)
+    VALIDATION=$(wc -l < processed/val.jsonl 2>/dev/null || echo 0)
+    echo "Total examples: $TOTAL"
+    
+    echo ""
+    echo "Domain breakdown:"
+    if [ -f processed/all.jsonl ]; then
+        jq -s 'group_by(.metadata.domain) | map({domain: .[0].metadata.domain, count: length})' processed/all.jsonl | jq '.[] | "  \(.domain): \(.count)"'
+    fi
+else
+    echo "No data processed yet. Collect some interactions first."
+fi
+
+echo ""
+echo "Next steps:"
+echo "  1. Collect interactions: node collect-interaction.js --query \"...\" --qwen \"...\" --expert \"...\""
+echo "  2. Process: bash process.sh"
+echo "  3. Train: bash train.sh [domain]"
diff --git a/training-data/train.sh b/training-data/train.sh
new file mode 100755
index 0000000..85094ce
--- /dev/null
+++ b/training-data/train.sh
@@ -0,0 +1,205 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# train.sh — Train a LoRA adapter for Qwen3-Coder-Next
+# Usage:
+#   bash train.sh              # train on all domains (multi-domain)
+#   bash train.sh zddc-naming  # train on a specific domain
+#
+# Output: adapters/<domain>-lora-v1/
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+DOMAIN="${1:-all}"
+BASE_MODEL="Qwen/Qwen2.5-7B-Instruct"
+LORA_RANK=64
+LORA_ALPHA=64
+LEARNING_RATE="1e-4"
+NUM_EPOCHS=3
+MAX_SEQ_LENGTH=2048
+WARMUP_RATIO=0.1
+WEIGHT_DECAY=0.01
+
+if [ "$DOMAIN" = "all" ]; then
+    TRAIN_FILE="validation/train.jsonl"
+    OUTPUT_DIR="adapters/multi-domain-lora-v1"
+else
+    TRAIN_FILE="processed/${DOMAIN}.jsonl"
+    OUTPUT_DIR="adapters/${DOMAIN}-lora-v1"
+fi
+VAL_FILE="validation/val.jsonl"
+
+echo "=== ZDDC LoRA Fine-Tuning ==="
+echo "Domain:        $DOMAIN"
+echo "Base model:    $BASE_MODEL"
+echo "Train file:    $TRAIN_FILE"
+echo "Output dir:    $OUTPUT_DIR"
+echo "LoRA rank:     $LORA_RANK / alpha: $LORA_ALPHA"
+echo "Learning rate: $LEARNING_RATE  Epochs: $NUM_EPOCHS"
+echo ""
+
+if [ ! -f "$TRAIN_FILE" ]; then
+    echo "Error: training file not found: $TRAIN_FILE"
+    echo "Run bash process.sh first."
+    exit 1
+fi
+TRAIN_COUNT=$(grep -c . "$TRAIN_FILE" 2>/dev/null || echo 0)
+if [ "$TRAIN_COUNT" -eq 0 ]; then
+    echo "Error: training file is empty. Collect at least 50 interactions first."
+    exit 1
+fi
+echo "Training examples: $TRAIN_COUNT"
+
+NO_EVAL=0
+if [ ! -f "$VAL_FILE" ] || [ "$(grep -c . "$VAL_FILE" 2>/dev/null || echo 0)" -eq 0 ]; then
+    echo "Warning: no validation data found. Skipping eval."
+    NO_EVAL=1
+fi
+
+command -v python3 &>/dev/null || { echo "Error: python3 required"; exit 1; }
+
+echo "Checking Python dependencies..."
+python3 -c "import torch, transformers, peft, trl, datasets, accelerate" 2>/dev/null || {
+    echo "Installing required packages..."
+    pip install torch transformers peft trl datasets accelerate --quiet
+}
+echo "Dependencies OK"
+echo ""
+
+mkdir -p "$OUTPUT_DIR"
+
+TRAIN_PY=$(mktemp /tmp/train_lora_XXXXXX.py)
+trap 'rm -f "$TRAIN_PY"' EXIT
+
+cat > "$TRAIN_PY" << 'PYEOF'
+import json, sys, argparse, torch
+from pathlib import Path
+from datasets import Dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments
+from peft import LoraConfig, get_peft_model, TaskType
+from trl import SFTTrainer
+
+def load_jsonl(path):
+    out = []
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                out.append(json.loads(line))
+    return out
+
+def fmt(ex):
+    text = ""
+    for m in ex["messages"]:
+        text += f"<|im_start|>{m['role']}\n{m['content']}<|im_end|>\n"
+    return {"text": text}
+
+p = argparse.ArgumentParser()
+p.add_argument("--model_name", default="Qwen/Qwen2.5-7B-Instruct")
+p.add_argument("--train_file", required=True)
+p.add_argument("--val_file")
+p.add_argument("--output_dir", required=True)
+p.add_argument("--lora_rank", type=int, default=64)
+p.add_argument("--lora_alpha", type=int, default=64)
+p.add_argument("--learning_rate", type=float, default=1e-4)
+p.add_argument("--num_epochs", type=int, default=3)
+p.add_argument("--max_seq_length", type=int, default=2048)
+p.add_argument("--warmup_ratio", type=float, default=0.1)
+p.add_argument("--weight_decay", type=float, default=0.01)
+p.add_argument("--no_eval", action="store_true")
+args = p.parse_args()
+
+print(f"Loading tokenizer: {args.model_name}")
+tok = AutoTokenizer.from_pretrained(
+    args.model_name, model_max_length=args.max_seq_length,
+    padding_side="right", trust_remote_code=True)
+if tok.pad_token is None:
+    tok.pad_token = tok.eos_token
+
+print("Loading base model...")
+model = AutoModelForCausalLM.from_pretrained(
+    args.model_name, torch_dtype=torch.bfloat16,
+    device_map="auto", trust_remote_code=True)
+model.gradient_checkpointing_enable()
+
+print("Applying LoRA...")
+lora_cfg = LoraConfig(
+    r=args.lora_rank, lora_alpha=args.lora_alpha,
+    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
+    lora_dropout=0.05, bias="none", task_type=TaskType.CAUSAL_LM)
+model = get_peft_model(model, lora_cfg)
+model.print_trainable_parameters()
+
+train_ds = Dataset.from_list([fmt(d) for d in load_jsonl(args.train_file)])
+print(f"Training examples: {len(train_ds)}")
+
+eval_ds = None
+if not args.no_eval and args.val_file:
+    vp = Path(args.val_file)
+    if vp.exists() and vp.stat().st_size > 0:
+        vdata = load_jsonl(args.val_file)
+        if vdata:
+            eval_ds = Dataset.from_list([fmt(d) for d in vdata])
+            print(f"Validation examples: {len(eval_ds)}")
+
+ta = TrainingArguments(
+    output_dir=args.output_dir,
+    per_device_train_batch_size=4,
+    per_device_eval_batch_size=4,
+    gradient_accumulation_steps=2,
+    learning_rate=args.learning_rate,
+    num_train_epochs=args.num_epochs,
+    warmup_ratio=args.warmup_ratio,
+    weight_decay=args.weight_decay,
+    lr_scheduler_type="cosine",
+    bf16=True, fp16=False,
+    logging_steps=10,
+    save_steps=100,
+    eval_steps=50 if eval_ds else None,
+    evaluation_strategy="steps" if eval_ds else "no",
+    save_strategy="steps",
+    save_total_limit=3,
+    load_best_model_at_end=(eval_ds is not None),
+    report_to=[],
+    seed=42,
+)
+
+trainer = SFTTrainer(
+    model=model, args=ta,
+    train_dataset=train_ds, eval_dataset=eval_ds,
+    dataset_text_field="text",
+    max_seq_length=args.max_seq_length,
+    tokenizer=tok)
+
+print("\nStarting training...")
+trainer.train()
+
+print(f"\nSaving adapter to {args.output_dir} ...")
+trainer.model.save_pretrained(args.output_dir)
+tok.save_pretrained(args.output_dir)
+print(f"Done. Adapter saved to: {args.output_dir}")
+PYEOF
+
+CMD="python3 $TRAIN_PY \
+  --model_name $BASE_MODEL \
+  --train_file $TRAIN_FILE \
+  --val_file $VAL_FILE \
+  --output_dir $OUTPUT_DIR \
+  --lora_rank $LORA_RANK \
+  --lora_alpha $LORA_ALPHA \
+  --learning_rate $LEARNING_RATE \
+  --num_epochs $NUM_EPOCHS \
+  --max_seq_length $MAX_SEQ_LENGTH \
+  --warmup_ratio $WARMUP_RATIO \
+  --weight_decay $WEIGHT_DECAY"
+
+[ "$NO_EVAL" -eq 1 ] && CMD="$CMD --no_eval"
+
+echo "Launching training..."
+eval "$CMD"
+
+echo ""
+echo "=== Training Complete ==="
+echo "Adapter: $OUTPUT_DIR"
+echo "Next: bash test.sh $DOMAIN  OR  bash deploy.sh $DOMAIN"
diff --git a/training-data/validate.sh b/training-data/validate.sh
new file mode 100755
index 0000000..f29795a
--- /dev/null
+++ b/training-data/validate.sh
@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$SCRIPT_DIR"
+
+DOMAIN="${1:-all}"
+PASS=0
+WARN=0
+FAIL=0
+
+ok()   { echo "  ✓ $*"; ((PASS+=1)) || true; }
+warn() { echo "  ⚠ $*"; ((WARN+=1)) || true; }
+fail() { echo "  ✗ $*"; ((FAIL+=1)) || true; }
+
+echo "=== ZDDC Training Data Validator ==="
+echo "Domain: $DOMAIN"
+echo ""
+
+echo "[ Raw Data ]"
+RAW_FILE="raw/interactions.jsonl"
+if [ ! -f "$RAW_FILE" ]; then
+    warn "No raw interactions file found. Collect interactions first."
+else
+    RAW_COUNT=$(grep -c . "$RAW_FILE" 2>/dev/null || echo 0)
+    ok "Raw interactions: $RAW_COUNT"
+fi
+
+echo ""
+echo "[ JSONL Validity ]"
+check_jsonl() {
+    local file="$1"
+    if [ ! -f "$file" ]; then warn "File not found: $file"; return; fi
+    if [ ! -s "$file" ]; then warn "File is empty: $file"; return; fi
+    local count
+    count=$(grep -c . "$file" 2>/dev/null || echo 0)
+    ok "$file — $count lines"
+}
+
+if [ "$DOMAIN" = "all" ]; then
+    for f in processed/*.jsonl validation/*.jsonl; do
+        [ -f "$f" ] && check_jsonl "$f"
+    done
+else
+    check_jsonl "processed/${DOMAIN}.jsonl"
+fi
+
+echo ""
+echo "[ Domain Balance ]"
+if [ -f "processed/all.jsonl" ] && [ -s "processed/all.jsonl" ]; then
+    python3 -c "
+import json
+from collections import Counter
+counts = Counter()
+with open('processed/all.jsonl') as f:
+    for line in f:
+        line = line.strip()
+        if line:
+            try:
+                obj = json.loads(line)
+                domain = obj.get('metadata', {}).get('domain', 'unknown')
+                counts[domain] += 1
+            except Exception:
+                pass
+if not counts:
+    print('  no domain data found')
+else:
+    print(f'  Total: {sum(counts.values())} examples')
+    for domain, count in sorted(counts.items(), key=lambda x: -x[1]):
+        status = 'OK' if count >= 200 else 'LOW'
+        print(f'  [{status}] {domain}: {count}')
+"
+else
+    warn "processed/all.jsonl not found — run bash process.sh first"
+fi
+
+echo ""
+echo "[ Train/Val/Test Split ]"
+for split in train val test; do
+    f="validation/${split}.jsonl"
+    if [ ! -f "$f" ] || [ ! -s "$f" ]; then
+        warn "$split split missing or empty"
+    else
+        count=$(grep -c . "$f" 2>/dev/null || echo 0)
+        ok "$split: $count examples"
+    fi
+done
+
+echo ""
+echo "[ Existing Adapters ]"
+if [ -d "adapters" ] && [ "$(ls -A adapters 2>/dev/null)" ]; then
+    for adapter_dir in adapters/*/; do
+        name=$(basename "$adapter_dir")
+        if [ -f "${adapter_dir}adapter_config.json" ]; then
+            ok "$name (trained)"
+        else
+            warn "$name (incomplete)"
+        fi
+    done
+else
+    echo "  (no adapters yet)"
+fi
+
+echo ""
+echo "================================="
+echo "PASS: $PASS   WARN: $WARN   FAIL: $FAIL"
+if [ "$FAIL" -gt 0 ]; then
+    echo "Status: FAIL"
+    exit 1
+elif [ "$WARN" -gt 0 ]; then
+    echo "Status: WARN"
+else
+    echo "Status: PASS"
+fi
diff --git a/transmittal/README.md b/transmittal/README.md
new file mode 100644
index 0000000..f6e757b
--- /dev/null
+++ b/transmittal/README.md
@@ -0,0 +1,502 @@
+# Transmittal Creator
+
+[← Back to ZDDC](../README.md)
+
+Create professional document transmittals that are impossible to forge or tamper with. Each transmittal is a self-contained HTML file with built-in integrity checking and optional digital signatures. Email it, archive it, trust it.
+
+**[🔗 Open Transmittal Creator](dist/transmittal.html)** - Click to use online, or right-click → "Save Link As" to keep your own copy.
+
+## The "Record Player with the Record" Concept
+
+This tool embodies true data portability - each transmittal contains both the data AND the viewer. Recipients don't need special software, accounts, or training. They just open the HTML file in any browser to see a professional transmittal with full verification capabilities. In 20 years, it will still work exactly the same.
+
+## What Makes Transmittals Special?
+
+✅ **Tamper-Proof**  
+Every file gets a SHA-256 fingerprint. If even one character changes, it's detected instantly.
+
+🔒 **Digitally Signable**  
+Optionally sign with cryptographic keys. Proves WHO sent it and WHEN, forever.
+
+📧 **Self-Contained**  
+The entire transmittal is one HTML file. Email it, archive it, open it anywhere.
+
+📊 **Machine-Readable**  
+Embedded JSON data means your systems can parse and process automatically.
+
+🔍 **Independently Verifiable**  
+Anyone can verify signatures and checksums - but verification MUST be done using a trusted copy of this tool, not the transmittal itself. See [Verification Security](#verification-security) below.
+
+## Quick Start
+
+### Workflow A: Paste file list first (typical for new transmittals)
+
+1. **Fill in the header** — Tracking Number, Date, To, From, Subject, Purpose, Remarks
+2. **Create Folder** — Menu → Create Folder → select staging directory → folder is created and selected
+3. **Paste file list** — Copy 3-5 adjacent columns from Excel (Tracking, Title, Revision, [Status], [Extension]) → Menu → Paste New Rows
+4. **Drop files onto rows** — Drag individual files from your OS onto matching rows to copy with ZDDC names and compute hashes
+5. **Save Draft** — Menu → Save Draft → save into the created folder
+6. **Publish** — When ready, Menu → Publish → choose Unsigned or Signed
+
+### Workflow B: Scan an existing directory
+
+1. **Click "Select Directory"** — Choose folder with files to transmit
+2. **Files auto-populate** — With tracking numbers, revisions, and checksums parsed from ZDDC filenames
+3. **Fill in the form** — To, From, Subject, and any remarks
+4. **Click Publish** — Choose Draft, Unsigned, or Signed
+5. **Send the HTML file** — Email it or save to your archive
+
+## Verification Security
+
+⚠️ **CRITICAL: Self-Verification is NOT Secure**
+
+When you open a transmittal, it may display "✓ Signature Valid" - but **this display can be faked**. A malicious actor could create a transmittal that shows valid signatures while containing altered data.
+
+### How to Verify Securely
+
+**For Document Controllers / Official Verification:**
+
+1. **Use a trusted tool instance** - Download the official transmittal tool from a trusted source (e.g., your organization's approved version or https://zddc.varasys.io/releases/transmittal_latest.html)
+2. **Export JSON from the transmittal** - Open the transmittal → Click "Download Data"
+3. **Import JSON into trusted tool** - Open your trusted tool → Click "Load JSON" → Paste the exported data
+4. **Verify file hashes** - Click "Select Directory" and point to the actual files
+5. **Check the verification display** - Only trust the verification shown in YOUR trusted tool, not the transmittal itself
+
+**Why This Works:**
+- The trusted tool's code is verified (by you or your organization)
+- The JSON data is extracted and re-verified independently
+- File hashes are computed fresh from the actual files
+- The verification logic cannot be tampered with
+
+**For Casual Review:**
+- The self-verification display is fine for informal checks
+- Useful for catching accidental modifications
+- NOT sufficient for legal/contractual verification
+
+### Verification Workflow
+
+```
+Received Transmittal (untrusted)
+    ↓
+Export JSON Data
+    ↓
+Trusted Tool Instance (verified by your organization)
+    ↓
+Import JSON → Verify Signatures → Verify File Hashes
+    ↓
+Official Verification Result
+```
+
+**Best Practice:** Organizations should maintain a verified copy of the transmittal tool at a known URL or network location for all document controllers to use for official verification.
+
+## Technical Architecture
+
+### Data-First Design
+- **Single source of truth**: `<script id="transmittal-data" type="application/json">` block
+- All UI state derived from this embedded JSON
+- No duplicate data storage in the HTML
+
+### Build System
+- **Build script** that:
+  - Concatenates modular CSS and JavaScript files
+  - Inlines everything into template.html
+  - Embeds this README as help documentation
+  - Outputs single `dist/transmittal.html` file
+
+### Security Model
+- All cryptographic operations happen **client-side** (Web Crypto API)
+- Private keys never stored or uploaded
+- **Self-verification is informational only** - a malicious transmittal can fake verification displays
+- **Secure verification requires external validation** - see [Verification Security](#verification-security)
+- Organizations should maintain a trusted tool instance for official verification
+
+## Key Features
+
+✅ **Portable**: Single HTML file works offline  
+✅ **Cryptographic**: SHA-256 hashing + ECDSA signatures  
+✅ **Parseable**: Embedded JSON for machine automation  
+✅ **Human-readable**: Clean UI with print optimization  
+✅ **Filterable**: Boolean logic filtering on all columns  
+✅ **Verifiable**: Independent signature verification  
+✅ **Standards-based**: ZDDC filename convention compliance  
+
+## Use Case
+
+This tool is designed for **engineering/construction document transmittals** where:
+- Multiple files need to be transmitted with metadata
+- Cryptographic integrity verification is required
+- Non-repudiation via digital signatures is valuable
+- Recipients need human-readable + machine-parseable format
+- Offline/portable distribution is essential
+
+The project achieves a **self-contained, verifiable document package** that bridges human workflow needs with automation requirements.
+
+## How It Works
+
+The transmittal operates on a simple principle: all data lives in a single JSON block inside the HTML. When you save or publish, it updates this JSON and downloads a new HTML file. This ensures:
+
+- Complete data portability
+- No hidden state or complexity  
+- Easy integration with other systems
+- Full transparency of what's stored
+
+
+## Field reference (canonical payload)
+
+Form values map to a stable canonical payload used for hashing/signing and JSON export. This payload lives inside the `<script type="application/json" id="transmittal-data">` block.
+
+**JSON Schema**: See [`transmittal.schema.json`](./transmittal/transmittal.schema.json) for the complete, machine-readable schema definition.
+
+### Key Fields
+
+**Payload** (core document data):
+- `version` — Payload schema version (currently 1)
+- `type` — Document type: "Transmittal", "Submittal", or custom text (e.g., "Contract Attachment 1")
+- `title` — Optional descriptive title
+- `client` — The Owner Name
+- `project` — The Project Name
+- `projectNumber` — The Project Number
+- `date` — Date in YYYY-MM-DD format (canonicalized from friendly text)
+- `trackingNumber` — Must not contain spaces or underscores
+- `from` — Who issued the document (hidden when type is not Transmittal or Submittal)
+- `to` — Recipient (hidden when type is not Transmittal or Submittal)
+- `purpose` — Purpose of document (hidden when type is not Transmittal or Submittal)
+- `responseDue` — Response deadline (shown only when type is Submittal)
+- `subject` — Subject line
+- `remarks` — Free-form Markdown content
+- `files[]` — Array of file objects, each containing:
+  - `trackingNumber`, `revision`, `status`, `title` (parsed from ZDDC filename)
+  - `path` — Directory path relative to transmittal root (empty string for root-level files)
+  - `filename` — Filename only (without path)
+  - `sha256` — SHA-256 hash of file contents (hex)
+  - `fileSize` — File size in bytes
+
+**Envelope** (cryptographic metadata):
+- `version` — Envelope schema version (currently 1)
+- `digestAlgorithm` — Always "SHA-256"
+- `digest` — SHA-256 hash of canonical payload string (hex)
+- `digestedAt` — ISO 8601 timestamp when digest was computed
+- `signatureAlgorithm` — "ECDSA-P256-SHA256"
+- `signatures[]` — Array of signature objects, each containing:
+  - `signature` — ECDSA signature over canonical envelope (base64)
+  - `signedAt` — ISO 8601 timestamp when this signature was created
+  - `publicKeyJwk` — EC P-256 public key (JWK) for verification
+
+**Security Model**: Signatures sign the envelope (which contains the digest), not the payload directly. This prevents tampering with the digest field while maintaining a two-layer verification:
+1. **Digest verification**: Confirms payload hasn't been modified (fast, no crypto)
+2. **Signature verification**: Confirms envelope (including digest) is authentic (cryptographic proof)
+
+**Presentation** (optional display assets - not signed):
+- `leftLogo` — Left logo as data URL
+- `rightLogo` — Right logo as data URL
+- `theme` — Visual theme identifier
+- `customCss` — Optional custom CSS for styling
+
+
+## Files table
+
+**Columns**: Tracking Number, Title, Revision, Status, EXT, Size, SHA256
+
+**Column visibility**:
+- **Default view**: Shows Tracking Number, Title, Revision, Status (essential columns)
+- **Show Details**: Toggle to reveal EXT, Size, SHA256 (technical details)
+- **Fullscreen**: Expand table to full browser window for better viewing of large file lists
+
+**Pasting file lists**:
+- Copy 3-5 **adjacent** tab-separated columns from Excel or any spreadsheet
+- Expected column order: Tracking, Title, Revision, [Status], [Extension]
+- 3-column paste: third column can be combined "A (IFR)" → splits into Revision "A" and Status "IFR"
+- Pastes with more than 5 columns are rejected with an error — condition your data into adjacent columns first
+- **Paste New Rows**: Replaces entire file list (confirms first)
+- **Paste Append Rows**: Adds to existing list, updates matching rows by tracking+revision key
+
+**Drop file onto row**:
+- Drag a file from your OS onto any table row in edit mode
+- The file is copied to the selected directory with the proper ZDDC filename
+- SHA-256 hash is computed and stored
+- If no directory is selected, you will be prompted to pick one
+
+**File scanning**:
+- "Select Directory" / "Scan Directory" scans recursively using the File System Access API, hashing files locally and parsing names
+- Filename parser expects: `trackingNumber_revision (status) - title.ext`
+  - Example: `A101-203_revA (Issued) - Site Plan.pdf`
+  - If a filename doesn't match, it still appears; parsed fields default to empty and `title` becomes the base name
+- Imports are merged on key `(trackingNumber|revision)`; newer scans update/replace matching rows
+- For known viewable types (`pdf,png,jpg,jpeg,gif,svg,webp,txt,html,htm,md`), links open in a new tab; others download
+
+
+## Filtering
+
+Each column has a filter input. Supported expression syntax:
+
+| Expression | Meaning |
+|---|---|
+| `term` | Contains "term" (case-insensitive) |
+| `!term` | Does not contain "term" |
+| `^term` | Starts with "term" |
+| `term$` | Ends with "term" |
+| `a b` | Matches both (AND) |
+| `a \| b` | Matches either (OR) |
+| `^IFA \| ^IFB` | Starts with IFA or IFB |
+| `pdf !draft` | Contains "pdf" and not "draft" |
+| `!^~` | Does not start with ~ (excludes drafts) |
+| `el.*spc` | Regex: "el" followed by "spc" |
+| `[ei]fa` | Regex character class: "efa" or "ifa" |
+
+Examples:
+
+- Only PDFs: in EXT filter, type `pdf$`.
+- Exclude drafts: in Revision, type `!^~`.
+- Status IFA or IFB: type `^IFA | ^IFB`.
+- Title contains both "floor" and "plan": type `floor plan`.
+- Tracking contains "el" then "spc": type `el.*spc`.
+
+
+## Form validation
+
+The transmittal provides real-time validation to catch errors early:
+
+**Inline validation** (as you type):
+- **Tracking Number**: Highlights if contains spaces or underscores (invalid characters)
+- **Date fields**: Auto-formats to YYYY-MM-DD, shows format hint on focus
+- **File table**: Shows parsing warnings for filenames that don't match ZDDC convention
+
+**Publish-time validation**:
+- All required fields must be filled
+- Tracking numbers must not contain spaces or underscores
+- File revisions must not contain spaces
+- At least one file must be included
+
+**Smart defaults**:
+- **Date**: Pre-filled with today's date in YYYY-MM-DD format
+
+
+## Signature verification
+
+⚠️ **WARNING: For official verification, see [Verification Security](#verification-security) above. The verification display shown here can be faked by a malicious transmittal.**
+
+When viewing a published transmittal, signature status is displayed above the files table:
+
+**For each signature**:
+- ✓ **Valid** — Signature verified successfully (in this document's context)
+- ⚠ **Warning** — Signature valid but transmittal has been edited
+- ✗ **Invalid** — Signature verification failed
+
+**Verification Actions**:
+- **Verify Externally** — Opens a trusted tool instance for independent verification
+  - Copies JSON data to clipboard
+  - Opens https://zddc.varasys.io/releases/transmittal_latest.html in validation mode
+  - Paste JSON and select directory to verify file hashes independently
+  - Only trust verification results from the trusted tool, not this document
+
+**Signature details** (expandable):
+- Public key fingerprint (click to copy)
+- Signature timestamp (from `signedAt` field)
+- Signature index (e.g., "Signature 1 of 3")
+
+**Other Actions**:
+- **Delete signature** — Remove invalid or outdated signatures
+- **Add signature** — Co-sign the document with your key
+  - Opens signing dialog (select existing key or generate new key)
+  - New signature appended to `signatures[]` array with current timestamp
+  - Downloads updated document (cannot save in place)
+
+
+## Saving and loading transmittals
+
+**Save Draft** (Menu → Save Draft):
+- Saves current state as an HTML file via the system file picker
+- All header info, file list, and remarks are preserved
+- Open the saved HTML in a browser to resume editing
+- Drafts have no digest or signature
+
+**Create Folder** (Menu → Create Folder):
+- Builds a folder name from the form: `YYYY-MM-DD_TRACKING (PURPOSE) - SUBJECT`
+- Prompts you to select a staging directory, then creates the subfolder
+- The new folder becomes the selected directory for file drops and Save Draft
+- Requires at least a tracking number
+
+**Remove Files** (Menu → Remove Files):
+- Clears the file list while keeping all header info and remarks
+- Useful when reusing a transmittal template with a new set of files
+
+**Save as JSON**:
+- Click **Download Data** to export the current transmittal as JSON
+- This file can be reloaded later as either:
+  - A finished transmittal (view/verify)
+  - A starting point for a new transmittal (edit/modify)
+
+**Load from JSON**:
+- Click **Load JSON** to import a previously saved transmittal
+- All form fields, files, and presentation assets (logos) are restored
+
+**Import HTML** (Menu → Import HTML):
+- Load a previously saved draft or published transmittal HTML file
+- Extracts the embedded JSON and restores all fields
+- You can also drag-and-drop an HTML or JSON file directly onto the page — see **Drag-and-Drop Zones** below
+
+## Drag-and-Drop Zones
+
+Whenever you drag any file or folder over the browser window, labelled drop zones appear on the transmittal to show you exactly where data can land:
+
+| Zone | Location | Accepts | Notes |
+|------|----------|---------|-------|
+| **Sender logo** | Top-left logo area | Image files (png, jpg, svg, …) | Edit mode only |
+| **Receiver logo** | Top-right logo area | Image files | Edit mode only |
+| **Header** | Header info block | Transmittal HTML or JSON file | Imports all header fields and file list; edit mode only |
+| **File table** | Document table area | Folder (scan or verify) · Transmittal HTML or JSON | Works in both edit and published mode |
+
+**Visual feedback during drag:**
+- Zones that can accept the dragged data are highlighted with a blue dashed outline and a descriptive label.
+- Zones that cannot accept the data are shown with a grey outline and dimmed.
+- When you hover over an eligible zone, it brightens further to confirm where the drop will land.
+
+**Logos and presentation assets**:
+- Logos ARE included in JSON exports (in the optional `presentation` object)
+- Logos are NOT part of the signed `payload` (separate top-level object)
+- When you drag-drop logos, they're converted to data URLs
+- The `presentation` object includes:
+  - `leftLogo` and `rightLogo` (data URLs)
+  - `theme` (visual theme identifier)
+  - `customCss` (optional custom styling)
+- This keeps the cryptographic signature focused on document data, not visual styling
+
+
+## JSON export format
+
+Download Data exports the exact contents of the embedded JSON block.
+
+**Format**: See [`transmittal.schema.json`](./transmittal/transmittal.schema.json) for the complete structure.
+
+**Key Points**:
+- The `payload` contains all transmittal data (metadata + files)
+- The `envelope` contains cryptographic metadata (digest, timestamp, signatures)
+- The `presentation` (optional) contains display assets (logos, styling) - **not signed**
+- The digest is computed over the canonical JSON string of `payload` only (sorted keys, stable formatting)
+- Each signature in the `signatures[]` array signs the same canonical payload string
+- If unsigned, the `signatures` array is empty `[]`
+- Presentation assets travel with the JSON but are excluded from cryptographic operations
+
+
+## Browser compatibility and printing
+
+- Directory selection requires the File System Access API (Chromium‑based browsers). On unsupported browsers, file scanning will not work.
+- Print styles are optimized for US Letter (8.5in×11in). Table header "sticky" behavior is disabled in print.
+
+
+## Publishing & Signing
+
+When you click **Publish**, a modal opens with these options:
+
+1. **Save Draft** — Saves HTML with current data (no digest, no signature)
+   - Also available directly from Menu → Save Draft (without opening the publish modal)
+   - Use for work-in-progress transmittals
+   - Can be reopened and edited later
+
+2. **Publish Unsigned** — Creates transmittal with digest only (no signature)
+   - Provides integrity verification via SHA-256 digest
+   - Proves content hasn't been modified
+   - No identity authentication
+
+3. **Publish Signed** — Creates transmittal with digest + signature(s)
+   - Choose one of:
+     - **Sign with Existing Key** — Select your saved private key JWK file
+     - **Sign with New Key** — Generate new EC P-256 key pair (downloads private key for you to save)
+   - Provides both integrity and authentication
+   - Supports multiple signatures (co-signing)
+
+**Security notes**:
+- All cryptographic operations happen locally in the browser (Web Crypto API)
+- Private keys are never stored or uploaded
+- Only public keys are embedded in the published transmittal for verification
+- If you generate a new key, **save the downloaded private key file** — you'll need it to sign future transmittals with the same identity
+- Editing a published transmittal invalidates existing signatures (they can be deleted)
+
+## Workflow
+
+The transmittal operates in different modes that control what actions are available:
+
+### Edit Mode (Default)
+
+**When active**: New transmittals or when explicitly toggled to Edit mode.
+
+**Document type selector**:
+
+The `type` field is a text input with autocomplete suggestions. Type to select or enter custom text.
+
+| Field | Transmittal | Submittal | File List (custom text) |
+|-------|-------------|-----------|-------------------------|
+| From | ✓ | ✓ | — |
+| To | ✓ | ✓ | — |
+| Purpose | ✓ | ✓ | — |
+| Response Due | — | ✓ | — |
+| Subject | ✓ | ✓ | ✓ |
+| Remarks | ✓ | ✓ | ✓ |
+
+**Usage**:
+- **Transmittal** — General document transmittals (no response required)
+- **Submittal** — Submittals requiring response (shop drawings, product data, samples)
+- **Custom text** — Type any text (e.g., "Contract Attachment 1", "Document Register") for file lists without workflow fields
+
+**Primary actions** (toolbar buttons):
+- **Select Directory** / **Scan Directory** — Scan filesystem to populate files table
+- **Verify Directory** — Re-hash files and compare against stored hashes
+- **Publish** — Opens publish modal (Draft / Unsigned / Signed)
+
+**Menu actions** (☰ dropdown):
+- **Scan Directory** / **Verify Directory** — Same as toolbar buttons
+- **Publish** / **Save Draft** / **Create Folder** — Publishing and folder management
+- **Paste New Rows** / **Paste Append Rows** — Paste file lists from clipboard
+- **Copy Table** — Copy file table to clipboard as tab-separated text
+- **Remove Files** — Clear file list, keep header and remarks
+- **Import HTML** — Load a saved draft or published transmittal
+- **Copy JSON** / **Paste JSON** — JSON clipboard operations
+- **Reset** — Clear all form data and files (start over)
+- **Create Index** — Generate archive redirect index in selected directory
+
+**Header bar actions** (always available):
+- **View/Edit toggle** — Switch between edit and read-only mode
+- **Load JSON** — Import a previously saved document
+- **Download Data** — Export JSON for signature verification or system integration
+- **Help** — View this documentation
+
+**UI behavior**: All form fields and table cells are editable. Filter inputs remain active for searching.
+
+### View Mode
+
+**When active**: Toggle from Edit mode or when opening a published transmittal.
+
+**Available actions**:
+- **View/Edit** — Switch to Edit mode (allows modifications)
+- **Download Data** — Export JSON for signature verification or system integration
+- **Help** — View this documentation
+
+**UI behavior**: Form fields and table cells are read-only. Filter inputs remain active for searching. All editing controls hidden (Select Directory, Publish, Reset).
+
+### Published State
+
+**When active**: Automatically detected when transmittal contains a valid digest.
+
+**Additional display**: Signature verification status shown above files table with public key fingerprint(s).
+
+**Behavior**: Defaults to View mode on load. Can toggle to Edit mode, but signature status indicates the transmittal has been published.
+
+### Mode Transitions
+
+```
+New Transmittal → Edit Mode
+                    ↓
+              Save Draft → Edit Mode (unsigned)
+                    ↓
+           Sign & Publish → Published State (View Mode)
+                    ↓
+              Toggle Edit → Published State (Edit Mode)
+```
+
+
+---
+
+Authoring notes:
+
+- UI copy uses “Tracking Number” consistently. The underlying key remains `trackingNumber`.
+- This README documents only the transmittal folder assets and does not change any code outside this directory.
diff --git a/transmittal/build.sh b/transmittal/build.sh
new file mode 100755
index 0000000..663d1b0
--- /dev/null
+++ b/transmittal/build.sh
@@ -0,0 +1,170 @@
+#!/bin/sh
+set -eu
+
+root_dir=$(cd "$(dirname "$0")" && pwd)
+. "$root_dir/../shared/build-lib.sh"
+
+src_html="$root_dir/template.html"
+output_dir="$root_dir/dist"
+output_html="$output_dir/transmittal.html"
+
+mkdir -p "$output_dir"
+ensure_exists "$src_html"
+readme_file="$root_dir/README.md"
+ensure_exists "$readme_file"
+
+css_temp=$(mktemp)
+js_raw=$(mktemp)
+js_temp=$(mktemp)
+md_temp=$(mktemp)
+cleanup() { rm -f "$css_temp" "$js_raw" "$js_temp" "$md_temp"; }
+trap cleanup EXIT
+
+# CSS files to concatenate in order
+concat_files \
+  "../shared/base.css" \
+  "css/base.css" \
+  "css/layout.css" \
+  "css/forms.css" \
+  "css/table.css" \
+  "css/remarks.css" \
+  "css/markdown.css" \
+  "css/markdown-editor.css" \
+  "css/filter.css" \
+  "css/modal.css" \
+  "css/utilities.css" \
+  "css/print.css" \
+  > "$css_temp"
+
+# JavaScript files to concatenate in order
+concat_files \
+  "../shared/zddc.js" \
+  "../shared/hash.js" \
+  "../shared/theme.js" \
+  "js/app.js" \
+  "js/reactive.js" \
+  "js/dom.js" \
+  "js/util.js" \
+  "js/json.js" \
+  "js/hydrate.js" \
+  "js/state.js" \
+  "js/mode.js" \
+  "js/visibility.js" \
+  "js/live-digest.js" \
+  "js/files.js" \
+  "js/files-archive.js" \
+  "js/files-render.js" \
+  "js/files-preview.js" \
+  "../shared/zddc-filter.js" \
+  "js/filters.js" \
+  "js/markdown.js" \
+  "js/markdown-editor.js" \
+  "js/email-tags.js" \
+  "js/validation.js" \
+  "js/security.js" \
+  "js/verification.js" \
+  "js/data.js" \
+  "js/publish.js" \
+  "js/reset.js" \
+  "js/publish-modal.js" \
+  "js/logos.js" \
+  "js/drop-zones.js" \
+  "js/focus.js" \
+  "../shared/help.js" \
+  "js/main.js" \
+  > "$js_raw"
+
+# Escape '</' in JS and the inlined README so neither can prematurely close
+# the inline <script> blocks they get embedded in.
+escape_js_close_tags "$js_raw" "$js_temp"
+escape_js_close_tags "$readme_file" "$md_temp"
+
+compute_build_label "transmittal" "${1:-}" "${2:-}"
+
+awk -v css_file="$css_temp" -v js_file="$js_temp" -v md_file="$md_temp" -v build_label="$build_label" -v is_red="$is_red" '
+  BEGIN {
+    css_inserted = 0
+    js_inserted = 0
+    help_inserted = 0
+    in_help = 0
+  }
+  /<link rel="stylesheet" href="css\// { next }
+  /<link rel="stylesheet" href="tailwind-lite\.css"/ { next }
+  /<script src="js\// { next }
+  /<script src="\.\.\// { next }
+  /<script id="help-markdown" type="application\/markdown">/ {
+    in_help = 1
+    next
+  }
+  in_help {
+    if ($0 ~ /<\/script>/) {
+      in_help = 0
+    }
+    next
+  }
+  /<head>/ {
+    print
+    if (!css_inserted) {
+      print "<style>"
+      while ((getline line < css_file) > 0) print line
+      close(css_file)
+      print "</style>"
+      css_inserted = 1
+    }
+    next
+  }
+  /<\/body>/ {
+    if (!js_inserted) {
+      print "<script>"
+      while ((getline line < js_file) > 0) print line
+      close(js_file)
+      print "</script>"
+      js_inserted = 1
+    }
+    if (!help_inserted) {
+      print "<script id=\"help-markdown\" type=\"application/markdown\">"
+      while ((getline line < md_file) > 0) print line
+      close(md_file)
+      print "</script>"
+      help_inserted = 1
+    }
+    print
+    next
+  }
+  /\{\{BUILD_LABEL\}\}/ {
+    if (is_red == "1") {
+      gsub(/\{\{BUILD_LABEL\}\}/, "<span style=\"color:red;font-weight:bold\">" build_label "</span>")
+    } else {
+      gsub(/\{\{BUILD_LABEL\}\}/, build_label)
+    }
+    print
+    next
+  }
+  { print }
+  END {
+    if (!css_inserted) {
+      print "<style>"
+      while ((getline line < css_file) > 0) print line
+      close(css_file)
+      print "</style>"
+    }
+    if (!js_inserted) {
+      print "<script>"
+      while ((getline line < js_file) > 0) print line
+      close(js_file)
+      print "</script>"
+    }
+    if (!help_inserted) {
+      print "<script id=\"help-markdown\" type=\"application/markdown\">"
+      while ((getline line < md_file) > 0) print line
+      close(md_file)
+      print "</script>"
+    }
+  }
+' "$src_html" > "$output_html"
+
+echo "Wrote $output_html"
+
+if [ "$is_release" = "1" ]; then
+    promote_release "transmittal"
+fi
diff --git a/transmittal/css/base.css b/transmittal/css/base.css
new file mode 100644
index 0000000..fe0d378
--- /dev/null
+++ b/transmittal/css/base.css
@@ -0,0 +1,155 @@
+/* Placeholder for contenteditable elements */
+[data-placeholder]:empty::before {
+    content: attr(data-placeholder);
+    color: var(--text-muted);
+    pointer-events: none;
+}
+
+/* Hide elements that should be hidden when JavaScript is available */
+[data-hydrate-hide] {
+    display: none;
+}
+
+@media screen {
+    body {
+        margin: 0;
+        padding: 0;
+        background: var(--bg-secondary);
+    }
+
+    .stack-below-600 {
+        display: flex;
+        flex-direction: row;
+    }
+
+    .page-container {
+        width: 100%;
+        max-width: 8.5in;
+        margin: 20px auto;
+        padding: 0.375in;
+        min-height: 0;
+        background: var(--bg);
+        box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
+        border: 1px solid var(--border);
+    }
+}
+
+@media (max-width: 600px) {
+    .stack-below-600 {
+        flex-direction: column;
+    }
+}
+
+@media (max-width: 640px) {
+    .page-container {
+        padding: 12px;
+    }
+}
+
+/* ── Dark mode overrides for transmittal-specific hardcoded colours ──────── */
+/* Covers verify cards, table rows, path-diff, integrity cards, workflow badge */
+/* and Tailwind utility classes used as attributes in template.html.           */
+@media screen {
+    /* Integrity verify cards */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .verify-card--ok    { background: #052e16; }
+        :root:not([data-theme="light"]) .verify-card--fail  { background: #2d0c0c; }
+        :root:not([data-theme="light"]) .verify-card--draft { background: #2d2305; }
+        :root:not([data-theme="light"]) .verify-card--info  { background: #0c1a2e; }
+    }
+    [data-theme="dark"] .verify-card--ok    { background: #052e16; }
+    [data-theme="dark"] .verify-card--fail  { background: #2d0c0c; }
+    [data-theme="dark"] .verify-card--draft { background: #2d2305; }
+    [data-theme="dark"] .verify-card--info  { background: #0c1a2e; }
+
+    /* Per-row verify result rows in file table */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) tr.verify-match td    { background: #052e16; }
+        :root:not([data-theme="light"]) tr.verify-mismatch td { background: #2d0c0c; }
+        :root:not([data-theme="light"]) tr.verify-missing td  { background: #2d2305; }
+        :root:not([data-theme="light"]) tr.verify-new td      { background: #0c1a2e; }
+    }
+    [data-theme="dark"] tr.verify-match td    { background: #052e16; }
+    [data-theme="dark"] tr.verify-mismatch td { background: #2d0c0c; }
+    [data-theme="dark"] tr.verify-missing td  { background: #2d2305; }
+    [data-theme="dark"] tr.verify-new td      { background: #0c1a2e; }
+
+    /* Workflow warning badge */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .workflow-badge--warn {
+            background: #2d2305;
+            color: #fcd34d;
+            border-color: #92400e;
+        }
+    }
+    [data-theme="dark"] .workflow-badge--warn {
+        background: #2d2305;
+        color: #fcd34d;
+        border-color: #92400e;
+    }
+
+    /* Path diff semantic colours (verify mismatch) */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .path-diff del {
+            color: #fca5a5;
+            background: #2d0c0c;
+        }
+        :root:not([data-theme="light"]) .path-diff ins {
+            color: #86efac;
+            background: #052e16;
+            border-bottom-color: #86efac;
+        }
+    }
+    [data-theme="dark"] .path-diff del { color: #fca5a5; background: #2d0c0c; }
+    [data-theme="dark"] .path-diff ins {
+        color: #86efac;
+        background: #052e16;
+        border-bottom-color: #86efac;
+    }
+
+    /* Owner/Project names area and inline bg-white / bg-gray-50 utility classes */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .header-names {
+            background-color: var(--bg-secondary) !important;
+            border-color: var(--border) !important;
+        }
+        :root:not([data-theme="light"]) .text-gray-700 { color: var(--text-muted) !important; }
+        :root:not([data-theme="light"]) .bg-white  { background-color: var(--bg) !important; }
+        :root:not([data-theme="light"]) .bg-gray-50 { background-color: var(--bg-secondary) !important; }
+        :root:not([data-theme="light"]) .bg-gray-100 { background-color: var(--bg-secondary) !important; }
+        :root:not([data-theme="light"]) .border-gray-100,
+        :root:not([data-theme="light"]) .border-gray-200,
+        :root:not([data-theme="light"]) .border-gray-300 { border-color: var(--border) !important; }
+        :root:not([data-theme="light"]) .text-gray-900 { color: var(--text) !important; }
+    }
+    [data-theme="dark"] .header-names {
+        background-color: var(--bg-secondary) !important;
+        border-color: var(--border) !important;
+    }
+    [data-theme="dark"] .text-gray-700 { color: var(--text-muted) !important; }
+    [data-theme="dark"] .bg-white  { background-color: var(--bg) !important; }
+    [data-theme="dark"] .bg-gray-50 { background-color: var(--bg-secondary) !important; }
+    [data-theme="dark"] .bg-gray-100 { background-color: var(--bg-secondary) !important; }
+    [data-theme="dark"] .border-gray-100,
+    [data-theme="dark"] .border-gray-200,
+    [data-theme="dark"] .border-gray-300 { border-color: var(--border) !important; }
+    [data-theme="dark"] .text-gray-900 { color: var(--text) !important; }
+
+    /* Filter inputs in table column headers */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .table-filter-input {
+            background-color: var(--bg);
+            color: var(--text);
+            border-color: var(--border);
+        }
+        :root:not([data-theme="light"]) .table-header__caption { color: var(--text-muted); }
+        :root:not([data-theme="light"]) .focus\:bg-white:focus { background-color: var(--bg) !important; }
+    }
+    [data-theme="dark"] .table-filter-input {
+        background-color: var(--bg);
+        color: var(--text);
+        border-color: var(--border);
+    }
+    [data-theme="dark"] .table-header__caption { color: var(--text-muted); }
+    [data-theme="dark"] .focus\:bg-white:focus { background-color: var(--bg) !important; }
+}
diff --git a/transmittal/css/filter.css b/transmittal/css/filter.css
new file mode 100644
index 0000000..d8744b0
--- /dev/null
+++ b/transmittal/css/filter.css
@@ -0,0 +1,28 @@
+.table-header {
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+    gap: 0.2rem;
+    width: 100%;
+    padding: 0;
+}
+
+.table-header__caption {
+    font-weight: 600;
+    font-size: 0.7rem;
+    letter-spacing: 0.04em;
+    color: var(--text-muted);
+    margin-bottom: 0;
+}
+
+.table-header-cell {
+    padding: 0;
+}
+
+/* Transmittal uses a denser table — override shared .column-filter sizing */
+.column-filter {
+    font-size: 0.65rem;
+    padding: 0.1rem 0.3rem;
+    margin-top: 0.15rem;
+    line-height: 1.2;
+}
diff --git a/transmittal/css/forms.css b/transmittal/css/forms.css
new file mode 100644
index 0000000..8ad76ce
--- /dev/null
+++ b/transmittal/css/forms.css
@@ -0,0 +1,89 @@
+@media screen {
+    #transmittal-form .page-header .relative > input[type="text"] {
+        padding-top: 0.625rem;
+        padding-bottom: 0.25rem;
+        border-top: 0 !important;
+        border-left: 0 !important;
+        border-right: 0 !important;
+        border-bottom: 1px solid var(--border) !important;
+        border-radius: 0 !important;
+        background-color: var(--bg);
+        box-shadow: none !important;
+    }
+
+    #transmittal-form .page-header .relative > input[type="text"]:focus {
+        border-bottom-color: var(--primary);
+        box-shadow: none !important;
+    }
+
+    /* Remove underlines from title area inputs (type and title) */
+    #transmittal-form .page-header .title-area input[type="text"] {
+        border-bottom: 0 !important;
+    }
+
+    #transmittal-form .page-header label[for],
+    #transmittal-form .page-header .relative > label {
+        position: absolute;
+        left: 0.5rem;
+        top: -0.5rem;
+        font-weight: 700;
+        background: var(--bg);
+        padding: 0 0.25rem;
+        font-size: 10px;
+        color: var(--text-muted);
+        pointer-events: none;
+        z-index: 1;
+    }
+
+    #transmittal-form .page-header .relative {
+        margin-top: 0.375rem;
+    }
+
+    /* Boxed inputs (full-border, floating label) inside the grid need extra top
+       margin so the absolute-positioned label (-top-2 = -0.5rem) is not clipped */
+    #transmittal-form .page-header .grid .relative {
+        margin-top: 0.75rem;
+    }
+
+    /* ── From field rendered mailto link ──────────────────────── */
+    .from-render {
+        font-size: 12px;
+        font-family: var(--font-mono);
+        line-height: 1.6;
+        padding: 0.625rem 0.5rem 0.25rem;
+        border-bottom: 1px solid var(--border);
+    }
+
+    .from-mailto {
+        color: var(--primary);
+        text-decoration: none;
+    }
+
+    .from-mailto:hover {
+        text-decoration: underline;
+    }
+
+    /* ── To field rendered mailto links ───────────────────────── */
+    .to-render {
+        font-size: 12px;
+        font-family: var(--font-mono);
+        line-height: 1.6;
+        padding: 0.625rem 0.5rem 0.25rem;
+        border-bottom: 1px solid var(--border);
+        word-break: break-word;
+    }
+
+    .to-mailto {
+        color: var(--primary);
+        text-decoration: none;
+    }
+
+    .to-mailto:hover {
+        text-decoration: underline;
+    }
+
+    .to-sep {
+        color: var(--text-muted);
+    }
+
+}
diff --git a/transmittal/css/layout.css b/transmittal/css/layout.css
new file mode 100644
index 0000000..e2696a7
--- /dev/null
+++ b/transmittal/css/layout.css
@@ -0,0 +1,589 @@
+/* Logo row: flex layout — logo | title | logo */
+.logo-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    width: 100%;
+}
+
+.logo-cell {
+    width: 250px;
+    height: 60px;
+    flex-shrink: 0;
+}
+
+.logo-img {
+    display: block;
+    width: 250px;
+    height: 60px;
+    object-fit: contain;
+    user-select: none;
+}
+
+#left-logo-cell .logo-img { object-position: left center; }
+#right-logo-cell .logo-img { object-position: right center; }
+
+.logo-img:not([src]),
+.logo-img[src=""] {
+    display: none;
+}
+
+.logo-placeholder {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: 100%;
+    border: 2px dashed var(--border-dark);
+    border-radius: 0.375rem;
+    color: var(--text-muted);
+    font-size: 0.75rem;
+}
+
+.logo-cell.has-logo .logo-placeholder,
+.logo-placeholder.hidden {
+    display: none;
+}
+
+.title-area {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 2px;
+    text-align: center;
+    min-width: 0;
+}
+
+/* Type combo dropdown */
+.type-combo {
+    position: relative;
+    width: 100%;
+}
+
+.type-display {
+    display: block;
+    cursor: pointer;
+    white-space: nowrap;
+    overflow: hidden;
+    outline: none;
+    min-height: 1.5em;
+}
+
+.type-display:empty::before {
+    content: attr(data-placeholder);
+    color: var(--text-muted);
+}
+
+.type-combo__menu {
+    position: absolute;
+    top: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 0.375rem;
+    box-shadow: 0 4px 6px -1px rgba(0,0,0,.1), 0 2px 4px -2px rgba(0,0,0,.1);
+    z-index: 50;
+    min-width: 160px;
+    padding: 4px 0;
+}
+
+.type-combo__option {
+    display: block;
+    width: 100%;
+    text-align: center;
+    padding: 6px 16px;
+    font-size: 0.875rem;
+    font-weight: 600;
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: var(--text);
+}
+
+.type-combo__option:hover {
+    background: var(--bg-hover);
+    color: var(--primary);
+}
+
+/* ── Targeted drop zones ─────────────────────────────────────────────────── */
+
+/* Base: relative so the label can be absolute-positioned inside */
+[data-drop-zone] {
+    position: relative;
+    border-radius: 0.375rem;
+    transition: outline 0.12s, background 0.12s, opacity 0.12s;
+}
+
+/* Label: hidden by default, centered overlay inside the zone */
+.drop-zone-label {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    position: absolute;
+    inset: 0;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.375rem;
+    font-size: 0.7rem;
+    font-weight: 600;
+    text-align: center;
+    line-height: 1.3;
+    pointer-events: none;
+    opacity: 0;
+    transition: opacity 0.12s;
+    z-index: 30;
+    white-space: pre-line;
+}
+
+/* --- Visible state: outline appears, label fades in --- */
+[data-drop-zone].dz-visible .drop-zone-label {
+    opacity: 1;
+}
+
+/* Eligible zone: blue dashed outline + subtle blue tint */
+[data-drop-zone].dz-eligible {
+    outline: 2px dashed #60a5fa;
+    outline-offset: 2px;
+    background: rgba(239, 246, 255, 0.55);
+}
+[data-drop-zone].dz-eligible .drop-zone-label {
+    color: #1e40af;
+    background: rgba(239, 246, 255, 0.9);
+}
+
+/* Ineligible zone: grey dashed outline, dimmed */
+[data-drop-zone].dz-ineligible {
+    outline: 2px dashed #d1d5db;
+    outline-offset: 2px;
+    opacity: 0.5;
+}
+[data-drop-zone].dz-ineligible .drop-zone-label {
+    color: #6b7280;
+    background: rgba(249, 250, 251, 0.85);
+}
+
+/* Hover over eligible zone: solid outline, stronger tint, white-on-blue label */
+[data-drop-zone].dz-hover {
+    outline: 2px solid #2563eb;
+    outline-offset: 2px;
+    background: rgba(219, 234, 254, 0.85);
+    opacity: 1;
+}
+[data-drop-zone].dz-hover .drop-zone-label {
+    color: #1e3a8a;
+    background: rgba(191, 219, 254, 0.95);
+    font-weight: 700;
+}
+
+/* Logo cells: label sits centered over the cell content */
+#left-logo-cell[data-drop-zone] .drop-zone-label,
+#right-logo-cell[data-drop-zone] .drop-zone-label {
+    font-size: 0.65rem;
+}
+
+/* File-table zone wrapper: display:block, no extra spacing */
+#file-table-drop-zone {
+    display: block;
+}
+
+@media screen {
+    .page-header .header-names {
+        padding: 6px 8px;
+    }
+
+    .page-header .header-names h2 {
+        margin: 0;
+        line-height: 1.2;
+    }
+
+    .page-header #project-number {
+        margin: 2px 0 6px;
+        line-height: 1.2;
+    }
+
+    .page-header .grid {
+        column-gap: 1rem;
+        row-gap: 0.5rem;
+    }
+
+    /* .action-button removed — transmittal buttons now use .btn/.btn-primary/.btn-secondary */
+
+
+    /* ── Integrity section layout ──────────────────────── */
+    .integrity-body {
+        display: flex;
+        flex-direction: column;
+        align-items: stretch;
+        gap: 0.5rem;
+        width: 100%;
+    }
+
+    /* ── Verify cards ──────────────────────────────────── */
+    .verify-card {
+        display: flex;
+        flex-direction: row;
+        flex-wrap: wrap;
+        align-items: baseline;
+        gap: 0.25rem 0.75rem;
+        padding: 0.5rem 0.75rem;
+        border-left: 4px solid;
+        border-radius: 0.25rem;
+        font-size: 0.75rem;
+        line-height: 1.5;
+    }
+    .verify-card--ok    { background: #f0fdf4; border-left-color: #22c55e; }
+    .verify-card--fail  { background: #fef2f2; border-left-color: #ef4444; }
+    .verify-card--draft { background: #fefce8; border-left-color: #f59e0b; }
+    .verify-card--info  { background: #eff6ff; border-left-color: #3b82f6; }
+
+    .verify-card__status {
+        font-weight: 700;
+        font-size: 0.8rem;
+        display: flex;
+        align-items: center;
+        gap: 0.375rem;
+    }
+    .verify-card__status--ok    { color: #166534; }
+    .verify-card__status--fail  { color: #991b1b; }
+    .verify-card__status--draft { color: #92400e; }
+    .verify-card__status--info  { color: #1e40af; }
+
+    .verify-card__detail {
+        font-size: 0.7rem;
+        color: var(--text-muted);
+    }
+    .verify-card__detail code {
+        font-family: var(--font-mono);
+        font-size: 0.65rem;
+        word-break: break-all;
+        color: var(--primary);
+    }
+
+    /* Workflow Area */
+    .workflow-area {
+        border-top: 1px solid var(--border);
+        padding-top: 0.75rem;
+        margin-top: 0.75rem;
+        display: flex;
+        flex-direction: column;
+        gap: 0.875rem;
+    }
+
+    .workflow-step {
+        display: flex;
+        flex-direction: column;
+        gap: 0.375rem;
+    }
+
+    .workflow-step__label {
+        font-size: 0.6875rem;
+        font-weight: 700;
+        color: var(--text-muted);
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        margin: 0;
+    }
+
+    .workflow-step__body {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 0.5rem;
+    }
+
+    .workflow-dir {
+        font-family: var(--font-mono);
+        font-size: 0.625rem;
+        color: var(--text-muted);
+    }
+
+    .workflow-hint {
+        font-size: 0.625rem;
+        color: var(--text-muted);
+        font-style: italic;
+    }
+
+    .workflow-badge {
+        font-size: 0.625rem;
+        padding: 0.0625rem 0.375rem;
+        border: 1px solid;
+        border-radius: 0.25rem;
+        margin-left: 0.375rem;
+        vertical-align: middle;
+    }
+
+    .workflow-badge--warn {
+        background: #fef9c3;
+        color: #92400e;
+        border-color: #fcd34d;
+    }
+
+    /* Tools row — compact, de-emphasized */
+    .workflow-tools {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 0.375rem;
+        padding-top: 0.5rem;
+        border-top: 1px solid var(--border);
+    }
+
+    /* ── Table toolbar (above table) ───────────────────────── */
+    .table-toolbar {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: flex-end;
+        align-items: center;
+        gap: 0.25rem 0.5rem;
+        padding: 0.375rem 0;
+        border-top: 1px solid var(--border);
+        margin-top: 0.5rem;
+    }
+
+    .toolbar-btn {
+        background: none;
+        border: none;
+        font-size: 0.75rem;
+        font-weight: 500;
+        color: var(--primary);
+        cursor: pointer;
+        padding: 0.15rem 0.35rem;
+        border-radius: 0.25rem;
+    }
+
+    .toolbar-btn:hover {
+        text-decoration: underline;
+        background: var(--primary-light);
+    }
+
+    /* ── App chrome header (lives outside the transmittal) ── */
+    /* shared/base.css provides display, align-items, background, border-bottom */
+    .app-header {
+        position: sticky;
+        top: 0;
+        z-index: 1200;
+        gap: 0.5rem;
+        padding: 0.3rem 0.75rem;
+        /* Expose height for downstream sticky offsets */
+        --app-header-height: 2.1rem;
+        height: var(--app-header-height);
+        box-sizing: content-box;
+    }
+
+    .app-header__spacer {
+        flex: 1;
+    }
+
+    .app-header__icons {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+    }
+
+    .header-icon-btn {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 28px;
+        height: 28px;
+        border-radius: 0.25rem;
+        border: none;
+        background: transparent;
+        color: var(--text-muted);
+        cursor: pointer;
+        padding: 0;
+        text-decoration: none;
+        transition: color 0.15s, background 0.15s;
+    }
+
+    .header-icon-btn:hover {
+        color: var(--primary-hover);
+        background: var(--primary-light);
+    }
+
+    /* ── Fixed footer status bar at viewport bottom ───────── */
+    .page-footer {
+        position: fixed;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        z-index: 50;
+        background: var(--bg-secondary);
+        border-top: 1px solid var(--border);
+        padding: 0.2rem 0.75rem;
+    }
+
+    .page-footer__inner {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 0.5rem;
+        max-width: 8.5in;
+        margin: 0 auto;
+    }
+
+    .page-container {
+        padding-bottom: 2rem;
+    }
+
+    /* ── Split-button ─────────────────────────────────────── */
+    .split-button {
+        position: relative;
+        display: inline-flex;
+        align-items: stretch;
+    }
+
+    .split-button > .btn:last-of-type {
+        border-top-left-radius: 0;
+        border-bottom-left-radius: 0;
+    }
+
+    .split-button__toggle {
+        border-top-right-radius: 0;
+        border-bottom-right-radius: 0;
+        border-right: 1px solid rgba(255, 255, 255, 0.3);
+        min-width: 28px;
+        padding-left: 6px;
+        padding-right: 6px;
+        font-size: 0.75rem;
+        line-height: 1;
+    }
+
+    /* ── Dropdown menu ──────────────────────────────────────── */
+    .dropdown {
+        position: relative;
+        display: inline-block;
+    }
+
+    .dropdown-toggle {
+        min-width: 28px;
+        font-size: 1rem;
+        letter-spacing: 0.1em;
+        line-height: 1;
+    }
+
+    .dropdown-menu {
+        position: absolute;
+        left: 0;
+        top: 100%;
+        margin-top: 2px;
+        min-width: 120px;
+        background: var(--bg);
+        border: 1px solid var(--border);
+        border-radius: 0.375rem;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        z-index: 1100;
+        padding: 4px 0;
+    }
+
+    .dropdown-menu.dropdown-menu--up {
+        bottom: 100%;
+        top: auto;
+        margin-top: 0;
+        margin-bottom: 2px;
+    }
+
+    /* ── Dropdown separators ─────────────────────────────────── */
+    .dropdown-separator {
+        border-top: 1px solid var(--border);
+        margin: 4px 0;
+        padding: 0;
+        font-size: 0.625rem;
+        font-weight: 600;
+        color: var(--text-muted);
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+    }
+
+    .dropdown-separator:empty {
+        padding: 0;
+    }
+
+    .dropdown-separator:not(:empty) {
+        padding: 4px 12px 2px;
+    }
+
+    /* ── Scanning blur on table ─────────────────────────────── */
+    .table-wrapper.scanning {
+        filter: blur(1px);
+        opacity: 0.7;
+        pointer-events: none;
+        transition: filter 0.3s ease, opacity 0.3s ease;
+    }
+
+    .table-wrapper {
+        transition: filter 0.3s ease, opacity 0.3s ease;
+    }
+
+    /* ── Hash validation indicators ──────────────────────────── */
+    .hash-match {
+        color: #16a34a;
+        font-weight: 700;
+    }
+
+    .hash-mismatch {
+        color: #dc2626;
+        font-weight: 700;
+    }
+
+    /* ── Inline hash progress bar ────────────────────────────── */
+    .hash-progress {
+        display: flex;
+        align-items: center;
+        gap: 4px;
+        width: 100%;
+    }
+
+    .hash-progress-bar {
+        flex: 1;
+        height: 6px;
+        background: var(--border);
+        border-radius: 3px;
+        overflow: hidden;
+    }
+
+    .hash-progress-fill {
+        height: 100%;
+        width: 0%;
+        background: var(--primary);
+        border-radius: 3px;
+        transition: width 0.15s ease;
+    }
+
+    .hash-progress-fill.done {
+        background: #22c55e;
+        width: 100%;
+    }
+
+    /* ── Per-row verify result styling ───────────────────────── */
+    tr.verify-match td { background: #dcfce7; }
+    tr.verify-mismatch td { background: #fee2e2; }
+    tr.verify-missing td { background: #fef3c7; }
+    tr.verify-new td { background: #dbeafe; }
+    tr.verify-progress td:last-child { color: #6b7280; font-style: italic; }
+
+    .dropdown-item {
+        display: block;
+        width: 100%;
+        padding: 6px 12px;
+        border: none;
+        background: none;
+        text-align: left;
+        font-size: 0.8rem;
+        color: var(--text);
+        cursor: pointer;
+        white-space: nowrap;
+    }
+
+    .dropdown-item:hover {
+        background: var(--bg-secondary);
+    }
+
+    .dropdown-item:disabled {
+        opacity: 0.4;
+        cursor: not-allowed;
+    }
+
+}
diff --git a/transmittal/css/markdown-editor.css b/transmittal/css/markdown-editor.css
new file mode 100644
index 0000000..38fd614
--- /dev/null
+++ b/transmittal/css/markdown-editor.css
@@ -0,0 +1,66 @@
+/* ── Button bar ───────────────────────────────────────────── */
+.md-toolbar {
+    display: flex;
+    gap: 2px;
+    padding: 3px 4px;
+    background: #f3f4f6;
+    border: 1px solid #d1d5db;
+    border-bottom: none;
+    border-radius: 0.25rem 0.25rem 0 0;
+}
+
+.md-toolbar-btn {
+    min-width: 26px;
+    height: 24px;
+    padding: 0 5px;
+    border: 1px solid transparent;
+    border-radius: 3px;
+    background: transparent;
+    font-size: 12px;
+    font-weight: 600;
+    color: #374151;
+    cursor: pointer;
+    line-height: 1;
+}
+
+.md-toolbar-btn:hover {
+    background: #e5e7eb;
+    border-color: #d1d5db;
+}
+
+.md-toolbar-btn:active {
+    background: #d1d5db;
+}
+
+/* ── Edit area ────────────────────────────────────────── */
+.md-edit-area {
+    position: relative;
+    min-height: 80px;
+    border: 1px solid #d1d5db;
+    border-radius: 0 0 0.25rem 0.25rem;
+}
+
+.md-input {
+    display: block;
+    width: 100%;
+    min-height: 80px;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    font-size: 12px;
+    line-height: 1.6;
+    padding: 6px 8px;
+    margin: 0;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    tab-size: 4;
+    border: none;
+    outline: none;
+    resize: vertical;
+    background: #fff;
+    color: #111827;
+}
+
+.md-edit-area:focus-within {
+    border-color: #93c5fd;
+    box-shadow: 0 0 0 1px #93c5fd;
+}
diff --git a/transmittal/css/markdown.css b/transmittal/css/markdown.css
new file mode 100644
index 0000000..bb1f165
--- /dev/null
+++ b/transmittal/css/markdown.css
@@ -0,0 +1,113 @@
+#remarks-render h1,
+#remarks-render h2,
+#remarks-render h3,
+#remarks-render h4,
+#remarks-render h5,
+#remarks-render h6 {
+    margin: 0.5rem 0 0.25rem;
+    font-weight: 600;
+}
+
+#remarks-render h1 {
+    font-size: 1.25rem;
+    font-weight: 700;
+}
+
+#remarks-render h2 {
+    font-size: 1.125rem;
+    font-weight: 700;
+}
+
+#remarks-render h3 {
+    font-size: 1rem;
+    font-weight: 700;
+}
+
+#remarks-render h4 {
+    font-size: 0.9375rem;
+}
+
+#remarks-render h5 {
+    font-size: 0.875rem;
+}
+
+#remarks-render h6 {
+    font-size: 0.8125rem;
+}
+
+#remarks-render p {
+    margin: 0.5rem 0 0.85rem;
+}
+
+#remarks-render ul {
+    list-style: disc inside;
+    padding-left: 0.75rem;
+    margin: 0.25rem 0;
+}
+
+#remarks-render ol {
+    list-style: decimal inside;
+    padding-left: 0.75rem;
+    margin: 0.25rem 0;
+}
+
+#remarks-render li {
+    margin: 0.125rem 0;
+}
+
+#remarks-render blockquote {
+    border-left: 3px solid #e5e7eb;
+    padding-left: 0.75rem;
+    color: #374151;
+    margin: 0.25rem 0;
+}
+
+#remarks-render pre {
+    background: #f9fafb;
+    border: 1px solid #e5e7eb;
+    padding: 0.5rem;
+    border-radius: 0.25rem;
+    overflow: auto;
+}
+
+#remarks-render code {
+    background: #f3f4f6;
+    border: 1px solid #e5e7eb;
+    padding: 0 0.25rem;
+    border-radius: 0.125rem;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}
+
+#remarks-render hr {
+    border: 0;
+    border-top: 1px solid #e5e7eb;
+    margin: 0.5rem 0;
+}
+
+#remarks-render del {
+    text-decoration: line-through;
+    color: #9ca3af;
+}
+
+#remarks-render a {
+    color: #2563eb;
+    text-decoration: underline;
+}
+
+#remarks-render table {
+    border-collapse: collapse;
+    width: 100%;
+    margin: 0.25rem 0;
+}
+
+#remarks-render th,
+#remarks-render td {
+    border: 1px solid #d1d5db;
+    padding: 0.25rem 0.5rem;
+    text-align: left;
+}
+
+#remarks-render th {
+    background: #f3f4f6;
+    font-weight: 600;
+}
diff --git a/transmittal/css/modal.css b/transmittal/css/modal.css
new file mode 100644
index 0000000..b96e7d9
--- /dev/null
+++ b/transmittal/css/modal.css
@@ -0,0 +1,203 @@
+/* ── Native <dialog> base ─────────────────────────────── */
+dialog.modal {
+    border: none;
+    border-radius: 0.75rem;
+    max-width: 32rem;
+    width: min(90%, 32rem);
+    box-shadow: 0 20px 60px rgba(15, 23, 42, 0.25);
+    padding: 1.5rem;
+    gap: 1.25rem;
+    background: var(--bg);
+    color: var(--text);
+}
+
+dialog.modal[open] {
+    display: flex;
+    flex-direction: column;
+}
+
+dialog.modal::backdrop {
+    background: rgba(17, 24, 39, 0.55);
+}
+
+/* Prevent background scroll while a modal dialog is open */
+html:has(dialog.modal[open]) {
+    overflow: hidden;
+}
+
+/* ── Shared modal layout ─────────────────────────────── */
+.modal__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+}
+
+.modal__title {
+    font-size: 1.25rem;
+    line-height: 1.75rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.modal__close {
+    background: transparent;
+    border: none;
+    font-size: 1.5rem;
+    line-height: 1;
+    cursor: pointer;
+    color: var(--text-muted);
+}
+
+.modal__body {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.modal__options {
+    display: grid;
+    gap: 0.75rem;
+}
+
+.modal__footer {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.75rem;
+}
+
+.modal__feedback {
+    min-height: 1.25rem;
+    font-size: 0.85rem;
+    color: var(--danger);
+}
+
+/* ── Narrow modal variant ────────────────────────────── */
+dialog.modal--narrow {
+    max-width: 24rem;
+    width: min(90%, 24rem);
+}
+
+/* ── Publish field styles ────────────────────────────── */
+.publish-field__label {
+    display: block;
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+.publish-field__row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-top: 0.25rem;
+}
+
+.publish-field__input {
+    border: 1px solid var(--border);
+    border-radius: 0.375rem;
+    padding: 0.35rem 0.5rem;
+    font-size: 0.85rem;
+    width: 100%;
+    background: var(--bg);
+    color: var(--text);
+}
+
+.publish-field__warning {
+    font-size: 0.7rem;
+    color: #92400e;
+    white-space: nowrap;
+}
+
+.publish-outputs {
+    border: none;
+    margin: 0;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.35rem;
+}
+
+.publish-outputs legend {
+    margin-bottom: 0.25rem;
+}
+
+.publish-check {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.8rem;
+    cursor: pointer;
+}
+
+/* ── Key dialog ──────────────────────────────────────── */
+.key-dialog__desc {
+    font-size: 0.85rem;
+    color: var(--text-muted);
+    margin: 0 0 0.75rem;
+}
+
+.key-dialog__actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+/* ── Success notification ────────────────────────────── */
+@keyframes notification-slide-in {
+    from { transform: translateX(100%); opacity: 0; }
+    to { transform: translateX(0); opacity: 1; }
+}
+
+.publish-notification {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    background: #10b981;
+    color: white;
+    padding: 1rem 1.5rem;
+    border-radius: 0.5rem;
+    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
+    z-index: 10000;
+    max-width: 400px;
+    animation: notification-slide-in 0.3s ease-out;
+}
+
+.publish-notification__title {
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+}
+
+.publish-notification__file {
+    font-size: 0.875rem;
+}
+
+.publish-notification__close {
+    margin-top: 0.5rem;
+    background: rgba(255, 255, 255, 0.2);
+    border: none;
+    color: white;
+    padding: 0.25rem 0.75rem;
+    border-radius: 0.25rem;
+    cursor: pointer;
+    font-size: 0.875rem;
+}
+
+/* ── Responsive ──────────────────────────────────────── */
+@media (max-width: 480px) {
+    dialog.modal {
+        padding: 1.25rem;
+        gap: 1rem;
+    }
+
+    .modal__footer {
+        flex-direction: column-reverse;
+        align-items: stretch;
+    }
+
+    .key-dialog__actions {
+        flex-direction: column;
+        align-items: stretch;
+    }
+}
diff --git a/transmittal/css/print.css b/transmittal/css/print.css
new file mode 100644
index 0000000..c746362
--- /dev/null
+++ b/transmittal/css/print.css
@@ -0,0 +1,144 @@
+@media print {
+    body {
+        background: none;
+        padding: 0;
+    }
+
+    .page-container {
+        width: 100%;
+        margin: 0;
+        padding: 0;
+        min-height: 0;
+        box-shadow: none;
+        border: none;
+    }
+
+    @page {
+        margin: 0.375in;
+        size: 8.5in 11in;
+    }
+
+    .table-wrapper {
+        overflow: visible !important;
+        max-height: none !important;
+    }
+
+    thead th {
+        position: static !important;
+        top: auto !important;
+    }
+
+    /* Hide interactive-only elements in print */
+    .table-filter-input,
+    .logo-placeholder,
+    .drop-zone-label {
+        display: none !important;
+    }
+
+
+    /* Adjust table header caption spacing when filters are hidden */
+    .table-header__caption {
+        display: block;
+        padding: 0.25rem 0;
+    }
+
+    table {
+        width: 100% !important;
+        table-layout: fixed !important;
+        border: 1px solid #999 !important;
+        border-collapse: collapse !important;
+    }
+
+    th {
+        background-color: #e0e0e0 !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+        border-left: 1px solid #999 !important;
+        border-right: 1px solid #999 !important;
+        border-bottom: 1px solid #999 !important;
+        border-top: none !important;
+    }
+
+    td {
+        border-left: 1px solid #999 !important;
+        border-right: 1px solid #999 !important;
+        border-top: 1px solid #999 !important;
+        border-bottom: 1px solid #999 !important;
+    }
+
+    tr.self-entry td {
+        background-color: #f3f4f6 !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+    }
+
+    /* Fixed column widths for print */
+    thead th:nth-child(1),
+    tbody td:nth-child(1) {
+        width: 18% !important;
+    }
+
+    thead th:nth-child(2),
+    tbody td:nth-child(2) {
+        width: 30% !important;
+    }
+
+    thead th:nth-child(3),
+    tbody td:nth-child(3) {
+        width: 10% !important;
+    }
+
+    thead th:nth-child(4),
+    tbody td:nth-child(4) {
+        width: 8% !important;
+    }
+
+    thead th:nth-child(5),
+    tbody td:nth-child(5) {
+        width: 6% !important;
+    }
+
+    thead th:nth-child(6),
+    tbody td:nth-child(6) {
+        width: 8% !important;
+    }
+
+    thead th:nth-child(7),
+    tbody td:nth-child(7) {
+        width: 20% !important;
+    }
+
+    /* Ensure text wraps properly in print */
+    tbody td {
+        word-wrap: break-word;
+        overflow-wrap: break-word;
+    }
+
+    /* SHA256 column - allow breaking */
+    tbody td:nth-child(7) {
+        word-break: break-all;
+        font-size: 7pt !important;
+    }
+
+    /* From field: show rendered mailto link, hide input */
+    #from { display: none !important; }
+    .from-render {
+        display: block !important;
+    }
+    .from-mailto {
+        color: #2563eb !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+    }
+
+    /* To field: show rendered mailto links, hide input */
+    #to { display: none !important; }
+    .to-render {
+        display: block !important;
+    }
+    .to-mailto {
+        color: #2563eb !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+    }
+}
diff --git a/transmittal/css/remarks.css b/transmittal/css/remarks.css
new file mode 100644
index 0000000..63a3707
--- /dev/null
+++ b/transmittal/css/remarks.css
@@ -0,0 +1,24 @@
+#remarks-render-container {
+    padding: 6px;
+}
+
+/* In edit mode the rendered preview is clickable to re-enter the editor */
+#remarks-render-container.remarks-clickable {
+    cursor: text;
+    border: 1px dashed #d1d5db;
+    border-radius: 0.25rem;
+    min-height: 3.5rem;
+}
+
+#remarks-render-container.remarks-clickable:hover {
+    border-color: #93c5fd;
+    background: #f0f7ff;
+}
+
+/* Placeholder shown when remarks are empty and editable */
+#remarks-render-container .remarks-placeholder {
+    color: #9ca3af;
+    font-style: italic;
+    font-size: 12px;
+    pointer-events: none;
+}
diff --git a/transmittal/css/table.css b/transmittal/css/table.css
new file mode 100644
index 0000000..ee448ee
--- /dev/null
+++ b/transmittal/css/table.css
@@ -0,0 +1,103 @@
+@media screen {
+    .table-wrapper {
+        width: 100%;
+        max-width: 100%;
+    }
+
+    .table-wrapper table {
+        table-layout: auto;
+        width: 100%;
+        border-collapse: collapse;
+        border: 1px solid var(--border);
+    }
+
+    /* Header cells — stick below app-header (height + padding + border) */
+    .table-wrapper thead th {
+        white-space: nowrap;
+        position: sticky;
+        top: calc(2.1rem + 0.6rem + 1px);
+        z-index: 1000;
+        background-color: var(--bg-secondary);
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+        border-left: 1px solid var(--border);
+        border-right: 1px solid var(--border);
+        border-bottom: 1px solid var(--border);
+        border-top: none;
+    }
+    .table-wrapper thead th:first-child { border-left: none; }
+    .table-wrapper thead th:last-child  { border-right: none; }
+
+    /* Body cells: all gray borders */
+    .table-wrapper tbody td {
+        white-space: nowrap;
+        border-left: 1px solid var(--border);
+        border-right: 1px solid var(--border);
+        border-top: 1px solid var(--border);
+        border-bottom: 1px solid var(--border);
+    }
+    .table-wrapper tbody td:first-child { border-left: none; }
+    .table-wrapper tbody td:last-child  { border-right: none; }
+    .table-wrapper tbody tr:first-child td { border-top: none; }
+    .table-wrapper tbody tr:last-child td  { border-bottom: none; }
+
+    /* Self-entry row */
+    .table-wrapper tbody tr.self-entry td {
+        background-color: var(--bg-hover);
+    }
+
+    /* 3: Title — only column that wraps */
+    .table-wrapper thead th:nth-child(3) {
+        white-space: normal;
+    }
+
+    .table-wrapper tbody td:nth-child(3) {
+        white-space: normal;
+        overflow-wrap: anywhere;
+    }
+
+    /* 7: Size — right aligned */
+    .table-wrapper thead th:nth-child(7),
+    .table-wrapper tbody td:nth-child(7) {
+        text-align: right;
+    }
+
+    /* Row delete button */
+    .row-delete-btn {
+        display: none;
+        border: none;
+        background: none;
+        color: #dc2626;
+        font-size: 0.85rem;
+        line-height: 1;
+        padding: 0 0.2rem;
+        margin-right: 0.15rem;
+        cursor: pointer;
+        vertical-align: middle;
+        opacity: 0.5;
+    }
+    .row-delete-btn:hover {
+        opacity: 1;
+    }
+    .table-wrapper tbody tr:hover .row-delete-btn {
+        display: inline;
+    }
+
+    /* Path diff indicator (verify mismatch) */
+    .path-diff {
+        font-size: 0.65rem;
+        line-height: 1.3;
+        margin-top: 2px;
+    }
+
+    .path-diff del {
+        color: #991b1b;
+        background: #fef2f2;
+    }
+
+    .path-diff ins {
+        color: #166534;
+        background: #f0fdf4;
+        text-decoration: none;
+        border-bottom: 1px solid #166534;
+    }
+}
diff --git a/transmittal/css/utilities.css b/transmittal/css/utilities.css
new file mode 100644
index 0000000..6f19536
--- /dev/null
+++ b/transmittal/css/utilities.css
@@ -0,0 +1,149 @@
+/* Tailwind-inspired utility subset required by template.html */
+
+/* Typography */
+.font-sans { font-family: "Inter", "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif; }
+.font-mono { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; }
+.font-semibold { font-weight: 600; }
+.font-bold { font-weight: 700; }
+.italic { font-style: italic; }
+.text-left { text-align: left; }
+.text-center { text-align: center; }
+.text-xs { font-size: 0.75rem; line-height: 1rem; }
+.text-sm { font-size: 0.875rem; line-height: 1.25rem; }
+.text-base { font-size: 1rem; line-height: 1.5rem; }
+.text-lg { font-size: 1.125rem; line-height: 1.75rem; }
+.text-xl { font-size: 1.25rem; line-height: 1.75rem; }
+.text-2xl { font-size: 1.5rem; line-height: 2rem; }
+.text-\[12px\] { font-size: 12px; line-height: 1.4; }
+.text-\[10px\] { font-size: 10px; line-height: 1.3; }
+.text-gray-900 { color: #111827; }
+.text-gray-700 { color: #374151; }
+.text-gray-600 { color: #4b5563; }
+.text-gray-500 { color: #6b7280; }
+.text-gray-400 { color: #9ca3af; }
+.text-blue-600 { color: #2563eb; }
+.text-green-600 { color: #16a34a; }
+.text-red-600 { color: #dc2626; }
+.uppercase { text-transform: uppercase; }
+.tracking-wide { letter-spacing: 0.1em; }
+.leading-6 { line-height: 1.5rem; }
+.leading-snug { line-height: 1.375rem; }
+
+/* Backgrounds */
+.bg-white { background-color: #ffffff; }
+.bg-transparent { background-color: transparent; }
+.bg-gray-50 { background-color: #f9fafb; }
+.bg-gray-100 { background-color: #f3f4f6; }
+
+/* Borders */
+.border { border: 1px solid #d1d5db; }
+.border-0 { border: 0; }
+.border-b { border-bottom: 1px solid #d1d5db; }
+.border-t { border-top: 1px solid #d1d5db; }
+.border-gray-300 { border-color: #d1d5db; }
+.border-gray-200 { border-color: #e5e7eb; }
+.border-gray-100 { border-color: #f3f4f6; }
+.rounded-none { border-radius: 0; }
+.rounded-sm { border-radius: 0.125rem; }
+.rounded { border-radius: 0.25rem; }
+.rounded-md { border-radius: 0.375rem; }
+
+/* Effects */
+.shadow-lg { box-shadow: 0 10px 25px rgba(15, 23, 42, 0.15); }
+.transition-colors { transition: color 150ms ease, background-color 150ms ease, border-color 150ms ease, box-shadow 150ms ease; }
+
+/* Flex / Grid */
+.flex { display: flex; }
+.flex-col { flex-direction: column; }
+.flex-row { flex-direction: row; }
+.flex-1 { flex: 1 1 0%; }
+.items-center { align-items: center; }
+.items-start { align-items: flex-start; }
+.justify-between { justify-content: space-between; }
+.justify-center { justify-content: center; }
+.gap-2 { gap: 0.5rem; }
+.gap-0\.5 { gap: 0.125rem; }
+.grid { display: grid; }
+.grid-cols-12 { grid-template-columns: repeat(12, minmax(0, 1fr)); }
+.col-span-4 { grid-column: span 4 / span 4; }
+.col-span-6 { grid-column: span 6 / span 6; }
+.col-span-12 { grid-column: span 12 / span 12; }
+
+/* Positioning */
+.block { display: block; }
+.relative { position: relative; }
+.absolute { position: absolute; }
+.sticky { position: sticky; }
+.left-0 { left: 0; }
+.top-0 { top: 0; }
+.top-6 { top: 1.5rem; }
+.top-full { top: 100%; }
+.z-10 { z-index: 10; }
+.z-20 { z-index: 20; }
+.z-50 { z-index: 50; }
+
+/* Sizing */
+.w-full { width: 100%; }
+.w-auto { width: auto; }
+.w-64 { width: 16rem; }
+.w-5 { width: 1.25rem; }
+.h-5 { height: 1.25rem; }
+.h-6 { height: 1.5rem; }
+.h-auto { height: auto; }
+.min-w-0 { min-width: 0; }
+.max-w-\[1200px\] { max-width: 1200px; }
+.max-w-\[1600px\] { max-width: 1600px; }
+.max-h-96 { max-height: 24rem; }
+.min-h-\[3.5rem\] { min-height: 3.5rem; }
+.overflow-auto { overflow: auto; }
+
+/* Spacing */
+.p-2 { padding: 0.5rem; }
+.px-0 { padding-left: 0; padding-right: 0; }
+.px-1 { padding-left: 0.25rem; padding-right: 0.25rem; }
+.px-2 { padding-left: 0.5rem; padding-right: 0.5rem; }
+.px-3 { padding-left: 0.75rem; padding-right: 0.75rem; }
+.px-1\.5 { padding-left: 0.375rem; padding-right: 0.375rem; }
+.py-0 { padding-top: 0; padding-bottom: 0; }
+.py-0\.5 { padding-top: 0.125rem; padding-bottom: 0.125rem; }
+.py-1 { padding-top: 0.25rem; padding-bottom: 0.25rem; }
+.py-1\.5 { padding-top: 0.375rem; padding-bottom: 0.375rem; }
+.pt-1 { padding-top: 0.25rem; }
+.pt-5 { padding-top: 1.25rem; }
+.pb-2 { padding-bottom: 0.5rem; }
+.pb-3 { padding-bottom: 0.75rem; }
+.mt-1 { margin-top: 0.25rem; }
+.mt-2 { margin-top: 0.5rem; }
+.mb-1 { margin-bottom: 0.25rem; }
+.my-1 { margin-top: 0.25rem; margin-bottom: 0.25rem; }
+.gap-x-6 { column-gap: 1.5rem; }
+.gap-y-3 { row-gap: 0.75rem; }
+
+/* Drag-hover utilities (used by drop zone handlers) */
+.ring-2 { box-shadow: 0 0 0 2px var(--tw-ring-color, rgba(59, 130, 246, 0.5)); }
+.ring-blue-400 { --tw-ring-color: rgba(96, 165, 250, 0.7); }
+.bg-blue-50 { background-color: #eff6ff; }
+
+/* Validation error state (applied via JS in validation.js) */
+.ring-red-400 { box-shadow: 0 0 0 2px rgba(248, 113, 113, 0.5); }
+.border-red-500 { border-color: #ef4444 !important; }
+
+/* Hover & focus states */
+.hover\:bg-gray-50:hover { background-color: #f9fafb; }
+.hover\:bg-gray-100:hover { background-color: #f3f4f6; }
+.hover\:underline:hover { text-decoration: underline; }
+.focus\:outline-none:focus { outline: none; }
+.focus\:border-blue-400:focus { border-color: #60a5fa; }
+.focus\:ring-1:focus { box-shadow: 0 0 0 1px rgba(59, 130, 246, 0.35); }
+.focus\:ring-blue-400:focus { box-shadow: 0 0 0 2px rgba(96, 165, 250, 0.45); }
+.focus\:bg-white:focus { background-color: #ffffff; }
+.disabled\:pointer-events-none:disabled { pointer-events: none; }
+
+/* Table helpers */
+.table-auto { table-layout: auto; }
+.border-collapse { border-collapse: collapse; }
+
+/* Print helpers */
+@media print {
+    .print\:hidden { display: none !important; }
+}
diff --git a/transmittal/js/app.js b/transmittal/js/app.js
new file mode 100644
index 0000000..47b0915
--- /dev/null
+++ b/transmittal/js/app.js
@@ -0,0 +1,73 @@
+(function (global) {
+    'use strict';
+
+    if (global.transmittalApp) {
+        return;
+    }
+
+    const app = {
+        state: {
+            mode: 'edit',
+            published: false,
+            dirty: false
+        },
+        data: {
+            files: [],
+            selectedDirHandle: null,
+            selectedDirName: ''
+        },
+        constants: {
+            viewableExts: ['pdf', 'png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'txt', 'html', 'htm', 'md'],
+            digestAlgorithm: 'SHA-256',
+            signatureAlgorithm: 'ECDSA-P256-SHA256',
+            SELF_HASH: 'self:payload-digest'
+        },
+        modules: {},
+        initCallbacks: [],
+        registerInit(fn) {
+            if (typeof fn === 'function') {
+                app.initCallbacks.push(fn);
+            }
+        },
+        dirtyListeners: [],
+        onDirty(fn) {
+            if (typeof fn === 'function') {
+                app.dirtyListeners.push(fn);
+            }
+        },
+        markDirty() {
+            app.state.dirty = true;
+            app.dirtyListeners.forEach(function (fn) {
+                try { fn(); } catch (err) { console.error('[transmittal] dirtyListener error', err); }
+            });
+        },
+        ready(fn) {
+            if (typeof fn !== 'function') {
+                return;
+            }
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', fn, { once: true });
+            } else {
+                fn();
+            }
+        },
+        start() {
+            if (app._started) {
+                return;
+            }
+            app._started = true;
+            const run = function () {
+                app.initCallbacks.forEach(function (fn) {
+                    try {
+                        fn();
+                    } catch (err) {
+                        console.error('[transmittal] init error', err);
+                    }
+                });
+            };
+            app.ready(run);
+        }
+    };
+
+    global.transmittalApp = app;
+})(window);
diff --git a/transmittal/js/data.js b/transmittal/js/data.js
new file mode 100644
index 0000000..7ecef97
--- /dev/null
+++ b/transmittal/js/data.js
@@ -0,0 +1,355 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const json = app.json;
+
+    const dataModule = app.modules.data = {};
+
+    const STATUS_DISPLAY_MS = 6000;
+    let statusTimer = null;
+
+    function qs(selector) {
+        return dom.qs(selector);
+    }
+
+    function setStatus(message, type) {
+        const element = qs('#data-status');
+        if (!element) {
+            return;
+        }
+        element.textContent = message || '';
+        element.dataset.statusType = type || '';
+        element.classList.remove('text-red-600', 'text-green-600');
+        if (type === 'success') {
+            element.classList.add('text-green-600');
+        } else if (type === 'error') {
+            element.classList.add('text-red-600');
+        }
+        if (statusTimer) {
+            clearTimeout(statusTimer);
+        }
+        if (message) {
+            statusTimer = setTimeout(function () {
+                element.textContent = '';
+                element.classList.remove('text-red-600', 'text-green-600');
+            }, STATUS_DISPLAY_MS);
+        }
+    }
+
+    const INVALID_FILENAME_CHARS = /[\\/:*?"<>|]+/g;
+
+    function sanitizeFilenameSegment(value, fallback) {
+        const trimmed = (value || '').toString().trim();
+        if (!trimmed) {
+            return fallback || '';
+        }
+        return trimmed
+            .replace(INVALID_FILENAME_CHARS, '-')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+
+    function sanitizeTitle(value) {
+        const sanitized = sanitizeFilenameSegment(value, 'Transmittal');
+        return sanitized || 'Transmittal';
+    }
+
+    function sanitizeTracking(value) {
+        const sanitized = sanitizeFilenameSegment(value, 'TRANS');
+        return sanitized.replace(/[_\s]+/g, '-');
+    }
+
+    function sanitizeStatus(value, fallback) {
+        const sanitized = sanitizeFilenameSegment(value, fallback || '');
+        const cleaned = sanitized.replace(/[()]/g, '').trim();
+        if (cleaned) {
+            return cleaned;
+        }
+        return (fallback || 'Unspecified');
+    }
+
+    function sanitizeDate(value) {
+        const trimmed = (value || '').toString().trim();
+        if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+            return trimmed;
+        }
+        if (!trimmed) {
+            return '0000-00-00';
+        }
+        return trimmed.replace(/\s+/g, '-');
+    }
+
+    // Folder name: DATE_TRACKING (STATUS) - Title  (date first for chronological sort)
+    dataModule.buildFolderName = function buildFolderName(payload) {
+        const p = payload || {};
+        const date = sanitizeDate(p.date || '');
+        const tracking = sanitizeTracking(p.trackingNumber || '');
+        const status = sanitizeStatus(p.status || p.purpose || '', 'Unspecified');
+        const title = sanitizeTitle(p.subject || p.title || '');
+        const statusPart = status ? ' (' + status + ')' : '';
+        return date + '_' + tracking + statusPart + ' - ' + title;
+    };
+
+    // File name: TRACKING_[~]DATE (STATUS) - Subject.ext
+    // draft: true → ~DATE (tilde prefix indicates draft)
+    dataModule.buildFileName = function buildFileName(payload, options) {
+        const p = payload || {};
+        const opts = options || {};
+        const ext = opts.extension ? opts.extension.replace(/^\.+/, '') : 'json';
+        const isDraft = !!opts.draft;
+        const tracking = sanitizeTracking(p.trackingNumber || '');
+        const date = sanitizeDate(p.date || '');
+        const status = sanitizeStatus(p.status || p.purpose || '', 'Unspecified');
+        const title = sanitizeTitle(p.subject || p.title || '');
+        const statusPart = status ? ' (' + status + ')' : '';
+        const datePrefix = isDraft ? '~' : '';
+        return tracking + '_' + datePrefix + date + statusPart + ' - ' + title + '.' + ext;
+    };
+
+    async function saveFileWithPicker(filename, contents, mime) {
+        if (typeof window.showSaveFilePicker !== 'function') {
+            app.util.downloadBlob(filename, contents, mime);
+            return filename;
+        }
+        const handle = await window.showSaveFilePicker({
+            suggestedName: filename,
+            types: [
+                {
+                    description: mime || 'File',
+                    accept: { [mime || 'application/octet-stream']: ['.' + zddc.splitExtension(filename).extension] }
+                }
+            ]
+        });
+        const writable = await handle.createWritable();
+        await writable.write(new Blob([contents], { type: mime || 'application/octet-stream' }));
+        await writable.close();
+        return handle.name || filename;
+    }
+
+    async function serializeUiToJson() {
+        if (!app.modules.publish || typeof app.modules.publish.syncUiToJson !== 'function') {
+            throw new Error('Publish module not ready');
+        }
+        await app.modules.publish.syncUiToJson({ sign: false, computeDigest: false });
+        app.state.dirty = false;
+    }
+
+    // ── Extract JSON from an HTML transmittal string ────
+    function extractJsonFromHtml(htmlText) {
+        var m = htmlText.match(new RegExp('<script\\s+id\\s*=\\s*["\']transmittal-data["\'][^>]*>([\\s\\S]*?)</' + 'script>', 'i'));
+        if (!m || !m[1]) { return null; }
+        try {
+            var data = JSON.parse(m[1]);
+            if (data && typeof data === 'object' && data.payload) { return data; }
+        } catch (_) { /* not valid JSON */ }
+        return null;
+    }
+
+    function pickHtmlFile() {
+        if (typeof window.showOpenFilePicker === 'function') {
+            return window.showOpenFilePicker({
+                multiple: false,
+                types: [{ description: 'HTML Files', accept: { 'text/html': ['.html', '.htm'] } }]
+            }).then(function (handles) {
+                var handle = handles[0];
+                return handle.getFile().then(function (file) {
+                    return { file: file, name: handle.name || file.name || 'import.html' };
+                });
+            });
+        }
+        return new Promise(function (resolve, reject) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = 'text/html,.html,.htm';
+            input.addEventListener('change', function () {
+                var file = input.files && input.files[0];
+                if (!file) { reject(new Error('No file selected')); return; }
+                resolve({ file: file, name: file.name || 'import.html' });
+            });
+            input.click();
+        });
+    }
+
+    async function handleImportHtml() {
+        try {
+            var picked = await pickHtmlFile();
+            var text = await picked.file.text();
+            var data = extractJsonFromHtml(text);
+            if (!data) { throw new Error('No valid transmittal data found in this HTML file'); }
+            await applyLoadedData(data, picked.name || 'import.html');
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) { return; }
+            console.error('[transmittal] import-html failed', err);
+            setStatus('Failed to import HTML: ' + (err && err.message ? err.message : err), 'error');
+        }
+    }
+
+    async function applyLoadedData(data, sourceName) {
+        json.setData(data);
+        app.modules.files.loadFromJson();
+        app.state.mode = 'edit';
+        app.state.dirty = false;
+        if (app.modules.visibility && app.modules.visibility.applyFieldVisibility) {
+            app.modules.visibility.applyFieldVisibility();
+        }
+        await app.modules.security.verifySignatureIfPresent();
+        if (app.modules.security.renderSignaturesList) {
+            await app.modules.security.renderSignaturesList();
+        }
+        app.modules.mode.refresh();
+        app.state.apply();
+        if (app.modules.liveDigest && app.modules.liveDigest.schedule) {
+            app.modules.liveDigest.schedule();
+        }
+        setStatus('Loaded: ' + sourceName, 'success');
+    }
+
+    app.onDirty(function () {
+        setStatus('Unsaved changes', 'info');
+    });
+
+    async function handleLoadFromClipboard() {
+        try {
+            var text = await navigator.clipboard.readText();
+            if (!text || !text.trim()) {
+                setStatus('Clipboard is empty', 'error');
+                return;
+            }
+            var data = JSON.parse(text.trim());
+            if (!data || typeof data !== 'object' || !data.payload) {
+                throw new Error('Invalid ZDDC JSON data');
+            }
+            await applyLoadedData(data, 'clipboard');
+        } catch (err) {
+            console.error('[transmittal] load-from-clipboard failed', err);
+            if (err && err.name === 'NotAllowedError') {
+                setStatus('Clipboard access denied — please paste manually', 'error');
+            } else {
+                setStatus('Failed to load from clipboard: ' + (err && err.message ? err.message : err), 'error');
+            }
+        }
+    }
+
+    async function handleCopyJson() {
+        try {
+            await serializeUiToJson();
+            var data = json.parse();
+            var text = JSON.stringify(data, null, 2);
+            await navigator.clipboard.writeText(text);
+            setStatus('JSON copied to clipboard', 'success');
+        } catch (err) {
+            console.error('[transmittal] copy-json failed', err);
+            if (err && err.name === 'NotAllowedError') {
+                setStatus('Clipboard access denied', 'error');
+            } else {
+                setStatus('Failed to copy JSON: ' + (err && err.message ? err.message : err), 'error');
+            }
+        }
+    }
+
+    async function handleSaveHtmlDraft() {
+        try {
+            var pub = app.modules.publish;
+            if (!pub || typeof pub.syncUiToJson !== 'function' || typeof pub.buildHtmlString !== 'function') {
+                throw new Error('Publish module not ready');
+            }
+            await pub.syncUiToJson({ sign: false, computeDigest: false });
+            var html = await pub.buildHtmlString();
+            var data = json.parse();
+            var payload = (data && data.payload) || {};
+            var filename = dataModule.buildFileName(payload, { extension: 'html', draft: true });
+            await saveFileWithPicker(filename, html, 'text/html');
+            setStatus('Saved draft as ' + filename, 'success');
+        } catch (err) {
+            console.error('[transmittal] save-html-draft failed', err);
+            setStatus('Failed to save draft: ' + (err && err.message ? err.message : err), 'error');
+        }
+    }
+
+    async function handleCopyTable() {
+        try {
+            var TAB = '\t';
+            var NL = '\r\n';
+            var esc = app.util.escapeHtml;
+            var textStyle = ' style="mso-number-format:\'\\@\'"';
+            var headers = ['#', 'TRACKING NUMBER', 'TITLE', 'REVISION', 'STATUS', 'EXT', 'SIZE', 'SHA256'];
+            var headerTsv = headers.join(TAB);
+            var headerHtml = '<tr>' + headers.map(function (h) { return '<th' + textStyle + '>' + esc(h) + '</th>'; }).join('') + '</tr>';
+            var tsvLines = [headerTsv];
+            var htmlRows = [headerHtml];
+
+            function addRow(cells) {
+                tsvLines.push(cells.join(TAB));
+                htmlRows.push('<tr>' + cells.map(function (c) { return '<td' + textStyle + '>' + esc(c) + '</td>'; }).join('') + '</tr>');
+            }
+
+            // Row 0: self-entry
+            var filesModule = app.modules.files;
+            var self = filesModule && filesModule.buildSelfEntry ? filesModule.buildSelfEntry() : null;
+            if (self) {
+                addRow(['0', self.trackingNumber || '', self.title || '', self.revision || '', self.status || '', 'html', '\u2014', 'see above']);
+            }
+
+            // Regular files
+            var files = Array.isArray(app.data.files) ? app.data.files : [];
+            for (var i = 0; i < files.length; i++) {
+                var f = files[i];
+                var size = (f.fileSize != null ? f.fileSize : f.size);
+                addRow([
+                    String(i + 1),
+                    f.trackingNumber || '',
+                    f.title || '',
+                    f.revision || '',
+                    f.status || '',
+                    (f.extension || '').toLowerCase(),
+                    size ? String(size) : '',
+                    f.sha256 || ''
+                ]);
+            }
+
+            var plainText = tsvLines.join(NL);
+            var html = '<table>' + htmlRows.join('') + '</table>';
+            await navigator.clipboard.write([
+                new ClipboardItem({
+                    'text/plain': new Blob([plainText], { type: 'text/plain' }),
+                    'text/html': new Blob([html], { type: 'text/html' })
+                })
+            ]);
+            setStatus('Table copied (' + files.length + ' files)', 'success');
+        } catch (err) {
+            console.error('[transmittal] copy-table failed', err);
+            setStatus('Failed to copy table: ' + (err && err.message ? err.message : err), 'error');
+        }
+    }
+
+    async function handleRevise() {
+        if (!confirm('This will create a new draft from the published transmittal. The digest and signatures will be removed. Continue?')) {
+            return;
+        }
+        var data = json.parse();
+        if (!data) { return; }
+        // Strip digest and signatures; preserve existing date for user to update
+        data.envelope = { version: 1, digestAlgorithm: app.constants.digestAlgorithm, digest: '', digestedAt: '', signatureAlgorithm: app.constants.signatureAlgorithm, signatures: [] };
+        json.setData(data);
+        app.modules.files.loadFromJson();
+        app.state.mode = 'edit';
+        app.state.published = false;
+        app.state.dirty = true;
+        app.modules.mode.refresh();
+        setStatus('Created new draft from published transmittal', 'success');
+    }
+
+    dataModule.extractJsonFromHtml = extractJsonFromHtml;
+    dataModule.setStatus = setStatus;
+    dataModule.serializeUiToJson = serializeUiToJson;
+    dataModule.handleLoadFromClipboard = handleLoadFromClipboard;
+    dataModule.handleCopyJson = handleCopyJson;
+    dataModule.handleCopyTable = handleCopyTable;
+    dataModule.handleSaveHtmlDraft = handleSaveHtmlDraft;
+    dataModule.handleRevise = handleRevise;
+    dataModule.handleImportHtml = handleImportHtml;
+    dataModule.applyLoadedData = applyLoadedData;
+    dataModule.buildFileName = dataModule.buildFileName || buildFileName;
+
+})(window.transmittalApp);
diff --git a/transmittal/js/dom.js b/transmittal/js/dom.js
new file mode 100644
index 0000000..ca6ed86
--- /dev/null
+++ b/transmittal/js/dom.js
@@ -0,0 +1,20 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom = app.dom || {};
+
+    dom.qs = function (selector) {
+        return document.querySelector(selector);
+    };
+
+    dom.qsa = function (selector) {
+        return Array.from(document.querySelectorAll(selector));
+    };
+
+    dom.show = function (element, shouldShow) {
+        if (!element) {
+            return;
+        }
+        element.hidden = !shouldShow;
+    };
+})(window.transmittalApp);
diff --git a/transmittal/js/drop-zones.js b/transmittal/js/drop-zones.js
new file mode 100644
index 0000000..535ab7e
--- /dev/null
+++ b/transmittal/js/drop-zones.js
@@ -0,0 +1,262 @@
+(function (app) {
+    'use strict';
+
+    // ── Targeted drop zones ─────────────────────────────────────────────────
+    // Shows contextual zone outlines when anything is dragged over the window.
+    // Emphasises zones that can accept the dragged data type.
+    // Hands off actual processing to existing module helpers.
+
+    var dropZonesModule = app.modules.dropZones = {};
+
+    // ── Data-transfer classification ────────────────────────────────────────
+    // Returns { hasImage, hasHtmlJson, hasPossibleDir }
+    // NOTE: MIME types ARE accessible on items during dragenter/dragover,
+    // but filenames are not. Directories have kind === 'file' and type === ''.
+    function classifyTransfer(dt) {
+        var hasImage = false;
+        var hasHtmlJson = false;
+        var hasPossibleDir = false;
+
+        if (!dt || !dt.items) {
+            return { hasImage: hasImage, hasHtmlJson: hasHtmlJson, hasPossibleDir: hasPossibleDir };
+        }
+
+        var items = dt.items;
+        for (var i = 0; i < items.length; i++) {
+            var item = items[i];
+            if (item.kind !== 'file') { continue; }
+            var t = (item.type || '').toLowerCase();
+            if (t.indexOf('image/') === 0) {
+                hasImage = true;
+            } else if (t === 'text/html' || t === 'application/json') {
+                hasHtmlJson = true;
+            } else if (t === '') {
+                // Could be a directory or a file with no MIME (e.g. .json on some OSes)
+                hasPossibleDir = true;
+            }
+        }
+        return { hasImage: hasImage, hasHtmlJson: hasHtmlJson, hasPossibleDir: hasPossibleDir };
+    }
+
+    // ── Eligibility per zone type ───────────────────────────────────────────
+    function zoneIsEligible(zoneType, cls) {
+        var inEditMode = (app.state && app.state.mode === 'edit');
+        switch (zoneType) {
+            case 'logo-left':
+            case 'logo-right':
+                return cls.hasImage && inEditMode;
+            case 'header':
+                // Accept HTML/JSON imports; also allow unknown-type files (hasPossibleDir)
+                // so that dragging a JSON with no MIME still lights up the header zone.
+                return (cls.hasHtmlJson || cls.hasPossibleDir) && inEditMode;
+            case 'file-table':
+                // Directories and HTML/JSON imports are always eligible here.
+                // (Verify works in both edit and published mode.)
+                // Pure image-only drops are not accepted here.
+                return cls.hasHtmlJson || cls.hasPossibleDir;
+            default:
+                return false;
+        }
+    }
+
+    // ── Zone visibility helpers ─────────────────────────────────────────────
+    function getAllZones() {
+        return document.querySelectorAll('[data-drop-zone]');
+    }
+
+    function showZones(cls) {
+        getAllZones().forEach(function (el) {
+            var zoneType = el.getAttribute('data-drop-zone');
+            var eligible = zoneIsEligible(zoneType, cls);
+            el.classList.add('dz-visible');
+            el.classList.toggle('dz-eligible', eligible);
+            el.classList.toggle('dz-ineligible', !eligible);
+        });
+    }
+
+    function hideZones() {
+        getAllZones().forEach(function (el) {
+            el.classList.remove('dz-visible', 'dz-eligible', 'dz-ineligible', 'dz-hover');
+        });
+    }
+
+    // ── Window-level drag tracking ──────────────────────────────────────────
+    // Use relatedTarget to distinguish real enter/leave from child-element noise.
+    // relatedTarget is null when the drag crosses the window boundary.
+    // Note: this approach is reliable in Chromium-based browsers. Firefox has
+    // a known quirk where relatedTarget may not be null at true window boundary
+    // in all cases; zones may not appear in Firefox. Acceptable given the app's
+    // primary target is Chromium.
+
+    document.addEventListener('dragenter', function (e) {
+        e.preventDefault();
+        if (e.relatedTarget === null) {
+            showZones(classifyTransfer(e.dataTransfer));
+        }
+    });
+
+    document.addEventListener('dragleave', function (e) {
+        if (e.relatedTarget === null) {
+            hideZones();
+        }
+    });
+
+    document.addEventListener('dragover', function (e) { e.preventDefault(); });
+
+    document.addEventListener('drop', function (e) {
+        // Default handler: prevent browser navigation. Specific zones handle drops.
+        e.preventDefault();
+        hideZones();
+    });
+
+    // ── Per-zone drop handler: HTML / JSON import ───────────────────────────
+    async function handleDataFileDrop(file, sourceName) {
+        var dataModule = app.modules.data;
+        if (!dataModule) { return; }
+        var name = (sourceName || '').toLowerCase();
+        try {
+            var text = await file.text();
+            var data = null;
+            if (name.endsWith('.json')) {
+                data = JSON.parse(text);
+            } else {
+                // HTML: extract embedded JSON using the shared helper from data.js
+                if (dataModule.extractJsonFromHtml) {
+                    data = dataModule.extractJsonFromHtml(text);
+                }
+            }
+            if (!data) {
+                if (dataModule.setStatus) { dataModule.setStatus('Dropped file does not contain transmittal data', 'error'); }
+                return;
+            }
+            await dataModule.applyLoadedData(data, sourceName || 'dropped');
+        } catch (err) {
+            console.error('[transmittal] drop-zones: file drop failed', err);
+            if (dataModule.setStatus) {
+                dataModule.setStatus('Failed to import: ' + (err && err.message ? err.message : err), 'error');
+            }
+        }
+    }
+
+    // ── Per-zone drop handler: directory ────────────────────────────────────
+    async function handleDirectoryDrop(item) {
+        var dataModule = app.modules.data;
+        var filesModule = app.modules.files;
+        if (!item || typeof item.getAsFileSystemHandle !== 'function') { return false; }
+        try {
+            var handle = await item.getAsFileSystemHandle();
+            if (!handle || handle.kind !== 'directory') { return false; }
+            if (typeof handle.requestPermission === 'function') {
+                await handle.requestPermission({ mode: 'readwrite' });
+            }
+            app.data.selectedDirHandle = handle;
+            if (filesModule && filesModule.updateDirectoryIndicator) {
+                filesModule.updateDirectoryIndicator();
+            }
+            if (dataModule && dataModule.setStatus) {
+                dataModule.setStatus('Directory: ' + handle.name, 'info');
+            }
+            var isPublished = !!app.state.published;
+            var hasFiles = app.data.files && app.data.files.length > 0;
+            if (isPublished || hasFiles) {
+                document.dispatchEvent(new CustomEvent('transmittal:verify-directory'));
+            } else {
+                document.dispatchEvent(new CustomEvent('transmittal:scan-directory'));
+            }
+            return true;
+        } catch (err) {
+            console.warn('[transmittal] drop-zones: getAsFileSystemHandle failed', err);
+            return false;
+        }
+    }
+
+    // ── Wire a single zone element ──────────────────────────────────────────
+    function wireZone(el) {
+        var zoneType = el.getAttribute('data-drop-zone');
+
+        el.addEventListener('dragover', function (e) {
+            var cls = classifyTransfer(e.dataTransfer);
+            if (zoneIsEligible(zoneType, cls)) {
+                e.preventDefault();
+                e.stopPropagation();
+                el.classList.add('dz-hover');
+            }
+        });
+
+        el.addEventListener('dragleave', function (e) {
+            // Only remove hover if we're actually leaving this element
+            // (not just moving to a child element within it)
+            if (!el.contains(e.relatedTarget)) {
+                el.classList.remove('dz-hover');
+            }
+        });
+
+        el.addEventListener('drop', async function (e) {
+            var cls = classifyTransfer(e.dataTransfer);
+            if (!zoneIsEligible(zoneType, cls)) { return; }
+            e.preventDefault();
+            e.stopPropagation();
+            hideZones();
+
+            // ── Logo zones ──────────────────────────────────────────
+            if (zoneType === 'logo-left' || zoneType === 'logo-right') {
+                var file = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+                if (!file) { return; }
+                var imgId = zoneType === 'logo-left' ? 'left-logo' : 'right-logo';
+                if (app.modules.logos && app.modules.logos.applyLogoFile) {
+                    await app.modules.logos.applyLogoFile(imgId, file);
+                }
+                return;
+            }
+
+            // ── Header zone: HTML or JSON import only ───────────────
+            if (zoneType === 'header') {
+                var file = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+                if (!file) { return; }
+                var name = (file.name || '').toLowerCase();
+                if (!name.endsWith('.html') && !name.endsWith('.htm') && !name.endsWith('.json')) {
+                    if (app.modules.data && app.modules.data.setStatus) {
+                        app.modules.data.setStatus('Drop an HTML or JSON transmittal file here', 'error');
+                    }
+                    return;
+                }
+                await handleDataFileDrop(file, file.name);
+                return;
+            }
+
+            // ── File-table zone: directory or HTML/JSON ─────────────
+            if (zoneType === 'file-table') {
+                var ftItems = e.dataTransfer && e.dataTransfer.items;
+                var ftFirstItem = ftItems && ftItems.length > 0 ? ftItems[0] : null;
+                // Grab file synchronously before async work
+                var ftFile = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+
+                // Try directory first
+                if (ftFirstItem) {
+                    var wasDir = await handleDirectoryDrop(ftFirstItem);
+                    if (wasDir) { return; }
+                }
+
+                // Fall back to file-based import
+                if (!ftFile) { return; }
+                var ftName = (ftFile.name || '').toLowerCase();
+                if (!ftName.endsWith('.html') && !ftName.endsWith('.htm') && !ftName.endsWith('.json')) {
+                    if (app.modules.data && app.modules.data.setStatus) {
+                        app.modules.data.setStatus('Drop a folder, HTML, or JSON file here', 'error');
+                    }
+                    return;
+                }
+                await handleDataFileDrop(ftFile, ftFile.name);
+            }
+        });
+    }
+
+    // ── Initialization ──────────────────────────────────────────────────────
+    app.registerInit(function () {
+        document.querySelectorAll('[data-drop-zone]').forEach(wireZone);
+    });
+
+    dropZonesModule.classifyTransfer = classifyTransfer;
+    dropZonesModule.zoneIsEligible = zoneIsEligible;
+
+})(window.transmittalApp);
diff --git a/transmittal/js/email-tags.js b/transmittal/js/email-tags.js
new file mode 100644
index 0000000..d5e4b9d
--- /dev/null
+++ b/transmittal/js/email-tags.js
@@ -0,0 +1,114 @@
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+    function escapeHtml(str) {
+        return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    }
+
+    function escapeAttr(str) {
+        return str.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+    }
+
+    // Split on semicolons/commas but respect quoted strings
+    function splitRecipients(raw) {
+        var parts = [];
+        var current = '';
+        var inQuote = false;
+        for (var i = 0; i < raw.length; i++) {
+            var ch = raw[i];
+            if (ch === '"') {
+                inQuote = !inQuote;
+                current += ch;
+            } else if ((ch === ';' || ch === ',') && !inQuote) {
+                var trimmed = current.trim();
+                if (trimmed) { parts.push(trimmed); }
+                current = '';
+            } else {
+                current += ch;
+            }
+        }
+        var last = current.trim();
+        if (last) { parts.push(last); }
+        return parts;
+    }
+
+    // Extract email from entries like "Display Name <email@host.com>" or bare email
+    function extractEmail(entry) {
+        var angleMatch = entry.match(/<([^>]+)>/);
+        if (angleMatch && EMAIL_RE.test(angleMatch[1])) {
+            return angleMatch[1];
+        }
+        if (EMAIL_RE.test(entry)) {
+            return entry;
+        }
+        return null;
+    }
+
+    function renderRecipient(entry) {
+        var email = extractEmail(entry);
+        if (email) {
+            return '<a href="mailto:' + escapeAttr(email) + '" class="to-mailto">' + escapeHtml(entry) + '</a>';
+        }
+        return '<span>' + escapeHtml(entry) + '</span>';
+    }
+
+    function renderToField() {
+        var input = dom.qs('#to');
+        var render = dom.qs('#to-render');
+        if (!input || !render) { return; }
+
+        var raw = input.value || '';
+        var parts = splitRecipients(raw);
+        if (!parts.length) {
+            render.innerHTML = '';
+            return;
+        }
+
+        var html = parts.map(renderRecipient).join('<span class="to-sep">; </span>');
+        render.innerHTML = html;
+    }
+
+    function renderFromField() {
+        var input = dom.qs('#from');
+        var render = dom.qs('#from-render');
+        if (!input || !render) { return; }
+
+        var raw = (input.value || '').trim();
+        if (!raw) {
+            render.innerHTML = '';
+            return;
+        }
+
+        var email = extractEmail(raw);
+        if (email) {
+            render.innerHTML = '<a href="mailto:' + escapeAttr(email) + '" class="from-mailto">' + escapeHtml(raw) + '</a>';
+        } else {
+            render.innerHTML = '<span>' + escapeHtml(raw) + '</span>';
+        }
+    }
+
+    function init() {
+        var toInput = dom.qs('#to');
+        if (toInput) {
+            toInput.addEventListener('input', renderToField);
+            toInput.addEventListener('change', renderToField);
+            renderToField();
+        }
+        var fromInput = dom.qs('#from');
+        if (fromInput) {
+            fromInput.addEventListener('input', renderFromField);
+            fromInput.addEventListener('change', renderFromField);
+            renderFromField();
+        }
+    }
+
+    app.modules.emailTags = {
+        render: renderToField,
+        renderFrom: renderFromField
+    };
+
+    app.registerInit(init);
+})(window.transmittalApp);
diff --git a/transmittal/js/files-archive.js b/transmittal/js/files-archive.js
new file mode 100644
index 0000000..59dfaf2
--- /dev/null
+++ b/transmittal/js/files-archive.js
@@ -0,0 +1,214 @@
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+    var filesModule = app.modules.files;
+
+    var ARCHIVE_DIR_NAME = '.archive';
+
+    function sanitizeUrlSegment(value, fallback) {
+        var str = (value || '').toString().trim();
+        if (!str) {
+            return fallback;
+        }
+        var cleaned = str
+            .replace(/[^A-Za-z0-9._~-]+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '');
+        return cleaned || fallback;
+    }
+
+    function encodeRelativePath(path) {
+        return path.split('/').map(function (segment) {
+            return encodeURIComponent(segment);
+        }).join('/');
+    }
+
+    function buildRedirectHtml(targetHref, displayName) {
+        var safeHrefAttr = util.escapeHtmlAttribute(targetHref);
+        var safeLabel = util.escapeHtml(displayName || targetHref);
+        return '<!DOCTYPE html>\n' +
+            '<html lang="en">\n' +
+            '<head>\n' +
+            '<meta charset="utf-8">\n' +
+            '<meta http-equiv="refresh" content="0; url=' + safeHrefAttr + '">\n' +
+            '<title>' + safeLabel + '</title>\n' +
+            '</head>\n' +
+            '<body>\n' +
+            '<p>Redirecting to <a href="' + safeHrefAttr + '">' + safeLabel + '</a>.</p>\n' +
+            '</body>\n' +
+            '</html>\n';
+    }
+
+    async function ensureArchiveDirectory(rootHandle) {
+        return rootHandle.getDirectoryHandle(ARCHIVE_DIR_NAME, { create: true });
+    }
+
+    async function writeRedirectFile(directoryHandle, filename, html) {
+        var fileHandle = await directoryHandle.getFileHandle(filename, { create: true });
+        var writable = await fileHandle.createWritable();
+        await writable.write(new Blob([html], { type: 'text/html' }));
+        await writable.close();
+    }
+
+    function groupFilesByTracking(files) {
+        var map = new Map();
+        files.forEach(function (file) {
+            var key = file.trackingNumber || '';
+            if (!map.has(key)) {
+                map.set(key, []);
+            }
+            map.get(key).push(file);
+        });
+        return map;
+    }
+
+    function determineLatestByTracking(grouped) {
+        var latest = new Map();
+        grouped.forEach(function (files, tracking) {
+            if (!files || !files.length) {
+                return;
+            }
+            var sorted = files.slice().sort(function (a, b) {
+                var revisionCompare = util.compareRevisionPriority(a.revision, b.revision);
+                if (revisionCompare !== 0) {
+                    return revisionCompare;
+                }
+                var pathCompare = (a.path || '').localeCompare(b.path || '');
+                if (pathCompare !== 0) {
+                    return pathCompare;
+                }
+                return (a.name || '').localeCompare(b.name || '');
+            });
+            latest.set(tracking, sorted[sorted.length - 1]);
+        });
+        return latest;
+    }
+
+    function buildRedirectFilenames(file) {
+        var trackingSegment = sanitizeUrlSegment(file.trackingNumber || '', 'tracking');
+        var rawRevision = (file.revision || '').trim();
+        var revisionSegment = rawRevision ? sanitizeUrlSegment(rawRevision, 'rev') : '';
+        var rawHash = (file.sha256 || '').trim();
+        var hashSegment = rawHash ? sanitizeUrlSegment(rawHash, 'hash') : '';
+        var htmlSuffix = '.html';
+
+        var revisionFilename = revisionSegment ? (trackingSegment + '_' + revisionSegment + htmlSuffix) : '';
+        var hashFilename = hashSegment ? (hashSegment + htmlSuffix) : '';
+        var latestFilename = trackingSegment + htmlSuffix;
+
+        return {
+            latestFilename: latestFilename,
+            revisionFilename: revisionFilename,
+            hashFilename: hashFilename
+        };
+    }
+
+    async function resolveFileMetadata(entry) {
+        var parsed = zddc.parseFilename(entry.name || entry.path || '') || {};
+        if (!parsed.trackingNumber) {
+            return null;
+        }
+        var file = await entry.handle.getFile();
+        var sha256 = await util.hashFile(file);
+        return {
+            path: entry.path,
+            name: file.name,
+            extension: parsed.extension || zddc.splitExtension(file.name).extension,
+            trackingNumber: parsed.trackingNumber,
+            revision: parsed.revision,
+            status: parsed.status,
+            title: parsed.title,
+            sha256: sha256,
+            size: file.size
+        };
+    }
+
+    function buildRelativeHref(relativePath) {
+        var encoded = encodeRelativePath(relativePath);
+        return '../' + encoded;
+    }
+
+    async function createRedirectFiles(archiveHandle, file, isLatest) {
+        var filenames = buildRedirectFilenames(file);
+        var href = buildRelativeHref(file.path);
+        var html = buildRedirectHtml(href, file.name);
+
+        var writes = [];
+        if (filenames.revisionFilename) {
+            writes.push(writeRedirectFile(archiveHandle, filenames.revisionFilename, html));
+        }
+        if (filenames.hashFilename) {
+            writes.push(writeRedirectFile(archiveHandle, filenames.hashFilename, html));
+        }
+        if (isLatest) {
+            writes.push(writeRedirectFile(archiveHandle, filenames.latestFilename, html));
+        }
+
+        await Promise.all(writes);
+        return true;
+    }
+
+    async function pickIndexDirectory() {
+        if (typeof window.showDirectoryPicker !== 'function') {
+            throw new Error('File System Access API showDirectoryPicker is required');
+        }
+        return window.showDirectoryPicker();
+    }
+
+    filesModule.generateArchiveRedirects = async function generateArchiveRedirects() {
+        var rootHandle;
+        try {
+            rootHandle = await pickIndexDirectory();
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                console.log('[transmittal] Create Index cancelled.');
+                return;
+            }
+            throw err;
+        }
+
+        var overallStart = filesModule.nowMs();
+        var entries = await filesModule.collectDirectoryEntries(rootHandle);
+        if (!entries.length) {
+            console.log('[transmittal] Create Index: No files found.');
+            return;
+        }
+
+        var archiveHandle = await ensureArchiveDirectory(rootHandle);
+        var files = [];
+        for (var i = 0; i < entries.length; i++) {
+            try {
+                var metadata = await resolveFileMetadata(entries[i]);
+                if (metadata) {
+                    files.push(metadata);
+                }
+            } catch (err) {
+                console.warn('[transmittal] create-index skip', entries[i].path, err);
+            }
+        }
+        if (!files.length) {
+            console.log('[transmittal] Create Index: No ZDDC files found.');
+            return;
+        }
+
+        var grouped = groupFilesByTracking(files);
+        var latest = determineLatestByTracking(grouped);
+
+        var writePromises = files.map(function (file) {
+            var isLatest = latest.get(file.trackingNumber) === file;
+            return createRedirectFiles(archiveHandle, file, isLatest)
+                .catch(function (err) {
+                    console.error('[transmittal] create-index write failed', file.path, err);
+                    return null;
+                });
+        });
+
+        var results = await Promise.all(writePromises);
+        var created = results.filter(function (result) { return result !== null; }).length;
+
+        var totalElapsed = filesModule.nowMs() - overallStart;
+        console.log('[transmittal] Create Index: Generated redirects for ' + created + ' files in ' + filesModule.formatDuration(totalElapsed) + '.');
+    };
+})(window.transmittalApp);
diff --git a/transmittal/js/files-preview.js b/transmittal/js/files-preview.js
new file mode 100644
index 0000000..c2b29b7
--- /dev/null
+++ b/transmittal/js/files-preview.js
@@ -0,0 +1,585 @@
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+    var filesModule = app.modules.files;
+
+    // Blob URL cache keyed by file path
+    var blobCache = new Map();
+
+    // Current preview popup window reference
+    var previewWindow = null;
+
+    // Extensions that support rich in-browser preview
+    var PREVIEW_EXTENSIONS = ['pdf', 'docx', 'xlsx', 'xls'];
+
+    // Extensions that preview as images
+    var IMAGE_EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'bmp', 'ico'];
+
+    // Cache for lazily loaded CDN libraries
+    var loadedLibraries = new Map();
+
+    var MIME_TYPES = {
+        'pdf': 'application/pdf',
+        'doc': 'application/msword',
+        'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'xls': 'application/vnd.ms-excel',
+        'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'ppt': 'application/vnd.ms-powerpoint',
+        'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        'txt': 'text/plain',
+        'csv': 'text/csv',
+        'html': 'text/html',
+        'htm': 'text/html',
+        'xml': 'text/xml',
+        'json': 'application/json',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'png': 'image/png',
+        'gif': 'image/gif',
+        'bmp': 'image/bmp',
+        'svg': 'image/svg+xml',
+        'webp': 'image/webp',
+        'ico': 'image/x-icon',
+        'zip': 'application/zip',
+        'mp4': 'video/mp4',
+        'mp3': 'audio/mpeg',
+        'wav': 'audio/wav',
+        'md': 'text/markdown'
+    };
+
+    function getMimeType(ext) {
+        return MIME_TYPES[(ext || '').toLowerCase()] || 'application/octet-stream';
+    }
+
+    function loadLibrary(url) {
+        if (loadedLibraries.has(url)) {
+            return loadedLibraries.get(url);
+        }
+        var promise = new Promise(function (resolve, reject) {
+            var script = document.createElement('script');
+            script.src = url;
+            script.onload = resolve;
+            script.onerror = function () {
+                reject(new Error('Failed to load library: ' + url));
+            };
+            document.head.appendChild(script);
+        });
+        loadedLibraries.set(url, promise);
+        return promise;
+    }
+
+    function isPreviewable(ext) {
+        var lower = (ext || '').toLowerCase();
+        return PREVIEW_EXTENSIONS.indexOf(lower) !== -1 || IMAGE_EXTENSIONS.indexOf(lower) !== -1;
+    }
+
+    function hasFileSource(file) {
+        return !!(file.fileHandle || file.zipEntry);
+    }
+
+    async function getFileArrayBuffer(file) {
+        if (file.fileHandle) {
+            var fileData = await file.fileHandle.getFile();
+            return fileData.arrayBuffer();
+        }
+        if (file.zipEntry) {
+            return file.zipEntry.async('arraybuffer');
+        }
+        throw new Error('No file source available');
+    }
+
+    async function getFileBlobUrl(file) {
+        var cacheKey = file.path || file.name || '';
+        if (blobCache.has(cacheKey)) {
+            return blobCache.get(cacheKey);
+        }
+        var arrayBuffer = await getFileArrayBuffer(file);
+        var mimeType = getMimeType(file.extension);
+        var blob = new Blob([arrayBuffer], { type: mimeType });
+        var url = URL.createObjectURL(blob);
+        blobCache.set(cacheKey, url);
+        return url;
+    }
+
+    function cleanupBlobUrls() {
+        blobCache.forEach(function (url) {
+            URL.revokeObjectURL(url);
+        });
+        blobCache.clear();
+    }
+
+    function buildPreviewHtml(file, url) {
+        var ext = (file.extension || '').toLowerCase();
+        var safeName = util.escapeHtml(file.name || file.path || 'file');
+        var safeHref = util.escapeHtmlAttribute(url);
+
+        var contentHtml;
+        if (ext === 'pdf') {
+            contentHtml = '<iframe src="' + safeHref + '"></iframe>';
+        } else {
+            contentHtml = '<div id="previewContent"><div class="loading">Loading preview...</div></div>';
+        }
+
+        return '<!DOCTYPE html>\n' +
+            '<html>\n' +
+            '<head>\n' +
+            '<title>' + safeName + ' - Preview</title>\n' +
+            '<style>\n' +
+            '* { margin: 0; padding: 0; box-sizing: border-box; }\n' +
+            'body { display: flex; flex-direction: column; height: 100vh; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }\n' +
+            '.toolbar { display: flex; align-items: center; gap: 0.5rem; padding: 0.5rem 1rem; background: #f5f5f5; border-bottom: 1px solid #ddd; }\n' +
+            '.toolbar h1 { flex: 1; font-size: 0.95rem; font-weight: 500; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }\n' +
+            '.btn { padding: 0.4rem 0.8rem; font-size: 0.85rem; border: 1px solid #ccc; border-radius: 4px; background: white; cursor: pointer; }\n' +
+            '.btn:hover { background: #e8e8e8; }\n' +
+            'iframe { flex: 1; width: 100%; border: none; }\n' +
+            '#previewContent { flex: 1; overflow: auto; }\n' +
+            '.loading { display: flex; align-items: center; justify-content: center; height: 100%; color: #666; font-size: 1.1rem; }\n' +
+            '.docx-wrapper { padding: 1rem; }\n' +
+            '.xlsx-table { border-collapse: collapse; width: 100%; font-size: 0.85rem; }\n' +
+            '.xlsx-table th, .xlsx-table td { border: 1px solid #ddd; padding: 0.35rem 0.5rem; text-align: left; white-space: nowrap; }\n' +
+            '.xlsx-table th { background: #f0f0f0; font-weight: 600; position: sticky; top: 0; }\n' +
+            '.xlsx-table tr:nth-child(even) { background: #fafafa; }\n' +
+            '.xlsx-table tr:hover { background: #f0f7ff; }\n' +
+            '.sheet-tabs { display: flex; gap: 0; border-bottom: 1px solid #ddd; background: #f5f5f5; }\n' +
+            '.sheet-tab { padding: 0.4rem 1rem; cursor: pointer; border: 1px solid transparent; border-bottom: none; font-size: 0.85rem; background: transparent; }\n' +
+            '.sheet-tab:hover { background: #e8e8e8; }\n' +
+            '.sheet-tab.active { background: white; border-color: #ddd; border-bottom-color: white; margin-bottom: -1px; font-weight: 500; }\n' +
+            'img.preview-image { max-width: 100%; max-height: 100%; object-fit: contain; margin: auto; display: block; }\n' +
+            '</style>\n' +
+            '</head>\n' +
+            '<body>\n' +
+            '<div class="toolbar">\n' +
+            '<h1>' + safeName + '</h1>\n' +
+            '<button class="btn" onclick="downloadFile()">Download</button>\n' +
+            '</div>\n' +
+            contentHtml + '\n' +
+            '<script>\n' +
+            'var blobUrl = "' + url.replace(/"/g, '\\"') + '";\n' +
+            'var fileName = "' + safeName.replace(/"/g, '\\"') + '";\n' +
+            'function downloadFile() {\n' +
+            '  var a = document.createElement("a");\n' +
+            '  a.href = blobUrl;\n' +
+            '  a.download = fileName;\n' +
+            '  document.body.appendChild(a);\n' +
+            '  a.click();\n' +
+            '  document.body.removeChild(a);\n' +
+            '}\n' +
+            '</' + 'script>\n' +
+            '</body>\n' +
+            '</html>';
+    }
+
+    async function renderDocxInWindow(file) {
+        var container = previewWindow.document.getElementById('previewContent');
+        if (!container) {
+            return;
+        }
+        try {
+            await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+            await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+            var arrayBuffer = await getFileArrayBuffer(file);
+            container.innerHTML = '';
+            await window.docx.renderAsync(arrayBuffer, container);
+        } catch (err) {
+            console.error('[transmittal] Error rendering DOCX:', err);
+            container.innerHTML = '<div class="loading">Error rendering DOCX: ' + util.escapeHtml(err.message || '') + '<br>Click Download to view in Word.</div>';
+        }
+    }
+
+    async function renderXlsxInWindow(file) {
+        var container = previewWindow.document.getElementById('previewContent');
+        if (!container) {
+            return;
+        }
+        try {
+            await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+            var arrayBuffer = await getFileArrayBuffer(file);
+            var workbook = XLSX.read(arrayBuffer, { type: 'array' });
+            container.innerHTML = '';
+
+            var tableContainer = previewWindow.document.createElement('div');
+            tableContainer.style.flex = '1';
+            tableContainer.style.overflow = 'auto';
+
+            if (workbook.SheetNames.length > 1) {
+                var tabs = previewWindow.document.createElement('div');
+                tabs.className = 'sheet-tabs';
+                workbook.SheetNames.forEach(function (name, i) {
+                    var tab = previewWindow.document.createElement('button');
+                    tab.className = 'sheet-tab' + (i === 0 ? ' active' : '');
+                    tab.textContent = name;
+                    tab.addEventListener('click', function () {
+                        tabs.querySelectorAll('.sheet-tab').forEach(function (t) {
+                            t.classList.remove('active');
+                        });
+                        tab.classList.add('active');
+                        renderSheet(workbook, name, tableContainer);
+                    });
+                    tabs.appendChild(tab);
+                });
+                container.appendChild(tabs);
+            }
+
+            container.appendChild(tableContainer);
+            renderSheet(workbook, workbook.SheetNames[0], tableContainer);
+        } catch (err) {
+            console.error('[transmittal] Error rendering XLSX:', err);
+            container.innerHTML = '<div class="loading">Error rendering spreadsheet: ' + util.escapeHtml(err.message || '') + '<br>Click Download to view in Excel.</div>';
+        }
+    }
+
+    function renderSheet(workbook, sheetName, container) {
+        var sheet = workbook.Sheets[sheetName];
+        var html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+        container.innerHTML = html;
+        var table = container.querySelector('table');
+        if (table) {
+            table.className = 'xlsx-table';
+        }
+    }
+
+    async function renderImageInWindow(file, url) {
+        var container = previewWindow.document.getElementById('previewContent');
+        if (!container) {
+            return;
+        }
+        container.innerHTML = '';
+        var img = previewWindow.document.createElement('img');
+        img.className = 'preview-image';
+        img.src = url;
+        img.alt = file.name || '';
+        container.appendChild(img);
+    }
+
+    async function showFilePreview(file) {
+        var ext = (file.extension || '').toLowerCase();
+        try {
+            var url = await getFileBlobUrl(file);
+            var html = buildPreviewHtml(file, url);
+
+            if (previewWindow && !previewWindow.closed) {
+                previewWindow.document.open();
+                previewWindow.document.write(html);
+                previewWindow.document.close();
+                previewWindow.focus();
+            } else {
+                var width = Math.round(screen.width * 0.6);
+                var height = Math.round(screen.height * 0.8);
+                var left = Math.round((screen.width - width) / 2);
+                var top = Math.round((screen.height - height) / 2);
+                previewWindow = window.open('', 'filePreview',
+                    'width=' + width + ',height=' + height + ',left=' + left + ',top=' + top + ',resizable=yes,scrollbars=yes');
+                if (!previewWindow) {
+                    window.open(url, '_blank');
+                    return;
+                }
+                previewWindow.document.write(html);
+                previewWindow.document.close();
+                previewWindow.focus();
+            }
+
+            if (ext === 'docx') {
+                await renderDocxInWindow(file);
+            } else if (ext === 'xlsx' || ext === 'xls') {
+                await renderXlsxInWindow(file);
+            } else if (IMAGE_EXTENSIONS.indexOf(ext) !== -1) {
+                await renderImageInWindow(file, url);
+            }
+        } catch (err) {
+            console.error('[transmittal] Error loading file preview:', err);
+            alert('Error loading preview: ' + (err && err.message ? err.message : err));
+        }
+    }
+
+    // --- Load files for preview (directory or ZIP) ---
+
+    function updatePreviewStatus(text) {
+        var el = dom.qs('#preview-status');
+        if (el) {
+            el.textContent = text;
+        }
+    }
+
+    function matchFilesToSources(sourceEntries) {
+        var files = app.data.files || [];
+        if (!files.length || !sourceEntries.length) {
+            return 0;
+        }
+
+        // Build lookup by relative path and by filename
+        var byPath = new Map();
+        var byName = new Map();
+        sourceEntries.forEach(function (entry) {
+            if (entry.path) {
+                byPath.set(entry.path, entry);
+            }
+            if (entry.name) {
+                // Only use filename match if unique
+                if (byName.has(entry.name)) {
+                    byName.set(entry.name, null); // Mark as ambiguous
+                } else {
+                    byName.set(entry.name, entry);
+                }
+            }
+        });
+
+        var matched = 0;
+        files.forEach(function (file) {
+            var source = null;
+            // Try path match first
+            if (file.path && byPath.has(file.path)) {
+                source = byPath.get(file.path);
+            }
+            // Fall back to name match
+            if (!source && file.name) {
+                var nameMatch = byName.get(file.name);
+                if (nameMatch) {
+                    source = nameMatch;
+                }
+            }
+            if (source) {
+                if (source.fileHandle) {
+                    file.fileHandle = source.fileHandle;
+                }
+                if (source.zipEntry) {
+                    file.zipEntry = source.zipEntry;
+                }
+                matched += 1;
+            }
+        });
+        return matched;
+    }
+
+    async function loadFromDirectory() {
+        if (typeof window.showDirectoryPicker !== 'function') {
+            alert('Your browser does not support directory selection. Try Chrome or Edge.');
+            return;
+        }
+        var dirHandle;
+        try {
+            dirHandle = await window.showDirectoryPicker();
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                return;
+            }
+            throw err;
+        }
+        updatePreviewStatus('Scanning directory...');
+        var entries = await filesModule.collectDirectoryEntries(dirHandle);
+        var sourceEntries = entries.map(function (entry) {
+            return { path: entry.path, name: entry.name, fileHandle: entry.handle };
+        });
+        var matched = matchFilesToSources(sourceEntries);
+        if (matched > 0) {
+            filesLoadedForPreview = true;
+            updatePreviewStatus('from "' + dirHandle.name + '" — ' + matched + ' of ' + (app.data.files || []).length + ' files matched');
+            filesModule.render();
+        } else {
+            updatePreviewStatus('No matching files found in "' + dirHandle.name + '"');
+        }
+    }
+
+    async function loadFromZip() {
+        return new Promise(function (resolve) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = '.zip';
+            input.addEventListener('change', async function () {
+                var zipFile = input.files && input.files[0];
+                if (!zipFile) {
+                    resolve();
+                    return;
+                }
+                try {
+                    updatePreviewStatus('Loading ZIP...');
+                    await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+                    var arrayBuffer = await zipFile.arrayBuffer();
+                    var zip = await JSZip.loadAsync(arrayBuffer);
+                    var sourceEntries = [];
+                    zip.forEach(function (relativePath, zipEntry) {
+                        if (zipEntry.dir) {
+                            return;
+                        }
+                        // Strip the outermost folder if all entries share one
+                        var name = relativePath.split('/').pop();
+                        sourceEntries.push({
+                            path: relativePath,
+                            name: name,
+                            zipEntry: zipEntry
+                        });
+                    });
+
+                    // Try stripping common prefix for better path matching
+                    if (sourceEntries.length > 0) {
+                        var firstPath = sourceEntries[0].path;
+                        var prefix = firstPath.indexOf('/') !== -1 ? firstPath.substring(0, firstPath.indexOf('/') + 1) : '';
+                        if (prefix) {
+                            var allSharePrefix = sourceEntries.every(function (e) {
+                                return e.path.indexOf(prefix) === 0;
+                            });
+                            if (allSharePrefix) {
+                                sourceEntries.forEach(function (e) {
+                                    e.path = e.path.substring(prefix.length);
+                                });
+                            }
+                        }
+                    }
+
+                    var matched = matchFilesToSources(sourceEntries);
+                    if (matched > 0) {
+                        filesLoadedForPreview = true;
+                        updatePreviewStatus('from "' + zipFile.name + '" — ' + matched + ' of ' + (app.data.files || []).length + ' files matched');
+                        filesModule.render();
+                    } else {
+                        updatePreviewStatus('No matching files found in "' + zipFile.name + '"');
+                    }
+                } catch (err) {
+                    console.error('[transmittal] Error loading ZIP:', err);
+                    updatePreviewStatus('Failed to load ZIP: ' + (err && err.message ? err.message : err));
+                }
+                resolve();
+            });
+            input.click();
+        });
+    }
+
+    // Track whether files have been loaded for preview in view mode
+    var filesLoadedForPreview = false;
+
+    function isPreviewEnabled() {
+        var checkbox = dom.qs('#preview-toggle');
+        return checkbox && checkbox.checked;
+    }
+
+    function syncCheckboxToMode() {
+        var checkbox = dom.qs('#preview-toggle');
+        if (!checkbox) {
+            return;
+        }
+        if (app.state.mode === 'edit') {
+            checkbox.checked = true;
+            checkbox.disabled = true;
+            updatePreviewStatus('');
+        } else {
+            checkbox.disabled = false;
+            if (!filesLoadedForPreview) {
+                checkbox.checked = false;
+                updatePreviewStatus('');
+            }
+        }
+    }
+
+    function showSourcePicker() {
+        var bar = dom.qs('#preview-bar');
+        var existing = dom.qs('#preview-load-menu');
+        if (existing) {
+            existing.remove();
+            return;
+        }
+        var menu = document.createElement('div');
+        menu.id = 'preview-load-menu';
+        menu.style.cssText = 'position:absolute;z-index:50;background:white;border:1px solid #ccc;border-radius:4px;box-shadow:0 2px 8px rgba(0,0,0,0.15);padding:0.25rem 0;min-width:160px;';
+
+        function addOption(label, handler) {
+            var btn = document.createElement('button');
+            btn.type = 'button';
+            btn.textContent = label;
+            btn.style.cssText = 'display:block;width:100%;text-align:left;padding:0.4rem 0.75rem;border:none;background:none;cursor:pointer;font-size:0.8rem;';
+            btn.addEventListener('mouseenter', function () { btn.style.background = '#f0f0f0'; });
+            btn.addEventListener('mouseleave', function () { btn.style.background = 'none'; });
+            btn.addEventListener('click', function () {
+                menu.remove();
+                handler();
+            });
+            menu.appendChild(btn);
+        }
+
+        addOption('Select Directory', function () {
+            loadFromDirectory().then(function () {
+                if (!filesLoadedForPreview) {
+                    uncheckPreview();
+                }
+            }).catch(function (err) {
+                console.error('[transmittal] loadFromDirectory failed', err);
+                updatePreviewStatus('Failed: ' + (err && err.message ? err.message : err));
+                uncheckPreview();
+            });
+        });
+
+        addOption('Select ZIP File', function () {
+            loadFromZip().then(function () {
+                if (!filesLoadedForPreview) {
+                    uncheckPreview();
+                }
+            }).catch(function (err) {
+                console.error('[transmittal] loadFromZip failed', err);
+                updatePreviewStatus('Failed: ' + (err && err.message ? err.message : err));
+                uncheckPreview();
+            });
+        });
+
+        if (bar) {
+            bar.style.position = 'relative';
+            menu.style.top = '1.5rem';
+            menu.style.left = '0';
+            bar.appendChild(menu);
+        }
+
+        function closeMenu(e) {
+            if (!menu.contains(e.target)) {
+                menu.remove();
+                document.removeEventListener('click', closeMenu, true);
+            }
+        }
+        setTimeout(function () {
+            document.addEventListener('click', closeMenu, true);
+        }, 0);
+    }
+
+    function uncheckPreview() {
+        var checkbox = dom.qs('#preview-toggle');
+        if (checkbox) {
+            checkbox.checked = false;
+        }
+    }
+
+    function bindPreviewBar() {
+        var checkbox = dom.qs('#preview-toggle');
+        if (!checkbox) {
+            return;
+        }
+        checkbox.addEventListener('change', function () {
+            if (app.state.mode === 'edit') {
+                checkbox.checked = true;
+                return;
+            }
+            if (checkbox.checked) {
+                if (!filesLoadedForPreview) {
+                    showSourcePicker();
+                }
+            } else {
+                updatePreviewStatus('');
+            }
+        });
+        syncCheckboxToMode();
+    }
+
+    // Expose on filesModule
+    filesModule.isPreviewable = isPreviewable;
+    filesModule.hasFileSource = hasFileSource;
+    filesModule.isPreviewEnabled = isPreviewEnabled;
+    filesModule.syncPreviewCheckbox = syncCheckboxToMode;
+    filesModule.showFilePreview = showFilePreview;
+    filesModule.cleanupBlobUrls = cleanupBlobUrls;
+    filesModule.getFileArrayBuffer = getFileArrayBuffer;
+    filesModule.getFileBlobUrl = getFileBlobUrl;
+    filesModule.loadLibrary = loadLibrary;
+    filesModule.getMimeType = getMimeType;
+
+    app.registerInit(function () {
+        bindPreviewBar();
+        window.addEventListener('beforeunload', cleanupBlobUrls);
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/files-render.js b/transmittal/js/files-render.js
new file mode 100644
index 0000000..c381471
--- /dev/null
+++ b/transmittal/js/files-render.js
@@ -0,0 +1,585 @@
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+    var filesModule = app.modules.files;
+
+    // Build ZDDC filename from file row data — delegates to shared zddc.formatFilename()
+    function buildZddcFileName(fileData, droppedExt) {
+        var ext = (fileData.extension || droppedExt || '').toLowerCase().replace(/^\.+/, '');
+        return zddc.formatFilename({
+            trackingNumber: fileData.trackingNumber || '',
+            revision:       fileData.revision || '',
+            status:         fileData.status || '',
+            title:          fileData.title || '',
+            extension:      ext,
+        });
+    }
+
+    function setupRowDropTargets() {
+        if (app.state.mode !== 'edit') { return; }
+        var rows = document.querySelectorAll('table tbody tr:not(.self-entry)');
+        rows.forEach(function (row) {
+            row.addEventListener('dragover', function (e) {
+                if (app.state.mode !== 'edit') { return; }
+                e.preventDefault();
+                e.stopPropagation();
+                row.classList.add('ring-2', 'ring-blue-400', 'bg-blue-50');
+            });
+            row.addEventListener('dragleave', function () {
+                row.classList.remove('ring-2', 'ring-blue-400', 'bg-blue-50');
+            });
+            row.addEventListener('drop', async function (e) {
+                row.classList.remove('ring-2', 'ring-blue-400', 'bg-blue-50');
+                if (app.state.mode !== 'edit') { return; }
+                var droppedFile = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+                if (!droppedFile) { return; }
+                e.preventDefault();
+                e.stopPropagation();
+
+                var setStatus = app.modules.data && app.modules.data.setStatus;
+
+                // Prompt for directory if none selected
+                if (!app.data.selectedDirHandle) {
+                    try {
+                        app.data.selectedDirHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
+                        app.data.selectedDirName = app.data.selectedDirHandle.name || '';
+                        if (filesModule.updateDirectoryIndicator) {
+                            filesModule.updateDirectoryIndicator();
+                        }
+                    } catch (pickErr) {
+                        if (setStatus) { setStatus('A directory is required to copy files', 'error'); }
+                        return;
+                    }
+                }
+
+                var indexCell = row.querySelector('td[data-index]');
+                if (!indexCell) { return; }
+                var fileIndex = Number(indexCell.dataset.index);
+                var fileData = app.data.files[fileIndex];
+                if (!fileData) { return; }
+
+                var droppedExt = zddc.splitExtension(droppedFile.name).extension;
+                var zddcName = buildZddcFileName(fileData, droppedExt);
+                if (!zddcName) { zddcName = droppedFile.name; }
+
+                var hashCell = row.querySelector('td:last-child');
+                try {
+                    if (hashCell) { hashCell.textContent = 'copying\u2026'; }
+                    var dirHandle = app.data.selectedDirHandle;
+                    var newHandle = await dirHandle.getFileHandle(zddcName, { create: true });
+                    var writable = await newHandle.createWritable();
+                    await writable.write(droppedFile);
+                    await writable.close();
+
+                    if (hashCell) { hashCell.textContent = 'hashing\u2026'; }
+                    var written = await newHandle.getFile();
+                    var hash = await util.hashFile(written);
+
+                    fileData.fileHandle = newHandle;
+                    fileData.path = zddcName;
+                    fileData.name = zddcName;
+                    fileData.size = written.size;
+                    fileData.fileSize = written.size;
+                    fileData.sha256 = hash;
+                    if (!fileData.extension) { fileData.extension = droppedExt; }
+
+                    filesModule.updateFilesInJson(app.data.files);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    if (setStatus) { setStatus('Copied \u2192 ' + zddcName, 'success'); }
+                } catch (err) {
+                    console.error('[transmittal] row file drop failed', err);
+                    if (hashCell) { hashCell.textContent = 'error'; }
+                    if (setStatus) { setStatus('Drop failed: ' + (err.message || err), 'error'); }
+                }
+            });
+        });
+    }
+
+    filesModule.clearTable = function clearTable() {
+        var tbody = document.querySelector('table tbody');
+        if (tbody) { tbody.innerHTML = ''; }
+    };
+
+    filesModule.renderSingleRow = function renderSingleRow(file, index) {
+        var tbody = document.querySelector('table tbody');
+        if (!tbody) { return null; }
+        var row = document.createElement('tr');
+
+        var numCell = document.createElement('td');
+        numCell.className = 'px-2 py-1 align-top text-center text-gray-400';
+        numCell.textContent = String(index + 1);
+        row.appendChild(numCell);
+
+        var trackingCell = document.createElement('td');
+        trackingCell.className = 'px-2 py-1 align-top whitespace-nowrap font-mono';
+        var link = document.createElement('a');
+        link.textContent = file.trackingNumber || '';
+        var relativePath = file.path || file.name || '';
+        if (relativePath) {
+            link.href = encodeURI(relativePath);
+            link.dataset.relativePath = relativePath;
+        } else {
+            link.href = '#';
+        }
+        link.title = relativePath || (file.name || '');
+        link.className = 'text-blue-600 hover:underline';
+        var ext = (file.extension || zddc.splitExtension(relativePath).extension);
+        if (app.constants.viewableExts.indexOf(ext) !== -1) {
+            link.target = '_blank';
+            link.rel = 'noopener';
+        } else {
+            var filename = (relativePath.split('/').pop() || file.name || 'download');
+            link.setAttribute('download', filename);
+        }
+        trackingCell.appendChild(link);
+        trackingCell.contentEditable = 'false';
+        trackingCell.dataset.index = String(index);
+        trackingCell.dataset.field = 'trackingNumber';
+        row.appendChild(trackingCell);
+
+        var titleCell = document.createElement('td');
+        titleCell.className = 'px-2 py-1 align-top whitespace-normal break-words w-full';
+        titleCell.textContent = file.title || '';
+        titleCell.contentEditable = (app.state.mode === 'edit').toString();
+        titleCell.setAttribute('role', 'textbox');
+        titleCell.setAttribute('aria-multiline', 'false');
+        titleCell.setAttribute('tabindex', '0');
+        titleCell.dataset.index = String(index);
+        titleCell.dataset.field = 'title';
+        row.appendChild(titleCell);
+
+        var revisionCell = document.createElement('td');
+        revisionCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+        revisionCell.textContent = file.revision || '';
+        revisionCell.contentEditable = (app.state.mode === 'edit').toString();
+        revisionCell.setAttribute('role', 'textbox');
+        revisionCell.setAttribute('aria-multiline', 'false');
+        revisionCell.setAttribute('tabindex', '0');
+        revisionCell.dataset.index = String(index);
+        revisionCell.dataset.field = 'revision';
+        row.appendChild(revisionCell);
+
+        var statusCell = document.createElement('td');
+        statusCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+        statusCell.textContent = file.status || '';
+        statusCell.contentEditable = (app.state.mode === 'edit').toString();
+        statusCell.setAttribute('role', 'textbox');
+        statusCell.setAttribute('aria-multiline', 'false');
+        statusCell.setAttribute('tabindex', '0');
+        statusCell.dataset.index = String(index);
+        statusCell.dataset.field = 'status';
+        row.appendChild(statusCell);
+
+        var extCell = document.createElement('td');
+        extCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+        extCell.textContent = (file.extension || '').toLowerCase();
+        extCell.contentEditable = 'false';
+        row.appendChild(extCell);
+
+        var sizeCell = document.createElement('td');
+        sizeCell.className = 'px-2 py-1 align-top whitespace-nowrap text-right font-mono';
+        var fileSizeValue = (file.fileSize != null ? file.fileSize : file.size);
+        sizeCell.textContent = util.formatFileSize(fileSizeValue);
+        sizeCell.contentEditable = 'false';
+        row.appendChild(sizeCell);
+
+        var hashCell = document.createElement('td');
+        hashCell.className = 'px-2 py-1 align-top font-mono text-[9px] whitespace-normal break-all leading-snug';
+        if (file.sha256) {
+            hashCell.textContent = util.formatShortFileHash(file.sha256);
+        } else {
+            var prog = document.createElement('div');
+            prog.className = 'hash-progress';
+            var bar = document.createElement('div');
+            bar.className = 'hash-progress-bar';
+            var fill = document.createElement('div');
+            fill.className = 'hash-progress-fill';
+            bar.appendChild(fill);
+            prog.appendChild(bar);
+            hashCell.appendChild(prog);
+        }
+        row.appendChild(hashCell);
+
+        tbody.appendChild(row);
+        return hashCell;
+    };
+
+    function renderSelfRow(tbody, rowNum) {
+        var self = filesModule.buildSelfEntry ? filesModule.buildSelfEntry() : null;
+        if (!self) { return; }
+        var row = document.createElement('tr');
+        row.className = 'self-entry';
+
+        var numCell = document.createElement('td');
+        numCell.className = 'px-2 py-1 align-top text-center text-gray-400';
+        numCell.textContent = String(rowNum);
+        row.appendChild(numCell);
+
+        var trackingCell = document.createElement('td');
+        trackingCell.className = 'px-2 py-1 align-top whitespace-nowrap font-mono text-gray-500';
+        var selfPath = self.path || self.name || '';
+        if (selfPath) {
+            var link = document.createElement('a');
+            link.href = encodeURI(selfPath);
+            link.textContent = self.trackingNumber || '';
+            link.className = 'text-gray-500 hover:underline';
+            link.target = '_blank';
+            link.rel = 'noopener';
+            trackingCell.appendChild(link);
+        } else {
+            trackingCell.textContent = self.trackingNumber || '';
+        }
+        row.appendChild(trackingCell);
+
+        var titleCell = document.createElement('td');
+        titleCell.className = 'px-2 py-1 align-top whitespace-normal break-words w-full text-gray-500';
+        titleCell.textContent = self.title || '';
+        row.appendChild(titleCell);
+
+        var revisionCell = document.createElement('td');
+        revisionCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono text-gray-500';
+        revisionCell.textContent = self.revision || '';
+        row.appendChild(revisionCell);
+
+        var statusCell = document.createElement('td');
+        statusCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono text-gray-500';
+        statusCell.textContent = self.status || '';
+        row.appendChild(statusCell);
+
+        var extCell = document.createElement('td');
+        extCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono text-gray-500';
+        extCell.textContent = 'html';
+        row.appendChild(extCell);
+
+        var sizeCell = document.createElement('td');
+        sizeCell.className = 'px-2 py-1 align-top whitespace-nowrap text-right font-mono text-gray-400';
+        sizeCell.textContent = '\u2014';
+        row.appendChild(sizeCell);
+
+        var hashCell = document.createElement('td');
+        hashCell.className = 'px-2 py-1 align-top font-mono text-[9px] whitespace-nowrap text-gray-400 italic';
+        hashCell.textContent = 'see above';
+        row.appendChild(hashCell);
+
+        tbody.appendChild(row);
+    }
+
+    filesModule.render = function render() {
+        var tbody = document.querySelector('table tbody');
+        if (!tbody) {
+            return;
+        }
+        tbody.innerHTML = '';
+        filesModule.sortFilesInPlace(app.data.files);
+        var filters = app.modules.filters ? app.modules.filters.getActiveFilters() : {};
+        var filtered = [];
+        (app.data.files || []).forEach(function (file, originalIndex) {
+            if (!app.modules.filters || app.modules.filters.fileMatchesFilters(file, filters)) {
+                filtered.push({ file: file, index: originalIndex });
+            }
+        });
+
+        // Row 0: transmittal self-entry (always pinned first)
+        renderSelfRow(tbody, 0);
+
+        var rowNum = 0;
+        filtered.forEach(function (entry) {
+            var file = entry.file;
+            var index = entry.index;
+            var row = document.createElement('tr');
+            rowNum++;
+
+            var numCell = document.createElement('td');
+            numCell.className = 'px-2 py-1 align-top text-center text-gray-400 whitespace-nowrap';
+            if (app.state.mode === 'edit') {
+                var delBtn = document.createElement('button');
+                delBtn.type = 'button';
+                delBtn.className = 'row-delete-btn';
+                delBtn.textContent = '\u00d7';
+                delBtn.title = 'Remove this file';
+                delBtn.dataset.fileIndex = String(index);
+                numCell.appendChild(delBtn);
+                var numSpan = document.createElement('span');
+                numSpan.textContent = String(rowNum);
+                numCell.appendChild(numSpan);
+            } else {
+                numCell.textContent = String(rowNum);
+            }
+            row.appendChild(numCell);
+
+            var trackingCell = document.createElement('td');
+            trackingCell.className = 'px-2 py-1 align-top whitespace-nowrap font-mono';
+            var link = document.createElement('a');
+            link.textContent = file.trackingNumber || '';
+            var relativePath = file.path || file.name || '';
+            if (relativePath) {
+                link.href = encodeURI(relativePath);
+                link.dataset.relativePath = relativePath;
+            } else {
+                link.href = '#';
+            }
+            link.title = relativePath || (file.name || '');
+            link.className = 'text-blue-600 hover:underline';
+            var ext = (file.extension || zddc.splitExtension(relativePath).extension);
+            if (app.constants.viewableExts.indexOf(ext) !== -1) {
+                link.target = '_blank';
+                link.rel = 'noopener';
+            } else {
+                var filename = (relativePath.split('/').pop() || file.name || 'download');
+                link.setAttribute('download', filename);
+            }
+            trackingCell.appendChild(link);
+            trackingCell.contentEditable = 'false';
+            trackingCell.dataset.index = String(index);
+            trackingCell.dataset.field = 'trackingNumber';
+            row.appendChild(trackingCell);
+
+            var titleCell = document.createElement('td');
+            titleCell.className = 'px-2 py-1 align-top whitespace-normal break-words w-full';
+            titleCell.textContent = file.title || '';
+            titleCell.contentEditable = (app.state.mode === 'edit').toString();
+            titleCell.setAttribute('role', 'textbox');
+            titleCell.setAttribute('aria-multiline', 'false');
+            titleCell.setAttribute('tabindex', '0');
+            titleCell.dataset.index = String(index);
+            titleCell.dataset.field = 'title';
+            row.appendChild(titleCell);
+
+            var revisionCell = document.createElement('td');
+            revisionCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+            revisionCell.textContent = file.revision || '';
+            revisionCell.contentEditable = (app.state.mode === 'edit').toString();
+            revisionCell.setAttribute('role', 'textbox');
+            revisionCell.setAttribute('aria-multiline', 'false');
+            revisionCell.setAttribute('tabindex', '0');
+            revisionCell.dataset.index = String(index);
+            revisionCell.dataset.field = 'revision';
+            row.appendChild(revisionCell);
+
+            var statusCell = document.createElement('td');
+            statusCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+            statusCell.textContent = file.status || '';
+            statusCell.contentEditable = (app.state.mode === 'edit').toString();
+            statusCell.setAttribute('role', 'textbox');
+            statusCell.setAttribute('aria-multiline', 'false');
+            statusCell.setAttribute('tabindex', '0');
+            statusCell.dataset.index = String(index);
+            statusCell.dataset.field = 'status';
+            row.appendChild(statusCell);
+
+            var extCell = document.createElement('td');
+            extCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+            extCell.textContent = (file.extension || '').toLowerCase();
+            extCell.contentEditable = 'false';
+            row.appendChild(extCell);
+
+            var sizeCell = document.createElement('td');
+            sizeCell.className = 'px-2 py-1 align-top whitespace-nowrap text-right font-mono';
+            var isUnmatched = !file.fileHandle && !file.sha256;
+            if (isUnmatched) {
+                sizeCell.textContent = '\u2014';
+                sizeCell.classList.add('text-gray-400');
+            } else {
+                var fileSizeValue = (file.fileSize != null ? file.fileSize : file.size);
+                sizeCell.textContent = util.formatFileSize(fileSizeValue);
+            }
+            sizeCell.contentEditable = 'false';
+            row.appendChild(sizeCell);
+
+            var hashCell = document.createElement('td');
+            hashCell.className = 'px-2 py-1 align-top font-mono text-[9px] whitespace-normal break-all leading-snug';
+            if (isUnmatched) {
+                hashCell.textContent = 'pending';
+                hashCell.classList.add('italic', 'text-gray-400');
+            } else {
+                hashCell.textContent = util.formatShortFileHash(file.sha256 || '');
+            }
+            row.appendChild(hashCell);
+
+            if (file._verifyResult) {
+                row.classList.add('verify-' + file._verifyResult);
+            }
+
+            tbody.appendChild(row);
+        });
+
+        if (!filtered.length) {
+            var placeholderRow = document.createElement('tr');
+            for (var i = 0; i < 8; i += 1) {
+                var cell = document.createElement('td');
+                cell.className = 'px-2 py-1 align-top';
+                placeholderRow.appendChild(cell);
+            }
+            tbody.appendChild(placeholderRow);
+        }
+
+        if (app.modules.filters && typeof app.modules.filters.refreshPlaceholders === 'function') {
+            app.modules.filters.refreshPlaceholders();
+        }
+        setupRowDropTargets();
+    };
+
+    // Undo state for row deletion
+    var _lastDeleted = null;
+    var _undoTimer = null;
+
+    function deleteFileRow(fileIndex) {
+        var file = app.data.files[fileIndex];
+        if (!file) { return; }
+        var setStatus = app.modules.data && app.modules.data.setStatus;
+        var label = (file.trackingNumber || '') + (file.title ? ' - ' + file.title : '');
+
+        // Store for undo
+        _lastDeleted = { file: file, index: fileIndex };
+        if (_undoTimer) { clearTimeout(_undoTimer); }
+        _undoTimer = setTimeout(function () { _lastDeleted = null; }, 10000);
+
+        app.data.files.splice(fileIndex, 1);
+        filesModule.updateFilesInJson(app.data.files);
+        filesModule.render();
+        app.state.apply();
+        app.markDirty();
+
+        if (setStatus) {
+            setStatus('Removed ' + (label || 'row') + '  — click here to undo', 'success');
+            // Attach one-time undo click handler to status bar
+            var statusEl = document.querySelector('#data-status');
+            if (statusEl) {
+                statusEl.style.cursor = 'pointer';
+                var cleanup = function () {
+                    statusEl.removeEventListener('click', handler);
+                    statusEl.style.cursor = '';
+                };
+                var handler = function () {
+                    cleanup();
+                    if (!_lastDeleted) { return; }
+                    var d = _lastDeleted;
+                    _lastDeleted = null;
+                    if (_undoTimer) { clearTimeout(_undoTimer); _undoTimer = null; }
+                    var idx = Math.min(d.index, app.data.files.length);
+                    app.data.files.splice(idx, 0, d.file);
+                    filesModule.updateFilesInJson(app.data.files);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    if (setStatus) { setStatus('Restored ' + (label || 'row'), 'success'); }
+                };
+                // Clear cursor when undo expires
+                if (_undoTimer) { clearTimeout(_undoTimer); }
+                _undoTimer = setTimeout(function () { _lastDeleted = null; cleanup(); }, 10000);
+                statusEl.addEventListener('click', handler);
+            }
+        }
+    }
+
+    filesModule.setupTableEditing = function setupTableEditing() {
+        var tbody = document.querySelector('table tbody');
+        if (!tbody) {
+            return;
+        }
+        // Delegated handler for row delete buttons
+        tbody.addEventListener('click', function (event) {
+            var delBtn = event.target.closest('.row-delete-btn');
+            if (delBtn && delBtn.dataset.fileIndex !== undefined) {
+                event.preventDefault();
+                event.stopPropagation();
+                deleteFileRow(Number(delBtn.dataset.fileIndex));
+                return;
+            }
+        });
+        // Click delegation for file preview
+        // Edit mode: always preview (relative paths don't work until HTML is saved)
+        // View mode: preview only when checkbox is checked and file source is loaded
+        tbody.addEventListener('click', function (event) {
+            var link = event.target.closest('a');
+            if (!link) {
+                return;
+            }
+            var cell = link.closest('td');
+            if (!cell || !cell.dataset.index) {
+                return;
+            }
+            var file = app.data.files[Number(cell.dataset.index)];
+            if (!file || !filesModule.hasFileSource || !filesModule.hasFileSource(file)) {
+                return;
+            }
+            var usePreview = (app.state.mode === 'edit') ||
+                (filesModule.isPreviewEnabled && filesModule.isPreviewEnabled()) ||
+                !!(file.fileHandle);
+            if (usePreview) {
+                event.preventDefault();
+                event.stopPropagation();
+                filesModule.showFilePreview(file);
+            }
+        });
+        tbody.addEventListener('input', function (event) {
+            var target = event.target;
+            if (!(target instanceof HTMLElement)) {
+                return;
+            }
+            var index = target.dataset.index;
+            var field = target.dataset.field;
+            if (index === undefined || !field) {
+                return;
+            }
+            var entry = app.data.files[Number(index)];
+            if (!entry) {
+                return;
+            }
+            entry[field] = (target.textContent || '').replace(/\r?\n/g, ' ').trim();
+            filesModule.sortFilesInPlace(app.data.files);
+            filesModule.updateFilesInJson(app.data.files);
+            filesModule.render();
+            app.markDirty();
+            if (app.modules.liveDigest && app.modules.liveDigest.schedule) {
+                app.modules.liveDigest.schedule();
+            }
+        });
+        tbody.addEventListener('keydown', function (event) {
+            var target = event.target;
+            if (!(target instanceof HTMLElement)) {
+                return;
+            }
+            if (target.isContentEditable && event.key === 'Enter') {
+                event.preventDefault();
+            }
+        });
+        tbody.addEventListener('paste', function (event) {
+            var target = event.target;
+            if (!(target instanceof HTMLElement)) {
+                return;
+            }
+            if (!target.isContentEditable) {
+                return;
+            }
+            event.preventDefault();
+            var text = (event.clipboardData || window.clipboardData).getData('text');
+            var sanitized = (text || '').replace(/\r?\n/g, ' ');
+            try {
+                document.execCommand('insertText', false, sanitized);
+            } catch (err) {
+                target.textContent = (target.textContent || '') + sanitized;
+            }
+        });
+    };
+
+    filesModule.handleClear = function handleClear() {
+        if (app.state.mode !== 'edit') {
+            return;
+        }
+        if (filesModule.cleanupBlobUrls) {
+            filesModule.cleanupBlobUrls();
+        }
+        app.data.files = [];
+        app.data.selectedDirHandle = null;
+        filesModule.updateDirectoryIndicator('');
+        filesModule.updateFilesInJson([]);
+        filesModule.render();
+        app.state.apply();
+        app.markDirty();
+    };
+})(window.transmittalApp);
diff --git a/transmittal/js/files.js b/transmittal/js/files.js
new file mode 100644
index 0000000..9b3f3c8
--- /dev/null
+++ b/transmittal/js/files.js
@@ -0,0 +1,1542 @@
+(function (app) {
+    'use strict';
+
+    const DEBUG = false; // Set to true to enable verbose logging
+
+    const dom = app.dom;
+    const json = app.json;
+    const util = app.util;
+
+    const filesModule = app.modules.files = {};
+
+    var hasFileSystemAccess = typeof window.showDirectoryPicker === 'function';
+
+    function requireFileSystemAccess() {
+        if (hasFileSystemAccess) { return true; }
+        alert('This feature requires the File System Access API.\n\nPlease use a Chromium-based browser on desktop.');
+        return false;
+    }
+
+    function hasFiles() {
+        return Array.isArray(app.data.files) && app.data.files.length > 0;
+    }
+
+    // Three primary-button states: 'scan', 'verify', 'publish'
+    var _primaryIntent = null; // null = auto-detect, or explicit 'scan'|'verify'|'publish'
+    var _primaryHandler = null;
+
+    function setPrimary(intent) {
+        _primaryIntent = intent;
+        updateToolbars();
+    }
+
+    function setScanningState(active) {
+        var wrapper = document.querySelector('.table-wrapper');
+        if (!wrapper) { return; }
+        if (active) {
+            wrapper.classList.add('scanning');
+        } else {
+            wrapper.classList.remove('scanning');
+        }
+    }
+
+    function nowMs() {
+        if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+            return performance.now();
+        }
+        return Date.now();
+    }
+
+    function formatDuration(ms) {
+        const totalSeconds = Math.max(0, Math.round(ms / 1000));
+        const minutes = Math.floor(totalSeconds / 60);
+        const seconds = totalSeconds % 60;
+        if (minutes > 0) {
+            return minutes + 'm ' + seconds.toString().padStart(2, '0') + 's';
+        }
+        return seconds + 's';
+    }
+
+    // ── File handle permission and refresh helpers ─────────────────────
+
+    async function ensureDirHandlePermission(dirHandle) {
+        if (!dirHandle || typeof dirHandle.requestPermission !== 'function') {
+            return;
+        }
+        const permissionDescriptor = { mode: 'readwrite' };
+        const current = await dirHandle.queryPermission(permissionDescriptor);
+        if (current === 'granted') {
+            return;
+        }
+        // Request permission (requires user gesture in most browsers)
+        const result = await dirHandle.requestPermission(permissionDescriptor);
+        if (result !== 'granted') {
+            throw new Error('Read/write permission is required for the selected directory');
+        }
+    }
+
+    async function getFreshFile(fileHandle, fallbackData) {
+        if (!fileHandle || typeof fileHandle.getFile !== 'function') {
+            throw new Error('No valid file handle');
+        }
+
+        // Check permission state before attempting to get file
+        try {
+            const current = await fileHandle.queryPermission({ mode: 'read' });
+            if (current !== 'granted') {
+                // Try to request permission (will fail without user gesture)
+                try {
+                    await fileHandle.requestPermission({ mode: 'read' });
+                } catch (permErr) {
+                    // Permission request failed (likely no user gesture), skip with warning
+                    console.warn('[transmittal] Permission request failed for file:', fileHandle.name || 'unknown', permErr);
+                }
+                // Check permission again after potential request
+                const newPerm = await fileHandle.queryPermission({ mode: 'read' });
+                if (newPerm !== 'granted') {
+                    if (fallbackData) {
+                        // Use fallback data instead of throwing
+                        console.log('[transmittal] Permission not granted, using fallback for ' + (fallbackData.path || fallbackData.name || 'unknown file'));
+                        return fallbackData;
+                    }
+                    throw new Error('Permission denied for file access');
+                }
+            }
+        } catch (err) {
+            // queryPermission not supported or error
+            console.warn('[transmittal] Permission check error:', err);
+        }
+
+        try {
+            return await fileHandle.getFile();
+        } catch (err) {
+            if (err && err.name === 'NotReadableError') {
+                if (fallbackData) {
+                    console.log('[transmittal] NotReadableError, using fallback for ' + (fallbackData.path || fallbackData.name || 'unknown file'));
+                    return fallbackData;
+                }
+                throw err;
+            }
+            throw err;
+        }
+    }
+
+    function updateDirectoryIndicator(name) {
+        var indicator = dom.qs('#selected-directory');
+        if (indicator) {
+            indicator.textContent = name ? name : '';
+        }
+        updateToolbars();
+    }
+
+    function sortFilesInPlace(list) {
+        if (!Array.isArray(list)) {
+            return;
+        }
+        list.sort(util.compareFilesByTrackingRevision);
+    }
+
+    function buildFileHandleMap(files) {
+        var map = {};
+        (files || []).forEach(function (f) {
+            if (f.fileHandle) {
+                var key = (f.path || f.name || '').toLowerCase();
+                if (key) { map[key] = f.fileHandle; }
+            }
+        });
+        return map;
+    }
+
+    function restoreFileHandles(files, handleMap) {
+        (files || []).forEach(function (f) {
+            var key = (f.path || f.name || '').toLowerCase();
+            if (key && handleMap[key]) {
+                f.fileHandle = handleMap[key];
+            }
+        });
+    }
+
+    function selfEntryDate() {
+        var raw = (dom.qs('#date') || {}).value || '';
+        var trimmed = raw.trim();
+        if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) { return trimmed; }
+        var d = new Date(trimmed);
+        if (!isNaN(d.getTime())) { return d.toISOString().slice(0, 10); }
+        return trimmed;
+    }
+
+    function buildSelfEntry() {
+        var tracking = (dom.qs('#tracking-number') || {}).value || '';
+        var subject = (dom.qs('#subject') || {}).value || '';
+        var title = (dom.qs('#title') || {}).value || '';
+        var date = selfEntryDate();
+        var purpose = (dom.qs('#purpose') || {}).value || '';
+        var d = app.modules.data;
+        var filename = (d && d.buildFileName)
+            ? d.buildFileName({ trackingNumber: tracking, title: title, date: date, purpose: purpose }, { extension: 'html' })
+            : '';
+        return {
+            _isSelf: true,
+            path: filename ? ('./' + filename) : '',
+            name: filename || '',
+            trackingNumber: tracking,
+            title: subject || title,
+            revision: date,
+            status: purpose,
+            extension: 'html',
+            size: 0,
+            fileSize: 0,
+            sha256: app.constants.SELF_HASH
+        };
+    }
+
+    filesModule.buildSelfEntry = buildSelfEntry;
+
+    function canonicalFilePayload(entry) {
+        const relativePath = entry.path || entry.name || '';
+        const filename = relativePath.split('/').pop() || entry.name || '';
+        const pathOnly = relativePath.substring(0, relativePath.lastIndexOf('/')) || '';
+        return {
+            trackingNumber: entry.trackingNumber || '',
+            revision: entry.revision || '',
+            status: entry.status || '',
+            title: entry.title || '',
+            path: pathOnly,
+            filename: filename,
+            extension: entry.extension || '',
+            sha256: entry.sha256 || '',
+            fileSize: Number(entry.fileSize || entry.size || 0)
+        };
+    }
+
+    function updateFilesInJson(files) {
+        const data = json.parse();
+        const envelope = { ...(data.envelope || {}) };
+        const payload = { ...(data.payload || {}) };
+        const presentation = { ...(data.presentation || {}) };
+        
+        const sorted = (Array.isArray(files) ? files : []).slice().sort(util.compareFilesByTrackingRevision);
+        // Prepend self-entry, then regular files
+        var selfEntry = buildSelfEntry();
+        payload.files = [canonicalFilePayload(selfEntry)].concat(sorted.map(canonicalFilePayload));
+        
+        // Clear digest when files change (invalidates signatures)
+        envelope.digest = '';
+        envelope.digestedAt = '';
+        envelope.signatures = [];
+        
+        json.setData({ envelope: envelope, payload: payload, presentation: presentation });
+    }
+
+    var ARCHIVE_DIR_NAME = '.archive';
+    var MAX_DIRECTORY_DEPTH = 48;
+
+    function isHiddenName(name) {
+        return !!name && name.startsWith('.');
+    }
+
+    function shouldSkipDirectorySegment(name) {
+        if (!name) {
+            return false;
+        }
+        if (name === ARCHIVE_DIR_NAME) {
+            return true;
+        }
+        return isHiddenName(name);
+    }
+
+    async function collectFilesRecursive(handle, relPath, out, depth) {
+        const currentDepth = depth || 0;
+        if (DEBUG) console.log('[transmittal] collectFilesRecursive:', relPath, 'depth:', currentDepth, 'kind:', handle.kind);
+        
+        if (currentDepth > MAX_DIRECTORY_DEPTH) {
+            throw new Error('Directory nesting exceeds supported depth');
+        }
+        if (handle.kind === 'file') {
+            if (isHiddenName(handle.name)) {
+                if (DEBUG) console.log('[transmittal] Skipping hidden file:', relPath);
+                return;
+            }
+            if (DEBUG) console.log('[transmittal] Adding file to collection:', relPath);
+            out.push({ handle, path: relPath, name: handle.name });
+            return;
+        }
+        if (handle.kind !== 'directory') {
+            if (DEBUG) console.log('[transmittal] Unknown handle kind:', handle.kind, 'for', relPath);
+            return;
+        }
+        if (shouldSkipDirectorySegment(handle.name) && relPath) {
+            if (DEBUG) console.log('[transmittal] Skipping directory segment:', relPath);
+            return;
+        }
+        try {
+            if (DEBUG) console.log('[transmittal] Iterating directory:', relPath || 'root');
+            let childCount = 0;
+            for await (const child of handle.values()) {
+                childCount++;
+                if (DEBUG) console.log('[transmittal] Found child #' + childCount + ':', child.name, 'kind:', child.kind);
+                if (shouldSkipDirectorySegment(child.name)) {
+                    continue;
+                }
+                const childPath = relPath ? (relPath + '/' + child.name) : child.name;
+                if (DEBUG) console.log('[transmittal] Recursing into:', childPath);
+                await collectFilesRecursive(child, childPath, out, currentDepth + 1);
+            }
+            if (DEBUG) console.log('[transmittal] Finished iterating directory:', relPath || 'root', 'found', childCount, 'children');
+        } catch (err) {
+            if (err && err.name === 'NotFoundError') {
+                console.error('[transmittal] NotFoundError during directory traversal:', relPath || handle.name || '', {
+                    error: err,
+                    message: err.message,
+                    stack: err.stack,
+                    handleName: handle.name,
+                    handleKind: handle.kind
+                });
+                return;
+            }
+            console.error('[transmittal] Unexpected error during directory traversal:', relPath, err);
+            throw err;
+        }
+    }
+
+    async function collectDirectoryEntries(rootHandle) {
+        const entries = [];
+        
+        if (!rootHandle || rootHandle.kind !== 'directory') {
+            throw new Error('Invalid directory handle provided');
+        }
+        
+        try {
+            // Start directory scan
+            if (DEBUG) console.log('[transmittal] Starting directory scan for:', rootHandle.name);
+            
+            for await (const child of rootHandle.values()) {
+                if (shouldSkipDirectorySegment(child.name)) {
+                    continue;
+                }
+                const childPath = child.name;
+                try {
+                    await collectFilesRecursive(child, childPath, entries, 1);
+                } catch (err) {
+                    if (err && err.name === 'NotFoundError') {
+                        console.warn('[transmittal] directory entry missing', childPath, err);
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+        } catch (err) {
+            if (err && err.name === 'NotFoundError') {
+                console.error('[transmittal] NotFoundError during directory scan', {
+                    error: err,
+                    message: err.message,
+                    stack: err.stack,
+                    handle: rootHandle,
+                    handleName: rootHandle.name
+                });
+                // Return empty entries instead of throwing
+                return entries;
+            }
+            console.error('[transmittal] Unexpected error during directory scan', err);
+            throw err;
+        }
+        return entries;
+    }
+
+    // Promote shared helpers to filesModule for use by sub-modules
+    filesModule.nowMs = nowMs;
+    filesModule.formatDuration = formatDuration;
+    filesModule.updateDirectoryIndicator = updateDirectoryIndicator;
+    filesModule.sortFilesInPlace = sortFilesInPlace;
+    filesModule.updateFilesInJson = updateFilesInJson;
+    filesModule.collectDirectoryEntries = collectDirectoryEntries;
+
+    async function ensureDirHandle() {
+        if (typeof window.showDirectoryPicker !== 'function') {
+            throw new Error('File System Access API showDirectoryPicker is required');
+        }
+        const handle = await window.showDirectoryPicker();
+        
+        // Log the handle details for debugging
+        if (DEBUG) {
+            console.log('[transmittal] Directory selected:', {
+                name: handle.name,
+                kind: handle.kind,
+                hasQueryPermission: typeof handle.queryPermission === 'function',
+                hasRequestPermission: typeof handle.requestPermission === 'function'
+            });
+        }
+
+        async function ensureRwPermission(dirHandle) {
+            if (!dirHandle) {
+                throw new Error('Directory handle is undefined');
+            }
+            if (typeof dirHandle.requestPermission !== 'function') {
+                return;
+            }
+            const permissionDescriptor = { mode: 'readwrite' };
+            if (typeof dirHandle.queryPermission === 'function') {
+                const current = await dirHandle.queryPermission(permissionDescriptor);
+                if (current === 'granted') {
+                    return;
+                }
+            }
+            const result = await dirHandle.requestPermission(permissionDescriptor);
+            if (result !== 'granted') {
+                throw new Error('Read/write permission is required for the selected directory');
+            }
+        }
+
+        await ensureRwPermission(handle);
+        
+        // Verify the handle is still valid after permission check
+        if (!handle || handle.kind !== 'directory') {
+            throw new Error('Directory handle became invalid after permission check');
+        }
+
+        app.data.selectedDirHandle = handle;
+        updateDirectoryIndicator(handle.name);
+        app.state.apply();
+        
+        if (DEBUG) console.log('[transmittal] Directory handle ready:', handle.name);
+        return handle;
+    }
+
+    // Parse folder name: YYYY-MM-DD_TRACKING (STATUS) - TITLE
+    // Wraps zddc.parseFolder, preserving this module's null-on-invalid contract.
+    function parseFolderName(name) {
+        var parsed = zddc.parseFolder(name);
+        if (!parsed || !parsed.valid) { return null; }
+        return {
+            date:           parsed.date,
+            trackingNumber: parsed.trackingNumber,
+            status:         parsed.status,
+            title:          parsed.title
+        };
+    }
+
+    function populateFields(parsed) {
+        if (!parsed) { return; }
+        var map = {
+            'date': parsed.date,
+            'tracking-number': parsed.trackingNumber,
+            'purpose': parsed.status,
+            'subject': parsed.title
+        };
+        Object.keys(map).forEach(function (id) {
+            var el = dom.qs('#' + id);
+            if (el && map[id]) {
+                el.value = map[id];
+            }
+        });
+    }
+
+    // Shared scan pipeline: collect → populate rows → hash with progress
+    // onHash(item, hash) is called per file after hashing; return value sets cell content.
+    async function scanEntries(dirHandle, onHash) {
+        var entries = await collectDirectoryEntries(dirHandle);
+        entries.sort(function (a, b) { return a.path.localeCompare(b.path); });
+
+        // Phase 0: Ensure directory handle has permission
+        await ensureDirHandlePermission(dirHandle);
+
+        // Phase 1: merge with existing files
+        var existingIndex = filesModule.buildExistingIndex(app.data.files || []);
+        var existingPasteKeys = Object.keys(existingIndex);
+        setScanningState(true);
+        var hashCells = [];
+        for (var i = 0; i < entries.length; i++) {
+            var entry = entries[i];
+            try {
+                // Check and refresh handle permission before getFile
+                var file = await getFreshFile(entry.handle);
+                var parsed = (zddc.parseFilename(file.name) || {});
+                var fileData = {
+                    path: entry.path,
+                    name: file.name,
+                    size: file.size,
+                    fileSize: file.size,
+                    sha256: '',
+                    trackingNumber: parsed.trackingNumber,
+                    title: parsed.title,
+                    revision: parsed.revision,
+                    status: parsed.status,
+                    extension: parsed.extension || zddc.splitExtension(file.name).extension,
+                    fileHandle: entry.handle
+                };
+                var pasteKey = (fileData.trackingNumber || '').toLowerCase() + '|' + (fileData.revision || '').toLowerCase();
+                if (existingPasteKeys.indexOf(pasteKey) === -1) {
+                    app.data.files.push(fileData);
+                    var hashCell = filesModule.renderSingleRow(fileData, app.data.files.length - 1);
+                    hashCells.push({ cell: hashCell, fileData: fileData, handle: entry.handle });
+                }
+            } catch (err) {
+                console.error('[transmittal] Error reading file:', entry.path, err);
+            }
+            if (i % 20 === 0) {
+                await new Promise(function (r) { setTimeout(r, 0); });
+            }
+        }
+
+        // Phase 2: hash each file with progress bar
+        setScanningState(false);
+        for (var j = 0; j < hashCells.length; j++) {
+            var item = hashCells[j];
+            try {
+                var fill = item.cell ? item.cell.querySelector('.hash-progress-fill') : null;
+                var onProgress = fill ? function (f) {
+                    return function (loaded, total) {
+                        var pct = total > 0 ? Math.round((loaded / total) * 100) : 0;
+                        f.style.width = pct + '%';
+                    };
+                }(fill) : null;
+                var file = await getFreshFile(item.handle);
+                var hash = await util.hashFile(file, onProgress);
+                item.fileData.sha256 = hash;
+                if (onHash) {
+                    onHash(item, hash);
+                } else if (item.cell) {
+                    item.cell.textContent = util.formatShortFileHash(hash);
+                }
+            } catch (err) {
+                console.error('[transmittal] Error hashing file:', item.fileData.path, err);
+                if (item.cell) { item.cell.textContent = 'error'; }
+            }
+        }
+        return hashCells;
+    }
+
+    function finalizeAfterScan() {
+        var handleMap = buildFileHandleMap(app.data.files);
+        updateFilesInJson(app.data.files);
+        filesModule.render();
+        filesModule.loadFromJson({ filesOnly: true });
+        restoreFileHandles(app.data.files, handleMap);
+        app.state.apply();
+    }
+
+    async function selectDirectory(event) {
+        if (DEBUG) console.log('[transmittal] ========== SELECT DIRECTORY STARTED ==========');
+        const trigger = event && event.currentTarget instanceof HTMLElement ? event.currentTarget : null;
+        if (trigger) {
+            trigger.disabled = true;
+            trigger.classList.add('opacity-60');
+        }
+        try {
+            var dirHandle = app.data.selectedDirHandle;
+            if (!dirHandle) {
+                dirHandle = await ensureDirHandle();
+            }
+            populateFields(parseFolderName(dirHandle.name));
+            await scanEntries(dirHandle);
+            finalizeAfterScan();
+            app.markDirty();
+            setPrimary('publish');
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                if (DEBUG) console.log('[transmittal] User cancelled directory selection');
+            } else {
+                console.error('[transmittal] selectDirectory failed', err);
+            }
+        } finally {
+            setScanningState(false);
+            if (trigger) {
+                trigger.disabled = false;
+                trigger.classList.remove('opacity-60');
+            }
+        }
+    }
+
+    async function writeFileToSelectedDir(filename, contents, mime) {
+        if (!app.data.selectedDirHandle) {
+            throw new Error('No directory selected');
+        }
+        const fileHandle = await app.data.selectedDirHandle.getFileHandle(filename, { create: true });
+        const writable = await fileHandle.createWritable();
+        await writable.write(new Blob([contents], { type: mime || 'text/plain' }));
+        await writable.close();
+    }
+
+    filesModule.writeFileToSelectedDir = writeFileToSelectedDir;
+
+    // ── Paste helpers ─────────────────────────────────────
+    // Expected formats (tab-separated, 3-5 adjacent columns):
+    //   3 cols: Tracking \t Title \t Revision+Status   ("A (IFR)")
+    //   4 cols: Tracking \t Title \t Revision \t Status
+    //   5 cols: Tracking \t Title \t Revision \t Status \t Extension
+    var MAX_PASTE_COLS = 5;
+    var HEADER_RE = /^(#|tracking|number|title|revision|status|ext)/i;
+
+    function isHeaderLine(cols) {
+        if (!cols || !cols.length) { return false; }
+        return HEADER_RE.test((cols[0] || '').trim());
+    }
+
+    function columnsToFileRow(cols) {
+        var tracking = (cols[0] || '').trim();
+        if (!tracking) { return null; }
+        var revision = (cols[2] || '').trim();
+        var status = (cols[3] || '').trim();
+        var extension = (cols[4] || '').trim().toLowerCase();
+
+        // 3-column paste: split "A (IFR)" into revision "A" and status "IFR"
+        if (cols.length <= 3 && revision) {
+            var spaceIdx = revision.indexOf(' ');
+            if (spaceIdx > 0) {
+                status = revision.substring(spaceIdx + 1).trim().replace(/^\(+/, '').replace(/\)+$/, '');
+                revision = revision.substring(0, spaceIdx).trim();
+            }
+        }
+        return {
+            trackingNumber: tracking,
+            title: (cols[1] || '').trim(),
+            revision: revision,
+            status: status,
+            extension: extension,
+            path: '', name: '', size: 0, fileSize: 0, sha256: ''
+        };
+    }
+
+    // Parse plain-text tab-separated clipboard data.
+    // Returns { rows: [...], tooWide: false } or { rows: [], tooWide: true }.
+    function parseClipboardText(text) {
+        var lines = (text || '').split(/\r?\n/);
+        var rows = [];
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i].trim();
+            if (!line) { continue; }
+            var cols = line.split('\t');
+            if (isHeaderLine(cols)) { continue; }
+            if (cols.length > MAX_PASTE_COLS) {
+                return { rows: [], tooWide: true, colCount: cols.length };
+            }
+            var row = columnsToFileRow(cols);
+            if (row) { rows.push(row); }
+        }
+        return { rows: rows, tooWide: false };
+    }
+
+    function pasteFileKey(trackingNumber, revision) {
+        return (trackingNumber || '').toLowerCase() + '|' + (revision || '').toLowerCase();
+    }
+
+    function buildExistingIndex(files) {
+        var index = {};
+        for (var i = 0; i < files.length; i++) {
+            index[pasteFileKey(files[i].trackingNumber, files[i].revision)] = i;
+        }
+        return index;
+    }
+    filesModule.buildExistingIndex = buildExistingIndex;
+
+    async function handlePasteFiles(mode, clipText) {
+        var setStatus = app.modules.data && app.modules.data.setStatus;
+        try {
+            var text = clipText || await navigator.clipboard.readText();
+            var result = parseClipboardText(text);
+            if (result.tooWide) {
+                if (setStatus) {
+                    setStatus('Paste has ' + result.colCount + ' columns (max ' + MAX_PASTE_COLS + '). ' +
+                        'Copy only: Tracking, Title, Revision, [Status], [Extension]', 'error');
+                }
+                return;
+            }
+            var rows = result.rows;
+            if (!rows.length) {
+                if (setStatus) { setStatus('No valid rows found. Expected tab-separated: Tracking, Title, Revision, [Status], [Ext]', 'error'); }
+                return;
+            }
+
+            var added = 0, updated = 0;
+            if (mode === 'new') {
+                app.data.files = [];
+                for (var i = 0; i < rows.length; i++) {
+                    app.data.files.push(rows[i]);
+                    added++;
+                }
+            } else {
+                var index = buildExistingIndex(app.data.files || []);
+                for (var j = 0; j < rows.length; j++) {
+                    var row = rows[j];
+                    var key = pasteFileKey(row.trackingNumber, row.revision);
+                    if (index.hasOwnProperty(key)) {
+                        var existing = app.data.files[index[key]];
+                        existing.title = row.title;
+                        existing.status = row.status;
+                        if (row.extension) { existing.extension = row.extension; }
+                        updated++;
+                    } else {
+                        app.data.files.push(row);
+                        added++;
+                    }
+                }
+            }
+
+            filesModule.sortFilesInPlace(app.data.files);
+            updateFilesInJson(app.data.files);
+            filesModule.render();
+            app.state.apply();
+            app.markDirty();
+            setPrimary('verify');
+
+            var msg = mode === 'new'
+                ? 'Replaced file list: ' + added + ' rows'
+                : added + ' added, ' + updated + ' updated';
+            if (setStatus) { setStatus(msg, 'success'); }
+        } catch (err) {
+            console.error('[transmittal] paste failed', err);
+            if (setStatus) { setStatus('Paste failed: ' + (err && err.message ? err.message : err), 'error'); }
+        }
+    }
+
+    // ── Toolbar visibility per state ────────────────────
+    function updateToolbars() {
+        var docState = app.state.detectState();
+        buildBottomBar(docState);
+    }
+
+    function createMenuItem(label, handler, options) {
+        var btn = document.createElement('button');
+        btn.type = 'button';
+        btn.className = 'dropdown-item' + ((options && options.danger) ? ' text-red-600' : '');
+        btn.setAttribute('role', 'menuitem');
+        btn.textContent = label;
+        btn.addEventListener('click', handler);
+        return btn;
+    }
+
+    function createSeparator(label) {
+        var el = document.createElement('div');
+        el.className = 'dropdown-separator';
+        if (label) { el.textContent = label; }
+        return el;
+    }
+
+    function applyPrimaryButton(btn, intent) {
+        if (_primaryHandler) { btn.removeEventListener('click', _primaryHandler); }
+        btn.disabled = false;
+        btn.classList.remove('opacity-60');
+        if (intent === 'publish') {
+            btn.textContent = 'Publish';
+            _primaryHandler = function () {
+                document.dispatchEvent(new CustomEvent('transmittal:open-publish'));
+            };
+        } else if (intent === 'verify') {
+            btn.textContent = 'Verify Directory';
+            _primaryHandler = function () {
+                if (!requireFileSystemAccess()) { return; }
+                verifyFiles();
+            };
+        } else {
+            btn.textContent = 'Scan Directory';
+            _primaryHandler = function () {
+                if (!requireFileSystemAccess()) { return; }
+                selectDirectory({ currentTarget: null });
+            };
+        }
+        btn.addEventListener('click', _primaryHandler);
+    }
+
+    function buildBottomBar(docState) {
+        var primaryBtn = dom.qs('#bottom-primary');
+        var dropdown = dom.qs('#bottom-dropdown');
+        if (!primaryBtn || !dropdown) { return; }
+
+        var isPublished = docState === 'published';
+        var d = app.modules.data || {};
+
+        dropdown.innerHTML = '';
+        dropdown.classList.add('hidden');
+
+        if (isPublished) {
+            applyPrimaryButton(primaryBtn, 'verify');
+
+            dropdown.appendChild(createMenuItem('Copy Table', function () {
+                if (d.handleCopyTable) { d.handleCopyTable(); }
+            }));
+            dropdown.appendChild(createMenuItem('Copy JSON', function () {
+                if (d.handleCopyJson) { d.handleCopyJson(); }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Add Signature', function () {
+                if (app.modules.security && app.modules.security.addSignature) {
+                    app.modules.security.addSignature();
+                }
+            }));
+            dropdown.appendChild(createMenuItem('Acknowledge Receipt', function () {
+                if (app.modules.security && app.modules.security.addSignature) {
+                    app.modules.security.addSignature({ label: 'Received By' });
+                }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Revise', function () {
+                if (d.handleRevise) { d.handleRevise(); }
+            }));
+            dropdown.appendChild(createMenuItem('Import HTML', function () {
+                if (d.handleImportHtml) { d.handleImportHtml(); }
+            }));
+            dropdown.appendChild(createMenuItem('Reset', function () {
+                if (app.modules.reset && app.modules.reset.handleReset) {
+                    app.modules.reset.handleReset();
+                }
+            }, { danger: true }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Create Index', function () {
+                if (!requireFileSystemAccess()) { return; }
+                if (filesModule.generateArchiveRedirects) {
+                    filesModule.generateArchiveRedirects().catch(function (err) {
+                        console.error('[transmittal] create-index failed', err);
+                    });
+                }
+            }));
+        } else {
+            // Edit: respect explicit intent, or auto-detect
+            var intent = _primaryIntent;
+            if (!intent) {
+                intent = hasFiles() ? 'verify' : 'scan';
+            }
+            applyPrimaryButton(primaryBtn, intent);
+
+            dropdown.appendChild(createMenuItem('Scan Directory', function () {
+                if (!requireFileSystemAccess()) { return; }
+                selectDirectory({ currentTarget: null });
+            }));
+            dropdown.appendChild(createMenuItem('Verify Directory', function () {
+                if (!requireFileSystemAccess()) { return; }
+                verifyFiles();
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Publish', function () {
+                document.dispatchEvent(new CustomEvent('transmittal:open-publish'));
+            }));
+            dropdown.appendChild(createMenuItem('Save Draft', function () {
+                if (d.handleSaveHtmlDraft) { d.handleSaveHtmlDraft(); }
+            }));
+            dropdown.appendChild(createMenuItem('Create Folder', async function () {
+                var setStatus = d.setStatus;
+                try {
+                    // Sync UI so payload reflects current form values
+                    filesModule.syncUiToJson();
+                    var data = json.parse();
+                    var payload = (data && data.payload) || {};
+                    if (!payload.trackingNumber) {
+                        if (setStatus) { setStatus('Enter a tracking number first', 'error'); }
+                        return;
+                    }
+                    var folderName = d.buildFolderName(payload);
+                    // Sanitize for filesystem
+                    folderName = folderName.replace(/[<>:"/\\|?*]+/g, '_').replace(/_+/g, '_');
+
+                    // Prompt for staging directory
+                    var stagingHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
+                    var newFolderHandle = await stagingHandle.getDirectoryHandle(folderName, { create: true });
+
+                    // Set as selected directory for subsequent file operations
+                    app.data.selectedDirHandle = newFolderHandle;
+                    app.data.selectedDirName = folderName;
+                    if (filesModule.updateDirectoryIndicator) {
+                        filesModule.updateDirectoryIndicator();
+                    }
+
+                    // Save a draft into the new folder
+                    var pub = app.modules.publish;
+                    if (pub && typeof pub.syncUiToJson === 'function' && typeof pub.buildHtmlString === 'function') {
+                        await pub.syncUiToJson({ sign: false, computeDigest: false });
+                        var html = await pub.buildHtmlString();
+                        var draftName = d.buildFileName(
+                            ((json.parse() || {}).payload || {}),
+                            { extension: 'html', draft: true }
+                        );
+                        await writeFileToSelectedDir(draftName, html, 'text/html');
+                        // Verify both the folder and draft file exist
+                        var warnings = [];
+                        try {
+                            await stagingHandle.getDirectoryHandle(folderName);
+                        } catch (_) {
+                            warnings.push('folder \"' + folderName + '\" could not be verified');
+                        }
+                        try {
+                            await newFolderHandle.getFileHandle(draftName);
+                        } catch (_) {
+                            warnings.push('draft file \"' + draftName + '\" could not be verified');
+                        }
+                        if (warnings.length) {
+                            if (setStatus) { setStatus('Warning: ' + warnings.join('; ') + '. Path may be too long for Windows.', 'error'); }
+                        } else if (setStatus) {
+                            setStatus('Draft saved to ' + folderName + '. Close this file and open ' + draftName + ' from the new folder.', 'success');
+                        }
+                    } else {
+                        if (setStatus) { setStatus('Created folder: ' + folderName, 'success'); }
+                    }
+                } catch (err) {
+                    if (err && err.name === 'AbortError') { return; }
+                    console.error('[transmittal] create-folder failed', err);
+                    if (setStatus) { setStatus('Create folder failed: ' + (err.message || err), 'error'); }
+                }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Paste New Rows', async function () {
+                var text;
+                try { text = await navigator.clipboard.readText(); } catch (e) {
+                    if (d.setStatus) { d.setStatus('Clipboard access denied', 'error'); }
+                    return;
+                }
+                var result = parseClipboardText(text);
+                if (result.tooWide) {
+                    if (d.setStatus) {
+                        d.setStatus('Paste has ' + result.colCount + ' columns (max ' + MAX_PASTE_COLS + '). ' +
+                            'Copy only: Tracking, Title, Revision, [Status], [Extension]', 'error');
+                    }
+                    return;
+                }
+                if (!result.rows.length) {
+                    if (d.setStatus) { d.setStatus('No valid rows on clipboard', 'error'); }
+                    return;
+                }
+                if (confirm('Replace file list with ' + result.rows.length + ' rows from clipboard?')) {
+                    handlePasteFiles('new', text);
+                }
+            }));
+            dropdown.appendChild(createMenuItem('Paste Append Rows', function () {
+                handlePasteFiles('append');
+            }));
+            dropdown.appendChild(createMenuItem('Copy Table', function () {
+                if (d.handleCopyTable) { d.handleCopyTable(); }
+            }));
+            dropdown.appendChild(createMenuItem('Remove Files', function () {
+                if (!app.data.files.length) {
+                    if (d.setStatus) { d.setStatus('File list is already empty', 'error'); }
+                    return;
+                }
+                if (confirm('Remove all ' + app.data.files.length + ' files from the list? Header info and remarks will be kept.')) {
+                    app.data.files = [];
+                    updateFilesInJson([]);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    if (d.setStatus) { d.setStatus('File list cleared', 'success'); }
+                }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Import HTML', function () {
+                if (d.handleImportHtml) { d.handleImportHtml(); }
+            }));
+            dropdown.appendChild(createMenuItem('Copy JSON', function () {
+                if (d.handleCopyJson) { d.handleCopyJson(); }
+            }));
+            dropdown.appendChild(createMenuItem('Paste JSON', function () {
+                if (d.handleLoadFromClipboard) { d.handleLoadFromClipboard(); }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Reset', function () {
+                if (app.modules.reset && app.modules.reset.handleReset) {
+                    app.modules.reset.handleReset();
+                }
+            }, { danger: true }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Create Index', function () {
+                if (!requireFileSystemAccess()) { return; }
+                if (filesModule.generateArchiveRedirects) {
+                    filesModule.generateArchiveRedirects().catch(function (err) {
+                        console.error('[transmittal] create-index failed', err);
+                    });
+                }
+            }));
+        }
+    }
+
+    // ── Bottom bar dropdown toggle ──────────────────────
+    function initBottomBarToggle() {
+        var toggle = dom.qs('#bottom-toggle');
+        var menu = dom.qs('#bottom-dropdown');
+        if (!toggle || !menu) { return; }
+
+        toggle.addEventListener('click', function (e) {
+            e.stopPropagation();
+            var open = !menu.classList.contains('hidden');
+            menu.classList.toggle('hidden', open);
+            toggle.setAttribute('aria-expanded', String(!open));
+        });
+
+        menu.addEventListener('click', function () {
+            menu.classList.add('hidden');
+            toggle.setAttribute('aria-expanded', 'false');
+        });
+
+        document.addEventListener('click', function (e) {
+            var container = dom.qs('#bottom-menu');
+            if (container && !container.contains(e.target)) {
+                menu.classList.add('hidden');
+                toggle.setAttribute('aria-expanded', 'false');
+            }
+        });
+    }
+
+
+    async function refreshDirectory() {
+        var dirHandle = app.data.selectedDirHandle;
+        if (!dirHandle) { return; }
+        try {
+            // Ensure directory handle has permission before scanning
+            await ensureDirHandlePermission(dirHandle);
+            
+            // Build expected-hash lookup from current JSON
+            var expectedHashes = {};
+            var currentData = json.parse();
+            var loadedFiles = (currentData && currentData.payload && Array.isArray(currentData.payload.files)) ? currentData.payload.files : [];
+            loadedFiles.forEach(function (f) {
+                var key = (f.path ? f.path + '/' : '') + f.filename;
+                if (f.sha256) { expectedHashes[key.toLowerCase()] = f.sha256.toLowerCase(); }
+            });
+            var hasExpected = Object.keys(expectedHashes).length > 0;
+            var matchCount = 0;
+            var mismatchCount = 0;
+
+            var hashCells = await scanEntries(dirHandle, hasExpected ? function (item, hash) {
+                if (!item.cell) { return; }
+                var display = util.formatShortFileHash(hash);
+                var fileKey = (item.fileData.path || item.fileData.name).toLowerCase();
+                var expected = expectedHashes[fileKey];
+                if (expected && expected === hash.toLowerCase()) {
+                    item.cell.innerHTML = '<span class="hash-match" title="Hash matches expected value">\u2713</span> ' + display;
+                    matchCount++;
+                } else if (expected) {
+                    item.cell.innerHTML = '<span class="hash-mismatch" title="Hash does NOT match expected value">\u2717</span> ' + display;
+                    mismatchCount++;
+                } else {
+                    item.cell.textContent = display;
+                }
+            } : null);
+
+            if (hasExpected && app.modules.data && app.modules.data.setStatus) {
+                if (mismatchCount === 0 && matchCount > 0) {
+                    app.modules.data.setStatus(matchCount + '/' + hashCells.length + ' files verified', 'success');
+                } else if (mismatchCount > 0) {
+                    app.modules.data.setStatus(mismatchCount + ' hash mismatch(es) \u2014 ' + matchCount + ' matched', 'error');
+                }
+            }
+
+            finalizeAfterScan();
+            if (!hasExpected) { app.markDirty(); }
+        } catch (err) {
+            console.error('[transmittal] Refresh failed', err);
+        } finally {
+            setScanningState(false);
+        }
+    }
+
+    // ── Verify row helpers ────────────────────────────────────
+    function findRowByFileIndex(idx) {
+        var cell = document.querySelector('td[data-index="' + idx + '"]');
+        return cell ? cell.closest('tr') : null;
+    }
+
+    function getHashCell(row) {
+        return row ? row.querySelector('td:last-child') : null;
+    }
+
+    function setRowVerifyState(row, state) {
+        if (!row) { return; }
+        row.classList.remove('verify-match', 'verify-mismatch', 'verify-missing', 'verify-new', 'verify-progress');
+        if (state) { row.classList.add('verify-' + state); }
+    }
+
+    function clearAllVerifyStates() {
+        var rows = document.querySelectorAll('tr.verify-match, tr.verify-mismatch, tr.verify-missing, tr.verify-new, tr.verify-progress');
+        rows.forEach(function (r) {
+            r.classList.remove('verify-match', 'verify-mismatch', 'verify-missing', 'verify-new', 'verify-progress');
+        });
+    }
+
+    function escapeHtml(str) {
+        var div = document.createElement('div');
+        div.textContent = str;
+        return div.innerHTML;
+    }
+
+    function showPathDiff(trackingCell, expectedPath, actualPath) {
+        var diffEl = document.createElement('div');
+        diffEl.className = 'path-diff';
+        var del = document.createElement('del');
+        del.textContent = expectedPath;
+        var ins = document.createElement('ins');
+        ins.textContent = actualPath;
+        diffEl.appendChild(del);
+        diffEl.appendChild(document.createTextNode(' \u2192 '));
+        diffEl.appendChild(ins);
+        trackingCell.appendChild(diffEl);
+    }
+
+    // Hash every directory entry upfront, before any event-loop yields.
+    // On file:// origins in Chromium, FileSystemFileHandle.getFile() fails after
+    // macrotask boundaries have elapsed since the handle was created. The fix is
+    // to call getFile() + hashFile() back-to-back for each entry in one tight
+    // sequential pass, producing a complete index before any UI yields occur.
+    // Returns { sizeIndex, nameIndex } where each entry has hash already computed.
+    async function buildVerifyIndex(entries, onProgress) {
+        var sizeIndex = {};  // fileSize → [candidate]
+        var nameIndex = {};  // "tracking\trevision" → candidate
+        var entryList = [];  // List of file metadata for later use
+        for (var i = 0; i < entries.length; i++) {
+            var entry = entries[i];
+            try {
+                var file = await entry.handle.getFile();
+                var hash = await util.hashFile(file);
+                var cand = {
+                    handle: entry.handle,
+                    path: entry.path,
+                    name: file.name,
+                    fileSize: file.size,
+                    hash: hash,
+                    matched: false
+                };
+                // Store file metadata for later use
+                entryList.push({
+                    handle: entry.handle,
+                    path: entry.path,
+                    name: file.name,
+                    fileSize: file.size,
+                    hash: hash,
+                    parsed: (zddc.parseFilename(entry.name) || {})
+                });
+                // size index
+                if (!sizeIndex[file.size]) { sizeIndex[file.size] = []; }
+                sizeIndex[file.size].push(cand);
+                // name index
+                var parsed = (zddc.parseFilename(entry.name) || {});
+                if (parsed.trackingNumber) {
+                    var nkey = parsed.trackingNumber.toLowerCase() + '\t' + (parsed.revision || '').toLowerCase();
+                    if (!nameIndex[nkey]) { nameIndex[nkey] = []; }
+                    nameIndex[nkey].push(cand);
+                }
+                if (onProgress) { onProgress(i + 1, entries.length); }
+            } catch (err) {
+                console.warn('[transmittal] verify skip entry', entry.path, err);
+            }
+        }
+        return { sizeIndex: sizeIndex, nameIndex: nameIndex, entryList: entryList };
+    }
+
+    // Find a matching directory entry by sha256 hash.
+    function findByHash(sizeIndex, fileSize, expectedHash) {
+        if (!expectedHash || fileSize == null) { return null; }
+        var candidates = sizeIndex[fileSize];
+        if (!candidates) { return null; }
+        var target = expectedHash.toLowerCase();
+        for (var c = 0; c < candidates.length; c++) {
+            var cand = candidates[c];
+            if (cand.matched) { continue; }
+            if (cand.hash && cand.hash.toLowerCase() === target) {
+                cand.matched = true;
+                return cand;
+            }
+        }
+        return null;
+    }
+
+    // Find a matching directory entry by tracking number + revision.
+    function findByTrackingRevision(nameIndex, trackingNumber, revision) {
+        var key = (trackingNumber || '').toLowerCase() + '\t' + (revision || '').toLowerCase();
+        var candidates = nameIndex[key];
+        if (!candidates || !candidates.length) { return null; }
+        for (var i = 0; i < candidates.length; i++) {
+            if (!candidates[i].matched) {
+                candidates[i].matched = true;
+                return candidates[i];
+            }
+        }
+        return null;
+    }
+
+    // Count unmatched entries in a size index
+    function countUnmatched(sizeIndex) {
+        var count = 0;
+        for (var size in sizeIndex) {
+            var group = sizeIndex[size];
+            for (var i = 0; i < group.length; i++) {
+                if (!group[i].matched) { count++; }
+            }
+        }
+        return count;
+    }
+
+    async function verifyFiles() {
+        var isPublished = !!app.state.published;
+        var setStatus = app.modules.data && app.modules.data.setStatus;
+        try {
+            var dirHandle = app.data.selectedDirHandle;
+            if (!dirHandle) {
+                dirHandle = await ensureDirHandle();
+            }
+            clearAllVerifyStates();
+            if (setStatus) { setStatus('Hashing directory\u2026', 'info'); }
+
+            var entries = await collectDirectoryEntries(dirHandle);
+            var allFiles = app.data.files || [];
+
+            // Hash every file upfront before any UI yields — on file:// origins,
+            // Chromium invalidates FileSystemFileHandle after macrotask boundaries.
+            var idx = await buildVerifyIndex(entries);
+            var sizeIndex = idx.sizeIndex;
+            var nameIndex = idx.nameIndex;
+            var entryList = idx.entryList || [];
+
+            // Build pasteKey index for existing files to avoid duplicates
+            var existingIndex = buildExistingIndex(allFiles);
+            var existingPasteKeys = Object.keys(existingIndex);
+
+            if (isPublished) {
+                // ── Published: read-only verification by hash ──
+                var verified = 0;
+                var missingCount = 0;
+
+                for (var p = 0; p < allFiles.length; p++) {
+                    var tf = allFiles[p];
+                    var row = findRowByFileIndex(p);
+                    var hCell = getHashCell(row);
+                    var trackingCell = row ? row.querySelector('td[data-field="trackingNumber"]') : null;
+
+                    setRowVerifyState(row, 'progress');
+                    await new Promise(function (r) { setTimeout(r, 0); });
+
+                    var fileSize = tf.fileSize != null ? tf.fileSize : tf.size;
+                    var found = findByHash(sizeIndex, fileSize, tf.sha256);
+
+                    if (found) {
+                        verified++;
+                        tf.fileHandle = found.handle;
+                        setRowVerifyState(row, 'match');
+                        if (hCell) {
+                            hCell.innerHTML = '<span style="color:#166534;font-weight:700;">\u2713</span> ' + escapeHtml(util.formatShortFileHash(tf.sha256));
+                        }
+                        var expectedPath = tf.path || tf.name || '';
+                        if (trackingCell && expectedPath && found.path && expectedPath !== found.path) {
+                            showPathDiff(trackingCell, expectedPath, found.path);
+                        }
+                    } else {
+                        missingCount++;
+                        setRowVerifyState(row, 'missing');
+                        if (hCell) {
+                            hCell.innerHTML = '<span style="color:#92400e;">\u26A0 not found</span>';
+                        }
+                    }
+                }
+
+                var extra = countUnmatched(sizeIndex);
+                var msg = verified + ' verified';
+                if (missingCount) { msg += ', ' + missingCount + ' missing'; }
+                if (extra) { msg += ', ' + extra + ' extra in directory'; }
+                if (setStatus) {
+                    setStatus(msg, missingCount ? 'error' : 'success');
+                }
+            } else {
+                // ── Edit: match rows against directory ──
+                // Rows WITH hash+size → match by size+hash
+                // Rows WITHOUT hash → match by tracking+revision, then populate hash/size
+                var verified = 0;
+                var populated = 0;
+                var notFound = 0;
+                var dirty = false;
+
+                for (var mi = 0; mi < allFiles.length; mi++) {
+                    var mf = allFiles[mi];
+                    var mRow = findRowByFileIndex(mi);
+                    var mhCell = getHashCell(mRow);
+
+                    setRowVerifyState(mRow, 'progress');
+                    await new Promise(function (r) { setTimeout(r, 0); });
+
+                    var hasHash = !!mf.sha256;
+                    var mFileSize = mf.fileSize != null ? mf.fileSize : mf.size;
+
+                    if (hasHash && mFileSize != null) {
+                        var foundByHash = findByHash(sizeIndex, mFileSize, mf.sha256);
+                        if (foundByHash) {
+                            mf.fileHandle = foundByHash.handle;
+                            verified++;
+                            setRowVerifyState(mRow, 'match');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#166534;font-weight:700;">\u2713</span> ' + escapeHtml(util.formatShortFileHash(mf.sha256));
+                            }
+                        } else {
+                            mf.fileHandle = null;
+                            notFound++;
+                            setRowVerifyState(mRow, 'missing');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#92400e;">\u26A0 not found</span>';
+                            }
+                        }
+                    } else {
+                        var foundByName = findByTrackingRevision(nameIndex, mf.trackingNumber, mf.revision);
+                        if (foundByName) {
+                            mf.fileHandle = foundByName.handle;
+                            mf.path = foundByName.path;
+                            mf.name = foundByName.name;
+                            mf.size = foundByName.fileSize;
+                            mf.fileSize = foundByName.fileSize;
+                            mf.sha256 = foundByName.hash;
+                            mf.extension = mf.extension || zddc.splitExtension(foundByName.name).extension;
+                            populated++;
+                            dirty = true;
+                            setRowVerifyState(mRow, 'match');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#166534;font-weight:700;">\u2713</span> ' + escapeHtml(util.formatShortFileHash(mf.sha256));
+                            }
+                        } else {
+                            notFound++;
+                            setRowVerifyState(mRow, 'missing');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#92400e;">\u26A0 not found</span>';
+                            }
+                        }
+                    }
+                }
+
+                if (dirty) {
+                    updateFilesInJson(allFiles);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                }
+
+                var editMsg = '';
+                var parts = [];
+                if (verified) { parts.push(verified + ' verified'); }
+                if (populated) { parts.push(populated + ' matched'); }
+                if (notFound) { parts.push(notFound + ' not found'); }
+                editMsg = parts.join(', ') || 'No files to verify';
+
+                // Add new files from directory that don't match existing pasteKeys
+                var added = 0;
+                for (var ei = 0; ei < entryList.length; ei++) {
+                    var entryData = entryList[ei];
+                    if (!entryData.parsed.trackingNumber && !entryData.parsed.revision) continue; // Skip files without ZDDC pattern
+                    var pasteKey = (entryData.parsed.trackingNumber || '').toLowerCase() + '|' + (entryData.parsed.revision || '').toLowerCase();
+                    if (existingPasteKeys.indexOf(pasteKey) === -1) {
+                        // New file - use pre-hashed file data
+                        var fileData = {
+                            path: entryData.path,
+                            name: entryData.name,
+                            size: entryData.fileSize,
+                            fileSize: entryData.fileSize,
+                            sha256: '',
+                            trackingNumber: entryData.parsed.trackingNumber,
+                            title: entryData.parsed.title,
+                            revision: entryData.parsed.revision,
+                            status: entryData.parsed.status,
+                            extension: entryData.parsed.extension || zddc.splitExtension(entryData.name).extension,
+                            fileHandle: entryData.handle
+                        };
+                        app.data.files.push(fileData);
+                        added++;
+                    }
+                }
+                if (added > 0) {
+                    dirty = true;
+                    updateFilesInJson(app.data.files);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    editMsg = (editMsg ? editMsg + ', ' : '') + added + ' new file(s) added';
+                }
+
+                if (setStatus) {
+                    setStatus(editMsg, notFound && !added ? 'error' : 'success');
+                }
+            }
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                if (DEBUG) console.log('[transmittal] User cancelled verify');
+            } else {
+                console.error('[transmittal] verifyFiles failed', err);
+                if (setStatus) { setStatus('Verify failed: ' + (err.message || err), 'error'); }
+            }
+        }
+    }
+
+    document.addEventListener('transmittal:scan-directory', function () {
+        selectDirectory({ currentTarget: dom.qs('#bottom-primary') });
+    });
+
+    document.addEventListener('transmittal:verify-directory', function () {
+        verifyFiles();
+    });
+
+    filesModule.bindActionButtons = function bindActionButtons() {
+        // Reveal the menu now that JS is running
+        var bottomMenu = dom.qs('#bottom-menu');
+        if (bottomMenu) { bottomMenu.hidden = false; }
+        var noJsNotice = dom.qs('#no-js-notice');
+        if (noJsNotice) { dom.show(noJsNotice, false); }
+        initBottomBarToggle();
+        updateToolbars();
+    };
+
+    filesModule.updateToolbars = updateToolbars;
+
+    filesModule.syncUiToJson = function syncUiToJson() {
+        const val = function (selector) {
+            const el = dom.qs(selector);
+            return el ? (el.value || '') : '';
+        };
+
+        function toIsoDate(value) {
+            if (!value) {
+                return '';
+            }
+            const trimmed = String(value).trim();
+            if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+                return trimmed;
+            }
+            const match = trimmed.match(/^(?:[A-Za-z]+\s+)?([A-Za-z]{3,})\s+(\d{1,2}),\s*(\d{4})$/);
+            const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+            if (match) {
+                const monthIndex = months.indexOf(match[1].slice(0, 3));
+                if (monthIndex >= 0) {
+                    const day = String(parseInt(match[2], 10)).padStart(2, '0');
+                    const month = String(monthIndex + 1).padStart(2, '0');
+                    const year = match[3];
+                    return year + '-' + month + '-' + day;
+                }
+            }
+            const date = new Date(trimmed);
+            if (!Number.isNaN(date.getTime())) {
+                return date.toISOString().slice(0, 10);
+            }
+            return trimmed;
+        }
+
+        const data = json.parse();
+        const envelope = { ...(data.envelope || {}) };
+        const presentation = { ...(data.presentation || {}) };
+        
+        const payload = {
+            version: 1,
+            type: val('#type'),
+            title: val('#title') || '',
+            client: (dom.qs('#owner-name')?.textContent) || '',
+            project: (dom.qs('#project-name')?.textContent) || '',
+            projectNumber: (dom.qs('#project-number')?.textContent) || '',
+            date: toIsoDate(val('#date')),
+            trackingNumber: val('#tracking-number'),
+            from: val('#from'),
+            to: val('#to'),
+            purpose: val('#purpose'),
+            responseDue: val('#response-due'),
+            subject: val('#subject'),
+            remarks: val('#remarks'),
+            files: (function () {
+                var memFiles = Array.isArray(app.data.files) ? app.data.files : [];
+                var sorted = memFiles.slice().sort(util.compareFilesByTrackingRevision).map(canonicalFilePayload);
+                var self = buildSelfEntry();
+                return [canonicalFilePayload(self)].concat(sorted);
+            })()
+        };
+        
+        const leftLogoEl = dom.qs('#left-logo');
+        const rightLogoEl = dom.qs('#right-logo');
+        presentation.leftLogo = leftLogoEl && leftLogoEl.src ? leftLogoEl.src : '';
+        presentation.rightLogo = rightLogoEl && rightLogoEl.src ? rightLogoEl.src : '';
+        
+        json.setData({ envelope: envelope, payload: payload, presentation: presentation });
+    };
+
+    filesModule.loadFromJson = function loadFromJson(options) {
+        const opts = options || {};
+        const data = json.parse();
+        const payload = (data && data.payload) || {};
+        if (!opts.filesOnly) {
+            const assignValue = function (selector, value) {
+                const element = dom.qs(selector);
+                if (element) {
+                    element.value = value || '';
+                }
+            };
+            const assignText = function (selector, value) {
+                const element = dom.qs(selector);
+                if (element) {
+                    element.textContent = value || '';
+                }
+            };
+            assignValue('#type', payload.type || 'Transmittal');
+            var typeDisplay = dom.qs('#type-display');
+            if (typeDisplay) { typeDisplay.textContent = payload.type || 'Transmittal'; }
+            assignValue('#title', payload.title || '');
+            assignText('#owner-name', payload.client || '');
+            assignText('#project-name', payload.project || '');
+            assignText('#project-number', payload.projectNumber || '');
+            assignValue('#date', payload.date || '');
+            assignValue('#tracking-number', payload.trackingNumber || '');
+            assignValue('#from', payload.from || '');
+            assignValue('#to', payload.to || '');
+            assignValue('#purpose', payload.purpose || '');
+            assignValue('#response-due', payload.responseDue || '');
+            assignValue('#subject', payload.subject || '');
+            const remarks = dom.qs('#remarks');
+            if (remarks) {
+                remarks.value = payload.remarks || '';
+            }
+            
+            // Load logos from presentation data
+            const presentation = (data && data.presentation) || {};
+            const leftLogoEl = dom.qs('#left-logo');
+            const rightLogoEl = dom.qs('#right-logo');
+            if (leftLogoEl && presentation.leftLogo) {
+                leftLogoEl.src = presentation.leftLogo;
+            }
+            if (rightLogoEl && presentation.rightLogo) {
+                rightLogoEl.src = presentation.rightLogo;
+            }
+        }
+        var SELF_HASH = app.constants.SELF_HASH;
+        const files = Array.isArray(payload.files)
+            ? payload.files.filter(function (f) { return f.sha256 !== SELF_HASH; })
+            : [];
+        app.data.files = files.map(function (entry) {
+            const pathOnly = entry.path || '';
+            const filename = entry.filename || '';
+            const relativePath = pathOnly ? (pathOnly + '/' + filename) : filename;
+            
+            // When filename is empty (e.g., from pasted files), reconstruct from trackingNumber
+            let baseName = filename || relativePath.split('/').pop() || '';
+            if (!baseName && entry.trackingNumber) {
+                baseName = zddc.joinExtension(entry.trackingNumber, entry.extension || '');
+            }
+
+            const fileSize = entry.fileSize || entry.size || 0;
+            return {
+                path: relativePath,
+                name: baseName,
+                size: fileSize,
+                fileSize: fileSize,
+                sha256: entry.sha256 || '',
+                trackingNumber: entry.trackingNumber || '',
+                title: entry.title || '',
+                revision: entry.revision || '',
+                status: entry.status || '',
+                extension: zddc.splitExtension(baseName).extension
+            };
+        });
+        sortFilesInPlace(app.data.files);
+        // Don't call updateFilesInJson here - it clears digest/signatures
+        // The files are already in the JSON, we're just loading them into app.data.files
+        updateDirectoryIndicator(app.data.selectedDirHandle ? app.data.selectedDirHandle.name : '');
+        
+        // Render the table to populate it with file data
+        filesModule.render();
+        
+        if (!opts.filesOnly && app.modules.markdown && typeof app.modules.markdown.refresh === 'function') {
+            app.modules.markdown.refresh();
+        }
+        // Apply field visibility after loading data to ensure UI stays in sync
+        if (!opts.filesOnly && app.modules.visibility && typeof app.modules.visibility.applyFieldVisibility === 'function') {
+            app.modules.visibility.applyFieldVisibility();
+        }
+    };
+
+    app.registerInit(function () {
+        updateDirectoryIndicator(app.data.selectedDirHandle ? app.data.selectedDirHandle.name : '');
+        filesModule.bindActionButtons();
+        filesModule.setupTableEditing();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/filters.js b/transmittal/js/filters.js
new file mode 100644
index 0000000..ed89cda
--- /dev/null
+++ b/transmittal/js/filters.js
@@ -0,0 +1,96 @@
+(function (app) {
+    'use strict';
+
+    const filters = app.modules.filters = {};
+    const dom = app.dom;
+
+    filters.fieldString = function fieldString(file, field) {
+        let value = '';
+        switch (field) {
+            case 'trackingNumber': value = file.trackingNumber || ''; break;
+            case 'title': value = file.title || ''; break;
+            case 'revision': value = file.revision || ''; break;
+            case 'status': value = file.status || ''; break;
+            case 'extension': value = file.extension || ''; break;
+            case 'sha256': value = file.sha256 || ''; break;
+            default: value = '';
+        }
+        return String(value).toLowerCase();
+    };
+
+    filters.getActiveFilters = function getActiveFilters() {
+        const active = {};
+        const inputs = document.querySelectorAll('thead input[data-filter-field]');
+        inputs.forEach(function (input) {
+            const field = input.getAttribute('data-filter-field');
+            const query = (input.value || '').trim();
+            if (!query) return;
+            active[field] = window.zddc.filter.parse(query);
+        });
+        return active;
+    };
+
+    filters.fileMatchesFilters = function fileMatchesFilters(file, activeFilters) {
+        const fields = Object.keys(activeFilters);
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            const ast = activeFilters[field];
+            const value = filters.fieldString(file, field);
+            if (!window.zddc.filter.matches(value, ast)) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    filters.refreshPlaceholders = function refreshPlaceholders() {
+        const inputs = document.querySelectorAll('thead input[data-filter-field]');
+        inputs.forEach(function (input) {
+            const empty = !(input.value || '').trim().length;
+            input.toggleAttribute('data-empty', empty);
+        });
+    };
+
+    filters.bindFilters = function bindFilters() {
+        const head = document.querySelector('thead');
+        if (!head) return;
+
+        head.addEventListener('input', function (event) {
+            const target = event.target;
+            if (target && target.getAttribute && target.getAttribute('data-filter-field')) {
+                filters.refreshPlaceholders();
+                if (app.modules.files && typeof app.modules.files.render === 'function') {
+                    app.modules.files.render();
+                }
+            }
+        });
+
+        head.addEventListener('keydown', function (event) {
+            const target = event.target;
+            if (!(target instanceof HTMLElement)) return;
+            if (!target.getAttribute || !target.getAttribute('data-filter-field')) return;
+            if (event.key === 'Escape') {
+                target.value = '';
+                filters.refreshPlaceholders();
+                if (app.modules.files && typeof app.modules.files.render === 'function') {
+                    app.modules.files.render();
+                }
+                event.preventDefault();
+            } else if (event.key === 'Enter') {
+                event.preventDefault();
+                const inputs = Array.from(head.querySelectorAll('input[data-filter-field]'));
+                const index = inputs.indexOf(target);
+                if (index !== -1) {
+                    const next = inputs[(index + 1) % inputs.length];
+                    if (next && typeof next.focus === 'function') next.focus();
+                }
+            }
+        });
+
+        filters.refreshPlaceholders();
+    };
+
+    app.registerInit(function () {
+        filters.bindFilters();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/focus.js b/transmittal/js/focus.js
new file mode 100644
index 0000000..d97fc57
--- /dev/null
+++ b/transmittal/js/focus.js
@@ -0,0 +1,55 @@
+(function (app) {
+    'use strict';
+
+    app.registerInit(function () {
+        let tabbing = false;
+
+        document.addEventListener('keydown', function (event) {
+            if (event.key === 'Tab') {
+                tabbing = true;
+            }
+        }, true);
+
+        document.addEventListener('mousedown', function () {
+            tabbing = false;
+        }, true);
+
+        document.addEventListener('focusin', function (event) {
+            if (!tabbing) {
+                return;
+            }
+            tabbing = false;
+            const target = event.target;
+            if (!target) {
+                return;
+            }
+            if (target.id === 'remarks') {
+                return;
+            }
+            if (target instanceof HTMLInputElement) {
+                try {
+                    target.select();
+                } catch (_) {
+                    // ignore selection issues
+                }
+                return;
+            }
+            if (target instanceof HTMLTextAreaElement) {
+                return;
+            }
+            if (target.isContentEditable) {
+                try {
+                    const selection = window.getSelection && window.getSelection();
+                    if (selection && document.createRange) {
+                        const range = document.createRange();
+                        range.selectNodeContents(target);
+                        selection.removeAllRanges();
+                        selection.addRange(range);
+                    }
+                } catch (_) {
+                    // ignore
+                }
+            }
+        }, true);
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/hydrate.js b/transmittal/js/hydrate.js
new file mode 100644
index 0000000..61d762a
--- /dev/null
+++ b/transmittal/js/hydrate.js
@@ -0,0 +1,258 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const json = app.json;
+    const util = app.util;
+
+    /**
+     * Hydrates static HTML content with data from JSON.
+     * Called on page load to hide static placeholders and show dynamic content.
+     */
+    function hydrate() {
+        // Hide static "Not Validated" warning (will be replaced by dynamic validation)
+        const staticWarning = dom.qs('#signature-status-static');
+        if (staticWarning) {
+            staticWarning.hidden = true;
+        }
+        
+        // Digest will be populated by security.renderSignaturesList()
+        // which is called after signature verification
+    }
+
+    /**
+     * Populates static HTML before saving/publishing.
+     * This ensures the page displays content even without JavaScript.
+     */
+    async function populateStatic() {
+        const data = json.parse();
+        const envelope = data.envelope || {};
+        const payload = data.payload || {};
+        const signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+        const files = Array.isArray(payload.files) ? payload.files : [];
+        
+        // Populate all form fields with actual values
+        const fields = {
+            '#type': payload.type || 'Transmittal',
+            '#title': payload.title || '',
+            '#owner-name': payload.client || '',
+            '#project-name': payload.project || '',
+            '#project-number': payload.projectNumber || '',
+            '#tracking-number': payload.trackingNumber || '',
+            '#date': payload.date || '',
+            '#from': payload.from || '',
+            '#to': payload.to || '',
+            '#purpose': payload.purpose || '',
+            '#response-due': payload.responseDue || '',
+            '#subject': payload.subject || '',
+            '#remarks': payload.remarks || ''
+        };
+        
+        Object.keys(fields).forEach(function(selector) {
+            const el = dom.qs(selector);
+            if (el) {
+                if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+                    el.value = fields[selector];
+                    el.setAttribute('value', fields[selector]);
+                } else {
+                    el.textContent = fields[selector];
+                }
+            }
+        });
+        var typeDisp = dom.qs('#type-display');
+        if (typeDisp) { typeDisp.textContent = fields['#type']; }
+        
+        // Render markdown for static display
+        if (app.modules.markdown && payload.remarks) {
+            const remarksRender = dom.qs('#remarks-render');
+            if (remarksRender) {
+                remarksRender.innerHTML = app.modules.markdown.render(payload.remarks);
+            }
+        }
+        
+        // Populate table with file data
+        const SELF_HASH = app.constants.SELF_HASH;
+        const tbody = dom.qs('.table-wrapper tbody');
+        if (tbody) {
+            let html = '';
+            let rowNum = 0;
+            // Separate self-entry from regular files
+            var selfFile = null;
+            var regularFiles = [];
+            files.forEach(function(file) {
+                if (file.sha256 === SELF_HASH) {
+                    selfFile = file;
+                } else {
+                    regularFiles.push(file);
+                }
+            });
+            // If no explicit self-entry in JSON, synthesize one from payload header
+            if (!selfFile) {
+                selfFile = {
+                    trackingNumber: payload.trackingNumber || '',
+                    title: payload.subject || payload.title || '',
+                    revision: payload.date || '',
+                    status: payload.purpose || '',
+                    extension: 'html',
+                    fileSize: 0,
+                    sha256: SELF_HASH
+                };
+            }
+            // Build self-link filename from payload fields
+            var selfFilename = '';
+            var dataModule = app.modules.data;
+            if (dataModule && dataModule.buildFileName) {
+                selfFilename = dataModule.buildFileName(payload, { extension: 'html' });
+            }
+            var selfHref = selfFilename ? encodeURI('./' + selfFilename) : '';
+            var selfTrackingHtml = selfHref
+                ? '<a href="' + selfHref + '" class="text-gray-500 hover:underline" target="_blank" rel="noopener">' + util.escapeHtml(selfFile.trackingNumber || '') + '</a>'
+                : util.escapeHtml(selfFile.trackingNumber || '');
+            // Row 0: self-entry
+            html += '<tr class="self-entry">' +
+                '<td class="px-2 py-1 text-center text-gray-400">0</td>' +
+                '<td class="px-2 py-1 text-gray-500 font-mono">' + selfTrackingHtml + '</td>' +
+                '<td class="px-2 py-1 text-gray-500">' + util.escapeHtml(selfFile.title || '') + '</td>' +
+                '<td class="px-2 py-1 text-center text-gray-500 font-mono">' + util.escapeHtml(selfFile.revision || '') + '</td>' +
+                '<td class="px-2 py-1 text-center text-gray-500">' + util.escapeHtml(selfFile.status || '') + '</td>' +
+                '<td class="px-2 py-1 text-center text-gray-500">html</td>' +
+                '<td class="px-2 py-1 text-right text-gray-400">\u2014</td>' +
+                '<td class="px-2 py-1 font-mono text-[9px] text-gray-400 italic">see above</td>' +
+                '</tr>';
+            // Remaining files
+            regularFiles.forEach(function(file) {
+                rowNum++;
+                var isUnmatched = !file.sha256 && !file.fileSize;
+                var formattedSize = isUnmatched ? '\u2014' : (file.fileSize ? util.formatFileSize(file.fileSize) : '');
+                var sizeClass = isUnmatched ? 'px-2 py-1 text-right text-gray-400' : 'px-2 py-1 text-right';
+                var hashContent = isUnmatched ? '<span class="italic text-gray-400">pending</span>' : (file.sha256 ? util.formatShortFileHash(file.sha256) : '');
+                html += '<tr>' +
+                    '<td class="px-2 py-1 text-center text-gray-400">' + rowNum + '</td>' +
+                    '<td class="px-2 py-1">' + (file.trackingNumber || '') + '</td>' +
+                    '<td class="px-2 py-1">' + (file.title || '') + '</td>' +
+                    '<td class="px-2 py-1 text-center">' + (file.revision || '') + '</td>' +
+                    '<td class="px-2 py-1 text-center">' + (file.status || '') + '</td>' +
+                    '<td class="px-2 py-1 text-center">' + (file.extension || '') + '</td>' +
+                    '<td class="' + sizeClass + '">' + formattedSize + '</td>' +
+                    '<td class="px-2 py-1 font-mono text-[9px]">' + hashContent + '</td>' +
+                    '</tr>';
+            });
+            tbody.innerHTML = html || '<tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr>';
+        }
+        
+        // Populate digest card (static fallback using verify-card format)
+        const digestDisplay = dom.qs('#digest-display');
+        if (digestDisplay && envelope.digest) {
+            const digestedAt = envelope.digestedAt ? new Date(envelope.digestedAt).toLocaleString() : 'Unknown';
+            digestDisplay.innerHTML =
+                '<div class="verify-card verify-card--info">' +
+                '<div class="verify-card__status verify-card__status--info">Digest (SHA-256)</div>' +
+                '<div class="verify-card__detail"><code>' + envelope.digest + '</code></div>' +
+                '<div class="verify-card__detail">' + digestedAt + '</div>' +
+                '</div>';
+        }
+
+        // Populate digest in Advanced section
+        const digestEl = dom.qs('#digest-info');
+        if (digestEl && envelope.digest) {
+            const digestedAt = envelope.digestedAt ? new Date(envelope.digestedAt).toLocaleString() : 'Unknown';
+            digestEl.innerHTML = '<div class="flex flex-col gap-0.5">' +
+                '<div><strong>Digest (SHA-256):</strong></div>' +
+                '<code class="text-[9px] break-all bg-gray-100 px-1 py-0.5 rounded">' + envelope.digest + '</code>' +
+                '<div class="text-gray-500">Created: ' + digestedAt + '</div>' +
+                '</div>';
+        }
+
+        // Populate static signature cards
+        const sigList = dom.qs('#signatures-list');
+        if (sigList && signatures.length > 0) {
+            let html = '';
+            for (let i = 0; i < signatures.length; i++) {
+                const sig = signatures[i];
+                const fingerprint = await util.publicKeyFingerprint(sig.publicKeyJwk);
+                const fpDisplay = fingerprint === null ? 'unavailable' : (fingerprint || 'Unknown');
+                const signedAt = sig.signedAt ? new Date(sig.signedAt).toLocaleString() : 'Unknown';
+                html += '<div class="verify-card verify-card--info">' +
+                    '<div class="verify-card__status verify-card__status--info">Signature ' + (i + 1) + '</div>' +
+                    '<div class="verify-card__detail">Key: <code>' + fpDisplay + '</code></div>' +
+                    '<div class="verify-card__detail">' + signedAt + '</div>' +
+                    '</div>';
+            }
+            sigList.innerHTML = html;
+        }
+
+        // Show static warning
+        const staticWarning = dom.qs('#signature-status-static');
+        if (staticWarning) {
+            staticWarning.hidden = !(envelope.digest || signatures.length > 0);
+        }
+    }
+
+    /**
+     * Populates form fields from current JSON data at runtime.
+     * Used by verification mode to hydrate the form with loaded data.
+     */
+    function hydrateForm() {
+        const data = json.parse();
+        const payload = data.payload || {};
+        const files = Array.isArray(payload.files) ? payload.files : [];
+
+        var fields = {
+            '#type': payload.type || 'Transmittal',
+            '#title': payload.title || '',
+            '#owner-name': payload.client || '',
+            '#project-name': payload.project || '',
+            '#project-number': payload.projectNumber || '',
+            '#tracking-number': payload.trackingNumber || '',
+            '#date': payload.date || '',
+            '#from': payload.from || '',
+            '#to': payload.to || '',
+            '#purpose': payload.purpose || '',
+            '#response-due': payload.responseDue || '',
+            '#subject': payload.subject || '',
+            '#remarks': payload.remarks || ''
+        };
+
+        Object.keys(fields).forEach(function (selector) {
+            var el = dom.qs(selector);
+            if (el) {
+                if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+                    el.value = fields[selector];
+                } else {
+                    el.textContent = fields[selector];
+                }
+            }
+        });
+        var typeDisp2 = dom.qs('#type-display');
+        if (typeDisp2) { typeDisp2.textContent = fields['#type']; }
+
+        // Render markdown
+        if (app.modules.markdown && payload.remarks) {
+            var remarksRender = dom.qs('#remarks-render');
+            if (remarksRender) {
+                remarksRender.innerHTML = app.modules.markdown.render(payload.remarks);
+            }
+        }
+
+        // Render email fields
+        if (app.modules.emailTags) {
+            if (app.modules.emailTags.render) { app.modules.emailTags.render(); }
+            if (app.modules.emailTags.renderFrom) { app.modules.emailTags.renderFrom(); }
+        }
+
+        // Visibility
+        if (app.modules.visibility && app.modules.visibility.applyFieldVisibility) {
+            app.modules.visibility.applyFieldVisibility();
+        }
+    }
+
+    app.modules.hydrate = {
+        hydrate: hydrate,
+        hydrateForm: hydrateForm,
+        populateStatic: populateStatic
+    };
+
+    app.registerInit(function () {
+        hydrate();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/json.js b/transmittal/js/json.js
new file mode 100644
index 0000000..3b8e8fc
--- /dev/null
+++ b/transmittal/js/json.js
@@ -0,0 +1,40 @@
+(function (app) {
+    'use strict';
+
+    const json = app.json = app.json || {};
+
+    const SCRIPT_ID = 'transmittal-data';
+
+    json.getScriptElement = function getScriptElement() {
+        return document.getElementById(SCRIPT_ID);
+    };
+
+    json.getRawText = function getRawText() {
+        const el = json.getScriptElement();
+        return el && typeof el.textContent === 'string' ? el.textContent : '';
+    };
+
+    json.setData = function setData(obj) {
+        const el = json.getScriptElement();
+        if (!el) {
+            return;
+        }
+        try {
+            el.textContent = JSON.stringify(obj, null, 2);
+        } catch (err) {
+            console.error('[transmittal] failed to serialize JSON', err);
+        }
+    };
+
+    json.parse = function parse() {
+        try {
+            const raw = json.getRawText();
+            if (raw && raw.trim().length) {
+                return JSON.parse(raw);
+            }
+        } catch (err) {
+            console.error('[transmittal] failed to parse JSON store', err);
+        }
+        return app.util.createEmptyData('');
+    };
+})(window.transmittalApp);
diff --git a/transmittal/js/live-digest.js b/transmittal/js/live-digest.js
new file mode 100644
index 0000000..ba96b9c
--- /dev/null
+++ b/transmittal/js/live-digest.js
@@ -0,0 +1,106 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const util = app.util;
+    const json = app.json;
+
+    let debounceTimer = null;
+    const DEBOUNCE_MS = 300; // 300ms debounce
+
+    async function updateLiveDigest() {
+        var digestDisplay = dom.qs('#digest-display');
+        if (!digestDisplay) { return; }
+
+        // Published — let renderSignaturesList handle the display
+        var data = json.parse();
+        var envelope = (data && data.envelope) || {};
+        if (envelope.digest) { return; }
+
+        // Only compute live digest in edit mode
+        if (app.state && app.state.mode !== 'edit') { return; }
+
+        try {
+            // Sync form-field values to JSON only after the app has fully
+            // initialised (i.e. loadFromJson has run and app.data.files is
+            // populated). Calling syncUiToJson before that would overwrite
+            // the saved-draft JSON with the empty in-memory state.
+            if (app._initialized && app.modules.files && app.modules.files.syncUiToJson) {
+                app.modules.files.syncUiToJson();
+                // Re-read after sync so the digest reflects the updated payload.
+                data = json.parse();
+            }
+            var payload = (data && data.payload) || {};
+            var payloadStr = util.canonicalStringify(payload);
+            var digest = await util.hashString(payloadStr);
+            var now = new Date().toLocaleString();
+
+            // Render draft verify-card
+            digestDisplay.innerHTML = '';
+            var card = document.createElement('div');
+            card.className = 'verify-card verify-card--draft';
+
+            var status = document.createElement('div');
+            status.className = 'verify-card__status verify-card__status--draft';
+            status.textContent = 'DRAFT';
+            card.appendChild(status);
+
+            var detail = document.createElement('div');
+            detail.className = 'verify-card__detail';
+            detail.innerHTML = 'Digest (SHA-256): <code>' + digest + '</code>';
+            card.appendChild(detail);
+
+            var time = document.createElement('div');
+            time.className = 'verify-card__detail';
+            time.textContent = 'Live \u2014 ' + now;
+            card.appendChild(time);
+
+            digestDisplay.appendChild(card);
+        } catch (err) {
+            console.error('[live-digest] Failed to calculate digest:', err);
+        }
+    }
+
+    function scheduleDigestUpdate() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(updateLiveDigest, DEBOUNCE_MS);
+    }
+
+    function bindFormChanges() {
+        const form = dom.qs('#transmittal-form');
+        if (!form) {
+            return;
+        }
+
+        // Listen to all input changes
+        form.addEventListener('input', scheduleDigestUpdate);
+        form.addEventListener('change', scheduleDigestUpdate);
+    }
+
+    function subscribeToStateChanges() {
+        // Subscribe to reactive state changes
+        if (app.state && app.state.subscribe) {
+            app.state.subscribe(function(property, newValue, oldValue) {
+                scheduleDigestUpdate();
+            });
+        }
+    }
+
+    app.onDirty(function () {
+        scheduleDigestUpdate();
+    });
+
+    app.modules.liveDigest = {
+        update: updateLiveDigest,
+        schedule: scheduleDigestUpdate
+    };
+
+    app.registerInit(function () {
+        bindFormChanges();
+        subscribeToStateChanges();
+        // Calculate initial digest
+        updateLiveDigest();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/logos.js b/transmittal/js/logos.js
new file mode 100644
index 0000000..c6d1226
--- /dev/null
+++ b/transmittal/js/logos.js
@@ -0,0 +1,45 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const logosModule = app.modules.logos = {};
+
+    // Read an image file and apply it as a logo.
+    // imgId: 'left-logo' or 'right-logo'
+    async function applyLogoFile(imgId, file) {
+        if (!file) { return; }
+        var img = dom.qs('#' + imgId);
+        if (!img) { return; }
+        try {
+            var dataUrl = await new Promise(function (resolve, reject) {
+                var reader = new FileReader();
+                reader.onload = function () { resolve(reader.result); };
+                reader.onerror = function () { reject(reader.error); };
+                reader.readAsDataURL(file);
+            });
+            img.src = dataUrl;
+            // Mark logo-cell as having a logo so placeholder is hidden
+            var cell = img.closest('[data-drop-zone]');
+            if (cell) { cell.classList.add('has-logo'); }
+            app.state.apply();
+        } catch (err) {
+            console.error('[transmittal] logo apply failed', err);
+            alert('Failed to load logo: ' + (err && err.message ? err.message : err));
+        }
+    }
+
+    logosModule.applyLogoFile = applyLogoFile;
+
+    app.registerInit(function () {
+        // Nothing to wire here — drag-and-drop is handled by drop-zones.js.
+        // Keep the has-logo class in sync with existing logo src on load.
+        ['left-logo', 'right-logo'].forEach(function (imgId) {
+            var img = dom.qs('#' + imgId);
+            if (!img) { return; }
+            var cell = img.closest('[data-drop-zone]');
+            if (cell && img.src && img.src !== window.location.href) {
+                cell.classList.add('has-logo');
+            }
+        });
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/main.js b/transmittal/js/main.js
new file mode 100644
index 0000000..f5183bb
--- /dev/null
+++ b/transmittal/js/main.js
@@ -0,0 +1,129 @@
+(function (app) {
+    'use strict';
+
+    const filesModule = app.modules.files;
+    const security = app.modules.security;
+    const mode = app.modules.mode;
+
+    // Global handler: close parent <dialog> when any [data-modal-close] button is clicked
+    document.addEventListener('click', function (e) {
+        var btn = e.target.closest('[data-modal-close]');
+        if (!btn) { return; }
+        var dlg = btn.closest('dialog');
+        if (dlg && dlg.open) { dlg.close(); }
+    });
+
+    // ── Date field + calendar picker wiring ────────────
+    function toIso(str) {
+        if (!str || !str.trim()) { return ''; }
+        var t = str.trim();
+        if (/^\d{4}-\d{2}-\d{2}$/.test(t)) { return t; }
+        var d = new Date(t);
+        if (!isNaN(d.getTime())) {
+            var y = d.getFullYear();
+            var m = String(d.getMonth() + 1).padStart(2, '0');
+            var day = String(d.getDate()).padStart(2, '0');
+            return y + '-' + m + '-' + day;
+        }
+        return t;
+    }
+
+    function wireDatePicker(textId, pickerId) {
+        var dateText = app.dom.qs(textId);
+        var datePicker = app.dom.qs(pickerId);
+        if (!dateText || !datePicker) { return; }
+
+        dateText.addEventListener('click', function () {
+            var iso = toIso(dateText.value);
+            datePicker.value = (iso && /^\d{4}-\d{2}-\d{2}$/.test(iso)) ? iso : '';
+            datePicker.showPicker();
+        });
+
+        datePicker.addEventListener('change', function () {
+            if (datePicker.value) {
+                dateText.value = datePicker.value;
+                dateText.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        });
+
+        dateText.addEventListener('blur', function () {
+            var iso = toIso(dateText.value);
+            if (iso !== dateText.value) {
+                dateText.value = iso;
+                dateText.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        });
+    }
+
+    wireDatePicker('#date', '#date-picker-hidden');
+    wireDatePicker('#response-due', '#response-due-picker-hidden');
+
+    app.registerInit(async function () {
+        // ── Type combo dropdown wiring ───────────────────────
+        (function () {
+            var typeHidden = app.dom.qs('#type');
+            var typeDisplay = app.dom.qs('#type-display');
+            var menu = app.dom.qs('#type-menu');
+            if (!typeHidden || !typeDisplay || !menu) { return; }
+
+            function syncToHidden() {
+                var text = (typeDisplay.textContent || '').trim();
+                typeHidden.value = text;
+                typeHidden.dispatchEvent(new Event('input', { bubbles: true }));
+                if (app.state && app.state.apply) { app.state.apply(); }
+            }
+
+            function isOpen() { return !menu.classList.contains('hidden'); }
+            function closeMenu() { menu.classList.add('hidden'); }
+
+            typeDisplay.addEventListener('input', syncToHidden);
+
+            typeDisplay.addEventListener('blur', syncToHidden);
+
+            typeDisplay.addEventListener('keydown', function (e) {
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    typeDisplay.blur();
+                }
+            });
+
+            typeDisplay.addEventListener('paste', function (e) {
+                e.preventDefault();
+                var text = (e.clipboardData || window.clipboardData).getData('text/plain');
+                document.execCommand('insertText', false, text.replace(/\n/g, ' '));
+            });
+
+            typeDisplay.addEventListener('click', function () {
+                if (app.state.mode !== 'edit') { return; }
+                if (isOpen()) { closeMenu(); } else { menu.classList.remove('hidden'); }
+            });
+
+            menu.addEventListener('click', function (e) {
+                var opt = e.target.closest('[data-value]');
+                if (!opt) { return; }
+                var val = opt.getAttribute('data-value');
+                typeDisplay.textContent = val;
+                typeHidden.value = val;
+                typeHidden.dispatchEvent(new Event('input', { bubbles: true }));
+                closeMenu();
+                if (app.state && app.state.apply) { app.state.apply(); }
+            });
+
+            document.addEventListener('click', function (e) {
+                if (isOpen() && !menu.contains(e.target) && e.target !== typeDisplay) {
+                    closeMenu();
+                }
+            });
+        })();
+        filesModule.loadFromJson();
+        app._initialized = true;
+        app.state.updateHiddenFields();
+        app.state.apply();
+        await security.verifySignatureIfPresent();
+        mode.refresh();
+    });
+
+    app.ready(function () {
+        app.start();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/markdown-editor.js b/transmittal/js/markdown-editor.js
new file mode 100644
index 0000000..263b5e9
--- /dev/null
+++ b/transmittal/js/markdown-editor.js
@@ -0,0 +1,222 @@
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var markdown = app.modules.markdown;
+
+    var editor = app.modules.markdownEditor = {};
+    var inputEl = null;       // plain textarea
+    var toolbarEl = null;     // button bar
+    var wrapperEl = null;     // container for all editor elements
+    var initialized = false;
+    var renderClickBound = false;
+    var outsideClickBound = false;
+
+    // ── Textarea helpers ──────────────────────────────────────────────
+
+    function syncToHiddenTextarea() {
+        var remarks = dom.qs('#remarks');
+        if (remarks && inputEl) { remarks.value = inputEl.value; }
+    }
+
+    function insertText(before, after, placeholder) {
+        if (!inputEl) { return; }
+        inputEl.focus();
+        var start = inputEl.selectionStart;
+        var end = inputEl.selectionEnd;
+        var selected = inputEl.value.substring(start, end);
+        var insert = selected || placeholder || '';
+        var full = before + insert + (after || '');
+        // execCommand preserves undo stack in most browsers
+        document.execCommand('insertText', false, full);
+        // If we used placeholder, select it for easy replacement
+        if (!selected && insert) {
+            inputEl.selectionStart = start + before.length;
+            inputEl.selectionEnd = start + before.length + insert.length;
+        }
+    }
+
+    // ── Button bar ────────────────────────────────────────────────────
+
+    var buttons = [
+        { label: 'B',  title: 'Bold',           wrap: ['**', '**'],       placeholder: 'bold' },
+        { label: 'I',  title: 'Italic',          wrap: ['*', '*'],         placeholder: 'italic' },
+        { label: 'H',  title: 'Heading',         wrap: ['## ', ''],        placeholder: 'heading' },
+        { label: '\u2022', title: 'Bullet list',  wrap: ['- ', ''],         placeholder: 'item' },
+        { label: '1.', title: 'Numbered list',   wrap: ['1. ', ''],        placeholder: 'item' },
+        { label: '\uD83D\uDD17', title: 'Link',  wrap: ['[', '](url)'],    placeholder: 'link text' },
+        { label: '\u229E', title: 'Table',        insert: '| Col 1 | Col 2 | Col 3 |\n| --- | --- | --- |\n| | | |\n' }
+    ];
+
+    function onButtonClick(event) {
+        var btn = event.currentTarget;
+        var idx = parseInt(btn.getAttribute('data-idx'), 10);
+        var def = buttons[idx];
+        if (!def) { return; }
+        event.preventDefault();
+        if (def.wrap) {
+            insertText(def.wrap[0], def.wrap[1], def.placeholder);
+        } else if (def.insert) {
+            insertText(def.insert, '', '');
+        }
+        syncToHiddenTextarea();
+        app.markDirty();
+    }
+
+    function createToolbar() {
+        if (toolbarEl) { return toolbarEl; }
+        toolbarEl = document.createElement('div');
+        toolbarEl.className = 'md-toolbar';
+        buttons.forEach(function (def, i) {
+            var btn = document.createElement('button');
+            btn.type = 'button';
+            btn.className = 'md-toolbar-btn';
+            btn.textContent = def.label;
+            btn.title = def.title;
+            btn.setAttribute('data-idx', i);
+            btn.addEventListener('mousedown', function (e) { e.preventDefault(); });
+            btn.addEventListener('click', onButtonClick);
+            toolbarEl.appendChild(btn);
+        });
+        return toolbarEl;
+    }
+
+    // ── Visibility helpers ────────────────────────────────────────────
+
+    function refreshRender() {
+        var textarea = dom.qs('#remarks');
+        var renderEl = dom.qs('#remarks-render');
+        if (!textarea || !renderEl) { return; }
+        var value = textarea.value || '';
+        if (value.trim()) {
+            renderEl.innerHTML = markdown.render(value);
+        } else if (app.state.mode === 'edit' && !app.state.published) {
+            renderEl.innerHTML = '<span class="remarks-placeholder">Click to add remarks</span>';
+        } else {
+            renderEl.innerHTML = '';
+        }
+    }
+
+    function showRendered() {
+        if (wrapperEl) { wrapperEl.style.display = 'none'; }
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (renderContainer) { renderContainer.hidden = false; }
+        syncToHiddenTextarea();
+        refreshRender();
+    }
+
+    function showEditor() {
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (renderContainer) { renderContainer.hidden = true; }
+        if (!initialized) { editor.init(); }
+        if (wrapperEl) { wrapperEl.style.display = ''; }
+        var remarks = dom.qs('#remarks');
+        if (remarks && inputEl) {
+            inputEl.value = remarks.value || '';
+        }
+        if (inputEl) { inputEl.focus(); }
+    }
+
+    // ── Click-to-edit on rendered preview ─────────────────────────────
+
+    function onRenderClick() {
+        if (app.state.mode !== 'edit' || app.state.published) { return; }
+        showEditor();
+    }
+
+    function bindRenderClick() {
+        if (renderClickBound) { return; }
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (!renderContainer) { return; }
+        renderContainer.addEventListener('click', onRenderClick);
+        renderClickBound = true;
+    }
+
+    function setRenderClickable(clickable) {
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (!renderContainer) { return; }
+        if (clickable) {
+            renderContainer.classList.add('remarks-clickable');
+        } else {
+            renderContainer.classList.remove('remarks-clickable');
+        }
+    }
+
+    // ── Outside-click collapse ────────────────────────────────────────
+
+    function onDocumentMousedown(event) {
+        if (!wrapperEl) { return; }
+        if (wrapperEl.style.display === 'none') { return; }
+        if (wrapperEl.contains(event.target)) { return; }
+        showRendered();
+    }
+
+    function bindOutsideClick() {
+        if (outsideClickBound) { return; }
+        document.addEventListener('mousedown', onDocumentMousedown, true);
+        outsideClickBound = true;
+    }
+
+    // ── Public API ────────────────────────────────────────────────────
+
+    editor.init = function initEditor() {
+        if (initialized) { return; }
+        var remarksWrapper = dom.qs('#remarks-wrapper');
+        if (!remarksWrapper) { return; }
+
+        wrapperEl = document.createElement('div');
+        wrapperEl.id = 'remarks-editor';
+        wrapperEl.style.display = 'none';
+
+        wrapperEl.appendChild(createToolbar());
+
+        // Edit area container
+        var editArea = document.createElement('div');
+        editArea.className = 'md-edit-area';
+
+        // Plain textarea
+        inputEl = document.createElement('textarea');
+        inputEl.className = 'md-input';
+        inputEl.spellcheck = true;
+        inputEl.setAttribute('aria-label', 'Remarks');
+        editArea.appendChild(inputEl);
+
+        wrapperEl.appendChild(editArea);
+        remarksWrapper.appendChild(wrapperEl);
+
+        inputEl.addEventListener('input', function () {
+            syncToHiddenTextarea();
+            app.markDirty();
+        });
+
+        inputEl.addEventListener('keydown', function (e) {
+            if (e.key === 'Tab') {
+                e.preventDefault();
+                document.execCommand('insertText', false, '    ');
+            }
+        });
+
+        bindOutsideClick();
+        initialized = true;
+    };
+
+    editor.destroy = function destroyEditor() {
+        if (wrapperEl) { wrapperEl.style.display = 'none'; }
+        syncToHiddenTextarea();
+    };
+
+    editor.showRendered = showRendered;
+    editor.showEditor = showEditor;
+    editor.refreshRender = refreshRender;
+    editor.bindRenderClick = bindRenderClick;
+    editor.setRenderClickable = setRenderClickable;
+
+    editor.isActive = function isActive() {
+        return initialized && wrapperEl && wrapperEl.style.display !== 'none';
+    };
+
+    editor.getValue = function getValue() {
+        return inputEl ? inputEl.value : '';
+    };
+
+})(window.transmittalApp);
diff --git a/transmittal/js/markdown.js b/transmittal/js/markdown.js
new file mode 100644
index 0000000..acf5c60
--- /dev/null
+++ b/transmittal/js/markdown.js
@@ -0,0 +1,221 @@
+(function (app) {
+    'use strict';
+
+    const markdown = app.modules.markdown = {};
+    const dom = app.dom;
+
+    var escapeHtml = app.util.escapeHtml;
+
+    function renderInline(text) {
+        if (!text) {
+            return '';
+        }
+        let rendered = escapeHtml(text);
+        const codePlaceholders = [];
+        rendered = rendered.replace(/`([^`]+)`/g, function (_, code) {
+            codePlaceholders.push('<code>' + escapeHtml(code) + '</code>');
+            return '\u0000C' + (codePlaceholders.length - 1) + '\u0000';
+        });
+        rendered = rendered.replace(/\[([^\]]+)\]\(([^)]+)\)/g, function (_, label, url) {
+            const trimmedUrl = url.trim();
+            const allowed = /^(https?:\/\/|mailto:|tel:|\/|\.{1,2}\/)/i.test(trimmedUrl);
+            if (!allowed) {
+                return '[' + label + '](' + url + ')';
+            }
+            const safeUrl = trimmedUrl.replace(/\s+/g, '%20').replace(/"/g, '%22');
+            return '<a href="' + safeUrl + '" target="_blank" rel="noopener">' + escapeHtml(label) + '</a>';
+        });
+        rendered = rendered.replace(/(^|\s)((https?:\/\/)[^\s<]+)/gi, function (_, prefix, url) {
+            const safe = url.replace(/"/g, '%22');
+            return prefix + '<a href="' + safe + '" target="_blank" rel="noopener">' + url + '</a>';
+        });
+        rendered = rendered
+            .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+            .replace(/__([^_]+)__/g, '<strong>$1</strong>')
+            .replace(/(^|\W)\*([^*]+)\*(?=\W|$)/g, '$1<em>$2</em>')
+            .replace(/(^|\W)_([^_]+)_(?=\W|$)/g, '$1<em>$2</em>')
+            .replace(/~~([^~]+)~~/g, '<del>$1</del>');
+        rendered = rendered.replace(/\u0000C(\d+)\u0000/g, function (_, index) {
+            return codePlaceholders[Number(index)] || '';
+        });
+        return rendered;
+    }
+
+    function leadingIndent(text) {
+        const expanded = text.replace(/\t/g, '    ');
+        const match = expanded.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+    }
+
+    markdown.render = function renderMarkdownBasic(markdownText) {
+        const lines = (markdownText || '').replace(/\r\n?/g, '\n').split('\n');
+        const output = [];
+        let inCode = false;
+        let codeBuffer = [];
+        const listStack = [];
+        const tableSeparator = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+
+        function flushCode() {
+            if (!inCode) {
+                return;
+            }
+            output.push('<pre><code>' + escapeHtml(codeBuffer.join('\n')) + '</code></pre>');
+            inCode = false;
+            codeBuffer = [];
+        }
+
+        function closeListsTo(indent) {
+            while (listStack.length && listStack[listStack.length - 1].indent > indent) {
+                output.push('</' + listStack.pop().type + '>');
+            }
+        }
+
+        function closeAllLists() {
+            closeListsTo(-1);
+        }
+
+        function openList(type, indent) {
+            listStack.push({ type, indent });
+            output.push('<' + type + '>');
+        }
+
+        function splitCells(row) {
+            const trimmed = row.trim().replace(/^\|/, '').replace(/\|$/, '');
+            return trimmed.split('|').map(function (cell) {
+                return cell.trim();
+            });
+        }
+
+        for (let index = 0; index < lines.length; index += 1) {
+            const raw = lines[index];
+            const line = raw;
+            if (/^```/.test(line)) {
+                if (inCode) {
+                    flushCode();
+                } else {
+                    inCode = true;
+                    codeBuffer = [];
+                }
+                continue;
+            }
+            if (inCode) {
+                codeBuffer.push(raw);
+                continue;
+            }
+            if (!line.trim()) {
+                closeAllLists();
+                continue;
+            }
+            if (/\|/.test(line) && index + 1 < lines.length && tableSeparator.test(lines[index + 1])) {
+                closeAllLists();
+                const headerCells = splitCells(line);
+                index += 2;
+                const body = [];
+                while (index < lines.length && /\|/.test(lines[index]) && lines[index].trim()) {
+                    body.push(splitCells(lines[index]));
+                    index += 1;
+                }
+                index -= 1;
+                const thead = '<thead><tr>' + headerCells.map(function (cell) {
+                    return '<th>' + renderInline(cell) + '</th>';
+                }).join('') + '</tr></thead>';
+                const tbody = '<tbody>' + body.map(function (rowCells) {
+                    return '<tr>' + rowCells.map(function (cell) {
+                        return '<td>' + renderInline(cell) + '</td>';
+                    }).join('') + '</tr>';
+                }).join('') + '</tbody>';
+                output.push('<table>' + thead + tbody + '</table>');
+                continue;
+            }
+            if (/^\s*(?:---|\*\*\*|___)\s*$/.test(line)) {
+                closeAllLists();
+                output.push('<hr/>');
+                continue;
+            }
+            if (/^\s*>\s?/.test(line)) {
+                closeAllLists();
+                const quoteLines = [];
+                while (index < lines.length && /^\s*>\s?/.test(lines[index])) {
+                    quoteLines.push(lines[index].replace(/^\s*>\s?/, ''));
+                    index += 1;
+                }
+                index -= 1;
+                const html = quoteLines.map(function (text) {
+                    return '<p>' + renderInline(text) + '</p>';
+                }).join('\n');
+                output.push('<blockquote>' + html + '</blockquote>');
+                continue;
+            }
+            let match = line.match(/^(#{1,6})\s+(.*)$/);
+            if (match) {
+                closeAllLists();
+                const level = match[1].length;
+                const text = renderInline(match[2].trim());
+                output.push('<h' + level + '>' + text + '</h' + level + '>');
+                continue;
+            }
+            match = line.match(/^(\s*)[-*+]\s+(.*)$/);
+            if (match) {
+                const indent = leadingIndent(match[1]);
+                const type = 'ul';
+                if (!listStack.length || listStack[listStack.length - 1].indent < indent) {
+                    openList(type, indent);
+                } else {
+                    closeListsTo(indent);
+                    if (!listStack.length || listStack[listStack.length - 1].type !== type || listStack[listStack.length - 1].indent !== indent) {
+                        openList(type, indent);
+                    }
+                }
+                output.push('<li>' + renderInline(match[2].trim()) + '</li>');
+                continue;
+            }
+            match = line.match(/^(\s*)\d+\.\s+(.*)$/);
+            if (match) {
+                const indent = leadingIndent(match[1]);
+                const type = 'ol';
+                if (!listStack.length || listStack[listStack.length - 1].indent < indent) {
+                    openList(type, indent);
+                } else {
+                    closeListsTo(indent);
+                    if (!listStack.length || listStack[listStack.length - 1].type !== type || listStack[listStack.length - 1].indent !== indent) {
+                        openList(type, indent);
+                    }
+                }
+                output.push('<li>' + renderInline(match[2].trim()) + '</li>');
+                continue;
+            }
+            closeAllLists();
+            output.push('<p>' + renderInline(line) + '</p>');
+        }
+
+        closeAllLists();
+        flushCode();
+        return output.join('\n');
+    };
+
+    markdown.refresh = function refreshPreview() {
+        const textarea = dom.qs('#remarks');
+        const target = dom.qs('#remarks-render');
+        if (!textarea || !target) {
+            return;
+        }
+        target.innerHTML = markdown.render(textarea.value || '');
+    };
+
+    markdown.bindRemarksLivePreview = function bindRemarksLivePreview() {
+        const textarea = dom.qs('#remarks');
+        if (!textarea) {
+            return;
+        }
+        textarea.addEventListener('input', function () {
+            if (app.state.mode === 'edit') {
+                markdown.refresh();
+            }
+        });
+        markdown.refresh();
+    };
+
+    app.registerInit(function () {
+        markdown.bindRemarksLivePreview();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/mode.js b/transmittal/js/mode.js
new file mode 100644
index 0000000..72b1c76
--- /dev/null
+++ b/transmittal/js/mode.js
@@ -0,0 +1,58 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const json = app.json;
+    const state = app.state;
+
+    function computePublishedState() {
+        const data = json.parse();
+        const digest = (data.envelope && data.envelope.digest) || '';
+        state.published = !!digest;
+        return state.published;
+    }
+
+    function setMode(mode) {
+        if (mode !== 'edit' && mode !== 'view') {
+            return;
+        }
+        if (state.published && mode === 'edit') {
+            mode = 'view';
+        }
+        state.mode = mode;
+    }
+
+    var _previousMode = state.mode;
+
+    function refresh() {
+        const wasPublished = state.published;
+        const nowPublished = computePublishedState();
+        if (nowPublished && !wasPublished) {
+            state.mode = 'view';
+        }
+        // Re-render file table only when mode actually changes (edit↔view)
+        if (state.mode !== _previousMode) {
+            _previousMode = state.mode;
+            if (app.modules.files && typeof app.modules.files.render === 'function') {
+                app.modules.files.render();
+            }
+        }
+        if (app.modules.files && app.modules.files.updateToolbars) {
+            app.modules.files.updateToolbars();
+        }
+    }
+
+    app.modules.mode = {
+        setMode,
+        refresh
+    };
+
+    app.registerInit(function () {
+        computePublishedState();
+        if (state.published) {
+            state.mode = 'view';
+        } else {
+            state.mode = 'edit';
+        }
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/publish-modal.js b/transmittal/js/publish-modal.js
new file mode 100644
index 0000000..fae49a9
--- /dev/null
+++ b/transmittal/js/publish-modal.js
@@ -0,0 +1,488 @@
+(function (app) {
+    'use strict';
+
+    if (!app || !app.dom || !app.modules) {
+        console.error('[publish-modal] App not properly initialized');
+        return;
+    }
+
+    var dom = app.dom;
+    var util = app.util;
+
+    function qs(sel) { return dom.qs(sel); }
+
+    // ── Date helpers ────────────────────────────────────
+    function getTodayIso() {
+        var d = new Date();
+        return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
+    }
+
+    function toIsoDate(str) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(str)) { return str; }
+        var d = new Date(str);
+        if (isNaN(d.getTime())) { return str; }
+        return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
+    }
+
+    function syncDateWarning() {
+        var dateInput = qs('#publish-date-input');
+        var warning = qs('#publish-date-warning');
+        if (!dateInput || !warning) { return; }
+        var val = (dateInput.value || '').trim();
+        var today = getTodayIso();
+        if (!val || val === today) {
+            warning.textContent = '';
+            warning.hidden = true;
+        } else {
+            warning.textContent = '\u26A0 Date differs from today (' + today + ')';
+            warning.hidden = false;
+        }
+    }
+
+    // ── Feedback helpers ────────────────────────────────
+    function showFeedback(feedbackEl, message, type) {
+        if (!feedbackEl) { return; }
+        feedbackEl.textContent = message || '';
+        feedbackEl.style.color = type === 'error' ? '#dc2626' : type === 'success' ? '#16a34a' : '';
+    }
+
+    // ── Success notification ────────────────────────────
+    function showSuccessNotification(filename) {
+        var notification = document.createElement('div');
+        notification.className = 'publish-notification';
+        notification.setAttribute('data-publish-notification', 'true');
+
+        var title = document.createElement('div');
+        title.className = 'publish-notification__title';
+        title.textContent = '\u2713 Transmittal Published Successfully';
+
+        var file = document.createElement('div');
+        file.className = 'publish-notification__file';
+        file.textContent = 'Saved as: ' + filename;
+
+        var closeBtn = document.createElement('button');
+        closeBtn.className = 'publish-notification__close';
+        closeBtn.textContent = 'Close';
+        closeBtn.addEventListener('click', function () { notification.remove(); });
+
+        notification.appendChild(title);
+        notification.appendChild(file);
+        notification.appendChild(closeBtn);
+        document.body.appendChild(notification);
+        setTimeout(function () { if (notification.parentElement) { notification.remove(); } }, 10000);
+    }
+
+    // ── Password dialog ─────────────────────────────────
+    function promptForPassword(fingerprint) {
+        return new Promise(function (resolve) {
+            var dialog = qs('#password-dialog');
+            var input = qs('#password-dialog-input');
+            var okBtn = qs('#password-dialog-ok');
+            var feedback = qs('#password-dialog-feedback');
+            var fpEl = qs('#password-dialog-fingerprint');
+            if (!dialog || !input || !okBtn) { resolve(null); return; }
+
+            input.value = '';
+            showFeedback(feedback, '', '');
+            if (fpEl) {
+                fpEl.textContent = fingerprint ? 'Key fingerprint: ' + fingerprint : 'This key is password-protected.';
+            }
+            dialog.showModal();
+            input.focus();
+
+            function cleanup() {
+                okBtn.removeEventListener('click', onOk);
+                dialog.removeEventListener('close', onClose);
+            }
+            function onOk() {
+                var pw = input.value;
+                cleanup();
+                dialog.close();
+                resolve(pw);
+            }
+            function onClose() {
+                cleanup();
+                resolve(null);
+            }
+            okBtn.addEventListener('click', onOk);
+            dialog.addEventListener('close', onClose);
+
+            // Enter key submits
+            input.addEventListener('keydown', function handler(e) {
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    input.removeEventListener('keydown', handler);
+                    onOk();
+                }
+            });
+        });
+    }
+
+    // ── Key dialog ──────────────────────────────────────
+    function openKeyDialog() {
+        return new Promise(function (resolve) {
+            var dialog = qs('#key-dialog');
+            var selectBtn = qs('#key-select-file');
+            var generateBtn = qs('#key-generate');
+            var generatePanel = qs('#key-generate-panel');
+            var genConfirmBtn = qs('#key-generate-confirm');
+            var genCancelBtn = qs('#key-generate-cancel');
+            var pwInput = qs('#key-password');
+            var pwConfirm = qs('#key-password-confirm');
+            var feedback = qs('#key-dialog-feedback');
+            if (!dialog) { resolve(null); return; }
+
+            // Reset state
+            if (generatePanel) { generatePanel.hidden = true; }
+            if (pwInput) { pwInput.value = ''; }
+            if (pwConfirm) { pwConfirm.value = ''; }
+            showFeedback(feedback, '', '');
+            dialog.showModal();
+
+            var resolved = false;
+            function done(jwk) {
+                if (resolved) { return; }
+                resolved = true;
+                cleanup();
+                if (dialog.open) { dialog.close(); }
+                resolve(jwk);
+            }
+            function cleanup() {
+                if (selectBtn) { selectBtn.removeEventListener('click', onSelect); }
+                if (generateBtn) { generateBtn.removeEventListener('click', onGenerate); }
+                if (genConfirmBtn) { genConfirmBtn.removeEventListener('click', onGenConfirm); }
+                if (genCancelBtn) { genCancelBtn.removeEventListener('click', onGenCancel); }
+                dialog.removeEventListener('close', onDialogClose);
+            }
+
+            function onDialogClose() { done(null); }
+
+            async function onSelect() {
+                try {
+                    var security = app.modules.security;
+                    var jwk = await pickKeyFileWithPassword();
+                    if (jwk) { done(jwk); }
+                } catch (err) {
+                    showFeedback(feedback, 'Failed to load key: ' + (err.message || err), 'error');
+                }
+            }
+
+            function onGenerate() {
+                if (generatePanel) { generatePanel.hidden = false; }
+                if (generateBtn) { generateBtn.hidden = true; }
+                if (selectBtn) { selectBtn.hidden = true; }
+            }
+
+            function onGenCancel() {
+                if (generatePanel) { generatePanel.hidden = true; }
+                if (generateBtn) { generateBtn.hidden = false; }
+                if (selectBtn) { selectBtn.hidden = false; }
+                if (pwInput) { pwInput.value = ''; }
+                if (pwConfirm) { pwConfirm.value = ''; }
+            }
+
+            async function onGenConfirm() {
+                var pw = pwInput ? pwInput.value : '';
+                var pwc = pwConfirm ? pwConfirm.value : '';
+                if (pw && pw !== pwc) {
+                    showFeedback(feedback, 'Passwords do not match.', 'error');
+                    return;
+                }
+                try {
+                    showFeedback(feedback, 'Generating key\u2026', '');
+                    var security = app.modules.security;
+                    var keys = await window.crypto.subtle.generateKey(
+                        { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify']
+                    );
+                    var privateJwk = await window.crypto.subtle.exportKey('jwk', keys.privateKey);
+                    var publicJwk = security.derivePublicFromPrivate(privateJwk);
+                    var fingerprint = await util.publicKeyFingerprint(publicJwk);
+
+                    var keyFileData;
+                    if (pw) {
+                        keyFileData = await util.encryptPrivateKey(privateJwk, pw, fingerprint);
+                    } else {
+                        keyFileData = util.wrapKeyFile(privateJwk, fingerprint);
+                    }
+                    util.downloadBlob('signing-key.zddc-key', JSON.stringify(keyFileData, null, 2), 'application/json');
+                    showFeedback(feedback, 'Key downloaded. Fingerprint: ' + (fingerprint || '(unknown)'), 'success');
+                    done(privateJwk);
+                } catch (err) {
+                    showFeedback(feedback, 'Failed to generate key: ' + (err.message || err), 'error');
+                }
+            }
+
+            if (selectBtn) { selectBtn.addEventListener('click', onSelect); }
+            if (generateBtn) { generateBtn.addEventListener('click', onGenerate); }
+            if (genConfirmBtn) { genConfirmBtn.addEventListener('click', onGenConfirm); }
+            if (genCancelBtn) { genCancelBtn.addEventListener('click', onGenCancel); }
+            dialog.addEventListener('close', onDialogClose);
+        });
+    }
+
+    // ── Pick key file with automatic password prompt ────
+    function pickKeyFileWithPassword() {
+        return new Promise(function (resolve, reject) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = '.zddc-key';
+            input.addEventListener('change', async function () {
+                try {
+                    var file = input.files && input.files[0];
+                    if (!file) { resolve(null); return; }
+                    var text = await file.text();
+                    var jwk = await util.loadKeyFile(text, promptForPassword);
+                    resolve(jwk);
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            input.click();
+        });
+    }
+
+    // ── Output checkbox helpers ───────────────────────────
+    function readOutputOptions() {
+        var saveCb = qs('#publish-save-folder');
+        var dlCb = qs('#publish-download-html');
+        return {
+            saveToFolder: saveCb && saveCb.checked,
+            download: dlCb && dlCb.checked
+        };
+    }
+
+    function syncOutputCheckboxes() {
+        var saveCb = qs('#publish-save-folder');
+        var dlCb = qs('#publish-download-html');
+        var hasDir = !!app.data.selectedDirHandle;
+        if (saveCb) { saveCb.checked = hasDir; }
+        if (dlCb) { dlCb.checked = !hasDir; }
+    }
+
+    function restoreOutputOptions(opts) {
+        var saveCb = qs('#publish-save-folder');
+        var dlCb = qs('#publish-download-html');
+        if (saveCb) { saveCb.checked = !!opts.saveToFolder; }
+        if (dlCb) { dlCb.checked = !!opts.download; }
+    }
+
+    function feedbackLabel(mode) {
+        if (mode === 'draft') { return 'Saving draft'; }
+        if (mode === 'signed') { return 'Signing and publishing'; }
+        return 'Publishing';
+    }
+
+    function setPublishBusy(busy) {
+        var btns = [qs('#publish-confirm'), qs('#publish-signed-btn'), qs('#publish-draft-btn')];
+        for (var i = 0; i < btns.length; i++) {
+            if (!btns[i]) { continue; }
+            btns[i].disabled = busy;
+            if (busy) { btns[i].classList.add('opacity-60'); }
+            else { btns[i].classList.remove('opacity-60'); }
+        }
+    }
+
+    // ── Core publish execution ──────────────────────────
+    async function executePublishFlow(mode, signingKey) {
+        var feedback = qs('#publish-modal-feedback');
+        var opts = readOutputOptions();
+
+        if (!opts.saveToFolder && !opts.download) {
+            throw new Error('Select at least one output option.');
+        }
+
+        // Prompt for directory if Save in directory is checked but none selected
+        if (opts.saveToFolder && !app.data.selectedDirHandle) {
+            try {
+                var dirHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
+                app.data.selectedDirHandle = dirHandle;
+                if (app.modules.files && app.modules.files.updateDirectoryIndicator) {
+                    app.modules.files.updateDirectoryIndicator();
+                }
+            } catch (dirErr) {
+                throw new Error('A directory is required to save. Please select a directory.');
+            }
+        }
+
+        // Sync date from modal back to form
+        var dateInput = qs('#publish-date-input');
+        var formDate = qs('#date');
+        if (dateInput && formDate && dateInput.value) {
+            formDate.value = dateInput.value;
+        }
+
+        var publishModule = app.modules.publish;
+        if (!publishModule || typeof publishModule.executePublish !== 'function') {
+            throw new Error('Publish module not ready');
+        }
+
+        showFeedback(feedback, feedbackLabel(mode) + '\u2026', '');
+
+        var result = await publishModule.executePublish({
+            mode: mode,
+            saveToFolder: opts.saveToFolder,
+            download: opts.download,
+            signingKey: signingKey || null
+        });
+
+        return result;
+    }
+
+    // ── Publish modal ───────────────────────────────────
+    function initPublishModal() {
+        var modal = qs('#publish-modal');
+        if (!modal) { return; }
+
+        var feedback = qs('#publish-modal-feedback');
+        var confirmBtn = qs('#publish-confirm');
+        var signedBtn = qs('#publish-signed-btn');
+        var draftBtn = qs('#publish-draft-btn');
+        var dateInput = qs('#publish-date-input');
+
+        // Close buttons
+        modal.querySelectorAll('[data-modal-close]').forEach(function (btn) {
+            btn.addEventListener('click', function () {
+                if (modal.open) { modal.close(); }
+            });
+        });
+
+        // Backdrop click
+        modal.addEventListener('click', function (e) {
+            if (e.target === modal) { modal.close(); }
+        });
+
+        // Date warning
+        if (dateInput) { dateInput.addEventListener('input', syncDateWarning); }
+
+        function openModal() {
+            showFeedback(feedback, '', '');
+            syncOutputCheckboxes();
+            // Populate date
+            var formDate = qs('#date');
+            if (formDate && dateInput) {
+                var val = (formDate.value || '').trim();
+                dateInput.value = val ? toIsoDate(val) : getTodayIso();
+            }
+            syncDateWarning();
+            // Warn about missing hashes before user commits
+            var missingHash = 0;
+            (app.data.files || []).forEach(function (f) {
+                if (!f.sha256) { missingHash++; }
+            });
+            if (missingHash > 0) {
+                showFeedback(feedback, missingHash + ' file(s) have no SHA-256 hash.', 'error');
+            }
+            if (!modal.open) { modal.showModal(); }
+        }
+
+        function closeAndNotify(result) {
+            if (modal.open) { modal.close(); }
+            var msg = result.zipFilename ? result.filename + ' + ' + result.zipFilename : result.filename;
+            setTimeout(function () { showSuccessNotification(msg); }, 100);
+        }
+
+        function handleError(err) {
+            showFeedback(feedback, err && err.message ? err.message : 'Publish failed.', 'error');
+            if (err && err.focusEl && typeof err.focusEl.focus === 'function') {
+                if (modal.open) { modal.close(); }
+                err.focusEl.focus();
+                if (err.focusEl.scrollIntoView) { err.focusEl.scrollIntoView({ behavior: 'smooth', block: 'center' }); }
+            }
+        }
+
+        // Publish (unsigned with digest) — primary action
+        if (confirmBtn) {
+            confirmBtn.addEventListener('click', async function () {
+                setPublishBusy(true);
+                try {
+                    var result = await executePublishFlow('digest');
+                    setPublishBusy(false);
+                    closeAndNotify(result);
+                } catch (err) {
+                    setPublishBusy(false);
+                    handleError(err);
+                }
+            });
+        }
+
+        // Publish Signed — opens key dialog first
+        if (signedBtn) {
+            signedBtn.addEventListener('click', async function () {
+                // Save user's checkbox selections before closing
+                var savedOpts = readOutputOptions();
+                if (modal.open) { modal.close(); }
+
+                try {
+                    var jwk = await openKeyDialog();
+                    if (!jwk) { openModal(); restoreOutputOptions(savedOpts); return; }
+
+                    openModal();
+                    restoreOutputOptions(savedOpts);
+                    setPublishBusy(true);
+                    var result = await executePublishFlow('signed', jwk);
+                    setPublishBusy(false);
+                    closeAndNotify(result);
+                } catch (err) {
+                    setPublishBusy(false);
+                    openModal();
+                    restoreOutputOptions(savedOpts);
+                    handleError(err);
+                }
+            });
+        }
+
+        // Save Draft
+        if (draftBtn) {
+            draftBtn.addEventListener('click', async function () {
+                setPublishBusy(true);
+                try {
+                    var result = await executePublishFlow('draft');
+                    setPublishBusy(false);
+                    closeAndNotify(result);
+                } catch (err) {
+                    setPublishBusy(false);
+                    handleError(err);
+                }
+            });
+        }
+
+        // Listen for publish requests from the primary action button
+        document.addEventListener('transmittal:open-publish', function () {
+            openModal();
+        });
+    }
+
+    // ── Password dialog close buttons ───────────────────
+    function initPasswordDialog() {
+        var dialog = qs('#password-dialog');
+        if (!dialog) { return; }
+        dialog.querySelectorAll('[data-modal-close]').forEach(function (btn) {
+            btn.addEventListener('click', function () {
+                if (dialog.open) { dialog.close(); }
+            });
+        });
+        dialog.addEventListener('click', function (e) {
+            if (e.target === dialog) { dialog.close(); }
+        });
+    }
+
+    // ── Key dialog close buttons ────────────────────────
+    function initKeyDialog() {
+        var dialog = qs('#key-dialog');
+        if (!dialog) { return; }
+        dialog.querySelectorAll('[data-modal-close]').forEach(function (btn) {
+            btn.addEventListener('click', function () {
+                if (dialog.open) { dialog.close(); }
+            });
+        });
+        dialog.addEventListener('click', function (e) {
+            if (e.target === dialog) { dialog.close(); }
+        });
+    }
+
+    app.registerInit(function () {
+        initPublishModal();
+        initPasswordDialog();
+        initKeyDialog();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/publish.js b/transmittal/js/publish.js
new file mode 100644
index 0000000..59b28ae
--- /dev/null
+++ b/transmittal/js/publish.js
@@ -0,0 +1,260 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const util = app.util;
+    const json = app.json;
+    const security = app.modules.security;
+    const validation = app.modules.validation;
+    const filesModule = app.modules.files;
+    const dataModule = app.modules.data;
+    const mode = app.modules.mode;
+
+    async function syncUiToJson(options) {
+        const sign = !!(options && options.sign);
+        const computeDigest = !!(options && options.computeDigest);
+        
+        // First, sync UI to JSON to ensure JSON is up-to-date
+        filesModule.syncUiToJson();
+        
+        // Now use JSON as single source of truth
+        const data = json.parse();
+        const previousEnvelope = (data && data.envelope) || {};
+        const payload = (data && data.payload) || {};
+        const previousPresentation = (data && data.presentation) || {};
+        const payloadStr = util.canonicalStringify(payload);
+        const previousPayloadStr = util.canonicalStringify(payload);
+        const payloadChanged = false; // Always false since we just synced
+
+        let digest = previousEnvelope.digest || '';
+        let digestedAt = previousEnvelope.digestedAt || '';
+        let signatures = Array.isArray(previousEnvelope.signatures) ? previousEnvelope.signatures.slice() : [];
+
+        let computedDigest = '';
+        if (sign || computeDigest || payloadChanged || !digest) {
+            try {
+                computedDigest = await util.hashString(payloadStr);
+            } catch (err) {
+                computedDigest = '';
+            }
+        }
+
+        if (sign || computeDigest) {
+            if (!computedDigest) {
+                throw new Error('Unable to compute digest.');
+            }
+            digest = computedDigest;
+            digestedAt = util.fetchTrustedTime();
+        }
+        
+        if (sign) {
+            const jwk = options && options.signingKey;
+            if (!jwk || jwk.kty !== 'EC') {
+                throw new Error('A valid EC private key (JWK) is required to sign this transmittal.');
+            }
+            const envelopeForSigning = {
+                version: 1,
+                digestAlgorithm: app.constants.digestAlgorithm,
+                digest: digest,
+                digestedAt: digestedAt,
+                signatureAlgorithm: app.constants.signatureAlgorithm
+            };
+            const sigResult = await util.signEnvelope(envelopeForSigning, jwk);
+            const publicJwk = security.derivePublicFromPrivate(jwk);
+            signatures.push({
+                signature: sigResult.signature,
+                signedAt: sigResult.signedAt,
+                publicKeyJwk: publicJwk
+            });
+        }
+
+        const envelope = {
+            version: 1,
+            digestAlgorithm: app.constants.digestAlgorithm,
+            digest: digest,
+            digestedAt: digestedAt,
+            signatureAlgorithm: app.constants.signatureAlgorithm,
+            signatures: signatures
+        };
+        const presentation = previousPresentation;
+        json.setData({ envelope: envelope, payload: payload, presentation: presentation });
+        if (computeDigest || sign) {
+            try {
+                await security.verifySignatureIfPresent();
+            } catch (_) {
+                // ignore
+            }
+            app.state.apply();
+        }
+        app.state.dirty = false;
+    }
+
+    async function buildHtmlString() {
+        // Hide editor before cloning so its markup is not in the output
+        var mdEditor = app.modules.markdownEditor;
+        var editorWasActive = mdEditor && mdEditor.isActive();
+        if (editorWasActive) { mdEditor.destroy(); }
+
+        // ── Preferred path: fetch the page's own source and patch the JSON ──
+        // This produces an exact copy of the original file with only the data
+        // changed, avoiding DOM-snapshot drift. Falls back to the DOM-snapshot
+        // approach when the page cannot fetch itself (e.g. opaque origins).
+        try {
+            var jsonData = app.json.parse();
+            var html = await util.fetchAndPatchHtml(jsonData);
+            if (editorWasActive && mdEditor && typeof mdEditor.showRendered === 'function') {
+                mdEditor.showRendered();
+            }
+            return html;
+        } catch (fetchErr) {
+            console.warn('[transmittal] fetch-based save unavailable, falling back to DOM snapshot:', fetchErr.message);
+        }
+
+        // ── Fallback path: DOM snapshot ─────────────────────────────────────
+        // Populate static content before cloning for progressive enhancement
+        if (app.modules.hydrate && app.modules.hydrate.populateStatic) {
+            await app.modules.hydrate.populateStatic();
+        }
+
+        // Remove any existing success notifications
+        var notifications = document.querySelectorAll('[data-publish-notification]');
+        notifications.forEach(function (notif) { notif.remove(); });
+
+        // Hide workflow edit-only steps before cloning (viewers shouldn't see them)
+        var workflowEditSteps = dom.qsa('.workflow-step[data-edit-only], .workflow-tools');
+        var wasVisible = [];
+        workflowEditSteps.forEach(function (el) {
+            wasVisible.push(!el.hidden);
+            el.hidden = true;
+        });
+
+        // Re-hide bottom menu and restore no-js notice before cloning
+        var bottomMenu = dom.qs('#bottom-menu');
+        var bottomMenuWasVisible = bottomMenu && !bottomMenu.hidden;
+        if (bottomMenu) { bottomMenu.hidden = true; }
+        var noJsNotice = dom.qs('#no-js-notice');
+        var addedNotice = false;
+        if (!noJsNotice && bottomMenu && bottomMenu.parentNode) {
+            noJsNotice = document.createElement('span');
+            noJsNotice.id = 'no-js-notice';
+            noJsNotice.className = 'text-gray-400 text-xs italic';
+            noJsNotice.textContent = 'JavaScript not available';
+            bottomMenu.parentNode.insertBefore(noJsNotice, bottomMenu.nextSibling);
+            addedNotice = true;
+        }
+
+        // Close any open dialogs before cloning (they get reopened after)
+        var openDialogs = Array.from(document.querySelectorAll('dialog[open]'));
+        openDialogs.forEach(function (dlg) { dlg.close(); });
+
+        var snapshotHtml = util.cloneDocumentHtml();
+
+        // Restore bottom menu visibility
+        if (bottomMenu && bottomMenuWasVisible) { bottomMenu.hidden = false; }
+        if (noJsNotice) { dom.show(noJsNotice, false); }
+
+        // Reopen dialogs that were open
+        openDialogs.forEach(function (dlg) { dlg.showModal(); });
+
+        // Restore workflow elements
+        workflowEditSteps.forEach(function (el, i) {
+            if (wasVisible[i]) { el.hidden = false; }
+        });
+
+        // Re-hydrate to restore dynamic state after cloning
+        if (app.modules.hydrate && app.modules.hydrate.hydrate) {
+            app.modules.hydrate.hydrate();
+        }
+
+        // Show rendered preview again (editor loads on next click)
+        if (mdEditor) { mdEditor.showRendered(); }
+
+        return snapshotHtml;
+    }
+
+    function requireDirectoryHandle() {
+        if (!app.data.selectedDirHandle) {
+            throw new Error('Select a directory before saving.');
+        }
+        return app.data.selectedDirHandle;
+    }
+
+    async function writeHtmlToDirectory(filename, html) {
+        requireDirectoryHandle();
+        await filesModule.writeFileToSelectedDir(filename, html, 'text/html');
+    }
+
+    function loadSigningKey(providedKey) {
+        if (providedKey) { return providedKey; }
+        throw new Error('A signing key is required. Select or generate one first.');
+    }
+
+    async function executePublish(config) {
+        const modeSelection = (config && config.mode) || 'digest';
+        const wantDownload = !!(config && config.download);
+        const wantSaveToFolder = !!(config && config.saveToFolder);
+
+        const validationResult = validation.validateBeforePublish();
+        if (!validationResult.ok) {
+            const error = new Error(validationResult.message || 'Validation failed before publishing.');
+            error.focusEl = validationResult.focusEl || null;
+            throw error;
+        }
+
+        if (wantSaveToFolder) {
+            requireDirectoryHandle();
+        }
+
+        const shouldSign = modeSelection === 'signed';
+        const shouldComputeDigest = modeSelection === 'signed' || modeSelection === 'digest';
+        const isDraft = modeSelection === 'draft';
+
+        let signingKey = null;
+        if (shouldSign) {
+            signingKey = await loadSigningKey(config && config.signingKey);
+        }
+
+        await syncUiToJson({
+            sign: shouldSign,
+            computeDigest: shouldComputeDigest,
+            signingKey: signingKey
+        });
+
+        mode.refresh();
+        const html = await buildHtmlString();
+        const data = json.parse();
+        const payload = (data && data.payload) || {};
+        const filename = dataModule.buildFileName(payload, { extension: 'html', draft: isDraft });
+
+        if (wantSaveToFolder) {
+            await writeHtmlToDirectory(filename, html);
+            // If publishing (not draft), delete the draft file from the directory
+            if (!isDraft) {
+                var draftName = dataModule.buildFileName(payload, { extension: 'html', draft: true });
+                if (draftName !== filename) {
+                    try {
+                        await app.data.selectedDirHandle.removeEntry(draftName);
+                    } catch (_) {
+                        // Draft file may not exist — that's fine
+                    }
+                }
+            }
+        }
+        if (wantDownload) {
+            util.downloadBlob(filename, new Blob([html], { type: 'text/html' }), 'text/html');
+        }
+        mode.refresh();
+        dataModule.setStatus('Published HTML as ' + filename, 'success');
+
+        return {
+            filename: filename,
+            mode: modeSelection
+        };
+    }
+
+    app.modules.publish = {
+        syncUiToJson,
+        buildHtmlString,
+        executePublish
+    };
+})(window.transmittalApp);
diff --git a/transmittal/js/reactive.js b/transmittal/js/reactive.js
new file mode 100644
index 0000000..ada15b4
--- /dev/null
+++ b/transmittal/js/reactive.js
@@ -0,0 +1,64 @@
+(function (app) {
+    'use strict';
+
+    /**
+     * Creates a reactive state object using Proxy.
+     * When properties change, all registered subscribers are notified.
+     * 
+     * @param {Object} initialState - Initial state values
+     * @returns {Object} Reactive state proxy with subscribe/unsubscribe methods
+     */
+    function createReactiveState(initialState) {
+        const subscribers = new Set();
+        const state = { ...initialState };
+        
+        const handler = {
+            get(target, property) {
+                // Expose subscription methods
+                if (property === 'subscribe') {
+                    return function(callback) {
+                        if (typeof callback === 'function') {
+                            subscribers.add(callback);
+                        }
+                        return function unsubscribe() {
+                            subscribers.delete(callback);
+                        };
+                    };
+                }
+                
+                if (property === 'unsubscribeAll') {
+                    return function() {
+                        subscribers.clear();
+                    };
+                }
+                
+                // Return the actual property value
+                return target[property];
+            },
+            
+            set(target, property, value) {
+                const oldValue = target[property];
+                
+                // Only notify if value actually changed
+                if (oldValue !== value) {
+                    target[property] = value;
+                    
+                    // Notify all subscribers
+                    subscribers.forEach(function(callback) {
+                        try {
+                            callback(property, value, oldValue);
+                        } catch (err) {
+                            console.error('[reactive] Subscriber error:', err);
+                        }
+                    });
+                }
+                
+                return true;
+            }
+        };
+        
+        return new Proxy(state, handler);
+    }
+
+    app.createReactiveState = createReactiveState;
+})(window.transmittalApp);
diff --git a/transmittal/js/reset.js b/transmittal/js/reset.js
new file mode 100644
index 0000000..480ade6
--- /dev/null
+++ b/transmittal/js/reset.js
@@ -0,0 +1,81 @@
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var json = app.json;
+    var filesModule = app.modules.files;
+    var security = app.modules.security;
+
+    function originalEmptyData() {
+        return {
+            envelope: {
+                version: 1,
+                digestAlgorithm: app.constants.digestAlgorithm,
+                digest: '',
+                digestedAt: '',
+                signatureAlgorithm: app.constants.signatureAlgorithm,
+                signatures: []
+            },
+            payload: {
+                version: 1,
+                type: 'Transmittal',
+                title: '',
+                client: '',
+                project: '',
+                projectNumber: '',
+                date: '',
+                trackingNumber: '',
+                from: '',
+                to: '',
+                purpose: '',
+                responseDue: '',
+                subject: '',
+                remarks: '',
+                files: []
+            },
+            presentation: {
+                leftLogo: '',
+                rightLogo: '',
+                theme: 'default',
+                customCss: ''
+            }
+        };
+    }
+
+    async function handleReset() {
+        if (!confirm('Reset will clear all data. Continue?')) {
+            return;
+        }
+        json.setData(originalEmptyData());
+
+        // Clear logos in DOM
+        var leftLogo = dom.qs('#left-logo');
+        var rightLogo = dom.qs('#right-logo');
+        if (leftLogo) { leftLogo.src = ''; }
+        if (rightLogo) { rightLogo.src = ''; }
+
+        // Clear runtime state
+        app.data.files = [];
+        app.data.selectedDirHandle = null;
+        app.data.selectedDirName = '';
+
+        filesModule.loadFromJson();
+        app.state.mode = 'edit';
+        app.state.published = false;
+        app.state.dirty = false;
+        if (security.renderSignaturesList) {
+            security.renderSignaturesList();
+        }
+        if (app.modules.mode && app.modules.mode.refresh) {
+            app.modules.mode.refresh();
+        }
+        app.state.apply();
+        if (app.modules.liveDigest && app.modules.liveDigest.schedule) {
+            app.modules.liveDigest.schedule();
+        }
+    }
+
+    app.modules.reset = {
+        handleReset: handleReset
+    };
+})(window.transmittalApp);
diff --git a/transmittal/js/security.js b/transmittal/js/security.js
new file mode 100644
index 0000000..008a51b
--- /dev/null
+++ b/transmittal/js/security.js
@@ -0,0 +1,336 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const util = app.util;
+    const json = app.json;
+
+    const security = app.modules.security = {};
+
+    // ── Verify-card DOM helpers ────────────────────────
+    function makeCard(variant) {
+        var el = document.createElement('div');
+        el.className = 'verify-card verify-card--' + variant;
+        return el;
+    }
+    function makeStatus(text, variant) {
+        var el = document.createElement('div');
+        el.className = 'verify-card__status verify-card__status--' + variant;
+        el.textContent = text;
+        return el;
+    }
+    function makeDetail(html) {
+        var el = document.createElement('div');
+        el.className = 'verify-card__detail';
+        el.innerHTML = html;
+        return el;
+    }
+
+    security.renderSignaturesList = async function renderSignaturesList() {
+        var digestEl = dom.qs('#digest-display');
+        var container = dom.qs('#signatures-list');
+        var addButton = dom.qs('#add-signature-btn');
+        if (!container) { return; }
+
+        var data = json.parse();
+        var envelope = data.envelope || {};
+        var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+        var hasDigest = !!(envelope.digest);
+        var dv = app.data.digestVerified;
+        var results = app.data.signatureVerificationResults || [];
+
+        // ── Digest card ──
+        if (digestEl) {
+            digestEl.innerHTML = '';
+            if (hasDigest && dv) {
+                var unavailable = dv.unavailable;
+                var cardType = unavailable ? 'info' : (dv.match ? 'ok' : 'fail');
+                var dCard = makeCard(cardType);
+                if (unavailable) {
+                    dCard.appendChild(makeStatus('Digest Present \u2014 verification unavailable', 'info'));
+                } else {
+                    dCard.appendChild(makeStatus(
+                        (dv.match ? '\u2713 Digest Verified' : '\u2717 Digest Failed'),
+                        dv.match ? 'ok' : 'fail'
+                    ));
+                }
+                dCard.appendChild(makeDetail('SHA-256: <code>' + envelope.digest + '</code>'));
+                if (envelope.digestedAt) {
+                    dCard.appendChild(makeDetail(util.formatISOWithTZ(envelope.digestedAt)));
+                }
+                if (unavailable) {
+                    dCard.appendChild(makeDetail('<em>Open from file:// or https:// to verify integrity</em>'));
+                }
+                digestEl.appendChild(dCard);
+            }
+        }
+
+        // ── Signature cards ──
+        container.innerHTML = '';
+        if (!hasDigest) {
+            if (addButton) { addButton.hidden = true; }
+            return;
+        }
+
+        if (signatures.length === 0) {
+            var note = makeCard('info');
+            note.appendChild(makeStatus('No signatures \u2014 digest only', 'info'));
+            container.appendChild(note);
+        }
+
+        var cryptoUnavailable = dv && dv.unavailable;
+        for (var i = 0; i < signatures.length; i++) {
+            var sig = signatures[i];
+            var fingerprint = await util.publicKeyFingerprint(sig.publicKeyJwk);
+            var signedAt = sig.signedAt ? util.formatISOWithTZ(sig.signedAt) : 'Unknown';
+            var result = results.find(function (r) { return r.index === i; });
+            var ok = result ? result.valid : false;
+            var digestBad = dv && !dv.match && !cryptoUnavailable;
+            var pass = ok && !digestBad;
+
+            var sigLabel = sig.label || ('Signature ' + (i + 1));
+            var cardType = cryptoUnavailable ? 'info' : (pass ? 'ok' : 'fail');
+            var sCard = makeCard(cardType);
+            if (cryptoUnavailable) {
+                sCard.appendChild(makeStatus(sigLabel + ' \u2014 verification unavailable', 'info'));
+            } else {
+                sCard.appendChild(makeStatus(
+                    (pass ? '\u2713 ' + sigLabel + ' Verified' : '\u2717 ' + sigLabel + ' Failed Verification'),
+                    pass ? 'ok' : 'fail'
+                ));
+            }
+            sCard.appendChild(makeDetail('Key: <code>' + (fingerprint || 'Unknown') + '</code>'));
+            sCard.appendChild(makeDetail(signedAt));
+            container.appendChild(sCard);
+        }
+
+        if (addButton) { addButton.hidden = false; }
+    };
+
+    security.deleteSignature = async function deleteSignature(index) {
+        if (!confirm('Delete this signature?')) { return; }
+        try {
+            var data = json.parse();
+            var envelope = data.envelope || {};
+            var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+            signatures.splice(index, 1);
+            envelope.signatures = signatures;
+            json.setData({ envelope: envelope, payload: data.payload, presentation: data.presentation });
+            await security.verifySignatureIfPresent();
+            if (app.modules.data && app.modules.data.setStatus) {
+                app.modules.data.setStatus('Signature deleted', 'success');
+            }
+        } catch (err) {
+            console.error('[transmittal] failed to delete signature', err);
+            alert('Failed to delete signature: ' + (err && err.message ? err.message : err));
+        }
+    };
+
+    security.addSignature = async function addSignature(options) {
+        var opts = options || {};
+        var label = opts.label || '';
+        try {
+            var data = json.parse();
+            var envelope = data.envelope || {};
+            var payload = data.payload || {};
+
+            if (!envelope.digest) {
+                alert('Cannot add signature: document must be published first (needs digest).');
+                return;
+            }
+
+            var jwk = await security.pickSigningKey();
+            if (!jwk || jwk.kty !== 'EC') { return; }
+
+            var sigResult = await util.signEnvelope(envelope, jwk);
+            var publicJwk = security.derivePublicFromPrivate(jwk);
+
+            var sigEntry = {
+                signature: sigResult.signature,
+                signedAt: sigResult.signedAt,
+                publicKeyJwk: publicJwk
+            };
+            if (label) { sigEntry.label = label; }
+
+            var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+            signatures.push(sigEntry);
+
+            envelope.signatures = signatures;
+            json.setData({ envelope: envelope, payload: payload, presentation: data.presentation });
+            await security.verifySignatureIfPresent();
+
+            // Persist by downloading updated HTML
+            var publish = app.modules.publish;
+            if (publish && publish.buildHtmlString) {
+                var html = await publish.buildHtmlString();
+                var dataModule = app.modules.data;
+                var filename = dataModule && dataModule.buildFileName
+                    ? dataModule.buildFileName(payload, { extension: 'html' })
+                    : 'transmittal.html';
+                util.downloadBlob(filename, new Blob([html], { type: 'text/html' }), 'text/html');
+            }
+
+            var statusMsg = (label ? label : 'Signature') + ' added \u2014 download triggered';
+            if (app.modules.data && app.modules.data.setStatus) {
+                app.modules.data.setStatus(statusMsg, 'success');
+            }
+        } catch (err) {
+            console.error('[transmittal] failed to add signature', err);
+            alert('Failed to add signature: ' + (err && err.message ? err.message : err));
+        }
+    };
+
+    security.verifyPayloadSignature = async function verifyPayloadSignature(payloadStr, signatureB64, publicJwk) {
+        if (!signatureB64 || !publicJwk) {
+            return false;
+        }
+        try {
+            const key = await window.crypto.subtle.importKey(
+                'jwk',
+                publicJwk,
+                { name: 'ECDSA', namedCurve: 'P-256' },
+                false,
+                ['verify']
+            );
+            const signatureBuffer = util.base64ToArrayBuffer(signatureB64);
+            const ok = await window.crypto.subtle.verify(
+                { name: 'ECDSA', hash: { name: 'SHA-256' } },
+                key,
+                signatureBuffer,
+                new TextEncoder().encode(payloadStr)
+            );
+            return !!ok;
+        } catch (err) {
+            console.warn('[transmittal] verify error', err);
+            return false;
+        }
+    };
+
+    security.verifySignatureIfPresent = async function verifySignatureIfPresent() {
+        try {
+            var data = json.parse();
+            var envelope = data.envelope || {};
+            var payload = data.payload || {};
+            var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+            var hasDigest = !!(envelope.digest);
+
+            if (!hasDigest) {
+                app.data.digestVerified = null;
+                app.data.signatureVerificationResults = [];
+                await security.renderSignaturesList();
+                return;
+            }
+
+            if (!util.hasCrypto()) {
+                app.data.digestVerified = { match: false, unavailable: true };
+                app.data.signatureVerificationResults = [];
+                await security.renderSignaturesList();
+                return;
+            }
+
+            // Verify digest matches payload
+            var payloadStr = util.canonicalStringify(payload);
+            var computedDigest = await util.hashString(payloadStr);
+            var digestMatch = envelope.digest && computedDigest &&
+                (String(envelope.digest).toLowerCase() === computedDigest.toLowerCase());
+
+            app.data.digestVerified = {
+                match: digestMatch,
+                expected: envelope.digest,
+                computed: computedDigest
+            };
+
+            if (!digestMatch || signatures.length === 0) {
+                app.data.signatureVerificationResults = [];
+                await security.renderSignaturesList();
+                return;
+            }
+
+            // Reconstruct the envelope that was signed (without signatures)
+            var envelopeToVerify = {
+                version: envelope.version || 1,
+                digestAlgorithm: envelope.digestAlgorithm || app.constants.digestAlgorithm,
+                digest: envelope.digest,
+                digestedAt: envelope.digestedAt,
+                signatureAlgorithm: envelope.signatureAlgorithm || app.constants.signatureAlgorithm
+            };
+            var envelopeStr = util.canonicalStringify(envelopeToVerify);
+
+            var results = [];
+            for (var i = 0; i < signatures.length; i++) {
+                var sig = signatures[i];
+                var signatureOk = await security.verifyPayloadSignature(envelopeStr, sig.signature, sig.publicKeyJwk);
+                results.push({
+                    index: i,
+                    valid: signatureOk,
+                    publicKey: sig.publicKeyJwk,
+                    signedAt: sig.signedAt
+                });
+            }
+
+            app.data.signatureVerificationResults = results;
+            await security.renderSignaturesList();
+        } catch (err) {
+            console.error('[transmittal] signature verification failed', err);
+            app.data.digestVerified = { match: false, error: true };
+            app.data.signatureVerificationResults = [];
+            await security.renderSignaturesList();
+        }
+    };
+
+    security.derivePublicFromPrivate = function derivePublicFromPrivate(jwk) {
+        if (!jwk) {
+            return null;
+        }
+        if (jwk.x && jwk.y) {
+            return {
+                kty: jwk.kty || 'EC',
+                crv: jwk.crv || 'P-256',
+                x: jwk.x,
+                y: jwk.y,
+                ext: true
+            };
+        }
+        return null;
+    };
+
+    security.pickSigningKey = function pickSigningKey() {
+        return new Promise(function (resolve, reject) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = '.zddc-key';
+            input.addEventListener('change', async function () {
+                try {
+                    var file = input.files && input.files[0];
+                    if (!file) { resolve(null); return; }
+                    var text = await file.text();
+                    var jwk = await util.loadKeyFile(text, security.promptForPassword);
+                    resolve(jwk);
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            input.click();
+        });
+    };
+
+    security.promptForPassword = function promptForPassword(fingerprint) {
+        return new Promise(function (resolve) {
+            var pw = window.prompt(
+                fingerprint
+                    ? 'Enter password for key ' + fingerprint + ':'
+                    : 'Enter key password:'
+            );
+            resolve(pw);
+        });
+    };
+
+    app.registerInit(function () {
+        const addSigButton = dom.qs('#add-signature-btn');
+        if (addSigButton) {
+            addSigButton.addEventListener('click', function() {
+                security.addSignature();
+            });
+        }
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/state.js b/transmittal/js/state.js
new file mode 100644
index 0000000..5a9d882
--- /dev/null
+++ b/transmittal/js/state.js
@@ -0,0 +1,225 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    
+    // Convert existing state to reactive state
+    if (app.createReactiveState) {
+        const oldState = app.state;
+        app.state = app.createReactiveState({
+            mode: oldState.mode || 'edit',
+            published: oldState.published || false,
+            dirty: oldState.dirty || false
+        });
+        
+        // Subscribe to state changes to automatically update UI
+        app.state.subscribe(function(property, newValue, oldValue) {
+            // Auto-apply state changes
+            if (property === 'mode' || property === 'published') {
+                state.updateHiddenFields();
+                state.apply();
+                // Sync preview checkbox to current mode
+                if (app.modules.files && app.modules.files.syncPreviewCheckbox) {
+                    app.modules.files.syncPreviewCheckbox();
+                }
+            }
+            
+            if (property === 'dirty') {
+                // Could update UI indicator here
+            }
+        });
+    }
+    
+    const state = app.state;
+
+    state.updateHiddenFields = function updateHiddenFields() {
+        const modeInput = dom.qs('#mode');
+        const publishedInput = dom.qs('#published');
+        if (modeInput) {
+            modeInput.value = state.mode;
+        }
+        if (publishedInput) {
+            publishedInput.value = state.published ? 'true' : 'false';
+        }
+    };
+
+    function toggleEditOnlyElements() {
+        const isEdit = state.mode === 'edit';
+        dom.qsa('[data-edit-only]').forEach(function (element) {
+            const value = element.getAttribute('data-edit-only');
+            if (value === 'true') {
+                dom.show(element, isEdit);
+            } else if (value === 'false') {
+                dom.show(element, !isEdit);
+            }
+        });
+    }
+
+    function updateDirectoryDependentControls() {
+        const isEdit = state.mode === 'edit';
+        const hasDirectory = !!app.data.selectedDirHandle;
+        dom.qsa('[data-requires-directory="true"]').forEach(function (element) {
+            const shouldDisable = !(isEdit && hasDirectory);
+            if ('disabled' in element) {
+                element.disabled = shouldDisable;
+            } else {
+                if (shouldDisable) {
+                    element.setAttribute('aria-disabled', 'true');
+                } else {
+                    element.removeAttribute('aria-disabled');
+                }
+            }
+        });
+    }
+
+    function updateResponseDueVisibility() {
+        var typeDisplay = dom.qs('#type-display');
+        var typeHidden = dom.qs('#type');
+        var wrapper = dom.qs('#response-due-wrapper');
+        if (!wrapper) { return; }
+        var typeVal = '';
+        if (typeDisplay) {
+            typeVal = (typeDisplay.textContent || '').trim();
+        } else if (typeHidden) {
+            typeVal = (typeHidden.value || '').trim();
+        }
+        var isSubmittal = typeVal.toLowerCase() === 'submittal';
+        if (isSubmittal) {
+            wrapper.classList.remove('hidden');
+        } else {
+            wrapper.classList.add('hidden');
+        }
+    }
+
+    state.apply = function applyState() {
+        updateResponseDueVisibility();
+        const inputs = document.querySelectorAll('input, select, textarea');
+        inputs.forEach(function (element) {
+            const noDisable = element.hasAttribute('data-no-disable') || (!!element.closest('thead') && !!element.closest('.filter-row'));
+            element.disabled = (state.mode !== 'edit') && !noDisable;
+        });
+
+        ['#owner-name', '#project-name', '#project-number', '#type-display'].forEach(function (selector) {
+            const element = dom.qs(selector);
+            if (element) {
+                element.contentEditable = (state.mode === 'edit') ? 'true' : 'false';
+            }
+        });
+
+        const remarksTextarea = dom.qs('#remarks');
+        const remarksContainer = dom.qs('#remarks-render-container');
+        var mdEditor = app.modules.markdownEditor;
+        const isEdit = (state.mode === 'edit') && !state.published;
+
+        if (remarksTextarea) { remarksTextarea.hidden = true; }
+
+        if (mdEditor) {
+            if (isEdit) {
+                // Show rendered preview with click-to-edit; editor loads on first click
+                mdEditor.bindRenderClick();
+                mdEditor.setRenderClickable(true);
+                mdEditor.showRendered();
+            } else {
+                // View mode: destroy editor, show static rendered HTML
+                mdEditor.destroy();
+                mdEditor.setRenderClickable(false);
+                mdEditor.refreshRender();
+                if (remarksContainer) { remarksContainer.hidden = false; }
+            }
+        } else if (remarksContainer) {
+            remarksContainer.hidden = false;
+        }
+
+        const titleInput = dom.qs('#title');
+        if (titleInput) {
+            const empty = !(titleInput.value || '').trim();
+            titleInput.hidden = (state.mode === 'view' && empty);
+        }
+
+        // From field: input in edit mode, rendered mailto link in view mode
+        const fromInput = dom.qs('#from');
+        const fromRender = dom.qs('#from-render');
+        if (fromInput && fromRender) {
+            if (isEdit) {
+                fromInput.hidden = false;
+                fromRender.classList.add('hidden');
+                fromRender.hidden = true;
+            } else {
+                fromInput.hidden = true;
+                fromRender.classList.remove('hidden');
+                fromRender.hidden = false;
+                if (app.modules.emailTags && app.modules.emailTags.renderFrom) {
+                    app.modules.emailTags.renderFrom();
+                }
+            }
+        }
+
+        // To field: input in edit mode, rendered mailto links in view mode
+        const toInput = dom.qs('#to');
+        const toRender = dom.qs('#to-render');
+        if (toInput && toRender) {
+            if (isEdit) {
+                toInput.hidden = false;
+                toRender.classList.add('hidden');
+                toRender.hidden = true;
+            } else {
+                toInput.hidden = true;
+                toRender.classList.remove('hidden');
+                toRender.hidden = false;
+                if (app.modules.emailTags && app.modules.emailTags.render) {
+                    app.modules.emailTags.render();
+                }
+            }
+        }
+
+        // Logo placeholders: show in edit mode when no logo loaded
+        document.querySelectorAll('.logo-cell').forEach(function (cell) {
+            var img = cell.querySelector('.logo-img');
+            var placeholder = cell.querySelector('.logo-placeholder');
+            if (!placeholder) { return; }
+            var hasLogo = img && img.getAttribute('src');
+            if (hasLogo) {
+                cell.classList.add('has-logo');
+            } else {
+                cell.classList.remove('has-logo');
+            }
+            if (state.mode === 'edit' && !hasLogo) {
+                placeholder.classList.remove('hidden');
+            } else {
+                placeholder.classList.add('hidden');
+            }
+        });
+
+        toggleEditOnlyElements();
+        updateDirectoryDependentControls();
+    };
+
+    state.detectState = function detectState() {
+        var data = app.json.parse();
+        var envelope = (data && data.envelope) || {};
+        var payload = (data && data.payload) || {};
+        var presentation = (data && data.presentation) || {};
+
+        if (envelope.digest) { return 'published'; }
+
+        var hasDate = !!(payload.date && payload.date.trim());
+        if (hasDate) { return 'draft'; }
+
+        var hasHeader = !!(payload.client || payload.project || payload.projectNumber ||
+            presentation.leftLogo || presentation.rightLogo);
+        if (hasHeader) { return 'template'; }
+
+        return 'clean';
+    };
+
+    app.registerInit(function () {
+        state.updateHiddenFields();
+        toggleEditOnlyElements();
+        updateDirectoryDependentControls();
+        var typeInput = dom.qs('#type');
+        if (typeInput) {
+            typeInput.addEventListener('input', updateResponseDueVisibility);
+        }
+        updateResponseDueVisibility();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/util.js b/transmittal/js/util.js
new file mode 100644
index 0000000..cc29cb4
--- /dev/null
+++ b/transmittal/js/util.js
@@ -0,0 +1,473 @@
+(function (app) {
+    'use strict';
+
+    const util = app.util = app.util || {};
+
+    util.hasCrypto = function hasCrypto() {
+        return !!(window.crypto && window.crypto.subtle && typeof window.crypto.subtle.digest === 'function');
+    };
+
+    util.canonicalStringify = function canonicalStringify(input) {
+        if (input === null) {
+            return 'null';
+        }
+        const type = typeof input;
+        if (type === 'number' || type === 'boolean' || type === 'string') {
+            return JSON.stringify(input);
+        }
+        if (Array.isArray(input)) {
+            return '[' + input.map(util.canonicalStringify).join(',') + ']';
+        }
+        const keys = Object.keys(input).sort();
+        return '{' + keys.map(function (key) {
+            return JSON.stringify(key) + ':' + util.canonicalStringify(input[key]);
+        }).join(',') + '}';
+    };
+
+    util.hashString = function hashString(str) {
+        return zddc.crypto.sha256String(str);
+    };
+
+    util.arrayBufferToHex = function arrayBufferToHex(buffer) {
+        return zddc.crypto.bytesToHex(buffer);
+    };
+
+    util.base64ToArrayBuffer = function base64ToArrayBuffer(base64Value) {
+        if (!base64Value) {
+            return new ArrayBuffer(0);
+        }
+        const binaryString = atob(base64Value);
+        const length = binaryString.length;
+        const bytes = new Uint8Array(length);
+        for (let index = 0; index < length; index += 1) {
+            bytes[index] = binaryString.charCodeAt(index);
+        }
+        return bytes.buffer;
+    };
+
+    util.arrayBufferToBase64 = function arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let output = '';
+        for (let index = 0; index < bytes.length; index += 1) {
+            output += String.fromCharCode(bytes[index]);
+        }
+        return btoa(output);
+    };
+
+    // Revision comparison delegates to shared zddc library
+    util.compareRevisionPriority = function compareRevisionPriority(aRevision, bRevision) {
+        return zddc.compareRevisions(aRevision, bRevision);
+    };
+
+    util.compareFilesByTrackingRevision = function compareFilesByTrackingRevision(a, b) {
+        const trackingA = (a && a.trackingNumber ? String(a.trackingNumber) : '').toLowerCase();
+        const trackingB = (b && b.trackingNumber ? String(b.trackingNumber) : '').toLowerCase();
+        if (trackingA < trackingB) {
+            return -1;
+        }
+        if (trackingA > trackingB) {
+            return 1;
+        }
+
+        const revisionCompare = util.compareRevisionPriority(a && a.revision, b && b.revision);
+        if (revisionCompare !== 0) {
+            return revisionCompare;
+        }
+
+        const extA = (a && a.extension ? String(a.extension) : '').toLowerCase();
+        const extB = (b && b.extension ? String(b.extension) : '').toLowerCase();
+        if (extA < extB) {
+            return -1;
+        }
+        if (extA > extB) {
+            return 1;
+        }
+
+        return 0;
+    };
+
+    util.canonicalizePublicJwk = function canonicalizePublicJwk(pk) {
+        if (!pk) {
+            return { kty: 'EC', crv: 'P-256', x: '', y: '' };
+        }
+        return {
+            kty: pk.kty || 'EC',
+            crv: pk.crv || 'P-256',
+            x: pk.x || '',
+            y: pk.y || ''
+        };
+    };
+
+    util.publicKeyFingerprint = async function publicKeyFingerprint(pk) {
+        try {
+            if (!pk) {
+                return '';
+            }
+            if (!util.hasCrypto()) {
+                return null;
+            }
+            const canonical = util.canonicalizePublicJwk(pk);
+            const canonicalStr = util.canonicalStringify(canonical);
+            const hash = await util.hashString(canonicalStr);
+            return (hash || '').slice(0, 12);
+        } catch (err) {
+            console.error('[transmittal] publicKeyFingerprint error', err);
+            return '';
+        }
+    };
+
+    util.hashFile = function hashFile(file, onProgress) {
+        return zddc.crypto.sha256File(file, onProgress);
+    };
+
+    util.escapeHtml = function escapeHtml(value) {
+        return String(value || '')
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+    };
+
+    util.escapeHtmlAttribute = function escapeHtmlAttribute(value) {
+        return String(value || '')
+            .replace(/&/g, '&amp;')
+            .replace(/"/g, '&quot;');
+    };
+
+    util.downloadBlob = function downloadBlob(filename, contents, mime) {
+        var blob = (contents instanceof Blob)
+            ? contents
+            : new Blob([contents], { type: mime || 'application/octet-stream' });
+        var anchor = document.createElement('a');
+        anchor.href = URL.createObjectURL(blob);
+        anchor.download = filename;
+        document.body.appendChild(anchor);
+        anchor.click();
+        setTimeout(function () {
+            URL.revokeObjectURL(anchor.href);
+            anchor.remove();
+        }, 0);
+    };
+
+    util.createEmptyData = function createEmptyData(date) {
+        return {
+            envelope: {
+                version: 1,
+                digestAlgorithm: app.constants.digestAlgorithm,
+                digest: '',
+                digestedAt: '',
+                signatureAlgorithm: app.constants.signatureAlgorithm,
+                signatures: []
+            },
+            payload: {
+                version: 1,
+                type: 'Transmittal',
+                title: '',
+                client: '',
+                project: '',
+                projectNumber: '',
+                date: date || '',
+                trackingNumber: '',
+                from: '',
+                to: '',
+                purpose: '',
+                responseDue: '',
+                subject: '',
+                remarks: '',
+                files: []
+            },
+            presentation: {
+                leftLogo: '',
+                rightLogo: '',
+                theme: 'default',
+                customCss: ''
+            }
+        };
+    };
+
+    util.fetchTrustedTime = function fetchTrustedTime() {
+        return new Date().toISOString();
+    };
+
+    util.formatISOWithTZ = function formatISOWithTZ(isoStr) {
+        if (!isoStr) { return 'Unknown'; }
+        var d = new Date(isoStr);
+        if (isNaN(d.getTime())) { return isoStr; }
+        try {
+            return d.toLocaleDateString('en-US', {
+                weekday: 'long',
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric',
+                hour: 'numeric',
+                minute: '2-digit',
+                timeZoneName: 'short'
+            });
+        } catch (_) {
+            return d.toLocaleString();
+        }
+    };
+
+    util.signEnvelope = async function signEnvelope(envelope, jwk) {
+        if (!jwk || jwk.kty !== 'EC') {
+            throw new Error('A valid EC private key (JWK) is required to sign.');
+        }
+        var envelopeToSign = {
+            version: envelope.version || 1,
+            digestAlgorithm: envelope.digestAlgorithm || app.constants.digestAlgorithm,
+            digest: envelope.digest,
+            digestedAt: envelope.digestedAt,
+            signatureAlgorithm: envelope.signatureAlgorithm || app.constants.signatureAlgorithm
+        };
+        var envelopeStr = util.canonicalStringify(envelopeToSign);
+        var key = await window.crypto.subtle.importKey(
+            'jwk',
+            jwk,
+            { name: 'ECDSA', namedCurve: 'P-256' },
+            false,
+            ['sign']
+        );
+        var raw = await window.crypto.subtle.sign(
+            { name: 'ECDSA', hash: { name: 'SHA-256' } },
+            key,
+            new TextEncoder().encode(envelopeStr)
+        );
+        return {
+            signature: util.arrayBufferToBase64(raw),
+            signedAt: util.fetchTrustedTime()
+        };
+    };
+
+
+    util.formatShortHash = function formatShortHash(hex) {
+        const normalized = (hex || '').trim();
+        if (!normalized) {
+            return '';
+        }
+        if (normalized.length <= 20) {
+            return normalized;
+        }
+        return normalized.slice(0, 12) + '\u2026' + normalized.slice(-8);
+    };
+
+    util.formatShortFileHash = function formatShortFileHash(hex) {
+        const normalized = (hex || '').trim();
+        if (!normalized) {
+            return '';
+        }
+        if (normalized.length <= 12) {
+            return normalized;
+        }
+        return normalized.slice(0, 6) + '\u2026' + normalized.slice(-5);
+    };
+
+    util.formatFileSize = function formatFileSize(bytes) {
+        const num = Number(bytes) || 0;
+        if (num === 0) {
+            return '0 B';
+        }
+        if (num < 1024) {
+            return num + ' B';
+        }
+        if (num < 1024 * 1024) {
+            return (num / 1024).toFixed(1) + ' KB';
+        }
+        if (num < 1024 * 1024 * 1024) {
+            return (num / (1024 * 1024)).toFixed(1) + ' MB';
+        }
+        return (num / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+    };
+
+    util.fileToImage = function fileToImage(file) {
+        return new Promise(function (resolve, reject) {
+            const url = URL.createObjectURL(file);
+            const img = new Image();
+            img.onload = function () {
+                URL.revokeObjectURL(url);
+                resolve(img);
+            };
+            img.onerror = function (err) {
+                URL.revokeObjectURL(url);
+                reject(err);
+            };
+            img.src = url;
+        });
+    };
+
+    util.imageFileToPngDataUrl = async function imageFileToPngDataUrl(file, maxWidth, maxHeight) {
+        const img = await util.fileToImage(file);
+        const scale = Math.min(1, maxWidth / img.width, maxHeight / img.height);
+        const w = Math.round(img.width * scale);
+        const h = Math.round(img.height * scale);
+        const canvas = document.createElement('canvas');
+        canvas.width = w;
+        canvas.height = h;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0, w, h);
+        return canvas.toDataURL('image/png');
+    };
+
+    // ── ZDDC Signing Key utilities ─────────────────────────
+    var KEY_FORMAT = 'zddc-signing-key-v1';
+    var KDF_ITERATIONS = 100000;
+
+    function deriveWrappingKey(password, salt) {
+        var enc = new TextEncoder();
+        return window.crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveKey'])
+            .then(function (baseKey) {
+                return window.crypto.subtle.deriveKey(
+                    { name: 'PBKDF2', salt: salt, iterations: KDF_ITERATIONS, hash: 'SHA-256' },
+                    baseKey,
+                    { name: 'AES-GCM', length: 256 },
+                    false,
+                    ['encrypt', 'decrypt']
+                );
+            });
+    }
+
+    util.encryptPrivateKey = async function encryptPrivateKey(jwk, password, publicFingerprint) {
+        var plaintext = new TextEncoder().encode(JSON.stringify(jwk));
+        var salt = window.crypto.getRandomValues(new Uint8Array(16));
+        var iv = window.crypto.getRandomValues(new Uint8Array(12));
+        var wrappingKey = await deriveWrappingKey(password, salt);
+        var ciphertext = await window.crypto.subtle.encrypt({ name: 'AES-GCM', iv: iv }, wrappingKey, plaintext);
+        return {
+            format: KEY_FORMAT,
+            publicFingerprint: publicFingerprint || '',
+            encrypted: true,
+            kdf: 'PBKDF2-SHA256',
+            iterations: KDF_ITERATIONS,
+            salt: util.arrayBufferToBase64(salt),
+            iv: util.arrayBufferToBase64(iv),
+            ciphertext: util.arrayBufferToBase64(ciphertext)
+        };
+    };
+
+    util.decryptPrivateKey = async function decryptPrivateKey(keyData, password) {
+        var salt = util.base64ToArrayBuffer(keyData.salt);
+        var iv = util.base64ToArrayBuffer(keyData.iv);
+        var ciphertext = util.base64ToArrayBuffer(keyData.ciphertext);
+        var wrappingKey = await deriveWrappingKey(password, salt);
+        var plaintext = await window.crypto.subtle.decrypt({ name: 'AES-GCM', iv: iv }, wrappingKey, ciphertext);
+        return JSON.parse(new TextDecoder().decode(plaintext));
+    };
+
+    util.wrapKeyFile = function wrapKeyFile(jwk, publicFingerprint) {
+        return {
+            format: KEY_FORMAT,
+            publicFingerprint: publicFingerprint || '',
+            encrypted: false,
+            key: jwk
+        };
+    };
+
+    util.loadKeyFile = async function loadKeyFile(text, promptForPassword) {
+        var data = JSON.parse(text);
+        // ZDDC key format
+        if (data.format === KEY_FORMAT) {
+            if (data.encrypted) {
+                if (typeof promptForPassword !== 'function') {
+                    throw new Error('Password required but no prompt available.');
+                }
+                var password = await promptForPassword(data.publicFingerprint);
+                if (!password && password !== '') { return null; } // user cancelled
+                return util.decryptPrivateKey(data, password);
+            }
+            return data.key;
+        }
+        throw new Error('Unrecognized key file format. Expected a .zddc-key file.');
+    };
+
+    util.cloneDocumentHtml = function cloneDocumentHtml() {
+        // Temporarily remove inline scripts from the LIVE DOM so that
+        // outerHTML produces a clean string with zero script bodies.
+        // We never create a clone via innerHTML because the HTML parser
+        // would corrupt the JSON block if base64 data contains a close-script tag.
+        var scripts = document.querySelectorAll('script:not([src])');
+        var saved = [];
+        for (var i = 0; i < scripts.length; i++) {
+            var el = scripts[i];
+            saved.push({
+                el: el,
+                parent: el.parentNode,
+                next: el.nextSibling,
+                body: el.textContent || '',
+                attrs: ''
+            });
+            for (var a = 0; a < el.attributes.length; a++) {
+                var attr = el.attributes[a];
+                saved[i].attrs += ' ' + attr.name + '="' +
+                    attr.value.replace(/&/g, '&amp;').replace(/"/g, '&quot;') + '"';
+            }
+            el.parentNode.removeChild(el);
+        }
+
+        var html = document.documentElement.outerHTML;
+
+        // Restore every script element to the live DOM immediately
+        for (var r = 0; r < saved.length; r++) {
+            saved[r].parent.insertBefore(saved[r].el, saved[r].next);
+        }
+
+        // Build each script tag as a safe string and insert before </body>
+        var scriptStrings = '';
+        for (var j = 0; j < saved.length; j++) {
+            var s = saved[j];
+            var safeBody = s.body;
+            var scriptType = (s.el.getAttribute('type') || '').toLowerCase();
+            if (scriptType === 'application/json') {
+                // Re-serialize from parsed data so we control the output.
+                // \u003c is valid JSON; JSON.parse converts it back to <
+                var jsonData = app.json.parse();
+                safeBody = JSON.stringify(jsonData, null, 2).replace(/</g, '\\u003c');
+            }
+            scriptStrings += '\n<script' + s.attrs + '>' + safeBody +
+                '</' + 'script>';
+        }
+
+        // Insert scripts before closing </body>
+        var bodyClose = html.lastIndexOf('</' + 'body>');
+        if (bodyClose !== -1) {
+            html = html.substring(0, bodyClose) + scriptStrings + '\n' +
+                html.substring(bodyClose);
+        } else {
+            html += scriptStrings;
+        }
+
+        return '<!DOCTYPE html>\n' + html;
+    };
+
+    /**
+     * Fetch the current page's own source HTML and replace only the
+     * transmittal-data JSON block with the supplied data object.
+     *
+     * This is the preferred save mechanism for drafts because it produces
+     * an exact copy of the source file with only the data changed, rather
+     * than a DOM snapshot that may contain stale or mutated content.
+     *
+     * @param {object} jsonData - The data object to embed as JSON.
+     * @returns {Promise<string>} The patched HTML string.
+     * @throws {Error} If the fetch fails or the JSON block is not found.
+     */
+    util.fetchAndPatchHtml = async function fetchAndPatchHtml(jsonData) {
+        var response = await fetch(location.href, { cache: 'no-cache' });
+        if (!response.ok) {
+            throw new Error('fetch failed with status ' + response.status);
+        }
+        var html = await response.text();
+        // \u003c is valid JSON; JSON.parse converts it back to <
+        var jsonStr = JSON.stringify(jsonData, null, 2).replace(/</g, '\\u003c');
+        // Replace the transmittal-data script body. The non-greedy [\s\S]*? stops
+        // at the first close-script tag, which is safe because < is escaped above.
+        var patched = html.replace(
+            new RegExp(
+                '(<script\\b[^>]*\\bid\\s*=\\s*["\']transmittal-data["\'][^>]*>)[\\s\\S]*?(<\\/' + 'script>)',
+                'i'
+            ),
+            '$1\n' + jsonStr + '\n$2'
+        );
+        if (patched === html) {
+            throw new Error('transmittal-data script block not found in fetched HTML');
+        }
+        return patched;
+    };
+})(window.transmittalApp);
diff --git a/transmittal/js/validation.js b/transmittal/js/validation.js
new file mode 100644
index 0000000..1d363de
--- /dev/null
+++ b/transmittal/js/validation.js
@@ -0,0 +1,62 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+
+    const validation = app.modules.validation = {};
+
+    validation.bindTrackingNumberValidation = function bindTrackingNumberValidation() {
+        const input = dom.qs('#tracking-number');
+        if (!input) {
+            return;
+        }
+        function isInvalid(value) {
+            return /\s/.test(value) || /_/.test(value);
+        }
+        function apply() {
+            const value = input.value || '';
+            const bad = isInvalid(value);
+            input.setAttribute('aria-invalid', bad ? 'true' : 'false');
+            if (bad) {
+                input.classList.add('ring-1', 'ring-red-400', 'border-red-500');
+            } else {
+                input.classList.remove('ring-1', 'ring-red-400', 'border-red-500');
+            }
+        }
+        input.addEventListener('input', apply);
+        input.addEventListener('blur', apply);
+        apply();
+    };
+
+    validation.validateBeforePublish = function validateBeforePublish() {
+        const errors = [];
+        let focusEl = null;
+        const trackingInput = dom.qs('#tracking-number');
+        if (trackingInput) {
+            const value = trackingInput.value || '';
+            if (/\s/.test(value) || /_/.test(value)) {
+                errors.push('Tracking Number must not contain spaces or underscores.');
+                if (!focusEl) {
+                    focusEl = trackingInput;
+                }
+            }
+        }
+        (app.data.files || []).forEach(function (file, index) {
+            if (file.trackingNumber && (/\s/.test(file.trackingNumber) || /_/.test(file.trackingNumber))) {
+                errors.push('Row ' + (index + 1) + ': File tracking number must not contain spaces or underscores.');
+            }
+            if (file.revision && /\s/.test(file.revision)) {
+                errors.push('Row ' + (index + 1) + ': Revision must not contain spaces.');
+            }
+        });
+        return {
+            ok: errors.length === 0,
+            focusEl: focusEl,
+            message: errors.join('\n')
+        };
+    };
+
+    app.registerInit(function () {
+        validation.bindTrackingNumberValidation();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/js/verification.js b/transmittal/js/verification.js
new file mode 100644
index 0000000..66ba684
--- /dev/null
+++ b/transmittal/js/verification.js
@@ -0,0 +1,30 @@
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+
+    var verification = app.modules.verification = {};
+
+    // ── Directory scanning for file hash verification ────
+    verification.scanDirectoryForFiles = async function scanDirectoryForFiles(dirHandle, basePath) {
+        var base = basePath || '';
+        var files = [];
+
+        for await (var entry of dirHandle.values()) {
+            if (entry.kind === 'file') {
+                var file = await entry.getFile();
+                var sha256 = await util.hashFile(file);
+                var path = base ? base + '/' + entry.name : entry.name;
+                files.push({ name: entry.name, path: path, sha256: sha256, size: file.size });
+            } else if (entry.kind === 'directory') {
+                var subPath = base ? base + '/' + entry.name : entry.name;
+                var subFiles = await verification.scanDirectoryForFiles(entry, subPath);
+                for (var j = 0; j < subFiles.length; j++) { files.push(subFiles[j]); }
+            }
+        }
+
+        return files;
+    };
+
+})(window.transmittalApp);
diff --git a/transmittal/js/visibility.js b/transmittal/js/visibility.js
new file mode 100644
index 0000000..0d14a55
--- /dev/null
+++ b/transmittal/js/visibility.js
@@ -0,0 +1,75 @@
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+
+    const visibility = app.modules.visibility = {};
+
+    // Field visibility rules based on document type
+    const FIELD_RULES = {
+        'from': ['Transmittal', 'Submittal'],
+        'to': ['Transmittal', 'Submittal']
+    };
+
+    function getDocumentType() {
+        const typeInput = dom.qs('#type');
+        return typeInput ? (typeInput.value || 'Transmittal').trim() : 'Transmittal';
+    }
+
+    function isFieldVisible(fieldId, docType) {
+        const rules = FIELD_RULES[fieldId];
+        if (!rules) {
+            return true; // No rules = always visible
+        }
+        return rules.includes(docType);
+    }
+
+    function getFieldContainer(fieldId) {
+        const input = dom.qs('#' + fieldId);
+        if (!input) {
+            return null;
+        }
+        // Find the parent container (the div with col-span-6 or col-span-12)
+        let container = input.parentElement;
+        while (container && !container.className.includes('col-span-')) {
+            container = container.parentElement;
+            if (!container || container.tagName === 'FORM') {
+                break;
+            }
+        }
+        return container || input.parentElement;
+    }
+
+    visibility.applyFieldVisibility = function applyFieldVisibility() {
+        const docType = getDocumentType();
+        Object.keys(FIELD_RULES).forEach(function(fieldId) {
+            const container = getFieldContainer(fieldId);
+            if (!container) { return; }
+            container.hidden = !isFieldVisible(fieldId, docType);
+        });
+    };
+
+    visibility.bindTypeInput = function bindTypeInput() {
+        const typeInput = dom.qs('#type');
+        if (!typeInput) {
+            return;
+        }
+
+        // Apply visibility on input change
+        typeInput.addEventListener('input', function() {
+            visibility.applyFieldVisibility();
+            if (app.markDirty) {
+                app.markDirty();
+            }
+        });
+
+        typeInput.addEventListener('change', function() {
+            visibility.applyFieldVisibility();
+        });
+    };
+
+    app.registerInit(function () {
+        visibility.bindTypeInput();
+        visibility.applyFieldVisibility();
+    });
+})(window.transmittalApp);
diff --git a/transmittal/template.html b/transmittal/template.html
new file mode 100644
index 0000000..09b4626
--- /dev/null
+++ b/transmittal/template.html
@@ -0,0 +1,494 @@
+<!--
+This is a html transmittal template.
+It is meant to be an editable form to fill out transmittal information and
+scan documents to be included in the transmittal, and then complete the
+transmittal files table by parsing the file names according to ZDDC naming
+conventions at https://codeberg.org/VARASYS/ZDDC#file-naming-convention.
+-->
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Transmittal</title>
+    <link rel="stylesheet" href="css/base.css">
+    <link rel="stylesheet" href="css/layout.css">
+    <link rel="stylesheet" href="css/forms.css">
+    <link rel="stylesheet" href="css/table.css">
+    <link rel="stylesheet" href="css/remarks.css">
+    <link rel="stylesheet" href="css/markdown.css">
+    <link rel="stylesheet" href="css/markdown-editor.css">
+    <link rel="stylesheet" href="css/filter.css">
+    <link rel="stylesheet" href="css/modal.css">
+    <link rel="stylesheet" href="css/utilities.css">
+    <link rel="stylesheet" href="css/print.css">
+</head>
+
+<body class="font-sans text-gray-900">
+    <div class="app-header print:hidden" data-no-disable="true">
+        <div class="split-button" id="bottom-menu" hidden>
+            <button id="bottom-toggle" type="button" class="btn btn-primary split-button__toggle" data-no-disable="true" aria-haspopup="true" aria-expanded="false">&#x25BE;</button>
+            <button id="bottom-primary" type="button" class="btn btn-primary" data-no-disable="true">Publish</button>
+            <div class="dropdown-menu hidden" role="menu" id="bottom-dropdown"></div>
+        </div>
+        <span id="no-js-notice" class="text-gray-400 text-xs italic">JavaScript not available</span>
+        <div class="header-title-group">
+            <span class="app-header__title">ZDDC Transmittal</span>
+            <span class="build-timestamp">{{BUILD_LABEL}}</span>
+        </div>
+        <div class="app-header__spacer"></div>
+        <div class="app-header__icons">
+            <button type="button" id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+            <button type="button" id="help-btn" class="btn btn-secondary" aria-label="Help" title="Help">?</button>
+        </div>
+    </div>
+    <div class="page-container">
+    <form id="transmittal-form">
+    <input type="hidden" id="mode" value="edit">
+    <input type="hidden" id="published" value="false">
+    <header class="page-header flex flex-col gap-2 p-2 max-w-[1600px] relative">
+        <div class="logo-row">
+            <div class="logo-cell" id="left-logo-cell" data-drop-zone="logo-left">
+                <img id="left-logo" class="logo-img" alt="Sender Logo">
+                <span class="logo-placeholder">Drop sender logo (optional)</span>
+                <span class="drop-zone-label">Drop sender logo</span>
+            </div>
+            <div class="title-area">
+              <div class="type-combo" id="type-combo">
+                <input type="hidden" name="type" id="type" value="Transmittal">
+                <span id="type-display" role="combobox" contenteditable="true" class="type-display w-full text-2xl font-bold bg-transparent border-0 p-0 focus:outline-none text-center" data-placeholder="Type">Transmittal</span>
+                <div class="type-combo__menu hidden" id="type-menu" role="listbox">
+                  <button type="button" class="type-combo__option" role="option" data-value="Transmittal">Transmittal</button>
+                  <button type="button" class="type-combo__option" role="option" data-value="Submittal">Submittal</button>
+                </div>
+              </div>
+              <input type="text" name="title" id="title" placeholder="Title" class="w-full text-base italic bg-transparent border-0 p-0 focus:outline-none disabled:pointer-events-none text-center" value="">
+            </div>
+            <div class="logo-cell" id="right-logo-cell" data-drop-zone="logo-right">
+                <img id="right-logo" class="logo-img" alt="Receiver Logo">
+                <span class="logo-placeholder">Drop receiver logo (optional)</span>
+                <span class="drop-zone-label">Drop receiver logo</span>
+            </div>
+        </div>
+        
+        
+
+        <div id="header-info" data-drop-zone="header">
+        <div class="drop-zone-label">Drop HTML or JSON&#10;to import transmittal data</div>
+        <div class="header-names w-full bg-gray-50 border border-gray-100 rounded-md px-3 py-1.5 flex flex-col gap-0.5">
+            <h2 id="owner-name" class="text-xl font-semibold" data-placeholder="Owner Name"></h2>
+            <h2 id="project-name" class="text-lg font-semibold" data-placeholder="Project Name"></h2>
+            <div id="project-number" class="text-sm text-gray-700" data-placeholder="Project Number"></div>
+        </div>
+
+        <div class="grid grid-cols-12 gap-x-6 gap-y-3 items-start">
+          <!-- Row 1: Tracking Number (A), Date (B) -->
+          <div class="col-span-6">
+            <div class="relative">
+              <input type="text" name="tracking-number" id="tracking-number" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <label for="tracking-number" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Tracking Number</label>
+            </div>
+          </div>
+          <div class="col-span-6">
+            <div class="relative">
+              <input type="text" name="date" id="date" placeholder="YYYY-MM-DD" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <label for="date" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Date</label>
+              <input type="date" id="date-picker-hidden" style="position:absolute;width:0;height:0;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);" tabindex="-1" aria-hidden="true">
+            </div>
+          </div>
+
+          <!-- Row 2: From | Purpose (+ Response Due for Submittals) -->
+          <div class="col-span-6">
+            <div class="relative">
+              <input type="text" name="from" id="from" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <div id="from-render" class="from-render hidden"></div>
+              <label for="from" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">From</label>
+            </div>
+          </div>
+          <div class="col-span-6">
+            <div class="flex gap-x-6" id="purpose-group">
+              <div class="relative flex-1">
+                <input type="text" name="purpose" id="purpose" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+                <label for="purpose" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Purpose</label>
+              </div>
+              <div class="relative flex-1 hidden" id="response-due-wrapper">
+                <input type="text" name="response-due" id="response-due" placeholder="YYYY-MM-DD" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+                <label for="response-due" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Response Due</label>
+                <input type="date" id="response-due-picker-hidden" style="position:absolute;width:0;height:0;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);" tabindex="-1" aria-hidden="true">
+              </div>
+            </div>
+          </div>
+
+          <!-- Row 3: To full width -->
+          <div class="col-span-12">
+            <div class="relative">
+              <input type="text" name="to" id="to" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <div id="to-render" class="to-render hidden"></div>
+              <label for="to" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">To</label>
+            </div>
+          </div>
+
+          <!-- Row 4: Subject full width -->
+          <div class="col-span-12">
+            <div class="relative">
+              <input type="text" name="subject" id="subject" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-bold focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400" />
+              <label for="subject" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Subject</label>
+            </div>
+          </div>
+
+          <!-- Row 5: Remarks full width (Markdown) -->
+          <div class="col-span-12">
+            <div class="relative w-full">
+              <div id="remarks-wrapper" class="w-full">
+                <textarea id="remarks" name="remarks" placeholder="Remarks" aria-label="Remarks" class="px-2 pt-1 pb-3 bg-white border-0 rounded-none text-[12px] w-full min-h-[3.5rem] leading-snug resize-y"></textarea>
+                <div id="remarks-render-container" class="w-full p-2 overflow-auto">
+                  <div id="remarks-render" class="text-sm"></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+        </div>
+    </header>
+
+    <main class="p-2 max-w-[1600px]">
+
+          <!-- Step: Integrity — "Is this verified?" -->
+          <div class="workflow-step" id="integrity-section">
+            <h3 class="workflow-step__label">
+              Integrity
+              <span id="signature-status-static" class="workflow-badge workflow-badge--warn" data-hydrate-hide="true">Not Validated (requires JavaScript)</span>
+            </h3>
+            <div id="integrity-body" class="integrity-body">
+              <div id="digest-display"></div>
+              <div id="signatures-list"></div>
+              <button id="add-signature-btn" type="button" class="btn btn-secondary btn-sm hidden print:hidden">Add Signature</button>
+            </div>
+          </div>
+
+        <!-- file table goes here (tracking number, title, revision, status) -->
+        <div id="file-table-drop-zone" data-drop-zone="file-table">
+        <div class="drop-zone-label">Drop folder to scan / verify&#10;Drop HTML or JSON to import</div>
+        <div class="table-wrapper mt-2">
+         <table class="table-auto text-[10px] w-full">
+            <thead>
+                <tr>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap"><span class="table-header__caption">#</span></th>
+                    <th class="bg-gray-100 text-left px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">TRACKING NUMBER</span>
+                            <input type="text" data-no-disable="true" data-filter-field="trackingNumber" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by tracking number">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-left px-2 py-1 sticky top-0 z-20 w-full">
+                        <label class="table-header">
+                            <span class="table-header__caption">TITLE</span>
+                            <input type="text" data-no-disable="true" data-filter-field="title" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by title">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">REVISION</span>
+                            <input type="text" data-no-disable="true" data-filter-field="revision" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by revision">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">STATUS</span>
+                            <input type="text" data-no-disable="true" data-filter-field="status" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by status">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">EXT</span>
+                            <input type="text" data-no-disable="true" data-filter-field="extension" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by extension">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-right px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">SIZE</span>
+                            <input type="text" data-no-disable="true" data-filter-field="fileSize" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by size">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-left px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">SHA256</span>
+                            <input type="text" data-no-disable="true" data-filter-field="sha256" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by SHA256">
+                        </label>
+                    </th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                </tr>
+            </tbody>
+         </table>
+        </div>
+        </div>
+
+    </main>
+
+    <footer class="page-footer print:hidden">
+        <div class="page-footer__inner">
+            <span id="data-status" class="text-gray-600 text-[10px]" aria-live="polite"></span>
+            <span id="selected-directory" class="workflow-dir text-[10px]"></span>
+        </div>
+    </footer>
+    </form>
+    </div>
+
+    <dialog id="publish-modal" class="modal" data-edit-only="true" aria-labelledby="publish-modal-title">
+      <div class="modal__header">
+        <h2 id="publish-modal-title" class="modal__title">Publish Transmittal</h2>
+        <button type="button" class="modal__close" data-modal-close aria-label="Close">&times;</button>
+      </div>
+      <div class="modal__body">
+        <div id="publish-date-row" class="publish-field">
+          <label for="publish-date-input" class="publish-field__label">Date</label>
+          <div class="publish-field__row">
+            <input type="text" id="publish-date-input" class="publish-field__input" placeholder="YYYY-MM-DD" pattern="\d{4}-\d{2}-\d{2}">
+            <span id="publish-date-warning" class="publish-field__warning" hidden></span>
+          </div>
+        </div>
+        <fieldset class="publish-outputs">
+          <legend class="publish-field__label">Output</legend>
+          <label class="publish-check">
+            <input type="checkbox" id="publish-save-folder"> Save in directory
+          </label>
+          <label class="publish-check">
+            <input type="checkbox" id="publish-download-html"> Download HTML
+          </label>
+        </fieldset>
+      </div>
+      <div class="modal__feedback" id="publish-modal-feedback" role="status" aria-live="polite"></div>
+      <div class="modal__footer">
+        <button type="button" class="btn btn-secondary" data-modal-close>Cancel</button>
+        <button type="button" class="btn btn-secondary" id="publish-draft-btn">Save Draft</button>
+        <button type="button" class="btn btn-secondary" id="publish-signed-btn">Publish Signed</button>
+        <button type="button" class="btn btn-primary" id="publish-confirm">Publish</button>
+      </div>
+    </dialog>
+
+    <dialog id="key-dialog" class="modal modal--narrow" aria-labelledby="key-dialog-title">
+      <div class="modal__header">
+        <h2 id="key-dialog-title" class="modal__title">Signing Key</h2>
+        <button type="button" class="modal__close" data-modal-close aria-label="Close">&times;</button>
+      </div>
+      <div class="modal__body">
+        <p class="key-dialog__desc">Select your signing key file or generate a new key pair.</p>
+        <div class="key-dialog__actions">
+          <button type="button" class="btn btn-secondary" id="key-select-file">Select Key File</button>
+          <button type="button" class="btn btn-secondary" id="key-generate">Generate New Key</button>
+        </div>
+        <div id="key-generate-panel" hidden>
+          <label class="publish-field__label" for="key-password">Password (optional)</label>
+          <input type="password" id="key-password" class="publish-field__input" placeholder="Leave blank for no password" autocomplete="new-password">
+          <label class="publish-field__label" for="key-password-confirm" style="margin-top:0.25rem;">Confirm password</label>
+          <input type="password" id="key-password-confirm" class="publish-field__input" placeholder="Confirm password" autocomplete="new-password">
+          <div class="key-dialog__actions" style="margin-top:0.5rem;">
+            <button type="button" class="btn btn-primary" id="key-generate-confirm">Generate &amp; Download</button>
+            <button type="button" class="btn btn-secondary" id="key-generate-cancel">Back</button>
+          </div>
+        </div>
+        <div class="modal__feedback" id="key-dialog-feedback" role="status" aria-live="polite"></div>
+      </div>
+    </dialog>
+
+    <dialog id="password-dialog" class="modal modal--narrow" aria-labelledby="password-dialog-title">
+      <div class="modal__header">
+        <h2 id="password-dialog-title" class="modal__title">Enter Key Password</h2>
+        <button type="button" class="modal__close" data-modal-close aria-label="Close">&times;</button>
+      </div>
+      <div class="modal__body">
+        <p id="password-dialog-fingerprint" class="key-dialog__desc"></p>
+        <input type="password" id="password-dialog-input" class="publish-field__input" placeholder="Password" autocomplete="current-password">
+        <div class="modal__feedback" id="password-dialog-feedback" role="status" aria-live="polite"></div>
+      </div>
+      <div class="modal__footer">
+        <button type="button" class="btn btn-secondary" data-modal-close>Cancel</button>
+        <button type="button" class="btn btn-primary" id="password-dialog-ok">Unlock</button>
+      </div>
+    </dialog>
+
+    <!-- Help panel (non-modal slide-out) -->
+    <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+      <div class="help-panel__header">
+        <h2 id="help-panel-title" class="help-panel__title">Help</h2>
+        <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+      </div>
+      <div class="help-panel__body">
+        <h3>What is a Transmittal?</h3>
+        <p>A transmittal is a cover sheet that travels with a set of files. It records <em>what</em> was sent, <em>to whom</em>, and <em>when</em>. This tool produces a single self-contained HTML file that serves as both the cover sheet and a cryptographic proof of what was delivered.</p>
+        <p><strong>How it works:</strong> Each file in the transmittal is fingerprinted with a SHA-256 hash &mdash; a value computed from the file&rsquo;s contents. Change even one byte and the hash changes, so a matching hash proves the file is unaltered. The transmittal then hashes the entire payload (header, file list, and all per-file hashes) into a single <em>digest</em>. Optionally, one or more people can digitally sign that digest.</p>
+
+        <h3>Typical Workflow</h3>
+        <ol>
+          <li><strong>Fill in the header</strong> &mdash; tracking number, date, recipient, project, etc.</li>
+          <li>Optionally <em>Save Draft</em> to create a reusable template.</li>
+          <li><strong>Add files</strong> &mdash; paste rows from a spreadsheet, or use <em>Scan Directory</em> to read a folder and compute hashes automatically.</li>
+          <li><strong>Review</strong> the file table and remarks.</li>
+          <li>Use <em>Verify Directory</em> to confirm every listed file is present and unchanged.</li>
+          <li><strong>Publish</strong> &mdash; click <em>Publish</em> for an unsigned digest, or use the dropdown for <em>Publish Signed</em> (with a signing key) or <em>Save Draft</em>. The output is saved to the working directory, or downloaded if no directory is selected.</li>
+          <li><strong>Distribute</strong> &mdash; send the HTML alongside the actual files.</li>
+        </ol>
+
+        <h3>Signing Keys</h3>
+        <p>Signing keys are stored in <code>.zddc-key</code> files. When generating a new key, you can optionally protect it with a password. Password-protected keys require the password each time they are used to sign.</p>
+        <p>Keys without a password work immediately, like an unprotected SSH key.</p>
+
+        <h3>Verification Levels</h3>
+        <p>A published transmittal provides up to four escalating levels of integrity protection. Higher levels guard against increasingly sophisticated threats:</p>
+        <ol>
+          <li><strong>Static HTML</strong> &mdash; A human-readable record of everything sent. Works without JavaScript (e.g.&nbsp;on a SharePoint site). No cryptographic protection.</li>
+          <li><strong>Digest check</strong> &mdash; With JavaScript, the tool recomputes the SHA-256 digest and compares it to the stored value. A match proves nothing changed since publication. Detects accidental corruption, but someone could alter both the data and the digest.</li>
+          <li><strong>Digital signatures</strong> &mdash; ECDSA signatures bind the digest to a signer&rsquo;s private key. Any change invalidates the signature, preventing undetected tampering. Add signatures after publishing via <em>Add Signature</em>.</li>
+          <li><strong>Independent verification</strong> &mdash; A tampered HTML file could ship modified JavaScript that always says &ldquo;Verified.&rdquo; To rule this out, the recipient opens the sender&rsquo;s file in their <em>own</em> trusted copy of the tool using <em>Import HTML</em>. This extracts the raw data and re-verifies it with the recipient&rsquo;s own code. Use this level for anything that matters.</li>
+        </ol>
+        <p class="text-sm text-gray-500">Level&nbsp;4 assumes the recipient&rsquo;s tool is trustworthy (downloaded from a known source or built from source). A reference instance is at <a href="https://zddc.varasys.io/releases/transmittal_latest.html" target="_blank" rel="noopener">zddc.varasys.io</a>.</p>
+
+        <h3>Menu Actions</h3>
+        <p>Actions available from the dropdown button. <span class="help-badge help-badge--draft">draft</span> items appear only while editing. <span class="help-badge help-badge--published">published</span> items appear only after publishing. Unmarked items appear in both modes.</p>
+
+        <dl>
+          <dt>Save Draft <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Downloads the current state as an HTML file. Reopen it later to continue editing, or use it as a template for new transmittals.</dd>
+
+          <dt>Revise <span class="help-badge help-badge--published">published</span></dt>
+          <dd>Unlocks a published transmittal back into an editable draft.</dd>
+
+          <dt>Add Signature <span class="help-badge help-badge--published">published</span></dt>
+          <dd>Signs the digest with a new ECDSA key and downloads the updated file. Multiple people can sign sequentially.</dd>
+
+          <dt>Acknowledge Receipt <span class="help-badge help-badge--published">published</span></dt>
+          <dd>Same as Add Signature, but labeled &ldquo;Received By&rdquo; in the signature list &mdash; used by the recipient to confirm delivery.</dd>
+        </dl>
+
+        <h4>Table Clipboard</h4>
+        <dl>
+          <dt>Paste New Rows <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Replaces the file table with tab-separated data from the clipboard (e.g.&nbsp;copied from Excel).</dd>
+          <dt>Paste Append Rows <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Appends clipboard rows to the existing file table.</dd>
+          <dt>Copy Table</dt>
+          <dd>Copies the file table as tab-separated text for pasting into spreadsheets.</dd>
+        </dl>
+
+        <h4>Data Import &amp; Export</h4>
+        <dl>
+          <dt>Import HTML</dt>
+          <dd>Opens a published transmittal HTML, extracts its data, and re-verifies it with your own code (Level&nbsp;4). You can also drag-and-drop an HTML or JSON file directly onto the <strong>Header</strong> or <strong>File table</strong> drop zones &mdash; drag anything over the page to reveal the zones.</dd>
+          <dt>Copy JSON</dt>
+          <dd>Copies the raw transmittal data as JSON for backup or transfer.</dd>
+          <dt>Paste JSON <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Loads transmittal data from JSON on the clipboard.</dd>
+        </dl>
+
+        <h4>Drag-and-Drop Zones</h4>
+        <p>Drag any file or folder over the page to reveal labelled drop zones. Zones that can accept your data are highlighted in blue; others are dimmed.</p>
+        <dl>
+          <dt>Sender / Receiver logo zones</dt>
+          <dd>Top-left and top-right areas. Accept image files. Edit mode only.</dd>
+          <dt>Header zone <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>The form header area. Accepts a transmittal HTML or JSON file to import all fields.</dd>
+          <dt>File table zone</dt>
+          <dd>The document list area. Accepts a folder (triggers Scan or Verify), or a transmittal HTML/JSON file.</dd>
+        </dl>
+
+        <h4>Directory Operations</h4>
+        <p class="text-sm text-gray-500">Requires a Chromium-based desktop browser (File System Access API).</p>
+        <dl>
+          <dt>Scan Directory <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Picks a local folder, lists every file, and computes SHA-256 hashes to populate the file table.</dd>
+          <dt>Verify Directory</dt>
+          <dd>Picks a local folder and checks that each file on disk matches its hash in the transmittal.</dd>
+        </dl>
+
+        <h4>Other</h4>
+        <dl>
+          <dt>Create Index</dt>
+          <dd>Scans transmittal folders and builds a <code>.archive</code> directory of small HTML redirects keyed by tracking number, revision, and hash &mdash; enabling direct links between documents in a file-based archive.</dd>
+          <dt>Reset</dt>
+          <dd>Clears everything and restores the blank template.</dd>
+        </dl>
+      </div>
+    </aside>
+
+    <!-- Single source of truth for all data; replace this block to swap content -->
+    <!-- Hydration: Populate static content from JSON on publish -->
+    <script id="transmittal-data" type="application/json">
+{
+  "envelope": {
+    "version": 1,
+    "digestAlgorithm": "SHA-256",
+    "digest": "",
+    "digestedAt": "",
+    "signatureAlgorithm": "ECDSA-P256-SHA256",
+    "signatures": []
+  },
+  "payload": {
+    "version": 1,
+    "type": "Transmittal",
+    "title": "",
+    "client": "",
+    "project": "",
+    "projectNumber": "",
+    "date": "",
+    "trackingNumber": "",
+    "from": "",
+    "to": "",
+    "purpose": "",
+    "responseDue": "",
+    "subject": "",
+    "remarks": "",
+    "files": []
+  },
+  "presentation": {
+    "leftLogo": "",
+    "rightLogo": "",
+    "theme": "default",
+    "customCss": ""
+  }
+}
+    </script>
+    <script src="js/app.js"></script>
+    <script src="js/reactive.js"></script>
+    <script src="js/dom.js"></script>
+    <script src="js/util.js"></script>
+    <script src="js/json.js"></script>
+    <script src="js/hydrate.js"></script>
+    <script src="js/state.js"></script>
+    <script src="js/mode.js"></script>
+    <script src="js/visibility.js"></script>
+    <script src="js/live-digest.js"></script>
+    <script src="js/files.js"></script>
+    <script src="js/files-archive.js"></script>
+    <script src="js/files-render.js"></script>
+    <script src="js/files-preview.js"></script>
+    <script src="js/filters.js"></script>
+    <script src="js/markdown.js"></script>
+    <script src="js/markdown-editor.js"></script>
+    <script src="js/email-tags.js"></script>
+    <script src="js/validation.js"></script>
+    <script src="js/security.js"></script>
+    <script src="js/verification.js"></script>
+    <script src="js/data.js"></script>
+    <script src="js/publish.js"></script>
+    <script src="js/reset.js"></script>
+    <script src="js/publish-modal.js"></script>
+    <script src="js/logos.js"></script>
+    <script src="js/drop-zones.js"></script>
+    <script src="js/focus.js"></script>
+    <script src="../shared/help.js"></script>
+    <script src="js/main.js"></script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/transmittal/transmittal.schema.json b/transmittal/transmittal.schema.json
new file mode 100644
index 0000000..96984ad
--- /dev/null
+++ b/transmittal/transmittal.schema.json
@@ -0,0 +1,230 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://zddc.varasys.io/transmittal.schema.json",
+  "title": "ZDDC Transmittal",
+  "description": "Schema for ZDDC transmittal documents with cryptographic envelope",
+  "type": "object",
+  "properties": {
+    "payload": {
+      "type": "object",
+      "description": "The core transmittal data",
+      "properties": {
+        "version": {
+          "type": "integer",
+          "description": "Payload schema version",
+          "const": 1
+        },
+        "type": {
+          "type": "string",
+          "description": "Document type - Transmittal and Submittal are fixed, or any custom text for file lists",
+          "default": "Transmittal"
+        },
+        "title": {
+          "type": "string",
+          "description": "Optional descriptive title"
+        },
+        "client": {
+          "type": "string",
+          "description": "The Owner Name"
+        },
+        "project": {
+          "type": "string",
+          "description": "The Project Name"
+        },
+        "projectNumber": {
+          "type": "string",
+          "description": "The Project Number"
+        },
+        "date": {
+          "type": "string",
+          "description": "Date in YYYY-MM-DD format (canonicalized from friendly text)",
+          "pattern": "^\\d{4}-\\d{2}-\\d{2}$"
+        },
+        "trackingNumber": {
+          "type": "string",
+          "description": "Tracking number; must not contain spaces or underscores",
+          "pattern": "^[^\\s_]+$"
+        },
+        "from": {
+          "type": "string",
+          "description": "Who issued the document (hidden for file lists)"
+        },
+        "to": {
+          "type": "string",
+          "description": "Recipient of the document (hidden for file lists)"
+        },
+        "purpose": {
+          "type": "string",
+          "description": "Purpose of document (hidden for file lists)"
+        },
+        "responseDue": {
+          "type": "string",
+          "description": "Response deadline (shown only for Submittal type)"
+        },
+        "subject": {
+          "type": "string",
+          "description": "Subject line"
+        },
+        "remarks": {
+          "type": "string",
+          "description": "Free-form Markdown content"
+        },
+        "files": {
+          "type": "array",
+          "description": "List of files included in the transmittal",
+          "items": {
+            "type": "object",
+            "properties": {
+              "trackingNumber": {
+                "type": "string",
+                "description": "File tracking number from ZDDC filename convention"
+              },
+              "revision": {
+                "type": "string",
+                "description": "File revision from ZDDC filename convention"
+              },
+              "status": {
+                "type": "string",
+                "description": "File status from ZDDC filename convention"
+              },
+              "title": {
+                "type": "string",
+                "description": "File title from ZDDC filename convention"
+              },
+              "path": {
+                "type": "string",
+                "description": "Directory path relative to transmittal root (without filename)",
+                "default": ""
+              },
+              "filename": {
+                "type": "string",
+                "description": "Filename only (without path)"
+              },
+              "sha256": {
+                "type": "string",
+                "description": "SHA-256 hash of file contents (hex)",
+                "pattern": "^[a-f0-9]{64}$"
+              },
+              "fileSize": {
+                "type": "integer",
+                "description": "File size in bytes",
+                "minimum": 0
+              }
+            },
+            "required": ["filename", "sha256"],
+            "additionalProperties": false
+          }
+        }
+      },
+      "required": ["version", "type", "date", "trackingNumber", "files"],
+      "additionalProperties": false
+    },
+    "envelope": {
+      "type": "object",
+      "description": "Cryptographic envelope capturing state after publish",
+      "properties": {
+        "version": {
+          "type": "integer",
+          "description": "Schema version number",
+          "const": 1
+        },
+        "digestAlgorithm": {
+          "type": "string",
+          "description": "Digest algorithm used",
+          "const": "SHA-256"
+        },
+        "digest": {
+          "type": "string",
+          "description": "SHA-256 hash of canonical payload string (hex)",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "digestedAt": {
+          "type": "string",
+          "format": "date-time",
+          "description": "ISO 8601 timestamp when digest was computed"
+        },
+        "signatureAlgorithm": {
+          "type": "string",
+          "description": "Signature algorithm used",
+          "const": "ECDSA-P256-SHA256"
+        },
+        "signatures": {
+          "type": "array",
+          "description": "Array of signatures from multiple signers",
+          "items": {
+            "type": "object",
+            "properties": {
+              "signature": {
+                "type": "string",
+                "description": "ECDSA signature over canonical payload (base64)",
+                "contentEncoding": "base64"
+              },
+              "signedAt": {
+                "type": "string",
+                "format": "date-time",
+                "description": "ISO 8601 timestamp when this signature was created"
+              },
+              "publicKeyJwk": {
+                "type": "object",
+                "description": "EC P-256 public key in JWK format for signature verification",
+                "properties": {
+                  "kty": {
+                    "type": "string",
+                    "const": "EC"
+                  },
+                  "crv": {
+                    "type": "string",
+                    "const": "P-256"
+                  },
+                  "x": {
+                    "type": "string",
+                    "description": "X coordinate (base64url)"
+                  },
+                  "y": {
+                    "type": "string",
+                    "description": "Y coordinate (base64url)"
+                  }
+                },
+                "required": ["kty", "crv", "x", "y"],
+                "additionalProperties": false
+              }
+            },
+            "required": ["signature", "signedAt", "publicKeyJwk"],
+            "additionalProperties": false
+          }
+        }
+      },
+      "required": ["version", "digestAlgorithm", "digest", "digestedAt", "signatureAlgorithm"],
+      "additionalProperties": false
+    },
+    "presentation": {
+      "type": "object",
+      "description": "Optional presentation assets (logos, styling) - not part of signed payload",
+      "properties": {
+        "leftLogo": {
+          "type": "string",
+          "description": "Left logo as data URL (e.g., data:image/png;base64,...)",
+          "pattern": "^data:image/[a-z]+;base64,"
+        },
+        "rightLogo": {
+          "type": "string",
+          "description": "Right logo as data URL (e.g., data:image/png;base64,...)",
+          "pattern": "^data:image/[a-z]+;base64,"
+        },
+        "theme": {
+          "type": "string",
+          "description": "Visual theme identifier",
+          "default": "default"
+        },
+        "customCss": {
+          "type": "string",
+          "description": "Optional custom CSS for styling the transmittal",
+          "default": ""
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "required": ["payload", "envelope"],
+  "additionalProperties": false
+}
diff --git a/website/css/style.css b/website/css/style.css
new file mode 100644
index 0000000..e55d0f9
--- /dev/null
+++ b/website/css/style.css
@@ -0,0 +1,1135 @@
+/* ZDDC — Zero Day Document Control */
+/* Professional, trustworthy, reliable — but friendly and inviting */
+
+/* ── Design tokens ── */
+:root {
+  /* Typography */
+  --font-sans:    'Inter', system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, sans-serif;
+  --font-mono:    'SF Mono', 'Fira Code', 'Consolas', monospace;
+  
+  /* Color palette - Steel blue accent (#2a5a8a) */
+  --color-accent:     #2a5a8a;
+  --color-accent-hover: #1d4060;
+  --color-accent-soft: #e8f0f7;
+  --color-accent-dark: #3d7ab5;
+  
+  --color-bg:         #ffffff;
+  --color-bg-subtle:  #f8f9fa;
+  --color-bg-muted:   #e9ecef;
+  
+  --color-text:       #1f2937;
+  --color-text-muted: #6b7280;
+  --color-text-light: #9ca3af;
+  
+  --color-border:     #e5e7eb;
+  
+  /* Semantic colors */
+  --color-Tracking:   #dbeafe;    /* blue-tint */
+  --color-Revision:   #bbf7d0;    /* green-tint */
+  --color-Status:     #fde68a;    /* amber-tint */
+  --color-Title:      #f3f4f6;    /* gray-tint */
+  
+  /* Spacing */
+  --spacing-xs:   0.25rem;
+  --spacing-sm:   0.5rem;
+  --spacing-md:   1rem;
+  --spacing-lg:   1.5rem;
+  --spacing-xl:   2rem;
+  --spacing-2xl:  3rem;
+  
+  /* Sizing */
+  --radius-sm:    6px;
+  --radius-md:    8px;
+  --radius-lg:    12px;
+  --radius-xl:    16px;
+  
+  /* Shadows */
+  --shadow-sm:    0 1px 2px rgba(0,0,0,0.05);
+  --shadow-md:    0 2px 4px rgba(0,0,0,0.05);
+  --shadow-lg:    0 4px 8px rgba(0,0,0,0.08);
+  --shadow-xl:    0 10px 15px -3px rgba(0,0,0,0.1);
+  
+  /* Max width & typography */
+  --max-width: 900px;
+  --font-size-base: 16px;
+  --line-height:  1.6;
+}
+
+/* ── Reset ── */
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+html { 
+  font-size: var(--font-size-base);
+  scroll-behavior: smooth;
+}
+
+body {
+  font-family: var(--font-sans);
+  color: var(--color-text);
+  background: var(--color-bg);
+  line-height: var(--line-height);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+/* ── Layout ── */
+.container {
+  max-width: var(--max-width);
+  margin: 0 auto;
+  padding: 0 var(--spacing-lg);
+}
+
+
+/* ── Header ── */
+.site-header {
+  background: var(--color-bg);
+  border-bottom: 1px solid var(--color-border);
+  padding: var(--spacing-sm) 0;
+  position: sticky;
+  top: 0;
+  z-index: 100;
+  box-shadow: var(--shadow-sm);
+}
+
+.header-content {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: var(--spacing-md);
+}
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+  text-decoration: none;
+  color: var(--color-text);
+  font-weight: 600;
+  font-size: 1.1rem;
+}
+
+.brand-logo {
+  width: 28px;
+  height: 28px;
+  background: var(--color-accent);
+  border-radius: var(--radius-sm);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+
+.brand-logo svg {
+  width: 18px;
+  height: 18px;
+  fill: white;
+}
+
+/* ── Header Navigation ── */
+.header-nav {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+}
+
+.nav-link {
+  color: var(--color-text);
+  text-decoration: none;
+  font-size: 0.9rem;
+  padding: var(--spacing-xs) var(--spacing-sm);
+  border-radius: var(--radius-sm);
+  transition: background 0.2s, color 0.2s;
+}
+
+.nav-link:hover {
+  background: var(--color-bg-subtle);
+  color: var(--color-accent);
+}
+
+.nav-link.active {
+  color: var(--color-accent);
+  font-weight: 600;
+}
+
+.dropdown {
+  position: relative;
+}
+
+.dropdown-toggle {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-xs);
+  color: var(--color-text);
+  text-decoration: none;
+  font-size: 0.9rem;
+  padding: var(--spacing-xs) var(--spacing-sm);
+  border-radius: var(--radius-sm);
+  cursor: pointer;
+  background: transparent;
+  border: none;
+  transition: background 0.2s;
+}
+
+.dropdown-toggle:hover {
+  background: var(--color-bg-subtle);
+}
+
+.dropdown-menu {
+  display: none;
+  position: absolute;
+  top: 100%;
+  left: 0;
+  /* transparent top padding bridges the gap between button and menu */
+  padding-top: 6px;
+  z-index: 1000;
+}
+
+.dropdown-menu__inner {
+  background: var(--color-bg);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  box-shadow: var(--shadow-lg);
+  min-width: 200px;
+  padding: var(--spacing-xs);
+}
+
+/* Show on JS class OR on CSS hover of the whole .dropdown wrapper */
+.dropdown-menu.show,
+.dropdown:hover .dropdown-menu {
+  display: block;
+}
+
+.dropdown-menu a {
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-sm);
+  padding: var(--spacing-xs) var(--spacing-sm);
+  color: var(--color-text);
+  text-decoration: none;
+  white-space: nowrap;
+  font-size: 0.9rem;
+  border-radius: var(--radius-sm);
+  transition: background 0.2s;
+}
+
+.dropdown-menu a:hover {
+  background: var(--color-bg-subtle);
+  color: var(--color-accent);
+}
+
+.dropdown-menu-icon {
+  width: 16px;
+  height: 16px;
+  flex-shrink: 0;
+  opacity: 0.6;
+  fill: currentColor;
+}
+
+/* ── Main Content ── */
+main {
+  flex: 1;
+}
+
+/* ── Hero Section ── */
+.hero {
+  padding: var(--spacing-2xl) 0 var(--spacing-xl);
+  text-align: center;
+  /* Subtle radial gradient background */
+  background: radial-gradient(circle at center, rgba(42, 90, 138, 0.03) 0%, transparent 60%);
+}
+
+.hero h1 {
+  font-size: clamp(2.5rem, 7vw, 3.75rem);
+  font-weight: 800;
+  line-height: 1.1;
+  letter-spacing: -0.02em;
+  margin-bottom: var(--spacing-md);
+  color: var(--color-text);
+}
+
+.hero-subtitle {
+  font-size: 1.25rem;
+  color: var(--color-text-muted);
+  max-width: 600px;
+  margin: 0 auto var(--spacing-xl);
+  line-height: 1.6;
+  font-weight: 400;
+}
+
+/* ── Pain Point Sections ── */
+.pain-section {
+  padding: var(--spacing-2xl) 0;
+  background: #fff8f8;
+  border-top: 1px solid #fce8e8;
+  border-bottom: 1px solid #fce8e8;
+  margin-bottom: -1px; /* collapse adjacent borders */
+}
+
+.pain-section__badge {
+  display: inline-block;
+  background: #fef2f2;
+  color: #991b1b;
+  border: 1px solid #fecaca;
+  font-size: 0.75rem;
+  font-weight: 700;
+  padding: var(--spacing-xs) var(--spacing-sm);
+  border-radius: 50px;
+  margin-bottom: var(--spacing-md);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.pain-section__heading {
+  font-size: 1.75rem;
+  font-weight: 700;
+  margin-bottom: var(--spacing-md);
+  color: var(--color-text);
+}
+
+.pain-section__body {
+  color: var(--color-text-muted);
+  line-height: 1.65;
+  max-width: 700px;
+}
+
+/* ── Solution sections ── */
+.solution-section {
+  padding: var(--spacing-2xl) 0;
+  background: #f4fbf6;
+  border-top: 1px solid #d1ead9;
+  border-bottom: 1px solid #d1ead9;
+  margin-bottom: -1px;
+}
+
+.solution-section__badge {
+  display: inline-block;
+  background: #f0faf4;
+  color: #166534;
+  border: 1px solid #bbf7d0;
+  font-size: 0.75rem;
+  font-weight: 700;
+  padding: var(--spacing-xs) var(--spacing-sm);
+  border-radius: 50px;
+  margin-bottom: var(--spacing-md);
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.solution-section__heading {
+  font-size: 1.75rem;
+  font-weight: 700;
+  margin-bottom: var(--spacing-md);
+  color: var(--color-text);
+}
+
+.solution-section__body {
+  color: var(--color-text-muted);
+  line-height: 1.65;
+  max-width: 700px;
+}
+
+/* ── Zone dividers (between problem and solution bands) ── */
+.zone-break {
+  padding: var(--spacing-2xl) 0;
+  background: var(--color-bg);
+  text-align: center;
+}
+
+.zone-break__heading {
+  font-size: 1.5rem;
+  font-weight: 800;
+  color: var(--color-text);
+  margin-bottom: var(--spacing-sm);
+}
+
+.zone-break__sub {
+  color: var(--color-text-muted);
+  max-width: 560px;
+  margin: 0 auto;
+  font-size: 1.05rem;
+  line-height: 1.6;
+}
+
+/* ── Filename Anatomy ── */
+.filename-anatomy {
+  font-family: var(--font-mono);
+  font-size: 0.95rem;
+  background: var(--color-bg-subtle);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  padding: var(--spacing-lg);
+  overflow-x: auto;
+  white-space: nowrap;
+}
+
+.filename-anatomy__part {
+  padding: 2px 4px;
+  border-radius: 4px;
+}
+
+.filename-anatomy__part--tracking {
+  background: var(--color-Tracking);
+  color: #1e40af;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .filename-anatomy__part--tracking {
+    color: #93c5fd;
+  }
+}
+html[data-theme="dark"] .filename-anatomy__part--tracking {
+  color: #93c5fd;
+}
+
+.filename-anatomy__part--revision {
+  background: var(--color-Revision);
+  color: #166534;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .filename-anatomy__part--revision {
+    color: #86efac;
+  }
+}
+html[data-theme="dark"] .filename-anatomy__part--revision {
+  color: #86efac;
+}
+
+.filename-anatomy__part--status {
+  background: var(--color-Status);
+  color: #92400e;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .filename-anatomy__part--status {
+    color: #fcd34d;
+  }
+}
+html[data-theme="dark"] .filename-anatomy__part--status {
+  color: #fcd34d;
+}
+
+.filename-anatomy__part--title {
+  background: var(--color-Title);
+  color: var(--color-text);
+}
+
+.filename-parts {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: var(--spacing-sm);
+  margin-top: var(--spacing-md);
+}
+
+.filename-parts__dot {
+  width: 12px;
+  height: 12px;
+  border-radius: 50%;
+  display: inline-block;
+  margin-right: var(--spacing-xs);
+}
+
+.filename-parts__dot--tracking { background: #1e40af; }
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .filename-parts__dot--tracking {
+    background: #93c5fd;
+  }
+}
+html[data-theme="dark"] .filename-parts__dot--tracking {
+  background: #93c5fd;
+}
+
+.filename-parts__dot--revision { background: #166534; }
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .filename-parts__dot--revision {
+    background: #86efac;
+  }
+}
+html[data-theme="dark"] .filename-parts__dot--revision {
+  background: #86efac;
+}
+
+.filename-parts__dot--status { background: #92400e; }
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .filename-parts__dot--status {
+    background: #fcd34d;
+  }
+}
+html[data-theme="dark"] .filename-parts__dot--status {
+  background: #fcd34d;
+}
+
+.filename-parts__dot--title { background: var(--color-text-muted); }
+
+.filename-parts__label {
+  font-size: 0.75rem;
+  color: var(--color-text-muted);
+}
+
+/* ── Status Badge ── */
+.status-badge {
+  display: inline-block;
+  font-family: var(--font-mono);
+  font-size: 0.75rem;
+  background: var(--color-accent-soft);
+  color: var(--color-accent);
+  padding: 2px 6px;
+  border-radius: 4px;
+  font-weight: 600;
+}
+
+/* ── Tool Cards ── */
+.tool-card {
+  background: var(--color-bg);
+  border: 1px solid var(--color-border);
+  border-radius: 10px;
+  padding: 24px;
+  transition: transform 0.2s, box-shadow 0.2s;
+}
+
+.tool-card:hover {
+  transform: translateY(-2px);
+  box-shadow: var(--shadow-xl);
+}
+
+.tool-card__title {
+  font-size: 1.1rem;
+  font-weight: 700;
+  margin-bottom: var(--spacing-sm);
+  color: var(--color-text);
+}
+
+.tool-card__desc {
+  color: var(--color-text-muted);
+  font-size: 0.95rem;
+  line-height: 1.6;
+  margin-bottom: var(--spacing-lg);
+}
+
+.tool-card__link {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--color-accent);
+  color: white;
+  padding: var(--spacing-sm) var(--spacing-lg);
+  border-radius: var(--radius-md);
+  font-weight: 600;
+  text-decoration: none;
+  font-size: 0.9rem;
+  transition: background 0.2s;
+}
+
+.tool-card__link:hover {
+  background: var(--color-accent-hover);
+}
+
+/* ── Steps List ── */
+.steps {
+  margin: var(--spacing-xl) 0;
+  padding-left: 0;
+}
+
+.step {
+  display: flex;
+  gap: var(--spacing-lg);
+  margin-bottom: var(--spacing-xl);
+}
+
+.step:last-child {
+  margin-bottom: 0;
+}
+
+.step__number {
+  flex-shrink: 0;
+  width: 36px;
+  height: 36px;
+  background: var(--color-accent);
+  color: white;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-weight: 700;
+  font-size: 1rem;
+  flex-shrink: 0;
+}
+
+.step__content {
+  flex: 1;
+}
+
+.step__content h3 {
+  font-size: 1.1rem;
+  font-weight: 600;
+  margin-bottom: var(--spacing-xs);
+  color: var(--color-text);
+}
+
+.step__content p {
+  margin: 0;
+  color: var(--color-text-muted);
+  line-height: 1.55;
+}
+
+/* ── Highlight Box ── */
+.highlight-box {
+  background: var(--color-bg-subtle);
+  border-left: 3px solid var(--color-accent);
+  padding: var(--spacing-lg);
+  margin: var(--spacing-lg) 0;
+  border-radius: 0 var(--radius-md) var(--radius-md) 0;
+}
+
+.highlight-box p {
+  margin-bottom: 0;
+  line-height: 1.65;
+  color: var(--color-text);
+}
+
+/* ── Reference Layout ── */
+.ref-layout {
+  display: grid;
+  grid-template-columns: 200px 1fr;
+  gap: var(--spacing-2xl);
+  margin-top: var(--spacing-xl);
+  margin-bottom: var(--spacing-xl);
+  max-width: 1100px;
+}
+
+.ref-toc {
+  position: sticky;
+  top: 80px;
+  height: fit-content;
+}
+
+.ref-toc__item {
+  margin-bottom: var(--spacing-xs);
+}
+
+.ref-toc__link {
+  display: block;
+  padding: var(--spacing-xs) var(--spacing-sm);
+  color: var(--color-text-muted);
+  text-decoration: none;
+  font-size: 0.9rem;
+  border-radius: var(--radius-sm);
+  transition: all 0.2s;
+}
+
+.ref-toc__link:hover {
+  color: var(--color-accent);
+  background: var(--color-bg-subtle);
+}
+
+.ref-toc__link--active {
+  color: var(--color-accent);
+  background: var(--color-accent-soft);
+  font-weight: 600;
+}
+
+.ref-content {
+  min-width: 0;
+  padding-top: var(--spacing-sm);
+}
+
+.ref-content h2 {
+  font-size: 1.5rem;
+  font-weight: 700;
+  margin-top: var(--spacing-2xl);
+  margin-bottom: var(--spacing-lg);
+  color: var(--color-text);
+}
+
+.ref-content p {
+  color: var(--color-text-muted);
+  line-height: 1.65;
+  margin-bottom: var(--spacing-md);
+}
+
+.ref-content code {
+  font-family: var(--font-mono);
+  color: var(--color-accent);
+  background: var(--color-bg-subtle);
+  padding: 2px 6px;
+  border-radius: 3px;
+  font-size: 0.9em;
+}
+
+.ref-content a {
+  color: var(--color-accent);
+  text-decoration: none;
+}
+
+.ref-content a:hover {
+  text-decoration: underline;
+}
+
+/* ── Tables ── */
+table {
+  width: 100%;
+  border-collapse: collapse;
+  margin-top: var(--spacing-lg);
+  font-size: 0.875rem;
+}
+
+th, td {
+  padding: 0.375rem var(--spacing-sm);
+  text-align: left;
+  border-bottom: 1px solid var(--color-border);
+}
+
+th {
+  background: var(--color-bg-subtle);
+  font-weight: 600;
+  color: var(--color-text);
+}
+
+tr:nth-child(even) {
+  background: var(--color-bg-subtle);
+}
+
+tr:nth-child(even) td {
+  background: var(--color-bg-subtle);
+}
+
+/* ── Section Divider ── */
+.section-divider {
+  height: 1px;
+  background: linear-gradient(to right, transparent, var(--color-border), transparent);
+  margin: var(--spacing-2xl) 0;
+  border: none;
+}
+
+/* ── Grid Utilities ── */
+.grid-2 {
+  display: grid;
+  grid-template-columns: repeat(2, 1fr);
+  gap: var(--spacing-lg);
+  margin: var(--spacing-xl) 0;
+}
+
+.grid-4 {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: var(--spacing-lg);
+  margin: var(--spacing-xl) 0;
+}
+
+/* ── Responsive grids ── */
+@media (max-width: 900px) {
+  .grid-4 { grid-template-columns: repeat(2, 1fr); }
+  .filename-parts { grid-template-columns: repeat(2, 1fr); }
+}
+
+@media (max-width: 640px) {
+  /* Container */
+  .container { padding: 0 var(--spacing-md); }
+
+  /* Header: brand left, nav below, theme toggle at end */
+  .header-content { flex-wrap: wrap; gap: var(--spacing-xs); }
+  .brand { flex: 1; }
+  .header-nav { width: 100%; justify-content: flex-start; }
+
+  /* Hero */
+  .hero { padding: var(--spacing-xl) 0 var(--spacing-lg); }
+  .hero-cta-group { flex-direction: column; align-items: center; }
+
+  /* Grids */
+  .grid-2, .grid-4 { grid-template-columns: 1fr; }
+  .filename-parts { grid-template-columns: repeat(2, 1fr); }
+
+  /* Reference page: sidebar becomes plain list above content */
+  .ref-layout { grid-template-columns: 1fr; gap: var(--spacing-lg); }
+  .ref-toc { position: static; }
+
+  /* Misc */
+  .filename-anatomy { font-size: 0.85rem; }
+}
+
+/* ── Content Block ── */
+.content-block {
+  margin-bottom: var(--spacing-xl);
+}
+
+.content-block h2 {
+  font-size: 1.5rem;
+  margin-bottom: var(--spacing-lg);
+  font-weight: 700;
+  color: var(--color-text);
+}
+
+.content-block h3 {
+  font-size: 1.25rem;
+  margin-top: var(--spacing-xl);
+  margin-bottom: var(--spacing-md);
+  font-weight: 600;
+  color: var(--color-text);
+}
+
+.content-block p {
+  margin-bottom: var(--spacing-md);
+  line-height: 1.65;
+  color: var(--color-text-muted);
+}
+
+.content-block a {
+  color: var(--color-accent);
+  text-decoration: none;
+}
+
+.content-block a:hover {
+  text-decoration: underline;
+}
+
+/* ── Feature Cards ── */
+.feature-card {
+  background: var(--color-bg);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  padding: var(--spacing-lg);
+  margin-bottom: var(--spacing-lg);
+  transition: border-color 0.2s;
+}
+
+.feature-card:hover {
+  border-color: var(--color-accent);
+}
+
+.feature-title {
+  font-weight: 600;
+  font-size: 1.1rem;
+  margin-bottom: var(--spacing-sm);
+  color: var(--color-text);
+}
+
+.feature-desc {
+  color: var(--color-text-muted);
+  font-size: 1rem;
+  line-height: 1.6;
+}
+
+/* ── Code Blocks ── */
+.code-block {
+  background: var(--color-bg-subtle);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  padding: var(--spacing-lg);
+  font-family: var(--font-mono);
+  font-size: 0.9rem;
+  overflow-x: auto;
+  white-space: pre;
+  margin: var(--spacing-md) 0;
+}
+
+.code-block code {
+  color: var(--color-text);
+  font-family: var(--font-mono);
+}
+
+/* ── Filename Example ── */
+.filename-example {
+  background: var(--color-bg-subtle);
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-md);
+  padding: var(--spacing-lg);
+  font-family: var(--font-mono);
+  font-size: 0.95rem;
+  white-space: pre-wrap;
+  word-break: break-all;
+  margin-top: var(--spacing-lg);
+}
+
+.filename-grid {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: var(--spacing-sm);
+  margin-top: var(--spacing-md);
+}
+
+.filename-item {
+  text-align: center;
+  padding: var(--spacing-sm);
+  border-radius: var(--radius-sm);
+  background: var(--color-bg);
+}
+
+.filename-item .name {
+  font-weight: 600;
+  font-size: 0.85rem;
+  margin-bottom: var(--spacing-xs);
+  color: var(--color-text);
+}
+
+.filename-item .desc {
+  font-size: 0.75rem;
+  color: var(--color-text-muted);
+  line-height: 1.4;
+}
+
+/* ── Process Flow ── */
+.process-flow {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-lg);
+  margin: var(--spacing-xl) 0;
+}
+
+.process-step {
+  display: flex;
+  align-items: flex-start;
+  gap: var(--spacing-lg);
+}
+
+.process-icon {
+  width: 40px;
+  height: 40px;
+  background: var(--color-accent-soft);
+  color: var(--color-accent);
+  border-radius: var(--radius-md);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+
+.process-icon svg {
+  width: 20px;
+  height: 20px;
+}
+
+.process-content {
+  flex: 1;
+}
+
+.process-content h3 {
+  font-size: 1.1rem;
+  font-weight: 600;
+  margin-bottom: var(--spacing-xs);
+  color: var(--color-text);
+}
+
+.process-content p {
+  margin: 0;
+  color: var(--color-text-muted);
+  font-size: 0.95rem;
+}
+
+/* ── Footer ── */
+.site-footer {
+  background: var(--color-bg);
+  border-top: 1px solid var(--color-border);
+  padding: var(--spacing-xl) 0;
+  margin-top: var(--spacing-2xl);
+}
+
+.footer-content {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: var(--spacing-md);
+}
+
+.footer-links {
+  display: flex;
+  gap: var(--spacing-md);
+}
+
+.footer-links a {
+  color: var(--color-text-muted);
+  text-decoration: none;
+  font-size: 0.9rem;
+  transition: color 0.2s;
+}
+
+.footer-links a:hover {
+  color: var(--color-accent);
+}
+
+/* ── Utility classes ── */
+.muted { color: var(--color-text-muted); }
+.text-center { text-align: center; }
+.text-left { text-align: left; }
+.my-md { margin: var(--spacing-md) 0; }
+.my-lg { margin: var(--spacing-lg) 0; }
+.text-xs { font-size: 0.75rem; }
+.text-sm { font-size: 0.875rem; }
+.text-lg { font-size: 1.125rem; }
+.text-xl { font-size: 1.25rem; }
+.font-mono { font-family: var(--font-mono); }
+
+/* ── Brand color utilities ── */
+.accent-text { color: var(--color-accent); }
+.accent-bg { background: var(--color-accent-soft); }
+
+/* ── Hero CTA ── */
+.hero-cta-group {
+  display: flex;
+  gap: var(--spacing-sm);
+  justify-content: center;
+  flex-wrap: wrap;
+}
+
+.hero-cta {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--spacing-xs);
+  background: var(--color-accent);
+  color: white;
+  padding: var(--spacing-sm) var(--spacing-lg);
+  border-radius: var(--radius-md);
+  font-weight: 600;
+  font-size: 1rem;
+  text-decoration: none;
+  transition: background 0.2s;
+}
+
+.hero-cta:hover {
+  background: var(--color-accent-hover);
+}
+
+/* ── Theme Toggle Button ── */
+.theme-toggle {
+  background: transparent;
+  border: none;
+  cursor: pointer;
+  padding: var(--spacing-xs) var(--spacing-sm);
+  border-radius: var(--radius-sm);
+  color: var(--color-text-muted);
+  font-size: 0.9rem;
+  display: flex;
+  align-items: center;
+  gap: var(--spacing-xs);
+  transition: background 0.2s, color 0.2s;
+}
+
+.theme-toggle:hover {
+  background: var(--color-bg-subtle);
+  color: var(--color-text);
+}
+
+.theme-toggle svg {
+  width: 16px;
+  height: 16px;
+  fill: currentColor;
+}
+
+/* ── Dark Mode (System Preference) ── */
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) {
+    --color-bg: #0d1117;
+    --color-bg-subtle: #161b22;
+    --color-bg-muted: #21262d;
+    --color-text: #e6edf3;
+    --color-text-muted: #8b949e;
+    --color-text-light: #6e7681;
+    --color-border: #30363d;
+    
+    --color-accent: #58a6ff;
+    --color-accent-hover: #3d84c2;
+    --color-accent-soft: #1a3550;
+    --color-accent-dark: #79c0ff;
+    
+    --color-Tracking: #1e3a5f;
+    --color-Revision: #134a29;
+    --color-Status: #5c4a00;
+    --color-Title: #2d3440;
+  }
+}
+
+/* ── Dark Theme (Explicit) ── */
+html[data-theme="dark"] {
+  --color-bg: #0d1117;
+  --color-bg-subtle: #161b22;
+  --color-bg-muted: #21262d;
+  --color-text: #e6edf3;
+  --color-text-muted: #8b949e;
+  --color-text-light: #6e7681;
+  --color-border: #30363d;
+  
+  --color-accent: #58a6ff;
+  --color-accent-hover: #3d84c2;
+  --color-accent-soft: #1a3550;
+  --color-accent-dark: #79c0ff;
+  
+  --color-Tracking: #1e3a5f;
+  --color-Revision: #134a29;
+  --color-Status: #5c4a00;
+  --color-Title: #2d3440;
+}
+
+/* ── Pain badge dark mode ── */
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .pain-section__badge {
+    background: #450a0a;
+    color: #fca5a5;
+    border-color: #7f1d1d;
+  }
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .pain-section {
+    background: #1c0f0f;
+    border-color: #3d1515;
+  }
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .solution-section {
+    background: #0d1f14;
+    border-color: #1a3d25;
+  }
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]):not([data-theme="dark"]) .solution-section__badge {
+    background: #0d1f14;
+    color: #86efac;
+    border-color: #166534;
+  }
+}
+
+html[data-theme="dark"] .pain-section {
+  background: #1c0f0f;
+  border-color: #3d1515;
+}
+
+html[data-theme="dark"] .solution-section {
+  background: #0d1f14;
+  border-color: #1a3d25;
+}
+
+html[data-theme="dark"] .solution-section__badge {
+  background: #0d1f14;
+  color: #86efac;
+  border-color: #166534;
+}
+
+html[data-theme="dark"] .pain-section__badge {
+  background: #450a0a;
+  color: #fca5a5;
+  border-color: #7f1d1d;
+}
+
+/* ── Light Theme (Explicit) ── */
+html[data-theme="light"] {
+  --color-bg: #ffffff;
+  --color-bg-subtle: #f8f9fa;
+  --color-bg-muted: #e9ecef;
+  --color-text: #1f2937;
+  --color-text-muted: #6b7280;
+  --color-text-light: #9ca3af;
+  --color-border: #e5e7eb;
+  
+  --color-accent: #2a5a8a;
+  --color-accent-hover: #1d4060;
+  --color-accent-soft: #e8f0f7;
+  --color-accent-dark: #3d7ab5;
+  
+  --color-Tracking: #dbeafe;
+  --color-Revision: #bbf7d0;
+  --color-Status: #fde68a;
+  --color-Title: #f3f4f6;
+}
+
+/* ── Responsive (tablet) ── */
+@media (max-width: 900px) {
+  .ref-layout { gap: var(--spacing-xl); }
+}
diff --git a/website/img/logo-dark-bg.png b/website/img/logo-dark-bg.png
new file mode 100644
index 0000000..9f9cfec
Binary files /dev/null and b/website/img/logo-dark-bg.png differ
diff --git a/website/img/logo-light-bg.png b/website/img/logo-light-bg.png
new file mode 100644
index 0000000..001f542
Binary files /dev/null and b/website/img/logo-light-bg.png differ
diff --git a/website/img/logo.svg b/website/img/logo.svg
new file mode 100644
index 0000000..bc65f9e
--- /dev/null
+++ b/website/img/logo.svg
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Creator: CorelDRAW X7 -->
+<svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" width="3.33333in" height="3.33333in" version="1.1" style="shape-rendering:geometricPrecision; text-rendering:geometricPrecision; image-rendering:optimizeQuality; fill-rule:evenodd; clip-rule:evenodd"
+viewBox="0 0 3333 3333"
+ xmlns:xlink="http://www.w3.org/1999/xlink">
+ <defs>
+  <style type="text/css">
+   <![CDATA[
+    .fil1 {fill:#0AB3F7}
+    .fil2 {fill:#1C283F}
+    .fil0 {fill:white}
+    .fil3 {fill:#1C283F;fill-rule:nonzero}
+   ]]>
+  </style>
+ </defs>
+ <g id="Layer_x0020_1">
+  <metadata id="CorelCorpID_0Corel-Layer"/>
+  <rect class="fil0" width="3333" height="3333"/>
+  <g id="_434161592">
+   <path class="fil1" d="M1732 1575l-1008 0 0 183 1008 0 0 -183zm-974 36l22 0 33 86 34 -86 21 0 -46 112 -18 0 -46 -112zm193 44l-10 23 0 0 -19 45 -20 0 40 -90 9 22zm0 -45l19 0 49 113 -18 0 -50 -113zm291 45l-10 23 0 0 -7 18 0 0 -12 27 -20 0 39 -90 10 22zm0 -45l18 0 50 113 -19 0 -49 -113zm151 114c-9,0 -17,-1 -25,-4 -8,-3 -15,-8 -22,-14l12 -14c5,5 11,8 16,11 6,2 12,4 19,4 6,0 11,-2 15,-4 3,-3 5,-6 5,-10l0 -1c0,-2 0,-3 -1,-5 -1,-2 -2,-3 -4,-4 -2,-2 -4,-3 -8,-4 -3,-1 -7,-3 -12,-4 -6,-1 -12,-3 -16,-4 -5,-2 -9,-4 -12,-7 -3,-2 -6,-5 -7,-9 -2,-4 -3,-8 -3,-13l0 0c0,-5 1,-10 3,-14 2,-4 5,-7 8,-10 3,-3 7,-5 12,-6 5,-2 10,-3 15,-3 9,0 16,1 22,4 7,2 13,6 19,10l-11 15c-5,-4 -10,-6 -15,-8 -5,-2 -10,-3 -15,-3 -6,0 -10,1 -13,3 -4,3 -5,6 -5,10l0 0c0,2 0,4 1,6 1,1 2,3 4,4 2,2 5,3 8,4 4,1 8,2 13,4 6,1 11,3 16,5 5,1 8,4 11,6 3,3 6,6 7,9 2,4 2,8 2,12l0 1c0,5 -1,10 -3,14 -1,4 -4,7 -8,10 -3,3 -7,5 -12,7 -5,1 -10,2 -16,2zm120 -46l-44 -67 23 0 41 67 0 45 -20 0 0 -45zm23 -38l19 -29 22 0 -30 46 -11 -17zm122 84c-8,0 -17,-1 -24,-4 -8,-3 -16,-8 -22,-14l12 -14c5,5 10,8 16,11 6,2 12,4 19,4 6,0 11,-2 14,-4 4,-3 6,-6 6,-10l0 -1c0,-2 -1,-3 -1,-5 -1,-2 -2,-3 -4,-4 -2,-2 -5,-3 -8,-4 -3,-1 -7,-3 -13,-4 -6,-1 -11,-3 -16,-4 -4,-2 -8,-4 -11,-7 -3,-2 -6,-5 -7,-9 -2,-4 -3,-8 -3,-13l0 0c0,-5 1,-10 3,-14 2,-4 4,-7 8,-10 3,-3 7,-5 12,-6 4,-2 10,-3 15,-3 8,0 16,1 22,4 7,2 13,6 19,10l-11 15c-5,-4 -10,-6 -15,-8 -5,-2 -10,-3 -15,-3 -6,0 -10,1 -14,3 -3,3 -4,6 -4,10l0 0c0,2 0,4 1,6 0,1 2,3 4,4 2,2 4,3 8,4 3,1 8,2 13,4 6,1 11,3 16,5 4,1 8,4 11,6 3,3 5,6 7,9 1,4 2,8 2,12l0 1c0,5 -1,10 -3,14 -2,4 -5,7 -8,10 -3,3 -8,5 -13,7 -4,1 -10,2 -16,2zm-547 -58c7,0 12,-2 17,-5 4,-3 6,-8 6,-14l0 0c0,-6 -2,-11 -6,-14 -4,-3 -10,-5 -17,-5l-49 0 0 -18 50 0c7,0 14,1 19,3 5,2 10,5 14,9 3,3 5,6 7,10 1,4 2,9 2,14l0 0c0,5 -1,9 -2,12 -1,4 -3,7 -6,10 -2,3 -5,6 -8,7 -3,2 -7,4 -11,5l30 43 -23 0 -27 -40 -1 0 -24 0 0 40 -20 0 0 -57 49 0z"/>
+   <rect class="fil2" x="1778" y="1553" width="6.50317" height="228.228"/>
+   <path class="fil3" d="M1836 1596c0,-7 6,-13 16,-13 8,0 16,3 23,9l5 -7c-8,-6 -16,-10 -27,-10 -15,0 -26,9 -26,22 0,13 8,18 26,22 16,4 20,8 20,15 0,8 -7,14 -17,14 -11,0 -19,-4 -27,-11l-5 6c9,8 19,12 32,12 15,0 26,-8 26,-22 0,-12 -8,-18 -25,-22 -17,-3 -21,-8 -21,-15zm71 -19l0 77 9 0 0 -77 -9 0zm104 14l0 63 9 0 0 -77 -9 0 -28 42 -29 -42 -9 0 0 77 9 0 0 -63 28 42 1 0 28 -42zm96 10c0,-15 -12,-24 -29,-24l-30 0 0 77 9 0 0 -27 19 0c17,0 31,-9 31,-26zm-9 1c0,10 -9,17 -22,17l-19 0 0 -34 20 0c12,0 21,5 21,17zm31 52l53 0 0 -8 -44 0 0 -69 -9 0 0 77zm76 -77l0 77 9 0 0 -77 -9 0zm94 0l-56 0 0 77 9 0 0 -34 42 0 0 -8 -42 0 0 -27 47 0 0 -8zm57 46l32 -46 -10 0 -26 38 -27 -38 -10 0 32 47 0 30 9 0 0 -31zm54 -46l0 77 8 0 0 -77 -8 0zm95 62l-49 -62 -8 0 0 77 8 0 0 -63 50 63 7 0 0 -77 -8 0 0 62zm104 5l0 -31 -32 0 0 8 24 0 0 19c-6,4 -14,8 -23,8 -19,0 -30,-14 -30,-33 0,-17 12,-32 29,-32 11,0 18,4 24,9l5 -6c-7,-7 -15,-11 -29,-11 -23,0 -39,19 -39,41 0,22 16,40 40,40 13,0 24,-6 31,-12z"/>
+   <path class="fil3" d="M1894 1744l-6 -5c-7,7 -14,11 -25,11 -17,0 -30,-14 -30,-32 0,-18 13,-32 30,-32 11,0 18,4 25,10l6 -6c-8,-7 -17,-12 -31,-12 -23,0 -39,18 -39,40 0,22 16,40 39,40 14,0 23,-5 31,-14zm94 -26c0,-22 -16,-40 -40,-40 -24,0 -40,18 -40,40 0,21 16,40 40,40 24,0 40,-19 40,-40zm-9 0c0,18 -13,32 -31,32 -18,0 -31,-15 -31,-32 0,-18 13,-32 31,-32 18,0 31,14 31,32zm98 -24l0 63 8 0 0 -78 -9 0 -28 42 -28 -42 -9 0 0 78 8 0 0 -63 29 41 0 0 29 -41zm93 10c0,-16 -11,-25 -29,-25l-29 0 0 78 9 0 0 -28 19 0c16,0 30,-8 30,-25zm-9 0c0,10 -8,17 -21,17l-19 0 0 -34 19 0c13,0 21,6 21,17zm30 53l53 0 0 -8 -44 0 0 -70 -9 0 0 78zm130 -78l-57 0 0 78 57 0 0 -8 -48 0 0 -28 43 0 0 -8 -43 0 0 -26 48 0 0 -8zm87 78l-30 -40 29 -38 -10 0 -24 32 -24 -32 -10 0 29 38 -30 40 10 0 25 -34 25 34 10 0zm22 -78l0 78 8 0 0 -78 -8 0zm65 8l26 0 0 -8 -61 0 0 8 26 0 0 70 9 0 0 -70zm81 39l32 -47 -10 0 -27 39 -26 -39 -10 0 32 47 0 31 9 0 0 -31z"/>
+  </g>
+ </g>
+</svg>
diff --git a/website/index.html b/website/index.html
new file mode 100644
index 0000000..226aa80
--- /dev/null
+++ b/website/index.html
@@ -0,0 +1,193 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>ZDDC — Zero Day Document Control</title>
+  <meta name="description" content="A file-naming convention and a small set of single-file HTML tools for managing project deliverables. Self-contained, offline-capable, dependency-free.">
+  <meta property="og:type" content="website">
+  <meta property="og:url" content="https://zddc.varasys.io/">
+  <meta property="og:title" content="ZDDC — Zero Day Document Control">
+  <meta property="og:description" content="A file-naming convention and a small set of single-file HTML tools for managing project deliverables. Self-contained, offline-capable, dependency-free.">
+  <meta name="theme-color" content="#2a5a8a">
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+  <link rel="stylesheet" href="css/style.css">
+  <style>
+    .channel-row { display: flex; flex-wrap: wrap; gap: 0.5rem; margin-top: 0.75rem; font-size: 0.9rem; }
+    .channel-row a { display: inline-block; padding: 0.25rem 0.625rem; border-radius: 999px; text-decoration: none; border: 1px solid var(--color-border); color: var(--color-text); }
+    .channel-row a:hover { background: var(--color-bg-subtle); }
+    .channel-row .channel-stable { border-color: var(--color-primary); color: var(--color-primary); font-weight: 600; }
+    .channel-row .channel-beta, .channel-row .channel-alpha { color: var(--color-text-muted); }
+    .install-grid { display: grid; grid-template-columns: 1fr; gap: var(--spacing-md); margin-top: var(--spacing-md); }
+    @media (min-width: 720px) { .install-grid { grid-template-columns: repeat(2, 1fr); } }
+    .install-card { padding: var(--spacing-md); border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-bg-subtle); }
+    .install-card h3 { margin-top: 0; }
+    code.inline { background: var(--color-bg-subtle); padding: 0.1rem 0.35rem; border-radius: 4px; font-size: 0.9em; }
+  </style>
+</head>
+<body>
+  <!-- Header -->
+  <header class="site-header">
+    <div class="container header-content">
+      <a href="/" class="brand">
+        <div class="brand-logo">
+          <svg viewBox="0 0 24 24">
+            <path d="M3 5h18v2H3V5zm0 6h12v2H3v-2zm0 6h6v2H3v-2z" />
+          </svg>
+        </div>
+        <span class="brand-name">ZDDC</span>
+      </a>
+      <nav class="header-nav">
+        <div class="dropdown">
+          <button class="dropdown-toggle" type="button" aria-haspopup="true">
+            <span>Tools</span>
+            <svg viewBox="0 0 24 24" style="width: 14px; height: 14px; fill: currentColor;">
+              <path d="M7 10l5 5 5-5z"/>
+            </svg>
+          </button>
+          <div class="dropdown-menu">
+            <div class="dropdown-menu__inner">
+              <a href="releases/archive_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M20 6H4a2 2 0 00-2 2v10a2 2 0 002 2h16a2 2 0 002-2V8a2 2 0 00-2-2zm0 12H4V8h16v10zM4 2h16v2H4z"/></svg>
+                Archive Browser
+              </a>
+              <a href="releases/transmittal_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M20 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"/></svg>
+                Transmittal Creator
+              </a>
+              <a href="releases/classifier_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"/></svg>
+                Document Classifier
+              </a>
+              <a href="releases/mdedit_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04a1 1 0 000-1.41l-2.34-2.34a1 1 0 00-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/></svg>
+                Markdown Editor
+              </a>
+            </div>
+          </div>
+        </div>
+        <a href="reference.html" class="nav-link">Docs</a>
+      </nav>
+    </div>
+  </header>
+
+  <!-- Hero -->
+  <section class="hero">
+    <div class="container">
+      <h1>Zero Day Document Control</h1>
+      <p class="hero-subtitle">A file-naming convention and a small set of single-file HTML tools for managing project deliverables. Self-contained, offline-capable, dependency-free.</p>
+    </div>
+  </section>
+
+  <main class="container" style="margin-bottom: var(--spacing-2xl);">
+
+    <section style="margin-top: var(--spacing-xl);">
+      <h2>What is it?</h2>
+      <p>ZDDC is a convention, not a platform. Every deliverable's filename encodes its tracking number, revision, status, and title; every transmittal folder is date-prefixed and self-describing. A plain shared folder becomes a fully searchable, auditable information-management system — no server, no database, no software required to read the archive.</p>
+      <p>The four tools below are <em>optional</em> interfaces around this structure. Each is a single self-contained HTML file. Save it locally and it works forever, without internet, updates, or a subscription.</p>
+      <p style="margin-top: var(--spacing-md);"><a href="reference.html">Read the full specification →</a></p>
+    </section>
+
+    <section style="margin-top: var(--spacing-2xl);">
+      <h2>Try the tools</h2>
+      <p>Each tool is published in three channels. <strong>Stable</strong> is versioned and immutable; <strong>beta</strong> and <strong>alpha</strong> are mutable previews of in-flight work.</p>
+
+      <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: var(--spacing-lg); margin-top: var(--spacing-lg);">
+
+        <div class="tool-card">
+          <div class="tool-card__title">Archive Browser</div>
+          <div class="tool-card__desc">Browse, search, and filter your project folder. Group by transmittal; filter by tracking number, revision, status, or free text. Export selections as ZIP.</div>
+          <div class="channel-row">
+            <a href="releases/archive_latest.html" class="channel-stable">stable</a>
+            <a href="releases/archive_beta.html" class="channel-beta">beta</a>
+            <a href="releases/archive_alpha.html" class="channel-alpha">alpha</a>
+          </div>
+        </div>
+
+        <div class="tool-card">
+          <div class="tool-card__title">Transmittal Creator</div>
+          <div class="tool-card__desc">Fill in metadata, drag in files, publish a self-contained HTML transmittal record with SHA-256 checksums. Optional digital signatures. The published file <em>is</em> the transmittal record.</div>
+          <div class="channel-row">
+            <a href="releases/transmittal_latest.html" class="channel-stable">stable</a>
+            <a href="releases/transmittal_beta.html" class="channel-beta">beta</a>
+            <a href="releases/transmittal_alpha.html" class="channel-alpha">alpha</a>
+          </div>
+        </div>
+
+        <div class="tool-card">
+          <div class="tool-card__title">Document Classifier</div>
+          <div class="tool-card__desc">Spreadsheet-like interface for bulk-renaming files into ZDDC format. Copy/paste with Excel. Point it at a folder, fill in the columns, save all at once.</div>
+          <div class="channel-row">
+            <a href="releases/classifier_latest.html" class="channel-stable">stable</a>
+            <a href="releases/classifier_beta.html" class="channel-beta">beta</a>
+            <a href="releases/classifier_alpha.html" class="channel-alpha">alpha</a>
+          </div>
+        </div>
+
+        <div class="tool-card">
+          <div class="tool-card__title">Markdown Editor</div>
+          <div class="tool-card__desc">Browser-based markdown editor with live preview, YAML front matter, and table of contents. Direct local file access via the File System Access API.</div>
+          <div class="channel-row">
+            <a href="releases/mdedit_latest.html" class="channel-stable">stable</a>
+            <a href="releases/mdedit_beta.html" class="channel-beta">beta</a>
+            <a href="releases/mdedit_alpha.html" class="channel-alpha">alpha</a>
+          </div>
+        </div>
+
+      </div>
+
+      <p style="margin-top: var(--spacing-lg); color: var(--color-text-muted);">Append <code class="inline">?v=alpha</code> (or <code class="inline">?v=0.0.4</code>, etc.) to any URL to switch versions for a single request — useful for sharing a link to an exact build. Direct local-folder access requires a Chromium-based browser (the File System Access API is unavailable in Firefox / Safari).</p>
+    </section>
+
+    <section style="margin-top: var(--spacing-2xl);">
+      <h2>Install on your server</h2>
+      <p>For a self-contained deployment with no dependency on this site at runtime, download <a href="install.zip"><code class="inline">install.zip</code></a> and extract it into the document root of your file server. To make a deployment auto-track a published channel from this site, use one of the <code class="inline">track-*.zip</code> bundles instead — each contains five tiny bootstrap stubs that fetch the named channel on every page load.</p>
+
+      <div class="install-grid">
+        <div class="install-card">
+          <h3>Self-contained</h3>
+          <p>Bundled stable tools + sample project bootstrap directory. No external dependencies after install.</p>
+          <p><a href="install.zip">install.zip →</a></p>
+        </div>
+        <div class="install-card">
+          <h3>Track stable</h3>
+          <p>Five level-2 bootstrap stubs. Drop over the deployment root to auto-track latest stable.</p>
+          <p><a href="track-latest.zip">track-latest.zip →</a></p>
+        </div>
+        <div class="install-card">
+          <h3>Track beta</h3>
+          <p>Five level-2 bootstrap stubs that fetch the beta channel.</p>
+          <p><a href="track-beta.zip">track-beta.zip →</a></p>
+        </div>
+        <div class="install-card">
+          <h3>Track alpha</h3>
+          <p>Five level-2 bootstrap stubs that fetch the alpha channel.</p>
+          <p><a href="track-alpha.zip">track-alpha.zip →</a></p>
+        </div>
+      </div>
+
+      <p style="margin-top: var(--spacing-md);">See <a href="https://codeberg.org/VARASYS/ZDDC/blob/main/bootstrap/README.md">bootstrap/README.md</a> for the install model, the per-project / per-tool override pattern, and the audit grep that lets you see what every project on a deployment is pointing at.</p>
+    </section>
+
+    <section style="margin-top: var(--spacing-2xl);">
+      <h2>Learn more</h2>
+      <ul style="line-height: 1.9;">
+        <li><a href="reference.html">Technical Reference</a> — the full ZDDC convention: filename format, tracking numbers, revisions, status codes, folder naming, transmittal workflow.</li>
+        <li><a href="https://codeberg.org/VARASYS/ZDDC">codeberg.org/VARASYS/ZDDC</a> — source code, issue tracker, contributor docs.</li>
+        <li><a href="https://codeberg.org/VARASYS/ZDDC/blob/main/zddc/README.md">zddc-server</a> — optional Go HTTP server for serving a ZDDC archive with ACL and a virtual <code class="inline">.archive</code> index.</li>
+      </ul>
+    </section>
+
+  </main>
+
+  <footer class="site-footer">
+    <div class="container footer-content">
+      <span>ZDDC is open source — <a href="https://codeberg.org/VARASYS/ZDDC">codeberg.org/VARASYS/ZDDC</a></span>
+    </div>
+  </footer>
+
+  <script src="js/layout.js"></script>
+</body>
+</html>
diff --git a/website/install.zip b/website/install.zip
new file mode 100644
index 0000000..5b8fda6
Binary files /dev/null and b/website/install.zip differ
diff --git a/website/js/layout.js b/website/js/layout.js
new file mode 100644
index 0000000..c86c926
--- /dev/null
+++ b/website/js/layout.js
@@ -0,0 +1,126 @@
+// Simple tab switching for ZDDC site
+// Include via <script src="/js/layout.js"></script> at end of <body>
+
+(function () {
+  'use strict';
+
+  // Theme system
+  const themeKey = 'zddc-theme';
+  const themes = ['system', 'light', 'dark'];
+  let currentThemeIndex = 0;
+
+  // SVG icons for theme toggle
+  const icons = {
+    system: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="3" width="20" height="14" rx="2" ry="2"/><polyline points="8 21 12 17 16 21"/><line x1="12" y1="17" x2="12" y2="21"/></svg>',
+    light: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="5"/><line x1="12" y1="1" x2="12" y2="3"/><line x1="12" y1="21" x2="12" y2="23"/><line x1="4.22" y1="4.22" x2="5.64" y2="5.64"/><line x1="18.36" y1="18.36" x2="19.78" y2="19.78"/><line x1="1" y1="12" x2="3" y2="12"/><line x1="21" y1="12" x2="23" y2="12"/><line x1="4.22" y1="19.78" x2="5.64" y2="18.36"/><line x1="18.36" y1="5.64" x2="19.78" y2="4.22"/></svg>',
+    dark: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z"/></svg>'
+  };
+
+  function getStoredTheme() {
+    const stored = localStorage.getItem(themeKey);
+    if (stored && themes.includes(stored)) {
+      return stored;
+    }
+    return 'system';
+  }
+
+  function setThemeIndex(index) {
+    currentThemeIndex = index;
+    const theme = themes[index];
+    applyTheme(theme);
+  }
+
+  function applyTheme(theme) {
+    if (theme === 'light') {
+      document.documentElement.setAttribute('data-theme', 'light');
+    } else if (theme === 'dark') {
+      document.documentElement.setAttribute('data-theme', 'dark');
+    } else {
+      document.documentElement.removeAttribute('data-theme');
+    }
+    localStorage.setItem(themeKey, theme);
+    updateToggleIcon();
+  }
+
+  function updateToggleIcon() {
+    const btn = document.querySelector('.theme-toggle');
+    if (!btn) return;
+    const theme = themes[currentThemeIndex];
+    btn.innerHTML = icons[theme];
+    btn.setAttribute('aria-label', 'Toggle theme (current: ' + theme + ')');
+  }
+
+  function cycleTheme() {
+    currentThemeIndex = (currentThemeIndex + 1) % themes.length;
+    setThemeIndex(currentThemeIndex);
+  }
+
+  function createToggle() {
+    const toggle = document.createElement('button');
+    toggle.className = 'theme-toggle';
+    toggle.setAttribute('aria-label', 'Toggle theme');
+    toggle.onclick = cycleTheme;
+    return toggle;
+  }
+
+  // Apply stored theme early (before DOM queries)
+  const storedTheme = getStoredTheme();
+  currentThemeIndex = themes.indexOf(storedTheme);
+  if (currentThemeIndex === -1) currentThemeIndex = 0;
+  applyTheme(storedTheme);
+
+  // Create and inject toggle button after DOM ready
+  document.addEventListener('DOMContentLoaded', function () {
+    const toggle = createToggle();
+    const headerNav = document.querySelector('.header-nav');
+    
+    if (headerNav) {
+      // Priority 1: .header-nav — append as last child (after Docs link)
+      headerNav.appendChild(toggle);
+    } else {
+      const navTabs = document.querySelector('.nav-tabs');
+      if (navTabs) {
+        // Priority 2: .nav-tabs — insert as sibling AFTER .nav-tabs
+        navTabs.parentNode.insertBefore(toggle, navTabs.nextSibling);
+      } else {
+        const headerContent = document.querySelector('.header-content');
+        if (headerContent) {
+          // Priority 3: .header-content — append as last child
+          headerContent.appendChild(toggle);
+        }
+      }
+    }
+    updateToggleIcon();
+  });
+
+  // Dropdown: click toggle for touch devices (CSS :hover handles desktop)
+  document.addEventListener('DOMContentLoaded', function () {
+    document.querySelectorAll('.dropdown-toggle').forEach(function (btn) {
+      btn.addEventListener('click', function (e) {
+        e.stopPropagation();
+        var menu = btn.closest('.dropdown').querySelector('.dropdown-menu');
+        if (menu) menu.classList.toggle('show');
+      });
+    });
+    document.addEventListener('click', function () {
+      document.querySelectorAll('.dropdown-menu.show').forEach(function (m) {
+        m.classList.remove('show');
+      });
+    });
+  });
+
+  // Tab switching (unchanged)
+  document.querySelectorAll('button[data-tab]').forEach(btn => {
+    btn.addEventListener('click', () => {
+      document.querySelectorAll('button[data-tab]').forEach(b => b.classList.remove('active'));
+      btn.classList.add('active');
+      
+      const tab = btn.dataset.tab;
+      if (tab === 'reference') {
+        if (window.location.pathname.endsWith('index.html')) {
+          window.location.hash = '';
+        }
+      }
+    });
+  });
+})();
diff --git a/website/reference.html b/website/reference.html
new file mode 100644
index 0000000..851d293
--- /dev/null
+++ b/website/reference.html
@@ -0,0 +1,1020 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Technical Reference — Zero Day Document Control (ZDDC)</title>
+  <meta name="description" content="Complete specification for the ZDDC filename convention, revision system, status codes, folder structure, and transmittal workflow.">
+  <meta property="og:type" content="website">
+  <meta property="og:url" content="https://zddc.varasys.io/reference.html">
+  <meta property="og:title" content="Technical Reference — ZDDC">
+  <meta property="og:description" content="Complete technical reference for ZDDC: naming convention, tracking numbers, revisions, status codes, folder structure, and transmittal workflow.">
+  <meta name="theme-color" content="#2a5a8a">
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+  <link rel="stylesheet" href="css/style.css">
+</head>
+<body>
+  <!-- Header -->
+  <header class="site-header">
+    <div class="container header-content">
+      <a href="/" class="brand">
+        <div class="brand-logo">
+          <svg viewBox="0 0 24 24">
+            <path d="M3 5h18v2H3V5zm0 6h12v2H3v-2zm0 6h6v2H3v-2z" />
+          </svg>
+        </div>
+        <span class="brand-name">ZDDC</span>
+      </a>
+      <nav class="header-nav">
+        <div class="dropdown">
+          <button class="dropdown-toggle" type="button" aria-haspopup="true">
+            <span>Tools</span>
+            <svg viewBox="0 0 24 24" style="width: 14px; height: 14px; fill: currentColor;">
+              <path d="M7 10l5 5 5-5z"/>
+            </svg>
+          </button>
+          <div class="dropdown-menu">
+            <div class="dropdown-menu__inner">
+              <a href="releases/archive_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M20 6H4a2 2 0 00-2 2v10a2 2 0 002 2h16a2 2 0 002-2V8a2 2 0 00-2-2zm0 12H4V8h16v10zM4 2h16v2H4z"/></svg>
+                Archive Browser
+              </a>
+              <a href="releases/transmittal_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M20 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 2-2V6c0-1.1-.9-2-2-2zm0 4l-8 5-8-5V6l8 5 8-5v2z"/></svg>
+                Transmittal Creator
+              </a>
+              <a href="releases/classifier_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M3 18h18v-2H3v2zm0-5h18v-2H3v2zm0-7v2h18V6H3z"/></svg>
+                Document Classifier
+              </a>
+              <a href="releases/mdedit_latest.html">
+                <svg class="dropdown-menu-icon" viewBox="0 0 24 24"><path d="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04a1 1 0 000-1.41l-2.34-2.34a1 1 0 00-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/></svg>
+                Markdown Editor
+              </a>
+            </div>
+          </div>
+        </div>
+        <a href="reference.html" class="nav-link active">Docs</a>
+      </nav>
+    </div>
+  </header>
+
+  <!-- Page Title Area -->
+  <div class="container" style="margin-top: var(--spacing-xl);">
+    <h1>Technical Reference</h1>
+    <p style="color: var(--color-text-muted); font-size: 1.125rem; margin-bottom: 0;">
+      Complete specification for the ZDDC information management convention. Sections 2–7 cover <strong>file naming</strong>. Sections 8–9 cover <strong>folder naming</strong> and the transmittal workflow.
+    </p>
+  </div>
+
+  <!-- Reference Layout: Sidebar TOC + Content -->
+  <div class="container ref-layout">
+    <!-- Sidebar TOC -->
+    <aside class="ref-toc" id="sidebar-toc">
+      <h3 class="muted" style="font-size: 0.875rem; font-weight: 600; margin-bottom: var(--spacing-sm);">On this page</h3>
+      <nav>
+        <div class="ref-toc__item"><a href="#overview" class="ref-toc__link">1. Overview</a></div>
+        <div class="ref-toc__item"><a href="#filename-format" class="ref-toc__link">2. Filename format</a></div>
+        <div class="ref-toc__item"><a href="#tracking-numbers" class="ref-toc__link">3. Tracking numbers</a></div>
+        <div class="ref-toc__item"><a href="#revisions" class="ref-toc__link">4. Revisions</a></div>
+        <div class="ref-toc__item"><a href="#draft-prefix" class="ref-toc__link">5. Draft prefix (~)</a></div>
+        <div class="ref-toc__item"><a href="#revision-modifiers" class="ref-toc__link">6. Revision modifiers (+)</a></div>
+        <div class="ref-toc__item"><a href="#status-codes" class="ref-toc__link">7. Status codes</a></div>
+        <div class="ref-toc__item"><a href="#folder-naming" class="ref-toc__link">8. Folder naming</a></div>
+        <div class="ref-toc__item"><a href="#transmittal-workflow" class="ref-toc__link">9. Transmittal workflow</a></div>
+        <div class="ref-toc__item"><a href="#tools" class="ref-toc__link">10. Tools</a></div>
+      </nav>
+    </aside>
+
+    <!-- Main Content -->
+    <main class="ref-content">
+      <!-- Section 1: Overview -->
+      <section id="overview">
+        <h2>1. Overview</h2>
+        <p>ZDDC — Zero Day Document Control — is an information management convention built on two rules:</p>
+        <ul style="margin: var(--spacing-md) 0; padding-left: 1.5rem; color: var(--color-text-muted); line-height: 1.65;">
+          <li><strong>File naming</strong> — every deliverable filename encodes its tracking number, revision, status, and title. This makes each file self-describing and independently searchable without opening it.</li>
+          <li><strong>Folder naming</strong> — transmittal folders follow the same convention, date-prefixed so they sort chronologically and can be searched by the tracking numbers of the deliverables they contain.</li>
+        </ul>
+        <p>Together, these two rules mean a plain folder on any shared drive becomes a fully searchable, auditable information management system. No server, no database, no software required to read the archive.</p>
+        <p>Because every deliverable is self-describing — its identity, revision, and status encoded in the filename itself — the convention works across organisational boundaries without requiring a shared platform. A project adopting ZDDC can extend the same convention to its clients, subcontractors, vendors, and any other party in the project ecosystem. Each party maintains their own archive; the shared naming convention makes every archive mutually intelligible. Adoption can be voluntary or contractually required. The result is a globally scalable, distributed information management system built on nothing more than agreed file naming and standard directory structures.</p>
+        <p>The four tools implement interfaces around this structure — but they're optional. The structure works without them, and any party can participate using only their file browser.</p>
+        <div class="highlight-box" style="margin-top: var(--spacing-lg);">
+          <p><strong>Convention harmonization.</strong> The convention is designed to be applied at multiple organisational scopes simultaneously — corporate, client, project, department — and the code registries at each scope should be harmonized so they do not conflict. A corporate discipline code such as <code>HR</code> (Human Resources) does not exist at the project level, so there is no clash. But a code that means one thing corporately and something different on a project would create ambiguity in a unified archive. The ideal is that conventions flow down: corporate establishes the master code registry, projects inherit it and extend it only where gaps exist, and no code is reused with a different meaning at a lower scope.</p>
+        </div>
+        <div class="highlight-box" style="margin-top: var(--spacing-md);">
+          <p><strong>A note on terminology.</strong> "Document control" is the traditional term for managing the flow of project information, inherited from an era when a document meant a literal piece of paper. Today the same discipline applies to any file or dataset — PDFs, models, spreadsheets, native CAD files — and the field has increasingly adopted the term <em>information management</em> to reflect this. ZDDC uses the word <strong>deliverable</strong> throughout: anything with a tracking number and a revision history, regardless of file format or medium.</p>
+        </div>
+      </section>
+
+      <!-- Section 2: Filename format -->
+      <section id="filename-format">
+        <h2>2. Filename format</h2>
+        <p>The ABNF-like grammar below is a formal machine-readable definition of the filename format — primarily useful for parsers and AI systems. The human-readable explanation of each field follows in the sections below.</p>
+        <div class="code-block">
+filename     = trackingNumber "_" revision " (" status ") - " title "." extension
+trackingNumber = field *("-" field)
+field        = 1*(%x41-5A / %x30-39)   ; uppercase alpha or digit; no spaces, no underscores
+revision     = ["~"] baseRevision ["+" modifier]
+baseRevision = letterRev / numberRev / dateRev
+letterRev    = 1*%x41-5A               ; A, B, C… — design/review phase
+numberRev    = 1*%x30-39               ; 0, 1, 2… — construction/record phase
+dateRev      = 4DIGIT "-" 2DIGIT "-" 2DIGIT  ; YYYY-MM-DD — recurring/living deliverables
+modifier     = modLetter 1*%x30-39     ; e.g. C1, N2, Q1, B1
+modLetter    = "C" / "N" / "Q" / "B"
+status       = "IFA" / "IFB" / "IFC" / "IFD" / "IFI" / "IFP" / "IFR" / "IFU" / "REC"
+             / "RSA" / "RSB" / "RSC" / "RSD" / "RSI"
+             / "---"
+; Constraint: RSA / RSB / RSC / RSD / RSI (review status codes) are only valid
+;             when modifier is present (i.e. on +C and +Q files).
+;             "---" indicates no status assigned; used on working drafts.
+</div>
+        <p>Rules:</p>
+        <ul style="margin: var(--spacing-md) 0; padding-left: 1.5rem; color: var(--color-text-muted); line-height: 1.65;">
+          <li>Tracking number: no spaces, no underscores, hyphens as separators only</li>
+          <li>Underscore <code>_</code> separates tracking number from revision</li>
+          <li>Revision: no spaces; may include <code>~</code> prefix and/or <code>+</code> modifier</li>
+          <li>Space before <code>(status)</code></li>
+          <li>Space-dash-space <code> - </code> before title</li>
+          <li>Extension is the original file extension, preserved exactly</li>
+        </ul>
+
+        <p>Anatomy (from left to right):</p>
+        <div class="filename-anatomy">
+          <span class="filename-anatomy__part filename-anatomy__part--tracking">123456-EL-SPC-2623</span>
+          <span class="filename-anatomy__part">_</span>
+          <span class="filename-anatomy__part filename-anatomy__part--revision">B</span>
+          <span class="filename-anatomy__part"> </span>
+          <span class="filename-anatomy__part filename-anatomy__part--status">(IFC)</span>
+          <span class="filename-anatomy__part"> - </span>
+          <span class="filename-anatomy__part filename-anatomy__part--title">Specification For Switchgear.pdf</span>
+        </div>
+
+        <p>Real examples:</p>
+        <div class="code-block">
+123456-EM-MDL-0001_A (IFR) - Master Deliverables List.pdf
+123456-EL-SPC-2623_A (IFR) - Specification For Switchgear.pdf
+123456-EL-ARR-0003_A+C1 (RSB) - Electrical Room Equipment Arrangement.pdf
+123456-EL-ARR-0003_0 (IFC) - Electrical Room Equipment Arrangement.pdf
+123456-ME-RFI-0024_A (IFR) - Mechanical Room Size RFI.pdf
+        </div>
+      </section>
+
+      <!-- Section 3: Tracking numbers -->
+      <section id="tracking-numbers">
+        <h2>3. Tracking numbers</h2>
+        <p>A tracking number is a deliverable's <strong>permanent identifier</strong>. It never changes — regardless of revision, status, or content changes. Think of it like a passport number: your name can change, your passport number doesn't.</p>
+        <p>No spaces, no underscores — hyphens as separators only. Format is yours to define; it must be consistent within the scope it covers.</p>
+
+        <h3>Field definitions (in order)</h3>
+        <p>Tracking numbers are composed of the following fields, in order:</p>
+        <ul style="margin: var(--spacing-md) 0; padding-left: 1.5rem; color: var(--color-text-muted); line-height: 1.65;">
+          <li><strong>originator</strong> — Organizational unit responsible for the deliverable</li>
+          <li><strong>project</strong> — Project identifier; 000000 reserved for corporate-scope deliverables</li>
+          <li><strong>[phase]</strong> — Optional phase code (e.g., P1, P2)</li>
+          <li><strong>[area]</strong> — Optional area/budget code</li>
+          <li><strong>discipline</strong> — Engineering or functional group (e.g., EL, ME, CV, PM)</li>
+          <li><strong>type</strong> — Document category within discipline</li>
+          <li><strong>sequence</strong> — Zero-padded integer</li>
+          <li><strong>[suffix]</strong> — Optional hyphenated suffix for appendices or sheets</li>
+        </ul>
+
+        <h3>Schema rules</h3>
+        <p>Choose the schema that matches your structure. The fields within brackets <code>[ ]</code> are optional and must be omitted consistently across all tracking numbers when not used.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Schema name</th>
+              <th scope="col">Pattern</th>
+              <th scope="col">Example</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>Basic</td>
+              <td><code>originator-project-discipline-type-sequence</code></td>
+              <td><code>ACME-123456-EL-SPC-2623</code></td>
+            </tr>
+            <tr>
+              <td>With Areas</td>
+              <td><code>originator-project-area-discipline-type-sequence</code></td>
+              <td><code>ACME-123456-B02-EL-SPC-2623</code></td>
+            </tr>
+            <tr>
+              <td>With Phases</td>
+              <td><code>originator-phase-project-discipline-type-sequence</code></td>
+              <td><code>ACME-P1-123456-EL-SPC-2623</code></td>
+            </tr>
+            <tr>
+              <td>Corporate</td>
+              <td><code>originator-000000-discipline-type-sequence</code></td>
+              <td><code>ACME-000000-QA-PROC-0042</code></td>
+            </tr>
+          </tbody>
+        </table>
+
+        <div class="highlight-box" style="margin-top: var(--spacing-lg);">
+          <p><strong>Rule: 000000 placeholder.</strong> The Corporate schema uses <code>000000</code> as a reserved project placeholder, indicating the document belongs to the originator's corporate library rather than a specific project. The same originator code and discipline/type conventions apply, so corporate documents sort naturally alongside project documents in a unified archive.</p>
+        </div>
+
+        <h3>Discipline codes</h3>
+        <p>Discipline codes identify the engineering or functional group responsible for the document. They are defined per project and should be documented in the Master Deliverables List.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Discipline</th>
+              <th scope="col">Description</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td><code>EL</code></td>
+              <td>Electrical</td>
+            </tr>
+            <tr>
+              <td><code>ME</code></td>
+              <td>Mechanical</td>
+            </tr>
+            <tr>
+              <td><code>CV</code></td>
+              <td>Civil</td>
+            </tr>
+            <tr>
+              <td><code>PM</code></td>
+              <td>Project Management</td>
+            </tr>
+            <tr>
+              <td><code>QA</code></td>
+              <td>Quality Assurance</td>
+            </tr>
+            <tr>
+              <td><code>PC</code></td>
+              <td>Procurement</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <h3>Type codes</h3>
+        <p>Type codes identify the document category within a discipline. Type codes are scoped per discipline — the same code may mean different things in different disciplines.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Discipline</th>
+              <th scope="col">Type</th>
+              <th scope="col">Description</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td rowspan="3"><code>EL</code></td>
+              <td><code>SPC</code></td>
+              <td>Specification</td>
+            </tr>
+            <tr>
+              <td><code>DWG</code></td>
+              <td>Drawing</td>
+            </tr>
+            <tr>
+              <td><code>RPT</code></td>
+              <td>Report</td>
+            </tr>
+            <tr>
+              <td rowspan="2"><code>ME</code></td>
+              <td><code>SPC</code></td>
+              <td>Specification</td>
+            </tr>
+            <tr>
+              <td><code>MEMO</code></td>
+              <td>Memorandum</td>
+            </tr>
+            <tr>
+              <td><code>PM</code></td>
+              <td><code>MOM</code></td>
+              <td>Minutes of Meeting</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <p><strong>Rule: Avoid ambiguity.</strong> On multi-discipline projects, type codes with overlapping meanings should be avoided or a cross-discipline registry should be agreed upon and documented.</p>
+
+        <h3>Sequence numbers</h3>
+        <p>Sequence numbers make the tracking number unique given all the preceding fields. Use zero-padded integers (e.g., <code>0001</code>, <code>0042</code>).</p>
+        <p>A suffix separated by a hyphen can denote appendices or sheets that are structural parts of the same deliverable:</p>
+        <div class="code-block">
+ACME-123456-EL-SPC-2623      ← base document
+ACME-123456-EL-SPC-2623-A    ← Appendix A
+ACME-123456-EL-SPC-2623-B    ← Appendix B
+ACME-123456-EL-SPC-2623-01   ← Sheet 1 of a multi-sheet drawing
+ACME-123456-EL-SPC-2623-02   ← Sheet 2</div>
+        <div class="highlight-box" style="margin-top: var(--spacing-md);">
+          <p><strong>Suffix vs. attachment rule:</strong> Use a suffix only for content that is a structural part of the deliverable (appendices, sheets). Files that accompany but are independent of the deliverable should be filed as separate documents with their own tracking numbers — not as suffixes.</p>
+        </div>
+
+        <div class="highlight-box" style="margin-top: var(--spacing-md);">
+          <p><strong>Search benefit:</strong> Because discipline and type are embedded in every filename, your file browser's search box is already a filter. Search <code>EL-SPC</code> to find all electrical specifications. Sort by name and every document groups with its full history.</p>
+        </div>
+      </section>
+
+      <!-- Section 4: Revisions -->
+      <section id="revisions">
+        <h2>4. Revisions</h2>
+        <p>The revision field indicates the iteration stage of the deliverable. It consists of an optional <code>~</code> draft prefix, a base revision, and an optional <code>+</code> modifier.</p>
+
+        <h3>Base revision types</h3>
+        <p>Base revisions are one of three types: letter revisions (A, B, C...), number revisions (0, 1, 2...), or date-based revisions.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Type</th>
+              <th scope="col">Format</th>
+              <th scope="col">Phase</th>
+              <th scope="col">Sort behavior</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>Letter revision</td>
+              <td><code>[A-Z]+</code></td>
+              <td>Design/review phase</td>
+              <td>Sorts before number revisions ( lexical)</td>
+            </tr>
+            <tr>
+              <td>Number revision</td>
+              <td><code>[0-9]+</code></td>
+              <td>Construction/record phase</td>
+              <td>Sorts after letter revisions ( lexical)</td>
+            </tr>
+            <tr>
+              <td>Date revision</td>
+              <td><code>YYYY-MM-DD</code></td>
+              <td>Recurring or living documents</td>
+              <td>Sorts chronologically (ISO 8601)</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <h3>Letter revisions (design/review phase)</h3>
+        <p>Letter revisions are used during the design and review phase. They sort lexically, so A < B < C, etc.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Revision</th>
+              <th scope="col">Meaning</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td><code>A</code></td>
+              <td>First issued revision</td>
+            </tr>
+            <tr>
+              <td><code>B</code></td>
+              <td>Second issued revision</td>
+            </tr>
+            <tr>
+              <td><code>C</code>, <code>D</code>, …</td>
+              <td>Subsequent revisions</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <h3>Number revisions (construction/record phase)</h3>
+        <p>Number revisions are used after approval, typically at the Issued For Construction (IFC) stage. They sort lexically after letter revisions.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Revision</th>
+              <th scope="col">Meaning</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td><code>0</code></td>
+              <td>First numeric revision (typically after approval, IFC)</td>
+            </tr>
+            <tr>
+              <td><code>1</code>, <code>2</code>, …</td>
+              <td>Subsequent numeric revisions</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <h3>Date-based revisions</h3>
+        <p>Date-based revisions apply to documents that are updated in place under a single permanent tracking number, where the date of the revision is the most meaningful piece of information a reader needs.</p>
+
+        <p><strong>Rule: Two use cases for date-based revisions:</strong></p>
+        <ol style="margin: var(--spacing-md) 0 0 1.5rem; color: var(--color-text-muted); line-height: 1.65;">
+          <li><strong>Recurring documents</strong> — issued on a fixed cadence (e.g., meeting minutes). The tracking number is fixed; the revision identifies which occurrence.</li>
+          <li><strong>Living documents</strong> — issued on demand (e.g., schedules, risk registers). The tracking number is fixed; the revision indicates freshness.</li>
+        </ol>
+
+        <p><strong>Rule: Contra-indication.</strong> Documents that get a new tracking number each period (e.g., monthly progress reports where each month is a distinct deliverable) use normal letter and number revisions, not date-based revisions.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Cadence</th>
+              <th scope="col">Revision format</th>
+              <th scope="col">Example</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>Quarterly</td>
+              <td><code>YYQX</code></td>
+              <td><code>25Q1</code> = Q1 2025</td>
+            </tr>
+            <tr>
+              <td>Monthly</td>
+              <td><code>YYMM</code></td>
+              <td><code>2503</code> = March 2025</td>
+            </tr>
+            <tr>
+              <td>Twice monthly</td>
+              <td><code>YYMM-XX</code></td>
+              <td><code>2503-01</code>, <code>2503-02</code></td>
+            </tr>
+            <tr>
+              <td>Daily</td>
+              <td><code>YYYY-MM-DD</code></td>
+              <td><code>2025-03-14</code> = 14 March 2025</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <div class="code-block" style="margin-top: var(--spacing-md);">
+<!-- Standing meeting minutes — monthly cadence -->
+ACME-123456-PM-MOM-0001_2503 (IFI) - Project Steering Committee Minutes.pdf
+ACME-123456-PM-MOM-0001_2504 (IFI) - Project Steering Committee Minutes.pdf
+ACME-123456-PM-MOM-0001_2505 (IFI) - Project Steering Committee Minutes.pdf
+
+<!-- Project schedule — issued on demand, date shows freshness -->
+ACME-123456-PM-SCH-0001_2503-07 (IFI) - Master Project Schedule.pdf
+ACME-123456-PM-SCH-0001_2503-21 (IFI) - Master Project Schedule.pdf
+ACME-123456-PM-SCH-0001_2505-14 (IFI) - Master Project Schedule.pdf
+
+<!-- Critical milestones — issued on demand -->
+ACME-123456-PM-MLT-0001_2503-07 (IFI) - Critical Milestones Table.pdf
+ACME-123456-PM-MLT-0001_2506-02 (IFI) - Critical Milestones Table.pdf</div>
+        <p>Date-based revisions sort lexically in the correct chronological order — your file browser will list them in date order when sorted by name.</p>
+      </section>
+
+      <!-- Section 5: Draft prefix (~) -->
+      <section id="draft-prefix">
+        <h2>5. Draft prefix (<code>~</code>)</h2>
+        <p>The <code>~</code> prefix indicates a working draft, not yet formally issued.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Field</th>
+              <th scope="col">Meaning</th>
+              <th scope="col">Effect on filename</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>~ position</td>
+              <td>Prepends the base revision</td>
+              <td><code>_<code>~A</code>, <code>~B</code></code></td>
+            </tr>
+            <tr>
+              <td>Sort position</td>
+              <td>Sorts after the base revision</td>
+              <td><code>~B</code> sorts after <code>B</code></td>
+            </tr>
+            <tr>
+              <td>Status field</td>
+              <td>Intended status when issued</td>
+              <td>Shows what status the draft will carry when issued</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <p>Examples:</p>
+        <div class="code-block">
+123456-EL-SPC-2623_~A (IFR) - Working draft — will be issued for review
+123456-EL-SPC-2623_A (IFR)  - Rev A — formally issued for review
+123456-EL-SPC-2623_~B (IFC) - Working draft of Rev B, for construction
+123456-EL-SPC-2623_B (IFA)  - Rev B — issued for approval
+123456-EL-SPC-2623_~0 (IFC) - Working draft ofRev 0, construction issue
+123456-EL-SPC-2623_0 (IFC)  - Rev 0 — Issued For Construction</div>
+      </section>
+
+      <!-- Section 6: Revision modifiers (+) -->
+      <section id="revision-modifiers">
+        <h2>6. Revision modifiers (<code>+</code>)</h2>
+        <p>Revision modifiers associate a file with a base revision without incrementing the revision. Used for comments, backup material, native source files, and quality records. Sorts after the base revision in alphabetical order.</p>
+
+        <p>The number after the modifier letter — <code>+C1</code>, <code>+C2</code>, and so on — is simply a sequence counter for uniqueness. If two reviewers each return a separate set of comments, they become <code>+C1</code> and <code>+C2</code>. The same applies to all modifiers: the number distinguishes multiple files of the same type attached to the same revision.</p>
+
+        <h3>Modifier table</h3>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Modifier</th>
+              <th scope="col">Meaning</th>
+              <th scope="col">Typical status</th>
+              <th scope="col">Sort position</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td><code>+C1</code>, <code>+C2</code></td>
+              <td>Comments on the base revision</td>
+              <td><span class="status-badge">RSA</span> <span class="status-badge">RSB</span> <span class="status-badge">RSC</span> <span class="status-badge">RSD</span></td>
+              <td>After base revision</td>
+            </tr>
+            <tr>
+              <td><code>+B1</code>, <code>+B2</code></td>
+              <td>Backup material supporting base content</td>
+              <td><span class="status-badge">IFI</span></td>
+              <td>After base revision</td>
+            </tr>
+            <tr>
+              <td><code>+N1</code>, <code>+N2</code></td>
+              <td>Native format files (editable source, e.g., CAD or source files)</td>
+              <td><span class="status-badge">IFI</span></td>
+              <td>After base revision</td>
+            </tr>
+            <tr>
+              <td><code>+Q1</code>, <code>+Q2</code></td>
+              <td>Quality check records</td>
+              <td><span class="status-badge">RSA</span> <span class="status-badge">RSI</span></td>
+              <td>After base revision</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <div style="margin-top: var(--spacing-xl); border-top: 1px solid var(--color-border); padding-top: var(--spacing-lg);">
+          <p style="margin-bottom: var(--spacing-md); color: var(--color-text-muted);">Every project team already does the things described below. ZDDC just gives each one a consistent place in the filename. Start with the formal revisions — the rest follows naturally.</p>
+
+          <h4 style="font-size: 1rem; font-weight: 600; margin-bottom: var(--spacing-sm); color: var(--color-text);">The formal revisions</h4>
+          <div style="overflow-x: auto;">
+            <table style="margin-top: 0;">
+              <thead>
+                <tr>
+                  <th scope="col">Filename</th>
+                  <th scope="col">What it is</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_~A (IFR)</code></td>
+                  <td>Working draft — intended for issue for review</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_A (IFR)</code></td>
+                  <td>Rev A — formally issued for review</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_~B (IFR)</code></td>
+                  <td>Working draft of Rev B, incorporating reviewer comments</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_B (IFA)</code></td>
+                  <td>Rev B — issued for approval</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_~0 (IFC)</code></td>
+                  <td>Working draft of construction issue</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_0 (IFC)</code></td>
+                  <td>Rev 0 — Issued For Construction</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_~1 (IFC)</code></td>
+                  <td>Working construction revision — field change</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_1 (IFC)</code></td>
+                  <td>Rev 1 — construction revision issued</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_~2 (REC)</code></td>
+                  <td>Working as-built — being prepared for record</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_2 (REC)</code></td>
+                  <td>Rev 2 — Issued For Record (as-built)</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+
+          <h4 style="font-size: 1rem; font-weight: 600; margin-top: var(--spacing-xl); margin-bottom: var(--spacing-sm); color: var(--color-text);">+ Native source files</h4>
+          <p style="margin-top: var(--spacing-sm); margin-bottom: var(--spacing-sm); color: var(--color-text-muted); font-size: 0.9rem;">Native source files are saved alongside the published PDF, tied to exactly the revision they produced.</p>
+          <div style="overflow-x: auto;">
+            <table style="margin-top: var(--spacing-sm);">
+              <thead>
+                <tr>
+                  <th scope="col">Filename</th>
+                  <th scope="col">What it is</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_A+N1 (IFI)</code></td>
+                  <td>Native source files for Rev A (e.g., CAD or Word ZIP)</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_B+N1 (IFI)</code></td>
+                  <td>Native source files for Rev B</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_0+N1 (IFI)</code></td>
+                  <td>Native source files for Rev 0</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_1+N1 (IFI)</code></td>
+                  <td>Native source files for Rev 1</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_2+N1 (IFI)</code></td>
+                  <td>Native source files for as-built record</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+
+          <h4 style="font-size: 1rem; font-weight: 600; margin-top: var(--spacing-xl); margin-bottom: var(--spacing-sm); color: var(--color-text);">+ Internal quality checks</h4>
+          <p style="margin-top: var(--spacing-sm); margin-bottom: var(--spacing-sm); color: var(--color-text-muted); font-size: 0.9rem;">Quality check records are kept in the archive, attached to the revision they checked, without cluttering the main sequence.</p>
+          <div style="overflow-x: auto;">
+            <table style="margin-top: var(--spacing-sm);">
+              <thead>
+                <tr>
+                  <th scope="col">Filename</th>
+                  <th scope="col">What it is</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_A+Q1 (RSA)</code></td>
+                  <td>Quality check of Rev A draft — approved</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_B+Q1 (RSA)</code></td>
+                  <td>Quality check of Rev B draft — approved</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_0+Q1 (RSA)</code></td>
+                  <td>Quality check of Rev 0 — approved</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_1+Q1 (RSA)</code></td>
+                  <td>Quality check of Rev 1 — approved</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_2+Q1 (RSA)</code></td>
+                  <td>Quality check of as-built — approved</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+
+          <h4 style="font-size: 1rem; font-weight: 600; margin-top: var(--spacing-xl); margin-bottom: var(--spacing-sm); color: var(--color-text);">+ Client or reviewer comments</h4>
+          <p style="margin-top: var(--spacing-sm); margin-bottom: var(--spacing-sm); color: var(--color-text-muted); font-size: 0.9rem;">Comments come back from reviewers anyway — as marked-up PDFs, emails, spreadsheets. The <code>+C</code> modifier gives each set of comments a place in the archive alongside the revision it applies to. The number suffix (<code>+C1</code>, <code>+C2</code>…) simply distinguishes between multiple sets of comments on the same revision.</p>
+          <div style="overflow-x: auto;">
+            <table style="margin-top: var(--spacing-sm);">
+              <thead>
+                <tr>
+                  <th scope="col">Filename</th>
+                  <th scope="col">What it is</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_A+C1 (RSB)</code></td>
+                  <td>Reviewer comments on Rev A — incorporate and resubmit</td>
+                </tr>
+                <tr>
+                  <td><code>123456-EL-SPC-2623_B+C1 (RSA)</code></td>
+                  <td>Reviewer comments on Rev B — approved, no further review</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </section>
+
+      <!-- Section 7: Status codes -->
+      <section id="status-codes">
+        <h2>7. Status codes</h2>
+        <p>Status codes indicate the approval or review state of a deliverable. They appear in parentheses in the filename.</p>
+
+        <h3>Primary status codes (closed set)</h3>
+        <p>Primary status codes are used on formally issued deliverables. The status field in a draft filename shows the <em>intended</em> status when issued.</p>
+
+        <p><strong>Rule: No DFT status.</strong> Draft status is not encoded as a status field. It is indicated by the <code>~</code> prefix on the revision, and <em>must also be physically marked</em> in the file itself (e.g., a DRAFT watermark or stamp).</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Code</th>
+              <th scope="col">Meaning</th>
+              <th scope="col">Action required</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td><span class="status-badge">IFA</span></td>
+              <td>Issued For Approval</td>
+              <td>Formal sign-off required before proceeding</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">IFB</span></td>
+              <td>Issued For Bid</td>
+              <td>Price to this — binding scope</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">IFC</span></td>
+              <td>Issued For Construction</td>
+              <td>Build to this — approved</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">IFD</span></td>
+              <td>Issued For Design</td>
+              <td>Rely-upon inputs for downstream design. Confirmed items may be used to proceed. Items marked as holds are issued for awareness only and must not be relied upon until the hold is lifted.</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">IFI</span></td>
+              <td>Issued For Information</td>
+              <td>No action required — for awareness only</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">IFP</span></td>
+              <td>Issued For Purchase</td>
+              <td>Procurement may proceed to this version</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">IFR</span></td>
+              <td>Issued For Review</td>
+              <td>Please review and return comments</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">IFU</span></td>
+              <td>Issued For Use</td>
+              <td>Approved for operational use</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">REC</span></td>
+              <td>Issued For Record</td>
+              <td>Final as-built or archived version</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">---</span></td>
+              <td>No status</td>
+              <td>Working version — status not yet assigned</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <h3>Review status codes (closed set)</h3>
+        <p>Review status codes are used as the status on <code>+C</code> (client or reviewer comments) and <code>+Q</code> (internal quality check) files. They record the outcome of the review — what the reviewer concluded and what action is required on the base document.</p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Code</th>
+              <th scope="col">Meaning</th>
+              <th scope="col">Consequence</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td><span class="status-badge">RSA</span></td>
+              <td>Review Status A</td>
+              <td>No comments — approved as submitted</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">RSB</span></td>
+              <td>Review Status B</td>
+              <td>Incorporate comments, resubmit for record</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">RSC</span></td>
+              <td>Review Status C</td>
+              <td>Incorporate comments, resubmit before proceeding</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">RSD</span></td>
+              <td>Review Status D</td>
+              <td>Rejected — resubmit per stated requirements</td>
+            </tr>
+            <tr>
+              <td><span class="status-badge">RSI</span></td>
+              <td>No Review Required</td>
+              <td>Supplemental information only</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <h3>Typical review cycles</h3>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Cycle type</th>
+              <th scope="col">Sequence</th>
+              <th scope="col">Notes</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>Typical</td>
+              <td><code>IFR</code> → <code>RSA</code></td>
+              <td>Reviewer approved without comments</td>
+            </tr>
+            <tr>
+              <td>Extended</td>
+              <td><code>IFR</code> → <code>RSC</code> → <code>IFA</code> → <code>RSB</code></td>
+              <td>Comments require resubmission, then approval, then final record</td>
+            </tr>
+          </tbody>
+        </table>
+      </section>
+
+      <!-- Section 8: Folder naming -->
+      <section id="folder-naming">
+        <h2>8. Folder naming</h2>
+        <p>Transmittal folders follow the same convention as filenames — date-prefixed so folders sort chronologically:</p>
+
+        <div class="code-block">
+folder = date "_" trackingNumber " (" status ") - " title
+date   = 4DIGIT "-" 2DIGIT "-" 2DIGIT
+</div>
+        <p>Format: <code>YYYY-MM-DD_trackingNumber (status) - title</code></p>
+
+        <div class="code-block">
+2025-10-31_123456-EM-SUB-0001 (IFR) - General Arrangement for Review
+2025-10-31_123456-EL-TRN-0043 (IFC) - Electrical Design Issued For Construction</div>
+
+        <h3>Two tracking numbers in play</h3>
+        <p>Two tracking numbers are always in play:</p>
+        <ul style="margin: var(--spacing-md) 0; padding-left: 1.5rem; color: var(--color-text-muted); line-height: 1.65;">
+          <li><strong>Deliverable tracking number</strong> — embedded in each filename; permanent; unchanged across all packages it ever travels in</li>
+          <li><strong>Submittal package tracking number</strong> — in the folder name; reused by the response (same number, different date/status/optionally different title); a resubmittal gets a NEW tracking number</li>
+        </ul>
+
+        <h3>Submittal, response, and resubmittal rules</h3>
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Action</th>
+              <th scope="col">Submittal tracking number</th>
+              <th scope="col">Revision date</th>
+              <th scope="col">Status</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>Initial submittal</td>
+              <td>New tracking number</td>
+              <td>Issue date</td>
+              <td>Issued For Review</td>
+            </tr>
+            <tr>
+              <td>Response</td>
+              <td>Reuses original tracking number</td>
+              <td>Response date</td>
+              <td>Review outcome (RSA, RSC, RSB, or RSD)</td>
+            </tr>
+            <tr>
+              <td>Resubmittal</td>
+              <td>New tracking number</td>
+              <td>Resubmittal date</td>
+              <td>Typically Issued For Approval</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <div class="code-block">
+<!-- Submittal package SUB-0026 contains twenty drawings -->
+2025-10-31_123456-ST-SUB-0026 (IFR) - Structural Steelwork for Review
+2025-11-14_123456-ST-SUB-0026 (RSC) - Structural Steelwork for Review
+
+<!-- Resubmittal SUB-0031 contains only the one drawing that needed revision -->
+2025-12-01_123456-ST-SUB-0031 (IFA) - Column Base Plate Detail — Resubmittal
+2025-12-09_123456-ST-SUB-0031 (RSB) - Column Base Plate Detail — Resubmittal</div>
+        <p>The status on a package folder is the lowest review outcome across all deliverables inside it. It summarises the package; it does not override the outcome of any individual deliverable.</p>
+
+        <h3>Tracking individual deliverables</h3>
+        <p>Search the deliverable's own tracking number across all transmittal folders in <code>issued/</code> and <code>received/</code>. Every folder containing that number is part of its history: which package first carried it, what the response was, which resubmittal carried the revision, and what the final outcome was.</p>
+      </section>
+
+      <!-- Section 9: Transmittal workflow -->
+      <section id="transmittal-workflow">
+        <h2>9. Transmittal workflow</h2>
+        <p>Each third party (client, contractor, vendor, etc.) has a separate subfolder. All communication with that party lives in one place.</p>
+
+        <div class="code-block">
+project/
+  {party-name}/
+    incoming/   ← transmittals received from party, awaiting acceptance
+    received/   ← permanent record of accepted transmittals from party
+    issued/     ← your copies of transmittals sent to party
+</div>
+        <p><strong>5-step workflow:</strong></p>
+
+        <table>
+          <thead>
+            <tr>
+              <th scope="col">Step</th>
+              <th scope="col">Actor</th>
+              <th scope="col">Action</th>
+              <th scope="col">Verification</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>1</td>
+              <td>Sender</td>
+              <td>Creates transmittal folder and uploads to receiver's <code>incoming/</code></td>
+              <td>Filenames match ZDDC convention</td>
+            </tr>
+            <tr>
+              <td>2</td>
+              <td>Receiver</td>
+              <td>Validates filenames, completeness, and SHA-256 checksums</td>
+              <td>All checksums match</td>
+            </tr>
+            <tr>
+              <td>3</td>
+              <td>Receiver</td>
+              <td>Moves folder from <code>incoming/</code> to <code>received/</code></td>
+              <td>Permanent record established</td>
+            </tr>
+            <tr>
+              <td>4</td>
+              <td>Receiver</td>
+              <td>Saves acknowledgment with SHA-256 hashes</td>
+              <td>"Official" version recorded</td>
+            </tr>
+            <tr>
+              <td>5</td>
+              <td>Receiver</td>
+              <td>Notifies sender and distribution list</td>
+              <td>Hashes included in notification</td>
+            </tr>
+          </tbody>
+        </table>
+
+        <div class="highlight-box" style="margin-top: var(--spacing-lg);">
+          <p><strong>What SHA-256 gives you:</strong> Mathematical fingerprint of file contents. Single byte change → hash changes. When acknowledgment records hashes, you can verify years later that the file is identical to what was transmitted.</p>
+        </div>
+      </section>
+
+      <!-- Section 10: Tools -->
+      <section id="tools">
+        <h2>10. Tools</h2>
+        <p>Four single-file HTML applications — each is complete and self-contained. Save them locally and they work forever, without internet, without updates, without a subscription.</p>
+
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: var(--spacing-lg); margin-top: var(--spacing-lg);">
+          <a href="releases/archive_latest.html" class="tool-card" style="text-decoration: none; display: block;">
+            <div class="tool-card__title">Archive Browser</div>
+            <div class="tool-card__desc">Browse, search, filter your project folder. Filter by tracking number, discipline, revision, status, or free text. Group by transmittal. Download selected files as ZIP.</div>
+            <div class="tool-card__link">Open Archive Browser</div>
+          </a>
+
+          <a href="releases/transmittal_latest.html" class="tool-card" style="text-decoration: none; display: block;">
+            <div class="tool-card__title">Transmittal Creator</div>
+            <div class="tool-card__desc">Fill in metadata, drag in files, publish a self-contained HTML transmittal record with SHA-256 checksums. Supports digital signatures. The published file IS the transmittal record.</div>
+            <div class="tool-card__link">Create Transmittal</div>
+          </a>
+
+          <a href="releases/classifier_latest.html" class="tool-card" style="text-decoration: none; display: block;">
+            <div class="tool-card__title">Document Classifier</div>
+            <div class="tool-card__desc">Spreadsheet-like interface for bulk-renaming files to ZDDC format. Copy/paste with Excel. Point it at a folder, fill in the columns, save all at once.</div>
+            <div class="tool-card__link">Run Classifier</div>
+          </a>
+
+          <a href="releases/mdedit_latest.html" class="tool-card" style="text-decoration: none; display: block;">
+            <div class="tool-card__title">Markdown Editor</div>
+            <div class="tool-card__desc">Browser-based markdown editor with live preview, YAML front matter support, and table of contents. Direct local file access via File System Access API.</div>
+            <div class="tool-card__link">Open Editor</div>
+          </a>
+        </div>
+
+        <p style="margin-top: var(--spacing-xl); color: var(--color-text-muted);">Local directory access relies on the <a href="https://www.chromium.org/Home/">Chromium</a>-based browser File System Access API. It does not work in Firefox or Safari.</p>
+      </section>
+    </main>
+  </div>
+
+  <!-- Footer -->
+  <footer class="site-footer">
+    <div class="container footer-content">
+      <span>ZDDC is open source — <a href="https://codeberg.org/VARASYS/ZDDC">codeberg.org/VARASYS/ZDDC</a></span>
+    </div>
+  </footer>
+
+  <script src="js/layout.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/website/releases/archive_latest.html b/website/releases/archive_latest.html
new file mode 120000
index 0000000..89556f8
--- /dev/null
+++ b/website/releases/archive_latest.html
@@ -0,0 +1 @@
+archive_v0.0.1.html
\ No newline at end of file
diff --git a/website/releases/archive_v0.0.1.html b/website/releases/archive_v0.0.1.html
new file mode 100644
index 0000000..753b624
--- /dev/null
+++ b/website/releases/archive_v0.0.1.html
@@ -0,0 +1,7800 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Archive</title>
+    <style>
+/* ==========================================================================
+   ZDDC Shared Base — single source of truth for tokens and primitives
+   Included first by every tool's build.sh via ../shared/base.css
+   ========================================================================== */
+
+/* ── CSS custom properties ────────────────────────────────────────────────── */
+:root {
+    /* Brand / accent (matches zddc.varasys.io website --accent) */
+    --primary:        #2a5a8a;
+    --primary-hover:  #1d4060;
+    --primary-active: #163352;
+    --primary-light:  #e8f0f7;
+
+    /* Semantic colours */
+    --success: #28a745;
+    --warning: #d97706;
+    --danger:  #dc3545;
+    --info:    #17a2b8;
+
+    /* Backgrounds */
+    --bg:           #ffffff;
+    --bg-secondary: #f8f9fa;
+    --bg-hover:     #f0f4f8;
+    --bg-selected:  var(--primary-light);
+
+    /* Text */
+    --text:       #212529;
+    --text-muted: #6c757d;
+    --text-light: #ffffff;
+
+    /* Borders */
+    --border:      #dee2e6;
+    --border-dark: #adb5bd;
+
+    /* Shape */
+    --radius: 4px;
+
+    /* Typography */
+    --font:      -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    --font-mono: 'SF Mono', 'Fira Code', 'Consolas', 'Courier New', monospace;
+}
+
+/* ── Dark mode tokens ─────────────────────────────────────────────────────── */
+/* Applied via: OS preference (auto) or [data-theme="dark"] on <html>          */
+/* The [data-theme="light"] selector locks light mode regardless of OS pref.   */
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+        --primary:        #4a90c4;
+        --primary-hover:  #5ba3d9;
+        --primary-active: #6ab5e8;
+        --primary-light:  #1a3550;
+
+        --bg:           #1e1e1e;
+        --bg-secondary: #252526;
+        --bg-hover:     #2d2d30;
+        --bg-selected:  #1a3550;
+
+        --text:       #d4d4d4;
+        --text-muted: #9d9d9d;
+        --text-light: #ffffff;
+
+        --border:      #3e3e42;
+        --border-dark: #6e6e72;
+    }
+}
+
+/* Manual dark override — wins over media query */
+[data-theme="dark"] {
+    --primary:        #4a90c4;
+    --primary-hover:  #5ba3d9;
+    --primary-active: #6ab5e8;
+    --primary-light:  #1a3550;
+
+    --bg:           #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover:     #2d2d30;
+    --bg-selected:  #1a3550;
+
+    --text:       #d4d4d4;
+    --text-muted: #9d9d9d;
+    --text-light: #ffffff;
+
+    --border:      #3e3e42;
+    --border-dark: #6e6e72;
+}
+
+/* ── Reset ────────────────────────────────────────────────────────────────── */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* ── Base document ────────────────────────────────────────────────────────── */
+html, body {
+    height: 100%;
+    font-family: var(--font);
+    font-size: 16px;
+    line-height: 1.5;
+    color: var(--text);
+    background-color: var(--bg-secondary);
+}
+
+/* ── Typography ───────────────────────────────────────────────────────────── */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 600;
+    line-height: 1.2;
+}
+
+a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+/* ── Utility ──────────────────────────────────────────────────────────────── */
+.hidden {
+    display: none !important;
+}
+
+.truncate {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* ── Scrollbars (webkit) ──────────────────────────────────────────────────── */
+::-webkit-scrollbar {
+    width: 7px;
+    height: 7px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a0a0a0;
+}
+
+/* ── Button primitive ─────────────────────────────────────────────────────── */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.4rem 0.85rem;
+    font-family: var(--font);
+    font-size: 0.875rem;
+    font-weight: 500;
+    line-height: 1.4;
+    text-align: center;
+    text-decoration: none;
+    white-space: nowrap;
+    vertical-align: middle;
+    cursor: pointer;
+    border: 1px solid transparent;
+    border-radius: var(--radius);
+    transition: background 0.15s, box-shadow 0.15s, border-color 0.15s, color 0.15s;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.btn:disabled,
+.btn[disabled] {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:not(:disabled):hover {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.12);
+}
+
+.btn:not(:disabled):active {
+    box-shadow: none;
+}
+
+/* Variants */
+.btn-primary {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-primary:not(:disabled):hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+    color: var(--text-light);
+}
+
+.btn-primary:not(:disabled):active {
+    background: var(--primary-active);
+    border-color: var(--primary-active);
+}
+
+.btn-secondary {
+    background: var(--bg);
+    color: var(--text);
+    border-color: var(--border);
+}
+
+.btn-secondary:not(:disabled):hover {
+    background: var(--bg-secondary);
+}
+
+.btn-success {
+    background: var(--success);
+    color: var(--text-light);
+    border-color: var(--success);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: var(--text-light);
+    border-color: var(--danger);
+}
+
+/* Sizes */
+.btn-sm {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.75rem;
+}
+
+.btn-lg {
+    padding: 0.6rem 1.4rem;
+    font-size: 1rem;
+}
+
+.btn-link {
+    background: transparent;
+    border-color: transparent;
+    color: var(--primary);
+    padding-left: 0;
+    padding-right: 0;
+}
+
+.btn-link:not(:disabled):hover {
+    text-decoration: underline;
+    box-shadow: none;
+}
+
+/* ── App header chrome ────────────────────────────────────────────────────── */
+.app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.35rem 1rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+/* Tool name inside the header */
+.app-header__title {
+    font-size: 17px;
+    font-weight: 600;
+    color: var(--text);
+    letter-spacing: 0.01em;
+    white-space: nowrap;
+}
+
+/* ── Build timestamp ──────────────────────────────────────────────────────── */
+.build-timestamp {
+    font-size: 0.55rem;
+    color: var(--text-muted);
+    opacity: 0.7;
+    font-weight: 300;
+    white-space: nowrap;
+    padding-top: 0.15rem;
+}
+
+/* Title + timestamp stacked vertically on the left side of the header */
+.header-title-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    line-height: 1;
+}
+
+/* ── Icon buttons (help, theme, refresh) ─────────────────────────────────── */
+/* Square, centered — overrides the asymmetric text-button padding/line-height */
+#help-btn,
+#theme-btn,
+#refreshHeaderBtn {
+    width: 2rem;
+    height: 2rem;
+    padding: 0;
+    line-height: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1rem;
+}
+
+/* Toast CSS lives in classifier/css/base.css — only that tool uses toasts. */
+
+/* ── Theme and help icon buttons ─────────────────────────────────────────── */
+#theme-btn,
+#help-btn {
+    font-size: 1rem;
+}
+
+/* ── Help panel (shared slide-out drawer) ─────────────────────────────────── */
+/* Used by all four tools. Toggle open/close via shared/help.js.               */
+
+.help-panel {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: min(420px, 85vw);
+    height: 100vh;
+    z-index: 1000;
+    background: var(--bg);
+    border-left: 1px solid var(--border);
+    box-shadow: -2px 0 12px rgba(0, 0, 0, 0.08);
+    display: flex;
+    flex-direction: column;
+    transform: translateX(100%);
+    transition: transform 0.25s ease;
+}
+
+.help-panel:not([hidden]) {
+    transform: translateX(0);
+}
+
+.help-panel[hidden] {
+    display: flex;
+    transform: translateX(100%);
+    pointer-events: none;
+}
+
+.help-panel__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+    background: var(--bg);
+}
+
+.help-panel__title {
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.help-panel__close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1.35rem;
+    cursor: pointer;
+    padding: 0.25rem 0.5rem;
+    border-radius: var(--radius);
+    line-height: 1;
+    transition: background 0.15s, color 0.15s;
+}
+
+.help-panel__close:hover {
+    color: var(--text);
+    background: var(--bg-secondary);
+}
+
+.help-panel__body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem 1rem 2rem;
+    font-size: 0.85rem;
+    line-height: 1.6;
+    color: var(--text);
+}
+
+.help-panel__body h3 {
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin: 1.25rem 0 0.35rem;
+    color: var(--text);
+    border-bottom: 1px solid var(--border);
+    padding-bottom: 0.15rem;
+}
+
+.help-panel__body h3:first-child {
+    margin-top: 0;
+}
+
+.help-panel__body h4 {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    margin: 1.25rem 0 0.3rem;
+    padding-left: 0.5rem;
+    border-left: 3px solid var(--border-dark);
+    color: var(--text-muted);
+}
+
+.help-panel__body p {
+    margin: 0 0 0.5rem;
+}
+
+.help-panel__body ol,
+.help-panel__body ul {
+    padding-left: 1.5rem;
+    margin: 0.3rem 0 0.5rem;
+}
+
+.help-panel__body li {
+    margin-bottom: 0.3rem;
+}
+
+.help-panel__body dl {
+    margin: 0.3rem 0;
+}
+
+.help-panel__body dt {
+    font-weight: 600;
+    color: var(--text);
+}
+
+.help-panel__body dd {
+    margin: 0 0 0.5rem 1rem;
+    color: var(--text-muted);
+}
+
+.help-panel__body code {
+    font-family: var(--font-mono);
+    font-size: 0.8em;
+    background: var(--bg-secondary);
+    padding: 0.1em 0.3em;
+    border-radius: 3px;
+}
+
+.help-badge {
+    font-size: 0.7rem;
+    font-weight: 600;
+    padding: 0.1rem 0.35rem;
+    border-radius: var(--radius);
+    vertical-align: middle;
+    letter-spacing: 0.02em;
+}
+
+.help-badge--draft {
+    color: #2563eb;
+    background: #eff6ff;
+}
+
+.help-badge--published {
+    color: #7c3aed;
+    background: #f5f3ff;
+}
+
+/* Shrink main content when help panel is open */
+body.help-open .app-header {
+    margin-right: min(420px, 85vw);
+}
+
+/* ── Column filter inputs (shared across archive, classifier, transmittal) ─── */
+.column-filter {
+    display: block;
+    width: 100%;
+    box-sizing: border-box;
+    margin-top: 0.25rem;
+    padding: 0.2rem 0.4rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.15s;
+}
+
+.column-filter:focus {
+    border-color: var(--primary);
+    outline: none;
+    box-shadow: 0 0 0 1px rgba(42, 90, 138, 0.35);
+}
+
+.column-filter::placeholder {
+    color: var(--text-muted);
+}
+
+/* Archive-specific base overrides
+   Reset, tokens, and font are provided by shared/base.css */
+
+#appContainer {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    overflow: hidden;
+}
+
+.note {
+    font-size: 0.9em;
+    color: var(--text-muted);
+    font-style: italic;
+}
+
+/* Scan spinner */
+.scan-spinner {
+    display: inline-block;
+    width: 0.85em;
+    height: 0.85em;
+    border: 2px solid var(--border);
+    border-top-color: var(--primary);
+    border-radius: 50%;
+    animation: spin 0.7s linear infinite;
+    vertical-align: middle;
+    margin-left: 0.4rem;
+}
+
+@keyframes spin {
+    to { transform: rotate(360deg); }
+}
+
+/* Archive layout — tokens from shared/base.css */
+
+/* Header — shared/base.css provides base .app-header; add archive-specific overrides */
+.app-header {
+    padding: 0.5rem 1rem;
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.header-right {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+}
+
+.preview-toggle-label {
+    display: flex;
+    align-items: center;
+    gap: 0.35rem;
+    font-size: 0.875rem;
+    cursor: pointer;
+    white-space: nowrap;
+}
+
+/* Main Container */
+.main-container {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+}
+
+/* Navigation Pane */
+.nav-pane {
+    width: 300px;
+    min-width: 200px;
+    background: var(--bg);
+    border-right: 1px solid var(--border);
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+    height: 100%;
+    position: relative;
+}
+
+.nav-section {
+    display: flex;
+    flex-direction: column;
+    padding: 1rem;
+    border-bottom: 1px solid var(--border);
+    overflow: hidden;
+    position: relative;
+}
+
+/* Grouping section - larger default size */
+.nav-section:first-child {
+    flex: 0 0 auto;
+    height: 250px;
+    min-height: 50px;
+}
+
+/* Grouping section when collapsed */
+.nav-section:first-child.collapsed {
+    height: auto;
+    flex: 0 0 auto;
+}
+
+/* Transmittal section takes remaining space */
+.nav-section:last-child {
+    flex: 1;
+    min-height: 150px;
+    border-bottom: none;
+}
+
+/* Nav section content wrapper */
+.nav-section-content {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    overflow: hidden;
+    min-height: 0;
+}
+
+/* Hide content when collapsed */
+.nav-section.collapsed .nav-section-content {
+    display: none;
+}
+
+/* Resize handles — persistent 1px divider; grab cursor on hover */
+.resize-handle-horizontal {
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 5px;
+    cursor: ew-resize;
+    z-index: 10;
+    /* Persistent 1px right-edge indicator */
+    border-right: 1px solid var(--border-dark);
+}
+
+.resize-handle-horizontal:hover,
+.resize-handle-horizontal.resizing {
+    background: rgba(42, 90, 138, 0.25);
+    cursor: col-resize;
+}
+
+.resize-handle-vertical {
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: -3px;
+    height: 6px;
+    cursor: ns-resize;
+    z-index: 10;
+    /* Persistent 1px bottom-edge indicator */
+    border-bottom: 1px solid var(--border-dark);
+}
+
+.resize-handle-vertical:hover,
+.resize-handle-vertical.resizing {
+    background: rgba(42, 90, 138, 0.25);
+    cursor: row-resize;
+}
+
+.nav-section h3 {
+    font-size: 1em;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    margin-bottom: 0.5rem;
+    flex-shrink: 0;
+}
+
+.nav-section h3 {
+    font-size: 1em;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    margin-bottom: 0;
+    flex-shrink: 0;
+}
+
+.folder-list {
+    flex: 1;
+    overflow-y: auto;
+    overflow-x: hidden;
+    margin-top: 0.5rem;
+    min-height: 0;
+}
+
+/* Content Area */
+.content-area {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    background: var(--bg-secondary);
+    overflow: hidden;
+}
+
+.content-header {
+    display: flex;
+    justify-content: flex-start;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.75rem 1rem;
+    background: var(--bg);
+    border-bottom: 1px solid var(--border);
+}
+
+.content-header .content-actions {
+    margin-left: auto;
+}
+
+.content-actions {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+}
+
+/* Table Container */
+.table-container {
+    flex: 1;
+    overflow: auto;
+    background: var(--bg);
+    margin: 1rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+}
+
+/* Status Bar */
+.status-bar {
+    display: flex;
+    justify-content: flex-start;
+    align-items: center;
+    padding: 0.35rem 1rem;
+    background: var(--bg);
+    border-top: 1px solid var(--border);
+    font-size: 0.85em;
+    color: var(--text-muted);
+    gap: 1rem;
+}
+
+/* Empty State — positioned below the app header */
+.empty-state {
+    position: absolute;
+    top: 50px; /* clear the header */
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--bg);
+    z-index: 10;
+}
+
+.empty-state-content {
+    text-align: center;
+    max-width: 500px;
+    padding: 2rem;
+}
+
+/* Project warning banner */
+.project-warning-banner {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 16px;
+    background: #fff3cd;
+    border-bottom: 1px solid #ffc107;
+    color: #664d03;
+    font-size: 0.875rem;
+    gap: 12px;
+}
+.project-warning-banner.hidden { display: none; }
+.project-warning-dismiss {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #664d03;
+    font-size: 1rem;
+    padding: 0 4px;
+    flex-shrink: 0;
+}
+
+.empty-state-content h2 {
+    color: var(--text);
+    margin-bottom: 1rem;
+}
+
+.empty-state-content p {
+    margin-bottom: 1rem;
+    color: var(--text-muted);
+}
+
+/* Project access warning banner */
+.project-warning-banner {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 16px;
+    background: #fff3cd;
+    border-bottom: 1px solid #ffc107;
+    color: #664d03;
+    font-size: 0.875rem;
+    gap: 12px;
+}
+.project-warning-banner.hidden { display: none; }
+.project-warning-dismiss {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #664d03;
+    font-size: 1rem;
+    padding: 0 4px;
+    flex-shrink: 0;
+}
+
+/* Archive component styles — tokens from shared/base.css */
+
+/* Select All checkbox label */
+.select-all-label {
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    font-size: 0.8rem;
+    color: var(--text-muted);
+    cursor: pointer;
+    white-space: nowrap;
+}
+
+.select-all-label input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+/* One-line bar variant — sits below the section header */
+.select-all-bar {
+    padding: 0.2rem 0;
+    margin-bottom: 0.35rem;
+}
+
+/* Filter + Select All inline row */
+.filter-select-row {
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    margin-bottom: 0.35rem;
+}
+
+.filter-select-row .filter-input {
+    flex: 1;
+    margin-bottom: 0;
+}
+
+/* Inline variant: label to the right of the filter, text above checkbox */
+.select-all-inline {
+    flex-shrink: 0;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.1rem;
+    font-size: 0.7rem;
+    line-height: 1.1;
+    color: var(--text-muted);
+    cursor: pointer;
+    white-space: nowrap;
+    text-align: center;
+}
+
+.select-all-inline input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+/* Form Inputs */
+.filter-input,
+.form-input {
+    width: 100%;
+    padding: 0.5rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    font-size: 0.9rem;
+    font-family: var(--font);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.2s;
+}
+
+.filter-input:focus,
+.form-input:focus {
+    outline: none;
+    border-color: var(--primary);
+}
+
+.filter-input.filter-active {
+    background: rgba(234, 179, 8, 0.18);
+    border-color: rgba(234, 179, 8, 0.7);
+}
+
+/* Form Groups */
+.form-group {
+    margin-bottom: 1rem;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 0.25rem;
+    font-weight: 500;
+}
+
+.form-help {
+    display: block;
+    margin-top: 0.25rem;
+    font-size: 0.85rem;
+    color: var(--text-muted);
+}
+
+/* Checkboxes */
+input[type="checkbox"] {
+    margin-right: 0.5rem;
+    cursor: pointer;
+}
+
+/* Folder Tree Chevrons */
+.folder-chevron {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1rem;
+    height: 1rem;
+    font-size: 0.6rem;
+    color: var(--text-muted);
+    cursor: pointer;
+    transition: transform 0.15s ease;
+    flex-shrink: 0;
+    margin-right: 0.25rem;
+}
+
+.folder-chevron:not(.collapsed) {
+    transform: rotate(90deg);
+}
+
+.folder-chevron:hover {
+    color: var(--primary);
+}
+
+.folder-chevron-placeholder {
+    width: 1rem;
+    flex-shrink: 0;
+    margin-right: 0.25rem;
+}
+
+/* Folder Items */
+.folder-item {
+    display: flex;
+    align-items: center;
+    padding: 0.25rem 0.5rem;
+    cursor: pointer;
+    user-select: none;
+    border-radius: 3px;
+    border-left: 3px solid transparent;
+}
+
+.folder-item:hover {
+    background: var(--bg-hover);
+}
+
+.folder-item.selected {
+    background: var(--bg-selected);
+    color: inherit;
+    border-left: 3px solid var(--primary);
+    padding-left: calc(0.5rem - 3px);
+}
+
+.folder-item.selected:hover {
+    background: var(--bg-hover);
+}
+
+.folder-item-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    user-select: text;
+    cursor: text;
+}
+
+/* Transmittal folder formatting */
+.transmittal-folder-content {
+    flex: 1;
+    overflow: hidden;
+    user-select: text;
+    cursor: text;
+}
+
+[data-folder-type="transmittal"] {
+    padding-top: 0.5rem;
+    padding-bottom: 0.5rem;
+}
+
+.transmittal-first-line {
+    font-size: 0.9em;
+    font-weight: 500;
+    color: var(--text);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.transmittal-second-line {
+    font-size: 0.85em;
+    color: var(--text-muted);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* Empty filter message in folder lists */
+.folder-list-empty {
+    padding: 0.75rem 0.5rem;
+    color: var(--text-muted);
+    font-size: 0.85rem;
+    font-style: italic;
+    text-align: center;
+}
+
+/* Focus styles for keyboard navigation */
+.folder-list:focus {
+    outline: 2px solid var(--primary);
+    outline-offset: -2px;
+}
+
+.folder-list:focus .folder-item:focus {
+    outline: 1px dotted var(--primary);
+    outline-offset: -1px;
+}
+
+/* ── Folder type toggle bar ─────────────────────────────────────────────── */
+.folder-type-bar {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.3rem;
+    padding: 0.3rem 0 0.4rem;
+    flex-shrink: 0;
+}
+
+.folder-type-toggle {
+    padding: 0.2rem 0.6rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: 999px;
+    background: var(--bg);
+    color: var(--text-muted);
+    cursor: pointer;
+    transition: background 0.15s, color 0.15s, border-color 0.15s;
+    line-height: 1.4;
+    white-space: nowrap;
+}
+
+.folder-type-toggle:hover {
+    background: var(--bg-hover);
+    color: var(--text);
+    border-color: var(--border-dark);
+}
+
+.folder-type-toggle.active {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.folder-type-toggle.active:hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+}
+
+/* Date Group Headers */
+.date-group-header {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    cursor: pointer;
+    user-select: none;
+    font-weight: 600;
+    color: var(--text);
+    position: sticky;
+    top: 0;
+    z-index: 1;
+}
+
+.date-group-header:hover {
+    background: var(--bg-hover);
+}
+
+.date-group-toggle {
+    font-size: 0.8em;
+    width: 1rem;
+    text-align: center;
+}
+
+.date-group-date {
+    flex: 1;
+}
+
+.date-group-count {
+    font-size: 0.85em;
+    color: var(--text-muted);
+    font-weight: normal;
+}
+
+/* Nav section header with button */
+.nav-section-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    background: var(--bg-secondary);
+    margin: -1rem -1rem 0.75rem -1rem;
+    padding: 0.4rem 1rem;
+    border-bottom: 1px solid var(--border);
+}
+
+.nav-section-header h3 {
+    margin-bottom: 0;
+}
+
+.btn-icon {
+    background: none;
+    border: none;
+    padding: 0.25rem;
+    cursor: pointer;
+    color: var(--text-muted);
+    font-size: 1rem;
+    line-height: 1;
+    border-radius: 3px;
+    transition: background 0.2s;
+}
+
+.btn-icon:hover {
+    background: var(--bg-hover);
+    color: var(--text);
+}
+
+/* Modals */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    z-index: 1000;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.modal-backdrop {
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: rgba(0, 0, 0, 0.5);
+}
+
+.modal-content {
+    position: relative;
+    background: var(--bg);
+    border-radius: 8px;
+    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+    max-width: 90vw;
+    max-height: 90vh;
+    display: flex;
+    flex-direction: column;
+}
+
+.modal-large {
+    width: 80vw;
+}
+
+.modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--border);
+}
+
+.modal-header h2 {
+    margin: 0;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    font-size: 1.5rem;
+    color: var(--text-muted);
+    padding: 0;
+    width: 2rem;
+    height: 2rem;
+    cursor: pointer;
+}
+
+.modal-close:hover {
+    color: var(--text);
+}
+
+.modal-body {
+    padding: 1.5rem;
+    overflow-y: auto;
+    flex: 1;
+}
+
+.modal-footer {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.5rem;
+    padding: 1rem 1.5rem;
+    border-top: 1px solid var(--border);
+}
+
+/* Preview Table */
+.preview-table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-top: 0.5rem;
+}
+
+.preview-table th,
+.preview-table td {
+    text-align: left;
+    padding: 0.5rem;
+    border-bottom: 1px solid var(--border);
+}
+
+.preview-table th {
+    font-weight: 600;
+    background: var(--bg-secondary);
+}
+
+/* Drag & Drop */
+.drag-over {
+    background: var(--bg-selected) !important;
+    border-color: var(--primary) !important;
+}
+
+/* Loading Spinner */
+.spinner {
+    display: inline-block;
+    width: 1rem;
+    height: 1rem;
+    border: 2px solid var(--border);
+    border-top: 2px solid var(--primary);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    0%   { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Revision Title Styling */
+.titles-container {
+    display: flex;
+    flex-direction: column;
+}
+
+.revision-title-base,
+.revision-title-modifier {
+    margin-bottom: 0.5rem;
+}
+
+.revision-title-base:last-child,
+.revision-title-modifier:last-child {
+    margin-bottom: 0;
+}
+
+.revision-title-base {
+    color: var(--text);
+}
+
+.revision-title-modifier {
+    color: var(--text-muted);
+}
+
+/* Modifier Filter Dropdown */
+.modifier-filter-container {
+    position: relative;
+    display: inline-block;
+}
+
+.modifier-filter-btn {
+    min-width: 100px;
+}
+
+.modifier-filter-dropdown {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    z-index: 1000;
+    min-width: 180px;
+    background: var(--bg);
+    border: 1px solid var(--border-dark);
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    margin-top: 4px;
+}
+
+.modifier-filter-header {
+    padding: 0.5rem 0.75rem;
+    border-bottom: 1px solid var(--border);
+    background: var(--bg-secondary);
+}
+
+.modifier-filter-header label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-weight: 500;
+    cursor: pointer;
+}
+
+.modifier-filter-list {
+    max-height: 250px;
+    overflow-y: auto;
+    padding: 0.25rem 0;
+}
+
+.modifier-filter-item {
+    padding: 0.4rem 0.75rem;
+}
+
+.modifier-filter-item label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+    font-size: 0.9rem;
+}
+
+.modifier-filter-item:hover {
+    background: var(--bg-hover);
+}
+
+.modifier-base {
+    font-weight: 500;
+    color: var(--text);
+}
+
+.modifier-type {
+    color: var(--text-muted);
+}
+
+/* Active toggle button state */
+.btn-active {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-active:hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+}
+
+/* Path Error Row Warning */
+.file-row-path-error {
+    background: rgba(217, 119, 6, 0.08) !important;
+}
+
+.file-row-path-error:hover {
+    background: rgba(217, 119, 6, 0.15) !important;
+}
+
+.path-error-indicator {
+    color: var(--warning);
+    cursor: help;
+    margin-right: 0.25rem;
+}
+
+.file-link-disabled {
+    color: var(--text-muted);
+    text-decoration: none;
+    cursor: not-allowed;
+}
+
+.file-link-disabled:hover {
+    text-decoration: none;
+    color: var(--text-muted);
+}
+
+/* PDF Preview Toggle */
+.preview-toggle-label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.9rem;
+    color: var(--text);
+    cursor: pointer;
+    padding: 0.4rem 0.85rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    transition: background 0.15s;
+}
+
+.preview-toggle-label:hover {
+    background: var(--bg-secondary);
+}
+
+.preview-toggle-label input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+.preview-toggle-label input[type="checkbox"]:checked + span {
+    color: var(--primary);
+    font-weight: 500;
+}
+
+/* ── Download progress indicator ────────────────────────────────────────── */
+.progress-indicator {
+    position: fixed;
+    bottom: 20px;
+    right: 20px;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 20px;
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+    z-index: 1000;
+    min-width: 300px;
+}
+
+.progress-indicator__message {
+    margin-bottom: 10px;
+}
+
+.progress-indicator__track {
+    background: var(--bg-secondary);
+    height: 20px;
+    border-radius: 10px;
+    overflow: hidden;
+}
+
+.progress-indicator__fill {
+    background: var(--primary);
+    height: 100%;
+    transition: width 0.3s;
+}
+
+.progress-indicator__label {
+    text-align: center;
+    margin-top: 5px;
+    font-size: 0.9em;
+    color: var(--text-muted);
+}
+
+/* ── Welcome screen list ─────────────────────────────────────────────────── */
+.welcome-list {
+    text-align: left;
+    margin: 0.5rem auto;
+    max-width: 400px;
+}
+
+/* ── Windows path tip (inside welcome screen) ────────────────────────────── */
+.windows-tip {
+    text-align: left;
+    margin: 1rem auto;
+    max-width: 500px;
+    font-size: 0.9rem;
+}
+
+.windows-tip summary {
+    cursor: pointer;
+    color: var(--text-muted);
+}
+
+.windows-tip__body {
+    margin-top: 0.5rem;
+    padding: 0.75rem;
+    background: var(--bg);
+    border: 1px solid var(--warning);
+    border-radius: var(--radius);
+}
+
+.windows-tip__body > p:first-child {
+    margin: 0 0 0.5rem 0;
+}
+
+.windows-tip__body ol {
+    margin: 0.5rem 0;
+    padding-left: 1.5rem;
+}
+
+.windows-tip__code {
+    display: block;
+    margin: 0.25rem 0;
+    padding: 0.25rem 0.5rem;
+    background: var(--bg-secondary);
+    border-radius: var(--radius);
+    font-family: var(--font-mono);
+    font-size: 0.85em;
+}
+
+.windows-tip__note {
+    margin: 0.5rem 0 0 0;
+    font-size: 0.85rem;
+    color: var(--text-muted);
+}
+
+/* Outstanding virtual transmittal — pinned at top of transmittal list */
+.outstanding-transmittal {
+    border-top: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 0.25rem;
+}
+
+.outstanding-label {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+.outstanding-transmittal.selected .outstanding-label {
+    color: var(--text);
+}
+
+/* Reset Filters Button */
+.btn-icon-only {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 2rem;
+    height: 2rem;
+    font-size: 1.1rem;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    cursor: pointer;
+    transition: background 0.2s, border-color 0.2s, color 0.2s;
+}
+
+.btn-icon-only:hover {
+    background: var(--bg-hover);
+    border-color: var(--primary);
+}
+
+.btn-icon-only:active {
+    background: var(--primary);
+    border-color: var(--primary);
+    color: var(--text-light);
+}
+
+/* Toolbar separator */
+.toolbar-separator {
+    width: 1px;
+    height: 1.5rem;
+    background: var(--border);
+    margin: 0 0.25rem;
+    align-self: center;
+    flex-shrink: 0;
+}
+
+/* ── Preset dropdown ─────────────────────────────────────────────────────── */
+.preset-section {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+}
+
+.preset-dropdown {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    z-index: 1000;
+    min-width: 350px;
+    max-height: 400px;
+    background: var(--bg);
+    border: 1px solid var(--border-dark);
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+}
+
+.preset-section-label {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--text-muted);
+    padding: 0.5rem 0.75rem 0.25rem;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.preset-list {
+    padding: 0.25rem 0;
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.preset-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.4rem 0.75rem;
+    cursor: pointer;
+    user-select: none;
+}
+
+.preset-item:hover {
+    background: var(--bg-hover);
+}
+
+.preset-item .preset-delete {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1rem;
+    padding: 0.25rem 0.5rem;
+    cursor: pointer;
+    border-radius: 3px;
+    line-height: 1;
+}
+
+.preset-item .preset-delete:hover {
+    background: rgba(255, 0, 0, 0.1);
+    color: var(--error);
+}
+
+.preset-no-presets {
+    padding: 0.75rem 0.75rem;
+    color: var(--text-muted);
+    font-size: 0.85rem;
+    font-style: italic;
+    text-align: center;
+}
+
+.preset-divider {
+    height: 1px;
+    background: var(--border);
+    margin: 0.5rem 0;
+}
+
+.preset-projects-list {
+    padding: 0.25rem 0;
+    max-height: 200px;
+    overflow-y: auto;
+}
+
+.preset-project-item {
+    padding: 0.25rem 0.75rem;
+}
+
+.preset-project-label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+    font-size: 0.9rem;
+    user-select: none;
+}
+
+.preset-project-label input[type="checkbox"] {
+    margin: 0;
+    cursor: pointer;
+}
+
+.preset-footer-actions {
+    padding: 0.5rem 0.75rem;
+    border-top: 1px solid var(--border);
+    background: var(--bg-secondary);
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+}
+
+.preset-footer-naming {
+    padding: 0.5rem 0.75rem;
+    border-top: 1px solid var(--border);
+    background: var(--bg-secondary);
+    display: flex;
+    gap: 0.5rem;
+}
+
+.preset-name-input {
+    flex: 1;
+    padding: 0.4rem 0.6rem;
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    font-size: 0.9rem;
+    font-family: var(--font);
+    background: var(--bg);
+    color: var(--text);
+}
+
+.preset-name-input:focus {
+    outline: none;
+    border-color: var(--primary);
+}
+
+.preset-section-top,
+.preset-section-bottom {
+    padding: 0.25rem 0;
+}
+
+.preset-section-bottom {
+    flex: 1;
+    overflow-y: auto;
+}
+
+
+
+/* Table styles */
+
+.files-table {
+    width: 100%;
+    border-collapse: collapse;
+    background: var(--bg);
+}
+
+/* Table Header */
+.files-table thead {
+    position: sticky;
+    top: 0;
+    background: var(--bg);
+    z-index: 10;
+}
+
+.files-table th {
+    position: relative;
+    text-align: left;
+    font-weight: 600;
+    background: var(--bg-secondary);
+    border-bottom: 2px solid var(--border);
+    user-select: none;
+}
+
+.th-content {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    cursor: default;
+}
+
+.sortable .th-content {
+    cursor: pointer;
+}
+
+.sortable .th-content:hover {
+    background: var(--bg-hover);
+}
+
+/* Sort Indicators */
+.sort-indicator {
+    display: inline-block;
+    width: 0.75rem;
+    height: 1rem;
+    margin-left: 0.5rem;
+    position: relative;
+}
+
+.sort-indicator::before,
+.sort-indicator::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    width: 0;
+    height: 0;
+    border-style: solid;
+}
+
+.sort-indicator::before {
+    top: 0;
+    border-width: 0 0.375rem 0.375rem 0.375rem;
+    border-color: transparent transparent var(--border-dark) transparent;
+}
+
+.sort-indicator::after {
+    bottom: 0;
+    border-width: 0.375rem 0.375rem 0 0.375rem;
+    border-color: var(--border-dark) transparent transparent transparent;
+}
+
+th[data-sort="asc"] .sort-indicator::before {
+    border-bottom-color: var(--text);
+}
+
+th[data-sort="desc"] .sort-indicator::after {
+    border-top-color: var(--text);
+}
+
+/* Resize Handle */
+.resize-handle {
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 4px;
+    cursor: col-resize;
+    background: transparent;
+}
+
+.resize-handle:hover {
+    background: var(--primary);
+}
+
+/* Table Body */
+.files-table tbody tr {
+    transition: background-color 0.1s;
+}
+
+.files-table tbody tr.group-last {
+    border-bottom: 1px solid var(--border);
+}
+
+.files-table tbody tr:hover {
+    background: var(--bg-hover);
+}
+
+.files-table td {
+    padding: 0.25rem 1rem;
+    vertical-align: top;
+}
+
+/* Tracking Number Column */
+td[data-field="trackingNumber"],
+th[data-sort="trackingNumber"] {
+    white-space: nowrap;
+}
+
+td[data-field="trackingNumber"] {
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.9em;
+}
+
+/* Revisions Column */
+.revision-group {
+    margin-bottom: 0.5rem;
+}
+
+.revision-group:last-child {
+    margin-bottom: 0;
+}
+
+.revision-item {
+    display: flex;
+    align-items: center;
+    margin-bottom: 0.25rem;
+}
+
+.revision-item:last-child {
+    margin-bottom: 0;
+}
+
+.revision-info {
+    display: inline-flex;
+    align-items: center;
+    margin-right: 0.5rem;
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.9em;
+}
+
+.revision-id {
+    font-weight: 600;
+    margin-right: 0.25rem;
+}
+
+.revision-status {
+    color: var(--text-muted);
+    font-size: 0.85em;
+}
+
+.revision-file {
+    display: inline-flex;
+    align-items: center;
+    margin-left: 0.25rem;
+}
+
+.file-link,
+.file-link-disabled {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: flex-start;
+    margin-right: 0.25rem;
+    line-height: 1.1;
+}
+
+.file-link {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+.file-link:hover {
+    text-decoration: underline;
+}
+
+
+.file-ext {
+    color: var(--text-muted);
+    font-size: 0.85em;
+    text-transform: uppercase;
+}
+
+/* Empty Table State */
+.empty-table {
+    text-align: center;
+    padding: 3rem;
+    color: var(--text-muted);
+}
+
+/* Column Widths */
+.files-table th:nth-child(1),
+.files-table td:nth-child(1) {
+    width: 240px;
+    min-width: 220px;
+}
+
+.files-table th:nth-child(2),
+.files-table td:nth-child(2) {
+    width: 40%;
+    min-width: 200px;
+}
+
+.files-table th:nth-child(3),
+.files-table td:nth-child(3) {
+    width: auto;
+    min-width: 300px;
+}
+
+/* File size — half the height of the extension badge, left-aligned below it */
+.file-size {
+    color: var(--text-muted);
+    font-size: 0.5em;
+    line-height: 1;
+    margin-top: 0.15em;
+}
+
+/* Active column filter highlight */
+.column-filter.filter-active {
+    background: rgba(234, 179, 8, 0.18);
+    border-color: rgba(234, 179, 8, 0.7);
+}
+
+/* Print styles */
+
+@media print {
+    /* Hide UI elements */
+    .app-header,
+    .nav-pane,
+    .content-header,
+    .status-bar,
+    .modal,
+    .btn,
+    .filter-input,
+    .global-search,
+    .column-filter,
+    input[type="checkbox"],
+    .resize-handle,
+    .sort-indicator {
+        display: none !important;
+    }
+
+    /* Reset layout */
+    body {
+        font-size: 10pt;
+        line-height: 1.4;
+    }
+
+    #appContainer {
+        height: auto;
+    }
+
+    .main-container {
+        display: block;
+    }
+
+    .content-area {
+        background: white;
+    }
+
+    .table-container {
+        margin: 0;
+        border: none;
+        overflow: visible;
+    }
+
+    /* Table adjustments */
+    .files-table {
+        font-size: 9pt;
+        border: 1px solid #000;
+    }
+
+    .files-table thead {
+        position: static;
+    }
+
+    .files-table th {
+        background: #f0f0f0;
+        border: 1px solid #000;
+        padding: 4pt 6pt;
+        font-weight: bold;
+    }
+
+    .files-table td {
+        border: 1px solid #000;
+        padding: 3pt 6pt;
+    }
+
+    .files-table tbody tr:hover {
+        background: transparent;
+    }
+
+    /* Show only text content for revisions */
+    .revision-item {
+        display: inline;
+        margin-right: 0.5em;
+    }
+
+    .file-link {
+        color: black;
+        text-decoration: none;
+    }
+
+    .file-link::after {
+        content: " (" attr(href) ")";
+        font-size: 8pt;
+        color: #666;
+    }
+
+    /* Page breaks */
+    .files-table {
+        page-break-inside: auto;
+    }
+
+    .files-table tr {
+        page-break-inside: avoid;
+        page-break-after: auto;
+    }
+
+    /* Header on each page */
+    @page {
+        size: letter portrait;
+        margin: 0.5in;
+    }
+
+    /* Add document title */
+    body::before {
+        content: "Archive Browser Report";
+        display: block;
+        font-size: 16pt;
+        font-weight: bold;
+        margin-bottom: 12pt;
+    }
+
+    /* Add timestamp */
+    body::after {
+        content: "Generated: " attr(data-print-date);
+        display: block;
+        margin-top: 12pt;
+        font-size: 9pt;
+        color: #666;
+        text-align: right;
+    }
+}
+
+    </style>
+</head>
+<body>
+    <div id="appContainer">
+        <!-- Project access warning banner (shown when URL contains inaccessible projects) -->
+        <div id="projectWarningBanner" class="project-warning-banner hidden" role="alert">
+            <span class="project-warning-text"></span>
+            <button class="project-warning-dismiss" onclick="dismissProjectWarning()" aria-label="Dismiss">×</button>
+        </div>
+
+        <!-- Header -->
+        <header class="app-header">
+            <div class="header-left">
+                <div class="header-title-group">
+                    <span class="app-header__title">ZDDC Archive</span>
+                    <span class="build-timestamp">v0.0.1</span>
+                </div>
+                <button id="addDirectoryBtn" class="btn btn-primary">Add Local Directory</button>
+                <button id="refreshHeaderBtn" class="btn btn-secondary hidden" title="Refresh Data" style="font-size:1.1rem;">⟳</button>
+            </div>
+            <div class="header-right">
+                <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+                <button id="help-btn" class="btn btn-secondary" title="Help">?</button>
+            </div>
+        </header>
+
+        <!-- Main Container -->
+        <div class="main-container">
+            <!-- Navigation Pane -->
+            <nav id="navigationPane" class="nav-pane">
+                <!-- Grouping Folders Section -->
+                <div class="nav-section" id="groupingSection">
+                    <div class="nav-section-header">
+                        <h3>Parties</h3>
+                        <div class="preset-section" id="presetSection">
+                            <button id="presetBtn" class="btn btn-secondary btn-sm" title="Party presets">▾ Presets</button>
+                            <div id="presetDropdown" class="preset-dropdown hidden"></div>
+                        </div>
+                        <button id="toggleGroupingBtn" class="btn-icon" title="Collapse/Expand">
+                            <span id="toggleGroupingIcon">▼</span>
+                        </button>
+                    </div>
+                    <div id="groupingContent" class="nav-section-content">
+                        <!-- Global folder type toggle bar -->
+                        <div id="folderTypeBar" class="folder-type-bar">
+                            <!-- Dynamically populated by renderFolderTypeBar() -->
+                        </div>
+                        <div class="filter-select-row">
+                            <input type="text" 
+                                   id="groupingFilter" 
+                                   class="filter-input" 
+                                   placeholder="Filter parties...">
+                            <label class="select-all-label select-all-inline" title="Auto-select all visible parties">
+                                <span>Select<br>All</span>
+                                <input type="checkbox" id="selectAllGroupingCheckbox" checked>
+                            </label>
+                        </div>
+                        <div id="groupingFoldersList" class="folder-list">
+                            <!-- Dynamically populated -->
+                        </div>
+                    </div>
+                    <div class="resize-handle-vertical" data-resize="nav-sections"></div>
+                </div>
+
+                <!-- Transmittal Folders Section -->
+                <div class="nav-section" id="transmittalSection">
+                    <div class="nav-section-header">
+                        <h3>Transmittal Folders</h3>
+                        <button id="toggleAllDatesBtn" class="btn-icon" title="Expand/Collapse All">
+                            <span id="toggleAllDatesIcon">▼</span>
+                        </button>
+                    </div>
+                    <div class="filter-select-row">
+                        <input type="text" 
+                               id="transmittalFilter" 
+                               class="filter-input" 
+                               placeholder="Filter transmittal folders...">
+                        <label class="select-all-label select-all-inline" title="Auto-select all visible transmittals">
+                            <span>Select<br>All</span>
+                            <input type="checkbox" id="selectAllTransmittalsCheckbox" checked>
+                        </label>
+                    </div>
+                    <div id="transmittalFoldersList" class="folder-list">
+                        <!-- Dynamically populated -->
+                    </div>
+                </div>
+                <div class="resize-handle-horizontal" data-resize="nav-pane"></div>
+            </nav>
+
+            <!-- Content Area -->
+            <main class="content-area">
+                <!-- Content Header -->
+                <div class="content-header">
+                    <!-- Reset Filters -->
+                    <button id="resetFiltersBtn" class="btn btn-secondary btn-icon-only" title="Reset all column filters">↺</button>
+
+                    <!-- Preview toggle -->
+                    <label class="preview-toggle-label" title="Preview PDF, Word, and Excel files in a popup window instead of downloading">
+                        <input type="checkbox" id="filePreviewToggle">
+                        <span>Preview</span>
+                    </label>
+
+                    <!-- Modifier Filter Dropdown -->
+                    <div class="modifier-filter-container">
+                        <button id="modifierFilterBtn" class="btn btn-secondary modifier-filter-btn">
+                            Modifiers ▼
+                        </button>
+                        <div id="modifierFilterDropdown" class="modifier-filter-dropdown hidden">
+                            <div class="modifier-filter-header">
+                                <label><input type="checkbox" id="modifierSelectAll" checked> Select All</label>
+                            </div>
+                            <div id="modifierFilterList" class="modifier-filter-list">
+                                <!-- Dynamically populated -->
+                            </div>
+                        </div>
+                    </div>
+
+                    <div class="toolbar-separator"></div>
+
+                    <div class="content-actions">
+                        <button id="filterSelectedBtn" class="btn btn-secondary">Filter Selected</button>
+                        <button id="downloadSelectedBtn" class="btn btn-secondary">Download (ZIP)</button>
+                        <button id="exportCsvBtn" class="btn btn-secondary">Export (CSV)</button>
+                    </div>
+                </div>
+
+                <!-- Files Table -->
+                <div class="table-container">
+                    <table id="filesTable" class="files-table">
+                        <thead>
+                            <tr>
+                                <th class="sortable resizable" data-field="trackingNumber">
+                                    <div class="th-content">
+                                        <span>Tracking Number</span>
+                                        <span class="sort-indicator"></span>
+                                    </div>
+<input type="text" 
+       class="column-filter" 
+       data-filter-field="trackingNumber"
+       placeholder="Filter...">
+                                    <div class="resize-handle"></div>
+                                </th>
+                                <th class="sortable resizable" data-field="title">
+                                    <div class="th-content">
+                                        <span>Title</span>
+                                        <span class="sort-indicator"></span>
+                                    </div>
+<input type="text" 
+       class="column-filter" 
+       data-filter-field="title"
+       placeholder="Filter...">
+                                    <div class="resize-handle"></div>
+                                </th>
+                                <th class="resizable" data-field="revisions">
+                                    <div class="th-content" style="justify-content: flex-start;">
+                                        <input type="checkbox" 
+                                               id="selectAllVisibleCheckbox" 
+                                               title="Select/deselect all visible files"
+                                               style="margin-right: 0.5rem;">
+                                        <span>Revisions</span>
+                                    </div>
+<input type="text" 
+       class="column-filter" 
+       data-filter-field="revisions"
+       placeholder="Filter...">
+                                    <div class="resize-handle"></div>
+                                </th>
+                            </tr>
+                        </thead>
+                        <tbody id="filesTableBody">
+                            <!-- Dynamically populated -->
+                        </tbody>
+                    </table>
+                </div>
+
+                <!-- Status Bar -->
+                <div class="status-bar">
+                    <span id="fileCount">0 files</span>
+                    <span id="selectedCount">0 selected</span>
+                    <span id="scanStatus"></span><span id="scanSpinner" class="scan-spinner hidden"></span>
+                </div>
+            </main>
+        </div>
+
+        <!-- Drop Modal -->
+        <div id="dropModal" class="modal hidden">
+            <div class="modal-backdrop"></div>
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h2>Create Transmittal</h2>
+                    <button class="modal-close">&times;</button>
+                </div>
+                <div class="modal-body">
+                    <div class="form-group">
+                        <label>Transmittal Folder Name:</label>
+                        <input type="text" id="transmittalName" class="form-input">
+                        <small class="form-help">Format: YYYY-MM-DD_TRACKINGNUMBER (STATUS) - TITLE</small>
+                    </div>
+                    <div class="files-preview">
+                        <h3>Files to Add:</h3>
+                        <table class="preview-table">
+                            <thead>
+                                <tr>
+                                    <th>Original Name</th>
+                                    <th>New Name</th>
+                                    <th>Status</th>
+                                </tr>
+                            </thead>
+                            <tbody id="filesPreviewBody">
+                                <!-- Dynamically populated -->
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button class="btn btn-secondary modal-cancel">Cancel</button>
+                    <button class="btn btn-primary modal-confirm">Create Transmittal</button>
+                </div>
+            </div>
+        </div>
+
+        <!-- No Directory Selected Message -->
+        <div id="noDirectoryMessage" class="empty-state">
+            <div class="empty-state-content">
+                <h2>Welcome to ZDDC Archive</h2>
+                <p>Click <strong>Add Local Directory</strong> to select an archive folder to browse.</p>
+                <p>This browser provides a convenient interface for searching and retrieving files from ZDDC-compliant archives.</p>
+                <p><strong>How to navigate:</strong></p>
+                <ul class="welcome-list">
+                    <li>Select a party to see their transmittal folders; toggle folder types (Issued, Received, MDL, Incoming) above the list</li>
+                    <li>Select transmittal folders to see their files</li>
+                    <li>Use <kbd>Ctrl+Click</kbd> to select multiple folders</li>
+                    <li>Use <kbd>Shift+Click</kbd> to select a range</li>
+                    <li><kbd>Ctrl+Click</kbd> chevrons to recursively expand/collapse</li>
+                </ul>
+                
+                <details class="windows-tip">
+                    <summary><strong>⚠️ Windows Path Length Deficiency</strong></summary>
+                    <div class="windows-tip__body">
+                        <p>Microsoft Windows has a legacy 260-character path limit that affects most applications. If you see "files skipped" warnings, use Microsoft's own workaround:</p>
+                        <ol>
+                            <li>Open Command Prompt as Administrator</li>
+                            <li>Map your archive to a short drive letter:<br>
+                                <code class="windows-tip__code">subst Z: "C:\Your\Long\Path\To\Archive"</code>
+                            </li>
+                            <li>Use the <strong>Z:</strong> drive in Archive Browser</li>
+                            <li>To remove later: <code>subst Z: /d</code></li>
+                        </ol>
+                        <p class="windows-tip__note">This limitation dates back to Windows 95. The mapping persists until reboot.</p>
+                    </div>
+                </details>
+                
+                <p class="note">Note: This application works entirely in your browser and does not transmit any data.</p>
+            </div>
+        </div>
+
+
+        <!-- Help Panel -->
+        <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+            <div class="help-panel__header">
+                <h2 id="help-panel-title" class="help-panel__title">Help — ZDDC Archive</h2>
+                <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+            </div>
+            <div class="help-panel__body">
+                <h3>What is the Archive Browser?</h3>
+                <p>The Archive Browser lets you search and retrieve files from a ZDDC-compliant archive stored on your local file system. Everything runs in your browser — no data is transmitted anywhere.</p>
+
+                <h3>Getting Started</h3>
+                <ol>
+                    <li>When opened from a web server, the archive loads automatically from that server.</li>
+                    <li>Click <strong>Add Local Directory</strong> to open a local archive folder — works in both offline and online modes, and local files are merged with any server files already loaded.</li>
+                    <li>The browser scans for grouping folders and transmittal folders automatically.</li>
+                    <li>Select folders in the left panel to see their files in the main table.</li>
+                </ol>
+
+                <h3>Navigating Folders</h3>
+                <p>The left panel has two sections:</p>
+                <dl>
+                    <dt>Parties</dt>
+                    <dd>Top-level folders representing other parties. Select one or more to filter which transmittals are shown. Use the folder type buttons above the list to show or hide Issued, Received, MDL, and Incoming folder content.</dd>
+                    <dt>Transmittal Folders</dt>
+                    <dd>Grouped by date. Select one or more to filter which files appear in the table.</dd>
+                </dl>
+                <p><strong>Multi-select:</strong> Hold <kbd>Ctrl</kbd> and click to toggle individual folders. Hold <kbd>Shift</kbd> and click to select a range. <kbd>Ctrl+Click</kbd> a chevron (&#9654;) to recursively expand or collapse all sub-folders.</p>
+
+                <h3>Searching and Filtering</h3>
+                <dl>
+                    <dt>Column Filters</dt>
+                    <dd>Type in the filter row under each column header to filter by tracking number, title, or revision/status/extension. Filters support the expression syntax below. Active filters are highlighted in blue; use the ↺ reset button in the toolbar to clear all filters at once.</dd>
+                </dl>
+                <dl>
+                    <dt><code>term</code></dt>
+                    <dd>Contains "term" (case-insensitive)</dd>
+                    <dt><code>!term</code></dt>
+                    <dd>Does not contain "term"</dd>
+                    <dt><code>^term</code></dt>
+                    <dd>Starts with "term"</dd>
+                    <dt><code>term$</code></dt>
+                    <dd>Ends with "term"</dd>
+                    <dt><code>a b</code></dt>
+                    <dd>Matches both (AND)</dd>
+                    <dt><code>a | b</code></dt>
+                    <dd>Matches either (OR)</dd>
+                    <dt><code>^IFA | ^IFB</code></dt>
+                    <dd>Starts with IFA or IFB</dd>
+                    <dt><code>pdf !draft</code></dt>
+                    <dd>Contains "pdf" and not "draft"</dd>
+                    <dt><code>!^~</code></dt>
+                    <dd>Does not start with ~ (excludes drafts)</dd>
+                    <dt><code>el.*spc</code></dt>
+                    <dd>Regex: contains "el" followed by "spc" (use <code>.</code> for any char, <code>.*</code> for any sequence)</dd>
+                    <dt><code>[ei]fa</code></dt>
+                    <dd>Regex character class: matches "efa" or "ifa"</dd>
+                </dl>
+                <dl>
+                    <dt>Modifiers</dt>
+                    <dd>Use the Modifiers dropdown to show or hide files by revision modifier type (+B, +C, +N, +Q, or base).</dd>
+                </dl>
+
+                <h3>Downloading Files</h3>
+                <dl>
+                    <dt>Download Selected (ZIP)</dt>
+                    <dd>Packages all checked files into a ZIP archive for download.</dd>
+                    <dt>Export Selected (CSV)</dt>
+                    <dd>Exports the visible file list as a CSV spreadsheet.</dd>
+                    <dt>File Preview</dt>
+                    <dd>When enabled, clicking a PDF, Word, or Excel file opens a preview popup instead of downloading it.</dd>
+                </dl>
+
+                <h3>Keyboard Shortcuts</h3>
+                <dl>
+                    <dt><kbd>Ctrl+A</kbd></dt>
+                    <dd>Select / deselect all visible files in the table.</dd>
+                    <dt><kbd>F5</kbd></dt>
+                    <dd>Refresh — rescan the current directory.</dd>
+                    <dt><kbd>Escape</kbd></dt>
+                    <dd>Close this help panel (or any open modal).</dd>
+                </dl>
+
+                <h3>Windows Path Length Note</h3>
+                <p>Windows limits file paths to 260 characters by default. If files are skipped during scanning, map your archive to a short drive letter using <code>subst Z: "C:\Your\Long\Path"</code> in an Administrator Command Prompt, then open the <strong>Z:</strong> drive in the Archive Browser.</p>
+            </div>
+        </aside>
+
+    </div>
+
+    <script>
+/**
+ * ZDDC — shared naming convention library
+ *
+ * Canonical implementation of all ZDDC filename, folder name, tracking number,
+ * revision, and status logic.  Included in every tool's build via shared/zddc.js.
+ *
+ * Exposed as window.zddc (plain global) so it works with every tool's module
+ * pattern (archive globals, classifier IIFE, transmittal IIFE, mdedit globals).
+ *
+ * Public API
+ * ----------
+ *   zddc.parseFilename(str)        → ParsedFile | null
+ *   zddc.parseFolder(str)          → ParsedFolder | null
+ *   zddc.parseRevision(str)        → ParsedRevision
+ *   zddc.formatFilename(parts)     → string
+ *   zddc.formatFolder(parts)       → string
+ *   zddc.compareRevisions(a, b)    → number  (-1 | 0 | 1)
+ *   zddc.isValidStatus(str)        → boolean
+ *   zddc.STATUSES                  → string[]
+ *
+ * ParsedFile   { trackingNumber, revision, status, title, extension }
+ * ParsedFolder { date, trackingNumber, status, title }
+ * ParsedRevision { base, modifier, modifierType, modifierNumber, isDraft, full }
+ */
+
+(function (root) {
+    'use strict';
+
+    // ── Valid status codes ───────────────────────────────────────────────────
+
+    /**
+     * Complete list of valid ZDDC document status codes.
+     * '---' denotes an unknown or not-yet-assigned status.
+     */
+    var STATUSES = [
+        '---',
+        'IFA', 'IFB', 'IFC', 'IFD', 'IFI', 'IFP', 'IFR', 'IFU',
+        'REC',
+        'RSA', 'RSB', 'RSC', 'RSD', 'RSI',
+    ];
+
+    var STATUS_SET = {};
+    for (var _i = 0; _i < STATUSES.length; _i++) {
+        STATUS_SET[STATUSES[_i]] = true;
+    }
+
+    function isValidStatus(str) {
+        return !!STATUS_SET[str];
+    }
+
+    // ── Filename parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Canonical file regex.
+     * Matches: TRACKING_REVISION (STATUS) - TITLE.EXT
+     *
+     * Tracking number: no underscores, no whitespace.
+     * Revision:        no whitespace, no parentheses.
+     * Status:          anything inside parentheses (validated separately).
+     * Title:           everything up to the last dot.
+     * Extension:       after the last dot (lowercased by parseFilename).
+     */
+    var FILE_RE = /^([^_\s]+)_([^\s()_]+)\s*\(([^)]+)\)\s*-\s*(\S.*\S|\S)\.\s*([^\s.]+)$/;
+
+    /**
+     * Parse a ZDDC filename.
+     *
+     * @param {string} filename
+     * @returns {{ trackingNumber: string, revision: string, status: string,
+     *             title: string, extension: string, valid: boolean } | null}
+     *   null only if filename is falsy.
+     *   `valid` is true when all fields matched the ZDDC pattern.
+     */
+    function parseFilename(filename) {
+        if (!filename) { return null; }
+
+        var match = filename.match(FILE_RE);
+
+        if (!match) {
+            var lastDot = filename.lastIndexOf('.');
+            return {
+                trackingNumber: '',
+                revision:       '',
+                status:         '',
+                title:          lastDot > 0 ? filename.substring(0, lastDot) : filename,
+                extension:      lastDot > 0 ? filename.substring(lastDot + 1).toLowerCase() : '',
+                valid:          false,
+            };
+        }
+
+        return {
+            trackingNumber: match[1].trim(),
+            revision:       match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            extension:      match[5].toLowerCase(),
+            valid:          true,
+        };
+    }
+
+    // ── Folder name parsing ──────────────────────────────────────────────────
+
+    /**
+     * Transmittal folder regex.
+     * Matches: YYYY-MM-DD_TRACKING (STATUS) - TITLE
+     */
+    var FOLDER_RE = /^(\d{4}-\d{2}-\d{2})_([^_\s(]+)\s*\(([^)]+)\)\s*-\s*(.+)$/;
+
+    /**
+     * Parse a ZDDC transmittal folder name.
+     *
+     * @param {string} foldername
+     * @returns {{ date: string, trackingNumber: string, status: string,
+     *             title: string, valid: boolean } | null}
+     *   null only if foldername is falsy.
+     */
+    function parseFolder(foldername) {
+        if (!foldername) { return null; }
+
+        var match = foldername.match(FOLDER_RE);
+
+        if (!match) {
+            return {
+                date:            '',
+                trackingNumber:  '',
+                status:          '',
+                title:           foldername,
+                valid:           false,
+            };
+        }
+
+        return {
+            date:           match[1],
+            trackingNumber: match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            valid:          true,
+        };
+    }
+
+    // ── Revision parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Modifier sub-regex: +LETTER DIGITS  e.g. +C1, +B2, +N1, +Q1
+     * The draft prefix (~) may appear inside the modifier: A+~C1
+     */
+    var MODIFIER_RE = /^\+(~?)([A-Za-z])(\d+)$/;
+
+    /**
+     * Parse a ZDDC revision string.
+     *
+     * Revision grammar:
+     *   revision     = ['~'] base ['+' ['~'] modifier_letter modifier_number]
+     *   base         = letter(s) | digit(s) | date(YYYY-MM-DD)
+     *   modifier     = letter + digits   e.g. C1, B2, N1, Q1
+     *
+     * @param {string} revision
+     * @returns {{
+     *   base: string,
+     *   modifier: string,       full modifier string e.g. '+C1', '' if none
+     *   modifierType: string,   modifier letter e.g. 'C', '' if none
+     *   modifierNumber: number, modifier number e.g. 1, 0 if none
+     *   modifierIsDraft: boolean,
+     *   isDraft: boolean,       true if base revision starts with ~
+     *   full: string,           original input
+     * }}
+     */
+    function parseRevision(revision) {
+        var raw = (revision || '').toString();
+
+        // Split on '+' to separate base from optional modifier
+        var plusIdx = raw.indexOf('+');
+        var basePart     = plusIdx === -1 ? raw : raw.substring(0, plusIdx);
+        var modifierPart = plusIdx === -1 ? ''  : raw.substring(plusIdx);
+
+        // Draft flag on the base part
+        var isDraft = basePart.startsWith('~');
+        var base    = isDraft ? basePart.substring(1) : basePart;
+
+        // Parse modifier
+        var modifier        = '';
+        var modifierType    = '';
+        var modifierNumber  = 0;
+        var modifierIsDraft = false;
+
+        if (modifierPart) {
+            var mMatch = modifierPart.match(MODIFIER_RE);
+            if (mMatch) {
+                modifierIsDraft = mMatch[1] === '~';
+                modifierType    = mMatch[2].toUpperCase();
+                modifierNumber  = parseInt(mMatch[3], 10);
+                modifier        = modifierPart;
+            } else {
+                // Unrecognised modifier — preserve as-is
+                modifier = modifierPart;
+            }
+        }
+
+        return {
+            base:           base,
+            modifier:       modifier,
+            modifierType:   modifierType,
+            modifierNumber: modifierNumber,
+            modifierIsDraft: modifierIsDraft,
+            isDraft:        isDraft,
+            full:           raw,
+        };
+    }
+
+    // ── Revision comparison ──────────────────────────────────────────────────
+
+    /**
+     * Classify a base revision string into a sort tier:
+     *   0 = date (YYYY-MM-DD)
+     *   1 = letter(s)   A, B, AA …
+     *   2 = number(s)   0, 1, 2, 1.5 …
+     *   3 = other
+     */
+    function _baseTier(base) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(base)) { return 0; }
+        if (/^[A-Za-z]+$/.test(base))          { return 1; }
+        if (/^\d+(\.\d+)?$/.test(base))         { return 2; }
+        return 3;
+    }
+
+    /**
+     * Compare two base revision strings.
+     * Sort order: dates < letters < numbers < other.
+     */
+    function _compareBase(a, b) {
+        var ta = _baseTier(a);
+        var tb = _baseTier(b);
+        if (ta !== tb) { return ta - tb; }
+
+        if (ta === 0) { return a < b ? -1 : a > b ? 1 : 0; }       // date lexicographic = chronological
+        if (ta === 1) { return a.toUpperCase() < b.toUpperCase() ? -1 : a.toUpperCase() > b.toUpperCase() ? 1 : 0; }
+        if (ta === 2) { return parseFloat(a) - parseFloat(b); }
+        return a.localeCompare(b);
+    }
+
+    /**
+     * Compare two ZDDC revision strings for sort ordering.
+     *
+     * Canonical order (ascending = older → newer):
+     *   ~A  <  A  <  A+B1  <  A+C1  <  A+~C2  <  A+C2  <  A+N1  <  A+Q1
+     *   <  ~B  <  B  < … < 0 < 1 < 2
+     *
+     * Rules:
+     *   1. Compare base revisions first (dates < letters < numbers).
+     *   2. For equal bases, draft (isDraft=true) comes before final.
+     *   3. For equal base+draft, no-modifier < has-modifier.
+     *   4. For equal base+draft+modifier presence:
+     *      a. modifier draft comes before modifier final (modifierIsDraft).
+     *      b. Sort modifier by type letter then by number.
+     *
+     * @param {string} a
+     * @param {string} b
+     * @returns {number}  negative if a < b, 0 if equal, positive if a > b
+     */
+    function compareRevisions(a, b) {
+        var pa = parseRevision(a);
+        var pb = parseRevision(b);
+
+        // 1. Base revision
+        var baseCmp = _compareBase(pa.base, pb.base);
+        if (baseCmp !== 0) { return baseCmp; }
+
+        // 2. Draft before final (for same base)
+        if (pa.isDraft !== pb.isDraft) { return pa.isDraft ? -1 : 1; }
+
+        // 3. No modifier before any modifier
+        var aHasMod = pa.modifier !== '';
+        var bHasMod = pb.modifier !== '';
+        if (aHasMod !== bHasMod) { return aHasMod ? 1 : -1; }
+
+        if (!aHasMod) { return 0; } // both have no modifier
+
+        // 4. Compare modifiers: type → number → draft (draft is a tie-breaker only)
+        // 4a. Modifier type letter (B < C < N < Q …)
+        if (pa.modifierType !== pb.modifierType) {
+            return pa.modifierType < pb.modifierType ? -1 : 1;
+        }
+
+        // 4b. Modifier number (1 < 2 …)
+        if (pa.modifierNumber !== pb.modifierNumber) {
+            return pa.modifierNumber - pb.modifierNumber;
+        }
+
+        // 4c. Draft of a modifier comes before the final modifier (same type+number)
+        if (pa.modifierIsDraft !== pb.modifierIsDraft) {
+            return pa.modifierIsDraft ? -1 : 1;
+        }
+
+        return 0;
+    }
+
+    // ── Filename / folder formatting ─────────────────────────────────────────
+
+    /**
+     * Build a ZDDC filename from its components.
+     *
+     * @param {{ trackingNumber: string, revision: string, status: string,
+     *           title: string, extension: string }} parts
+     * @returns {string}  e.g. "123456-EL-SPC-2623_A (IFR) - Specification.pdf"
+     */
+    function formatFilename(parts) {
+        var tn  = (parts.trackingNumber || '').trim();
+        var rev = (parts.revision       || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+        var ext = (parts.extension      || '').replace(/^\./, '');
+
+        if (!tn || !rev || !st || !ttl) { return ''; }
+
+        var name = tn + '_' + rev + ' (' + st + ') - ' + ttl;
+        return ext ? name + '.' + ext : name;
+    }
+
+    /**
+     * Build a ZDDC transmittal folder name from its components.
+     *
+     * @param {{ date: string, trackingNumber: string, status: string,
+     *           title: string }} parts
+     * @returns {string}  e.g. "2025-10-31_123456-EM-SUB-0001 (IFR) - Title"
+     */
+    function formatFolder(parts) {
+        var dt  = (parts.date           || '').trim();
+        var tn  = (parts.trackingNumber || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+
+        if (!dt || !tn || !st || !ttl) { return ''; }
+
+        return dt + '_' + tn + ' (' + st + ') - ' + ttl;
+    }
+
+    // ── Filename / extension splitting ───────────────────────────────────────
+
+    /**
+     * Split a filename into its base name and extension (no leading dot).
+     * Treats leading dot ('.gitignore') as no extension.
+     *
+     * @param {string} filename
+     * @returns {{ name: string, extension: string }}
+     */
+    function splitExtension(filename) {
+        if (!filename) { return { name: '', extension: '' }; }
+        var lastDot = filename.lastIndexOf('.');
+        if (lastDot <= 0) { return { name: filename, extension: '' }; }
+        return {
+            name:      filename.substring(0, lastDot),
+            extension: filename.substring(lastDot + 1).toLowerCase(),
+        };
+    }
+
+    /**
+     * Join a base name and extension. Tolerant of either form ('pdf' or '.pdf').
+     * Returns just the name when extension is empty.
+     */
+    function joinExtension(name, extension) {
+        var ext = (extension || '').replace(/^\./, '');
+        return ext ? name + '.' + ext : name;
+    }
+
+    // ── Public API ───────────────────────────────────────────────────────────
+
+    root.zddc = {
+        STATUSES:         STATUSES,
+        isValidStatus:    isValidStatus,
+        parseFilename:    parseFilename,
+        parseFolder:      parseFolder,
+        parseRevision:    parseRevision,
+        formatFilename:   formatFilename,
+        formatFolder:     formatFolder,
+        compareRevisions: compareRevisions,
+        splitExtension:   splitExtension,
+        joinExtension:    joinExtension,
+    };
+
+}(typeof window !== 'undefined' ? window : this));
+
+/**
+ * ZDDC — shared SHA-256 helpers
+ *
+ * Attaches to window.zddc.crypto. Must load AFTER shared/zddc.js (which creates
+ * the window.zddc object).
+ *
+ * Exports:
+ *   zddc.crypto.sha256Hex(buffer)       → Promise<string>  hex digest of ArrayBuffer/Uint8Array
+ *   zddc.crypto.sha256String(str)       → Promise<string>  hex digest of UTF-8 encoded string
+ *   zddc.crypto.sha256File(file, onProgress?) → Promise<string>
+ *       chunked streaming digest for File/Blob; for files >= 4 MB, streams 2 MB chunks
+ *       and invokes onProgress(loaded, total) every ~8 MB.
+ *   zddc.crypto.bytesToHex(buffer)      → string  (hex of ArrayBuffer/Uint8Array, no digest)
+ *
+ * Throws if Web Crypto SubtleCrypto is not available.
+ */
+(function (root) {
+    'use strict';
+
+    if (!root.zddc) {
+        throw new Error('shared/hash.js: window.zddc must be loaded first');
+    }
+
+    var HASH_CHUNK_SIZE = 2 * 1024 * 1024; // 2 MB
+
+    function requireSubtle() {
+        if (!root.crypto || !root.crypto.subtle || typeof root.crypto.subtle.digest !== 'function') {
+            throw new Error('Web Crypto SubtleCrypto is required');
+        }
+    }
+
+    function bytesToHex(buffer) {
+        return Array.from(new Uint8Array(buffer), function (byte) {
+            return byte.toString(16).padStart(2, '0');
+        }).join('');
+    }
+
+    async function sha256Hex(buffer) {
+        requireSubtle();
+        var input = (buffer instanceof Uint8Array) ? buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength) : buffer;
+        var hash = await root.crypto.subtle.digest('SHA-256', input);
+        return bytesToHex(hash);
+    }
+
+    async function sha256String(str) {
+        requireSubtle();
+        var bytes = new TextEncoder().encode(str);
+        var hash = await root.crypto.subtle.digest('SHA-256', bytes);
+        return bytesToHex(hash);
+    }
+
+    async function sha256File(file, onProgress) {
+        requireSubtle();
+        // Single-shot for small files or environments without ReadableStream
+        if (file.size < HASH_CHUNK_SIZE * 2 || typeof file.stream !== 'function') {
+            if (onProgress) { onProgress(file.size, file.size); }
+            var buf = await file.arrayBuffer();
+            var hash = await root.crypto.subtle.digest('SHA-256', buf);
+            return bytesToHex(hash);
+        }
+        // Chunked streaming for large files
+        var reader = file.stream().getReader();
+        var loaded = 0;
+        var chunks = [];
+        var yieldCounter = 0;
+        while (true) {
+            var result = await reader.read();
+            if (result.done) { break; }
+            chunks.push(result.value);
+            loaded += result.value.byteLength;
+            yieldCounter++;
+            if (onProgress && yieldCounter % 4 === 0) {
+                onProgress(loaded, file.size);
+                await new Promise(function (r) { setTimeout(r, 0); });
+            }
+        }
+        var total = new Uint8Array(loaded);
+        var offset = 0;
+        for (var i = 0; i < chunks.length; i++) {
+            total.set(chunks[i], offset);
+            offset += chunks[i].byteLength;
+        }
+        var digest = await root.crypto.subtle.digest('SHA-256', total.buffer);
+        if (onProgress) { onProgress(file.size, file.size); }
+        return bytesToHex(digest);
+    }
+
+    root.zddc.crypto = {
+        sha256Hex:    sha256Hex,
+        sha256String: sha256String,
+        sha256File:   sha256File,
+        bytesToHex:   bytesToHex,
+    };
+})(typeof window !== 'undefined' ? window : globalThis);
+
+/**
+ * ZDDC shared theme toggle — light / dark / auto.
+ * Persists choice to localStorage under 'zddc-theme'.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #theme-btn in the DOM (optional — skips gracefully if absent).
+ *
+ * Theme cycle: auto → light → dark → auto …
+ * 'auto' honours the OS prefers-color-scheme media query (CSS handles it).
+ * 'light' sets data-theme="light" on <html> (overrides dark media query).
+ * 'dark'  sets data-theme="dark"  on <html>.
+ */
+(function () {
+    'use strict';
+
+    var STORAGE_KEY = 'zddc-theme';
+    var THEMES = ['auto', 'light', 'dark'];
+
+    var LABELS = {
+        auto:  '◐',
+        light: '☀',
+        dark:  '☾'
+    };
+
+    var TITLES = {
+        auto:  'Theme: auto (follows OS)',
+        light: 'Theme: light',
+        dark:  'Theme: dark'
+    };
+
+    function load() {
+        var stored = localStorage.getItem(STORAGE_KEY);
+        return THEMES.indexOf(stored) !== -1 ? stored : 'auto';
+    }
+
+    function apply(theme) {
+        if (theme === 'dark') {
+            document.documentElement.setAttribute('data-theme', 'dark');
+        } else if (theme === 'light') {
+            document.documentElement.setAttribute('data-theme', 'light');
+        } else {
+            document.documentElement.removeAttribute('data-theme');
+        }
+    }
+
+    function save(theme) {
+        try { localStorage.setItem(STORAGE_KEY, theme); } catch (e) {}
+    }
+
+    function updateButton(btn, theme) {
+        btn.textContent = LABELS[theme];
+        btn.title = TITLES[theme];
+        btn.setAttribute('aria-label', TITLES[theme]);
+    }
+
+    function next(theme) {
+        return THEMES[(THEMES.indexOf(theme) + 1) % THEMES.length];
+    }
+
+    function init() {
+        var current = load();
+        apply(current);
+
+        var btn = document.getElementById('theme-btn');
+        if (!btn) { return; }
+
+        updateButton(btn, current);
+
+        btn.addEventListener('click', function () {
+            current = next(current);
+            apply(current);
+            save(current);
+            updateButton(btn, current);
+        });
+    }
+
+    /* Apply theme immediately (before DOM ready) to avoid flash */
+    apply(load());
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+/**
+ * ZDDC Archive - Initialization
+ * Sets up window.app and window.app.modules before other modules run.
+ * Must be the first JS file in the build.
+ */
+(function() {
+    'use strict';
+
+    window.app = {
+        sourceMode: null,
+        directories: [],
+        groupingFolders: [],
+        transmittalFolders: [],
+        files: [],
+        filteredFiles: [],
+        selectedFiles: new Set(),
+        isScanning: false,
+        scanProgress: '',
+
+        columnFilters: { trackingNumber: '', title: '', revisions: '' },
+        columnFilterASTs: { trackingNumber: null, title: null, revisions: null },
+        groupingFilter: '',
+        transmittalFilter: '',
+        enabledFolderTypes: new Set(['issued', 'received']),
+        sortField: 'trackingNumber',
+        sortDirection: 'asc',
+        selectedGroupingFolders: new Set(),
+        selectedTransmittalFolders: new Set(),
+        collapsedDateGroups: new Set(),
+        collapsedGroupingFolders: new Set(),
+        selectAllGroupingFolders: true,
+        selectAllTransmittals: true,
+        availableModifiers: new Set(),
+        selectedModifiers: new Set(),
+        showSelectedOnly: false,
+        projectFilter: new Set(),
+        FOLDER_TYPE_NAMES: ['issued', 'received', 'mdl', 'incoming'],
+        modules: {}
+    };
+
+})();
+
+// Archive grouping/sorting helpers — ZDDC parsing comes from window.zddc directly.
+(function() {
+    'use strict';
+
+    function isTransmittalFolder(name) {
+        var parsed = zddc.parseFolder(name);
+        return !!(parsed && parsed.valid);
+    }
+
+    function groupFilesByTrackingNumber(files) {
+        const groups = {};
+        files.forEach(file => {
+            if (!file.trackingNumber) return;
+            if (!groups[file.trackingNumber]) {
+                groups[file.trackingNumber] = { trackingNumber: file.trackingNumber, title: file.title, revisions: {} };
+            }
+            if (file.title.length > groups[file.trackingNumber].title.length) {
+                groups[file.trackingNumber].title = file.title;
+            }
+            const revKey = `${file.revision}_${file.status}`;
+            if (!groups[file.trackingNumber].revisions[revKey]) {
+                groups[file.trackingNumber].revisions[revKey] = {
+                    revision: file.revision, status: file.status, title: file.title,
+                    hasModifier: file.revision.includes('+'), files: []
+                };
+            }
+            if (file.title.length > groups[file.trackingNumber].revisions[revKey].title.length) {
+                groups[file.trackingNumber].revisions[revKey].title = file.title;
+            }
+            groups[file.trackingNumber].revisions[revKey].files.push(file);
+        });
+        return groups;
+    }
+
+    function sortGroupedFiles(groups) {
+        const field = window.app.sortField || 'trackingNumber';
+        const direction = window.app.sortDirection === 'desc' ? -1 : 1;
+        const sorted = Object.values(groups).sort((a, b) => {
+            let comparison = 0;
+            if (field === 'trackingNumber') comparison = a.trackingNumber.localeCompare(b.trackingNumber);
+            else if (field === 'title') comparison = a.title.localeCompare(b.title);
+            else if (field === 'revisions') {
+                const aRevs = Object.keys(a.revisions), bRevs = Object.keys(b.revisions);
+                comparison = zddc.compareRevisions(
+                    aRevs.length > 0 ? aRevs[aRevs.length - 1] : '',
+                    bRevs.length > 0 ? bRevs[bRevs.length - 1] : ''
+                );
+            }
+            return comparison * direction;
+        });
+        sorted.forEach(group => {
+            const revisions = Object.values(group.revisions);
+            revisions.sort((a, b) => zddc.compareRevisions(b.revision, a.revision));
+            group.sortedRevisions = revisions;
+        });
+        return sorted;
+    }
+
+    window.app.modules.parser = {
+        isTransmittalFolder,
+        groupFilesByTrackingNumber,
+        sortGroupedFiles,
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // Source abstraction — local (File System Access API) and HTTP (Caddy JSON browse)
+    //
+    // Shared utility used by both source implementations
+    function getDisplayPath(fullPath) {
+        if (fullPath.length <= 100) {
+            return fullPath;
+        }
+        const parts = fullPath.split('/');
+        if (parts.length > 3) {
+            return parts[0] + '/.../' + parts.slice(-2).join('/');
+        }
+        return '...' + fullPath.substring(fullPath.length - 80);
+    }
+
+    // createSource(type, options) returns a source object:
+    //   source.type       — 'local' | 'http'
+    //   source.canWrite   — boolean
+    //   source.scan(rootIdentifier, callbacks) — Promise; walks tree calling:
+    //       callbacks.onGroupingFolder(folder)     folder: { name, path, displayPath, handle? }
+    //       callbacks.onTransmittalFolder(folder)  folder: { name, path, displayPath, handle?, url? }
+    //       callbacks.onFile(file)                 file:   full file object (parsed + metadata)
+    //       callbacks.onProgress(message)
+    //   source.fetchFile(fileRef) — Promise<ArrayBuffer>
+
+    function createSource(type, options) {
+        if (type === 'local') {
+            return createLocalSource();
+        } else if (type === 'http') {
+            return createHttpSource(options.baseUrl);
+        }
+        throw new Error('Unknown source type: ' + type);
+    }
+
+    // ---------------------------------------------------------------------------
+    // Local source — wraps File System Access API
+    // ---------------------------------------------------------------------------
+
+    function createLocalSource() {
+        return {
+            type: 'local',
+            canWrite: true,
+
+            scan: function(dirHandle, callbacks) {
+                return scanLocalRecursive(dirHandle, dirHandle.name, 0, callbacks);
+            },
+
+            fetchFile: function(fileRef) {
+                return fileRef.handle.getFile().then(function(f) {
+                    return f.arrayBuffer();
+                });
+            }
+        };
+    }
+
+    async function scanLocalRecursive(dirHandle, currentPath, depth, callbacks) {
+        if (currentPath.length > 200) {
+            console.warn('Path too long, skipping deeper scan: ' + currentPath);
+            return;
+        }
+        if (depth > 10) {
+            console.warn('Directory depth limit reached at: ' + currentPath);
+            return;
+        }
+
+        callbacks.onProgress('Scanning ' + currentPath + '...');
+
+        const entries = [];
+        try {
+            for await (const entry of dirHandle.values()) {
+                entries.push(entry);
+            }
+        } catch (err) {
+            console.warn('Could not read directory ' + currentPath + ':', err);
+            return;
+        }
+
+        for (const entry of entries) {
+            if (entry.kind === 'directory') {
+                const subPath = currentPath + '/' + entry.name;
+                try {
+                    if (window.app.modules.parser.isTransmittalFolder(entry.name)) {
+                        const folder = {
+                            name: entry.name,
+                            path: subPath,
+                            displayPath: getDisplayPath(subPath),
+                            handle: entry
+                        };
+                        callbacks.onTransmittalFolder(folder);
+                        await scanLocalTransmittalFolder(entry, subPath, 0, subPath, callbacks);
+                    } else {
+                        const folder = {
+                            name: entry.name,
+                            path: subPath,
+                            displayPath: entry.name,
+                            handle: entry
+                        };
+                        callbacks.onGroupingFolder(folder);
+                        await scanLocalRecursive(entry, subPath, depth + 1, callbacks);
+                    }
+                } catch (err) {
+                    console.warn('Could not process directory ' + entry.name + ':', err);
+                }
+            } else if (entry.kind === 'file') {
+                // File directly in a grouping folder — assign to the Outstanding virtual transmittal.
+                // actualPath records the real containing folder for grouping-folder-scoped filtering.
+                try {
+                    const file = await entry.getFile();
+                    const parsed = zddc.parseFilename(file.name) || {};
+
+                    if (!parsed.trackingNumber) {
+                        console.warn('File does not match ZDDC naming convention: ' + file.name);
+                    }
+
+                    const fullPath = currentPath + '/' + file.name;
+                    const displayPath = fullPath.length > 250
+                        ? '...' + fullPath.substring(fullPath.length - 200)
+                        : fullPath;
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: file.name,
+                        path: fullPath,
+                        displayPath: displayPath,
+                        url: null,
+                        size: file.size,
+                        modified: file.lastModified,
+                        handle: entry,
+                        folderPath: '__outstanding__',
+                        actualPath: currentPath,
+                        hasPathError: false,
+                        ...parsed
+                    });
+                } catch (fileErr) {
+                    const fullPath = currentPath + '/' + entry.name;
+                    const displayPath = fullPath.length > 250
+                        ? '...' + fullPath.substring(fullPath.length - 200)
+                        : fullPath;
+                    const parsed = zddc.parseFilename(entry.name) || {};
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: entry.name,
+                        path: fullPath,
+                        displayPath: displayPath,
+                        url: null,
+                        size: null,
+                        modified: null,
+                        handle: null,
+                        folderPath: '__outstanding__',
+                        actualPath: currentPath,
+                        hasPathError: true,
+                        pathErrorMessage: fileErr.message || 'File access error',
+                        ...parsed
+                    });
+
+                    console.warn('Could not access file ' + entry.name + ' (path error):', fileErr.message);
+                }
+            }
+        }
+    }
+
+    async function scanLocalTransmittalFolder(dirHandle, folderPath, depth, transmittalPath, callbacks) {
+        if (depth > 10) {
+            console.warn('Directory depth limit reached in transmittal folder: ' + folderPath);
+            return;
+        }
+
+        try {
+            if (folderPath.length > 240) {
+                console.warn('Path approaching Windows limit (' + folderPath.length + ' chars): ' + folderPath);
+            }
+
+            for await (const entry of dirHandle.values()) {
+                if (entry.kind === 'file') {
+                    try {
+                        const file = await entry.getFile();
+                        const parsed = zddc.parseFilename(file.name) || {};
+
+                        if (!parsed.trackingNumber) {
+                            console.warn('File does not match ZDDC naming convention: ' + file.name);
+                        }
+
+                        const fullPath = folderPath + '/' + file.name;
+                        const displayPath = fullPath.length > 250
+                            ? '...' + fullPath.substring(fullPath.length - 200)
+                            : fullPath;
+
+                        callbacks.onFile({
+                            id: crypto.randomUUID(),
+                            name: file.name,
+                            path: fullPath,
+                            displayPath: displayPath,
+                            url: null,
+                            size: file.size,
+                            modified: file.lastModified,
+                            handle: entry,
+                            folderPath: transmittalPath,
+                            actualPath: folderPath,
+                            hasPathError: false,
+                            ...parsed
+                        });
+                    } catch (fileErr) {
+                        const fullPath = folderPath + '/' + entry.name;
+                        const displayPath = fullPath.length > 250
+                            ? '...' + fullPath.substring(fullPath.length - 200)
+                            : fullPath;
+                        const parsed = zddc.parseFilename(entry.name) || {};
+
+                        callbacks.onFile({
+                            id: crypto.randomUUID(),
+                            name: entry.name,
+                            path: fullPath,
+                            displayPath: displayPath,
+                            url: null,
+                            size: null,
+                            modified: null,
+                            handle: null,
+                            folderPath: transmittalPath,
+                            actualPath: folderPath,
+                            hasPathError: true,
+                            pathErrorMessage: fileErr.message || 'File access error',
+                            ...parsed
+                        });
+
+                        console.warn('Could not access file ' + entry.name + ' (path error):', fileErr.message);
+                    }
+                } else if (entry.kind === 'directory') {
+                    const subPath = folderPath + '/' + entry.name;
+                    try {
+                        await scanLocalTransmittalFolder(entry, subPath, depth + 1, transmittalPath, callbacks);
+                    } catch (err) {
+                        console.warn('Could not scan subdirectory ' + entry.name + ' in ' + folderPath + ':', err);
+                    }
+                }
+            }
+        } catch (err) {
+            console.error('Error scanning folder ' + folderPath + ':', err);
+        }
+    }
+
+    // ---------------------------------------------------------------------------
+    // HTTP source — uses Caddy JSON browse (Accept: application/json)
+    // ---------------------------------------------------------------------------
+
+    function createHttpSource(baseUrl) {
+        // Normalise: ensure baseUrl ends with /
+        const root = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
+
+        return {
+            type: 'http',
+            canWrite: false,
+
+            scan: function(rootUrl, callbacks) {
+                const scanRoot = (rootUrl && rootUrl !== root) ? rootUrl : root;
+                return scanHttpRecursive(scanRoot, root, 0, null, callbacks);
+            },
+
+            fetchFile: function(fileRef) {
+                return fetch(fileRef.url).then(function(r) {
+                    if (!r.ok) throw new Error('HTTP ' + r.status + ' fetching ' + fileRef.url);
+                    return r.arrayBuffer();
+                });
+            }
+        };
+    }
+
+    async function scanHttpRecursive(dirUrl, rootUrl, depth, transmittalPath, callbacks) {
+        if (depth > 10) {
+            console.warn('HTTP directory depth limit reached at: ' + dirUrl);
+            return;
+        }
+
+        let items;
+        try {
+            // Caddy returns JSON when the Accept header requests it
+            const resp = await fetch(dirUrl, {
+                headers: { 'Accept': 'application/json' }
+            });
+            if (!resp.ok) {
+                throw new Error('HTTP ' + resp.status + ' listing ' + dirUrl);
+            }
+            // Caddy encodes listing.Items directly — a bare JSON array of fileInfo objects
+            // fileInfo fields: name (dirs have trailing "/"), size, url, mod_time, mode, is_dir, is_symlink
+            items = await resp.json();
+            if (!Array.isArray(items)) {
+                throw new Error('Unexpected response format (expected JSON array)');
+            }
+        } catch (err) {
+            console.warn('Could not fetch directory listing for ' + dirUrl + ':', err);
+            return;
+        }
+
+        // Collect subdirectory scan promises so siblings run in parallel
+        const subdirPromises = [];
+
+        for (const item of items) {
+            // Caddy appends "/" to directory names; strip it to get the bare name for matching
+            const rawName = item.name.endsWith('/') ? item.name.slice(0, -1) : item.name;
+
+            // Skip hidden files
+            if (rawName.startsWith('.')) continue;
+
+            const isDir = item.is_dir === true;
+            // Project filter: at root depth, skip directories not in the allowed set
+            if (depth === 0 && isDir && window.app.projectFilter && window.app.projectFilter.size > 0) {
+                if (!window.app.projectFilter.has(rawName)) continue;
+            }
+
+            const itemUrl = resolveHttpUrl(dirUrl, rawName, isDir);
+            const logicalPath = urlToLogicalPath(itemUrl, rootUrl);
+
+            if (isDir) {
+                if (transmittalPath !== null) {
+                    // Inside a transmittal folder — recurse into subdirectories
+                    subdirPromises.push(
+                        scanHttpRecursive(itemUrl, rootUrl, depth + 1, transmittalPath, callbacks)
+                    );
+                } else if (window.app.modules.parser.isTransmittalFolder(rawName)) {
+                    const folder = {
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: getDisplayPath(logicalPath),
+                        handle: null,
+                        url: itemUrl
+                    };
+                    callbacks.onTransmittalFolder(folder);
+                    subdirPromises.push(
+                        scanHttpRecursive(itemUrl, rootUrl, depth + 1, logicalPath, callbacks)
+                    );
+                } else {
+                    const folder = {
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: rawName,
+                        handle: null,
+                        url: itemUrl
+                    };
+                    callbacks.onGroupingFolder(folder);
+                    subdirPromises.push(
+                        scanHttpRecursive(itemUrl, rootUrl, depth + 1, null, callbacks)
+                    );
+                }
+            } else {
+                // It's a file
+                if (transmittalPath === null) {
+                    // File directly in a grouping folder — assign to Outstanding virtual transmittal.
+                    // actualPath records the real containing folder for grouping-folder-scoped filtering.
+                    const dirLogicalPath = urlToLogicalPath(dirUrl, rootUrl);
+                    const parsed = zddc.parseFilename(rawName) || {};
+                    if (!parsed.trackingNumber) {
+                        console.warn('File does not match ZDDC naming convention: ' + rawName);
+                    }
+
+                    const modified = item.mod_time ? new Date(item.mod_time).getTime() : null;
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: logicalPath,
+                        url: itemUrl,
+                        size: item.size || null,
+                        modified: modified,
+                        handle: null,
+                        folderPath: '__outstanding__',
+                        actualPath: dirLogicalPath,
+                        hasPathError: false,
+                        ...parsed
+                    });
+                } else {
+                    // Inside a transmittal folder
+                    const parsed = zddc.parseFilename(rawName) || {};
+                    if (!parsed.trackingNumber) {
+                        console.warn('File does not match ZDDC naming convention: ' + rawName);
+                    }
+
+                    // mod_time is an ISO 8601 string from Go's time.Time.UTC()
+                    const modified = item.mod_time ? new Date(item.mod_time).getTime() : null;
+
+                    callbacks.onFile({
+                        id: crypto.randomUUID(),
+                        name: rawName,
+                        path: logicalPath,
+                        displayPath: logicalPath,
+                        url: itemUrl,
+                        size: item.size || null,
+                        modified: modified,
+                        handle: null,
+                        folderPath: transmittalPath,
+                        actualPath: logicalPath.substring(0, logicalPath.lastIndexOf('/')),
+                        hasPathError: false,
+                        ...parsed
+                    });
+                }
+            }
+        }
+
+        // Wait for all sibling subdirectory scans to complete in parallel
+        if (subdirPromises.length > 0) {
+            await Promise.all(subdirPromises);
+        }
+    }
+
+    // Build an absolute URL for an item inside a directory listing URL
+    function resolveHttpUrl(dirUrl, name, isDir) {
+        const base = dirUrl.endsWith('/') ? dirUrl : dirUrl + '/';
+        const encoded = encodeURIComponent(name);
+        return base + encoded + (isDir ? '/' : '');
+    }
+
+    // Convert an absolute item URL to a logical relative path (for display / filtering)
+    function urlToLogicalPath(itemUrl, rootUrl) {
+        const root = rootUrl.endsWith('/') ? rootUrl : rootUrl + '/';
+        let rel = itemUrl;
+        if (rel.startsWith(root)) {
+            rel = rel.substring(root.length);
+        }
+        // Decode percent-encoding for display
+        try { rel = decodeURIComponent(rel); } catch (e) { /* leave encoded */ }
+        // Strip trailing slash for directories
+        if (rel.endsWith('/')) rel = rel.slice(0, -1);
+        return rel;
+    }
+
+    window.app.modules.source = {
+        getDisplayPath,
+        createSource
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // SHA-256 hashing and cache management
+
+    const HASH_CACHE_FILENAME = '.hashes.json';
+
+    // Calculate SHA-256 hash for a file (delegates to shared/hash.js)
+    async function calculateFileHash(file) {
+        return zddc.crypto.sha256File(file);
+    }
+
+    // Load hash cache for a directory
+    async function loadHashCache(dirHandle) {
+        try {
+            const cacheHandle = await dirHandle.getFileHandle(HASH_CACHE_FILENAME);
+            const cacheFile = await cacheHandle.getFile();
+            const cacheText = await cacheFile.text();
+            return JSON.parse(cacheText);
+        } catch (err) {
+            // Cache doesn't exist or can't be read
+            return {};
+        }
+    }
+
+    // Save hash cache for a directory
+    async function saveHashCache(dirHandle, cache) {
+        try {
+            const cacheHandle = await dirHandle.getFileHandle(HASH_CACHE_FILENAME, { create: true });
+            const writable = await cacheHandle.createWritable();
+            await writable.write(JSON.stringify(cache, null, 2));
+            await writable.close();
+            return true;
+        } catch (err) {
+            console.warn('Unable to save hash cache:', err);
+            return false;
+        }
+    }
+
+    // Hash files in a directory with caching
+    async function hashDirectoryFiles(dirHandle, files) {
+        const cache = await loadHashCache(dirHandle);
+        const updatedCache = {};
+        const results = {};
+    
+        for (const fileInfo of files) {
+            try {
+                const file = await fileInfo.handle.getFile();
+                const cacheKey = file.name;
+                const lastModified = file.lastModified;
+            
+                // Check if we have a cached hash
+                if (cache[cacheKey] && cache[cacheKey].lastModified === lastModified) {
+                    // Use cached hash
+                    results[fileInfo.id] = cache[cacheKey].hash;
+                    updatedCache[cacheKey] = cache[cacheKey];
+                } else {
+                    // Calculate new hash
+                    const hash = await calculateFileHash(file);
+                    results[fileInfo.id] = hash;
+                    updatedCache[cacheKey] = {
+                        hash: hash,
+                        lastModified: lastModified,
+                        size: file.size
+                    };
+                }
+            } catch (err) {
+                console.error(`Error hashing file ${fileInfo.name}:`, err);
+            }
+        }
+    
+        // Try to save updated cache
+        await saveHashCache(dirHandle, updatedCache);
+    
+        return results;
+    }
+
+    // Add hash information to files
+    async function addHashesToFiles() {
+        if (!window.app.files.length) return;
+    
+        // Hash operations require local file handles — not available in HTTP mode
+        if (window.app.sourceMode === 'http') {
+            console.log('Hash operations not available in HTTP mode.');
+            return;
+        }
+    
+        window.app.modules.export.showProgress('Calculating file hashes...', 0, window.app.files.length);
+    
+        try {
+            // Group files by directory
+            const filesByDir = {};
+            window.app.files.forEach(file => {
+                const dirPath = file.folderPath;
+                if (!filesByDir[dirPath]) {
+                    filesByDir[dirPath] = {
+                        handle: null,
+                        files: []
+                    };
+                }
+                filesByDir[dirPath].files.push(file);
+            });
+        
+            // Find directory handles
+            for (const dirPath in filesByDir) {
+                const folder = window.app.transmittalFolders.find(f => f.path === dirPath);
+                if (folder) {
+                    filesByDir[dirPath].handle = folder.handle;
+                }
+            }
+        
+            // Hash files in each directory
+            let processed = 0;
+            for (const dirPath in filesByDir) {
+                const dirInfo = filesByDir[dirPath];
+                if (dirInfo.handle) {
+                    const hashes = await hashDirectoryFiles(dirInfo.handle, dirInfo.files);
+                
+                    // Update file objects with hashes
+                    dirInfo.files.forEach(file => {
+                        if (hashes[file.id]) {
+                            file.hash = hashes[file.id];
+                        }
+                    });
+                }
+            
+                processed += dirInfo.files.length;
+                window.app.modules.export.showProgress('Calculating file hashes...', processed, window.app.files.length);
+            }
+        
+            window.app.modules.export.hideProgress();
+        
+        } catch (err) {
+            window.app.modules.export.hideProgress();
+            console.error('Error calculating hashes:', err);
+        }
+    }
+
+    // Verify file integrity
+    async function verifyFileIntegrity(fileId) {
+        const file = window.app.files.find(f => f.id === fileId);
+        if (!file || !file.hash) {
+            alert('No hash available for this file.');
+            return;
+        }
+    
+        if (!file.handle) {
+            alert('File integrity verification is not available in HTTP mode.');
+            return;
+        }
+    
+        try {
+            const fileData = await file.handle.getFile();
+            const currentHash = await calculateFileHash(fileData);
+        
+            if (currentHash === file.hash) {
+                alert('File integrity verified. Hash matches.');
+            } else {
+                alert('WARNING: File has been modified! Hash does not match.');
+            }
+        } catch (err) {
+            alert('Error verifying file: ' + err.message);
+        }
+    }
+
+    // Export hash report
+    function exportHashReport() {
+        const headers = ['File Path', 'SHA-256 Hash', 'Size', 'Last Modified'];
+        const rows = [headers];
+    
+        window.app.filteredFiles.forEach(file => {
+            if (file.hash) {
+                rows.push([
+                    file.path,
+                    file.hash,
+                    window.app.modules.export.formatFileSize(file.size),
+                    new Date(file.modified).toISOString()
+                ]);
+            }
+        });
+    
+        window.app.modules.export.downloadFile(window.app.modules.export.rowsToCSV(rows), 'file-hashes.csv', 'text/csv');
+    }
+
+    window.app.modules.hash = {
+        calculateFileHash,
+        loadHashCache,
+        saveHashCache,
+        hashDirectoryFiles,
+        addHashesToFiles,
+        verifyFileIntegrity,
+        exportHashReport
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // Drag and drop functionality
+
+    let draggedFiles = [];
+    let targetGroupingFolder = null;
+
+    // Setup drag and drop
+    function setupDragAndDrop() {
+        // Prevent default drag behaviors
+        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+            document.addEventListener(eventName, preventDefaults, false);
+        });
+    
+        // Highlight drop zones
+        ['dragenter', 'dragover'].forEach(eventName => {
+            document.addEventListener(eventName, highlight, false);
+        });
+    
+        ['dragleave', 'drop'].forEach(eventName => {
+            document.addEventListener(eventName, unhighlight, false);
+        });
+    
+        // Handle drops on grouping folders (for creating transmittals)
+        document.getElementById('groupingFoldersList').addEventListener('drop', handleDrop, false);
+    
+        // Handle drops on the main app area (for adding directories)
+        document.getElementById('app').addEventListener('drop', handleAppDrop, false);
+    }
+
+    // Prevent default behaviors
+    function preventDefaults(e) {
+        e.preventDefault();
+        e.stopPropagation();
+    }
+
+    // Highlight drop zone
+    function highlight(e) {
+        const folderItem = e.target.closest('.folder-item');
+        if (folderItem && folderItem.parentElement.id === 'groupingFoldersList') {
+            folderItem.classList.add('drag-over');
+        }
+    }
+
+    // Remove highlight
+    function unhighlight(e) {
+        document.querySelectorAll('.drag-over').forEach(item => {
+            item.classList.remove('drag-over');
+        });
+    }
+
+    // Handle directory drop on main app area (for adding directories)
+    async function handleAppDrop(e) {
+        // Check if this is a drop on a grouping folder (handled separately)
+        const folderItem = e.target.closest('.folder-item');
+        if (folderItem && folderItem.parentElement.id === 'groupingFoldersList') {
+            return; // Let handleDrop handle this
+        }
+    
+        // Check if dataTransfer has directory items
+        const items = e.dataTransfer.items;
+        if (!items || items.length === 0) return;
+    
+        // Process each dropped item
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+        
+            // Check if it's a directory using the File System Access API
+            if (item.kind === 'file') {
+                const entry = await item.getAsFileSystemHandle();
+            
+                if (entry && entry.kind === 'directory') {
+                    // Check if already added
+                    const exists = window.app.directories.some(d => d.name === entry.name);
+                    if (exists) {
+
+                        continue;
+                    }
+                
+                    // Add to directories
+                    window.app.directories.push({
+                        handle: entry,
+                        name: entry.name,
+                        path: entry.name
+                    });
+                
+                    // Hide empty state if this is the first directory
+                    if (window.app.directories.length === 1) {
+                        window.app.modules.app.hideEmptyState();
+                    }
+                
+                    // Scan the new directory
+                    await window.app.modules.directory.scanDirectory(entry, entry.name);
+                }
+            }
+        }
+    
+        // Update UI after processing all dropped directories
+        if (window.app.directories.length > 0) {
+            window.app.modules.app.updateUI();
+        }
+    }
+
+    // Handle file drop on grouping folder (for creating transmittals)
+    async function handleDrop(e) {
+        const folderItem = e.target.closest('.folder-item');
+        if (!folderItem) return;
+    
+        const files = Array.from(e.dataTransfer.files);
+        if (files.length === 0) return;
+    
+        // Find the grouping folder
+        const folderPath = folderItem.getAttribute('data-path');
+        const groupingFolder = window.app.groupingFolders.find(f => f.path === folderPath);
+        if (!groupingFolder) return;
+    
+        targetGroupingFolder = groupingFolder;
+        draggedFiles = files;
+    
+        // Show transmittal creation dialog
+        showTransmittalDialog();
+    }
+
+    // Show transmittal creation dialog
+    function showTransmittalDialog() {
+        const modal = document.getElementById('dropModal');
+    
+        // Generate default transmittal name
+        const today = new Date();
+        const dateStr = today.toISOString().split('T')[0]; // YYYY-MM-DD
+    
+        // Try to extract tracking number from first file
+        let trackingNumber = 'TRACKING';
+        let title = 'Transmittal';
+    
+        if (draggedFiles.length > 0) {
+            const firstFile = draggedFiles[0];
+            const parsed = zddc.parseFilename(firstFile.name) || {};
+            if (parsed.trackingNumber) {
+                trackingNumber = parsed.trackingNumber;
+            }
+            if (parsed.title) {
+                title = parsed.title;
+            }
+        }
+    
+        const defaultName = `${dateStr}_${trackingNumber} (IFI) - ${title}`;
+        document.getElementById('transmittalName').value = defaultName;
+    
+        // Show file preview
+        updateFilePreview();
+    
+        modal.classList.remove('hidden');
+    }
+
+    // Update file preview in dialog
+    function updateFilePreview() {
+        const tbody = document.getElementById('filesPreviewBody');
+    
+        const rows = draggedFiles.map(file => {
+            const parsed = zddc.parseFilename(file.name) || {};
+        
+            // Generate ZDDC-compliant name
+            let newName = file.name;
+            if (parsed.trackingNumber) {
+                newName = `${parsed.trackingNumber}_${parsed.revision || 'A'} (${parsed.status || 'IFI'}) - ${parsed.title}.${parsed.extension}`;
+            }
+        
+            const isValid = !!parsed.trackingNumber;
+        
+            return `
+                <tr>
+                    <td>${window.app.modules.app.escapeHtml(file.name)}</td>
+                    <td>
+                        <input type="text" 
+                               class="form-input" 
+                               value="${window.app.modules.app.escapeHtml(newName)}"
+                               data-original="${window.app.modules.app.escapeHtml(file.name)}"
+                               style="width: 100%;">
+                    </td>
+                    <td style="color: ${isValid ? 'green' : 'red'};">
+                        ${isValid ? '✓ Valid' : '✗ Invalid'}
+                    </td>
+                </tr>
+            `;
+        }).join('');
+    
+        tbody.innerHTML = rows;
+    }
+
+    // Confirm transmittal creation
+    async function confirmTransmittal() {
+        const transmittalName = document.getElementById('transmittalName').value.trim();
+    
+        // Validate transmittal folder name
+        if (!window.app.modules.parser.isTransmittalFolder(transmittalName)) {
+            alert('Invalid transmittal folder name. Must follow format: YYYY-MM-DD_TRACKINGNUMBER (STATUS) - TITLE');
+            return;
+        }
+    
+        try {
+            // Create transmittal folder
+            const transmittalHandle = await targetGroupingFolder.handle.getDirectoryHandle(transmittalName, { create: true });
+        
+            // Get file mappings from preview
+            const fileMappings = [];
+            const inputs = document.querySelectorAll('#filesPreviewBody input');
+            inputs.forEach((input, index) => {
+                fileMappings.push({
+                    originalFile: draggedFiles[index],
+                    newName: input.value.trim()
+                });
+            });
+        
+            // Save files with new names
+            for (const mapping of fileMappings) {
+                const fileHandle = await transmittalHandle.getFileHandle(mapping.newName, { create: true });
+                const writable = await fileHandle.createWritable();
+                await writable.write(mapping.originalFile);
+                await writable.close();
+            }
+        
+            // Close modal
+            document.getElementById('dropModal').classList.add('hidden');
+        
+            // Refresh to show new files
+            await window.app.modules.directory.refreshDirectories();
+        
+            alert(`Transmittal created successfully with ${fileMappings.length} files.`);
+        
+        } catch (err) {
+            console.error('Error creating transmittal:', err);
+            alert('Error creating transmittal: ' + err.message);
+        }
+    }
+
+    // Handle drag and drop on table rows (for metadata copy)
+    function setupTableRowDragDrop() {
+        document.getElementById('filesTableBody').addEventListener('dragover', (e) => {
+            const tr = e.target.closest('tr');
+            if (tr) {
+                e.preventDefault();
+                tr.classList.add('drag-over');
+            }
+        });
+    
+        document.getElementById('filesTableBody').addEventListener('dragleave', (e) => {
+            const tr = e.target.closest('tr');
+            if (tr) {
+                tr.classList.remove('drag-over');
+            }
+        });
+    
+        document.getElementById('filesTableBody').addEventListener('drop', async (e) => {
+            const tr = e.target.closest('tr');
+            if (!tr) return;
+        
+            tr.classList.remove('drag-over');
+        
+            // Get tracking number and title from the row
+            const trackingNumber = tr.querySelector('td[data-field="trackingNumber"]').textContent;
+            const title = tr.querySelector('td[data-field="title"]').textContent;
+        
+            const files = Array.from(e.dataTransfer.files);
+            if (files.length === 0) return;
+        
+            // For table row drops, just copy metadata
+            alert(`Would copy metadata:\nTracking Number: ${trackingNumber}\nTitle: ${title}\n\nTo ${files.length} file(s)`);
+        });
+    }
+
+    window.app.modules.dragDrop = {
+        setupDragAndDrop,
+        showTransmittalDialog,
+        updateFilePreview,
+        confirmTransmittal,
+        setupTableRowDragDrop
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // Directory selection and scanning functionality
+
+    // Add directory
+    async function addDirectory() {
+        try {
+            const dirHandle = await window.showDirectoryPicker();
+        
+            // Check if already added
+            const exists = window.app.directories.some(d => d.name === dirHandle.name);
+            if (exists) {
+                alert('This directory has already been added.');
+                return;
+            }
+        
+            // Add to directories
+            window.app.directories.push({
+                handle: dirHandle,
+                name: dirHandle.name,
+                path: dirHandle.name // Root path
+            });
+        
+            // Hide empty state if this is the first directory
+            if (window.app.directories.length === 1) {
+                window.app.modules.app.hideEmptyState();
+            }
+        
+            // Scan the new directory
+            await scanDirectory(dirHandle, dirHandle.name);
+        
+            window.app.modules.app.updateUI();
+        } catch (err) {
+            if (err.name !== 'AbortError') {
+                console.error('Error selecting directory:', err);
+                alert('Error selecting directory: ' + err.message);
+            }
+        }
+    }
+
+    // Scan directory recursively (local mode — delegates to local source in source.js)
+    async function scanDirectory(dirHandle, path) {
+        window.app.isScanning = true;
+        window.app.scanProgress = 'Scanning ' + path + '...';
+        window.app.modules.app.updateStatusBar();
+    
+        const source = window.app.modules.source.createSource('local', {});
+    
+        const callbacks = {
+            onGroupingFolder: function(folder) {
+                window.app.groupingFolders.push(folder);
+            },
+            onTransmittalFolder: function(folder) {
+                window.app.transmittalFolders.push(folder);
+            },
+            onFile: function(file) {
+                window.app.files.push(file);
+            },
+            onProgress: function(message) {
+                window.app.scanProgress = message;
+                window.app.modules.app.updateStatusBar();
+            }
+        };
+    
+        try {
+            await source.scan(dirHandle, callbacks);
+        
+            // Only auto-select top-level party folders (shallowest depth)
+            const groupingDepths = window.app.groupingFolders.map(f => f.path.split('/').length);
+            const minGroupingDepth = groupingDepths.length > 0 ? Math.min(...groupingDepths) : 1;
+            window.app.groupingFolders.forEach(folder => {
+                if (folder.path.split('/').length === minGroupingDepth) {
+                    window.app.selectedGroupingFolders.add(folder.path);
+                }
+            });
+        
+            window.app.transmittalFolders.forEach(folder => {
+                if (!window.app.modules.app.isUnderHiddenFolderType(folder.path)) {
+                    window.app.selectedTransmittalFolders.add(folder.path);
+                }
+            });
+        
+            window.app.modules.app.ensureOutstandingTransmittal();
+            // Auto-select Outstanding if selectAllTransmittals is active
+            if (window.app.selectAllTransmittals) {
+                window.app.selectedTransmittalFolders.add('__outstanding__');
+            }
+
+            window.app.modules.app.collectModifiers();
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters();
+            if (window.app.modules.presets) {
+                window.app.modules.presets.init();
+            }
+        } catch (err) {
+            console.error('Error scanning directory:', err);
+            alert('Error scanning directory: ' + err.message);
+        } finally {
+            window.app.isScanning = false;
+            window.app.scanProgress = '';
+            window.app.modules.app.updateStatusBar();
+        }
+    }
+
+    // Refresh all directories
+    async function refreshDirectories() {
+        // Clear existing data
+        window.app.groupingFolders = [];
+        window.app.transmittalFolders = [];
+        window.app.files = [];
+        window.app.filteredFiles = [];
+    
+        if (window.app.sourceMode === 'http') {
+            // Re-scan all HTTP sources
+            const dirs = window.app.directories.slice();
+            window.app.directories = [];
+            for (const dir of dirs) {
+                await window.app.modules.app.addHttpSource(dir.url);
+            }
+        } else {
+            // Re-scan all local directories
+            for (const dir of window.app.directories) {
+                await scanDirectory(dir.handle, dir.name);
+            }
+        }
+    
+        window.app.modules.app.updateUI();
+    }
+
+    // Remove directory
+    function removeDirectory(dirName) {
+        const index = window.app.directories.findIndex(d => d.name === dirName);
+        if (index !== -1) {
+            window.app.directories.splice(index, 1);
+        
+            // Remove associated folders and files
+            window.app.groupingFolders = window.app.groupingFolders.filter(f => 
+                !f.path.startsWith(dirName)
+            );
+            window.app.transmittalFolders = window.app.transmittalFolders.filter(f => 
+                !f.path.startsWith(dirName)
+            );
+            window.app.files = window.app.files.filter(f => 
+                !f.path.startsWith(dirName)
+            );
+        
+            // Clean up the Outstanding virtual transmittal if no outstanding files remain
+            const hasAnyOutstanding = window.app.files.some(f => f.folderPath === '__outstanding__');
+            if (!hasAnyOutstanding) {
+                window.app.transmittalFolders = window.app.transmittalFolders.filter(f => f.path !== '__outstanding__');
+                window.app.selectedTransmittalFolders.delete('__outstanding__');
+            }
+        
+            // Show empty state if no directories left
+            if (window.app.directories.length === 0) {
+                window.app.modules.app.showEmptyState();
+            }
+        
+            window.app.modules.app.updateUI();
+        }
+    }
+
+    // Request permission for directory
+    async function requestPermission(dirHandle) {
+        const options = { mode: 'read' };
+    
+        // Check current permission state
+        if ((await dirHandle.queryPermission(options)) === 'granted') {
+            return true;
+        }
+    
+        // Request permission
+        if ((await dirHandle.requestPermission(options)) === 'granted') {
+            return true;
+        }
+    
+        return false;
+    }
+
+    window.app.modules.directory = {
+        addDirectory,
+        scanDirectory,
+        refreshDirectories,
+        removeDirectory,
+        requestPermission
+    };
+
+})();
+
+(function() {
+    'use strict';
+
+    // Escape a string for use in a RegExp (literal match)
+    function escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
+    // Build regex pattern at parse time based on anchors
+    function compilePattern(raw, anchorStart, anchorEnd) {
+        var src = (anchorStart ? '^' : '') + raw + (anchorEnd ? '$' : '');
+        try {
+            return new RegExp(src, 'i');
+        } catch (e) {
+            // Invalid regex — escape and retry (always succeeds)
+            var safe = (anchorStart ? '^' : '') + escapeRegex(raw) + (anchorEnd ? '$' : '');
+            return new RegExp(safe, 'i');
+        }
+    }
+
+    // Parse a single token string into a node
+    function parseToken(token) {
+        var s = token;
+        var negate = false;
+        var anchorStart = false;
+        var anchorEnd = false;
+
+        if (s.charAt(0) === '!') {
+            negate = true;
+            s = s.slice(1);
+        }
+        if (s.charAt(0) === '^') {
+            anchorStart = true;
+            s = s.slice(1);
+        }
+        if (s.length > 0 && s.charAt(s.length - 1) === '$') {
+            anchorEnd = true;
+            s = s.slice(0, -1);
+        }
+
+        if (s === '') return null;
+
+        // bare * (possibly after stripping !) → wildcard-all or wildcard-none
+        if (s === '*' && !anchorStart && !anchorEnd) {
+            return negate ? null : { type: 'wildcard-all' };
+        }
+
+        var re = compilePattern(s, anchorStart, anchorEnd);
+        return { type: negate ? 'no-match' : 'match', re: re };
+    }
+
+    // Parse expression string into AST array
+    function parse(expression) {
+        if (!expression || typeof expression !== 'string') return [];
+        var trimmed = expression.trim();
+        if (trimmed === '') return [];
+        if (trimmed === '*') return [{ type: 'wildcard-all' }];
+
+        var ast = [];
+        var i = 0;
+        var len = trimmed.length;
+
+        while (i < len) {
+            var ch = trimmed.charAt(i);
+
+            if (ch === '(') {
+                var depth = 1;
+                var j = i + 1;
+                while (j < len && depth > 0) {
+                    if (trimmed.charAt(j) === '(') depth++;
+                    else if (trimmed.charAt(j) === ')') depth--;
+                    j++;
+                }
+                var innerAst = parse(trimmed.slice(i + 1, j - 1));
+                if (innerAst.length === 1) {
+                    ast.push(innerAst[0]);
+                } else if (innerAst.length > 1) {
+                    for (var k = 0; k < innerAst.length; k++) ast.push(innerAst[k]);
+                }
+                i = j;
+            } else if (ch === '|') {
+                ast.push({ type: 'pipe' });
+                i++;
+            } else if (ch === ' ') {
+                i++;
+            } else {
+                var j = i;
+                while (j < len) {
+                    var c = trimmed.charAt(j);
+                    if (c === ' ' || c === '(' || c === '|' || c === ')') break;
+                    j++;
+                }
+                var token = trimmed.slice(i, j);
+                if (token.length > 0) {
+                    var node = parseToken(token);
+                    if (node !== null) ast.push(node);
+                }
+                i = j;
+            }
+        }
+
+        // Group pipes into OR nodes
+        var hasPipe = false;
+        var branches = [[]];
+        for (var l = 0; l < ast.length; l++) {
+            if (ast[l].type === 'pipe') {
+                hasPipe = true;
+                branches.push([]);
+            } else {
+                branches[branches.length - 1].push(ast[l]);
+            }
+        }
+        branches = branches.filter(function(b) { return b.length > 0; });
+
+        if (!hasPipe) {
+            return ast.filter(function(n) { return n.type !== 'pipe'; });
+        }
+
+        var orNodes = branches.map(function(branch) {
+            if (branch.length === 1) return branch[0];
+            return { type: 'and', nodes: branch };
+        });
+        return [{ type: 'or', nodes: orNodes }];
+    }
+
+    // Check if a single node matches the value
+    function nodeMatches(node, value) {
+        switch (node.type) {
+            case 'wildcard-all': return true;
+            case 'match':    return node.re.test(value);
+            case 'no-match': return !node.re.test(value);
+            case 'or':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (nodeMatches(node.nodes[i], value)) return true;
+                }
+                return false;
+            case 'and':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (!nodeMatches(node.nodes[i], value)) return false;
+                }
+                return true;
+            default: return false;
+        }
+    }
+
+    // Evaluate AST against value
+    function matches(value, ast) {
+        if (!ast || ast.length === 0) return true;
+        var v = String(value); // no forced lowercase — regex has 'i' flag
+        for (var i = 0; i < ast.length; i++) {
+            if (!nodeMatches(ast[i], v)) return false;
+        }
+        return true;
+    }
+
+    if (!window.zddc) {
+        throw new Error('shared/zddc-filter.js: window.zddc must be loaded first');
+    }
+    window.zddc.filter = { parse: parse, matches: matches };
+})();
+
+// Filtering functionality
+
+// Apply all filters
+function applyFilters() {
+    // Start with files from selected transmittal folders AND selected grouping folders
+    let filtered = window.app.files.filter(file => {
+        // Must have at least one grouping folder selected (if grouping folders exist)
+        if (window.app.groupingFolders.length > 0 && window.app.selectedGroupingFolders.size === 0) {
+            return false;
+        }
+        
+        // Must have at least one transmittal folder selected
+        if (window.app.selectedTransmittalFolders.size === 0) {
+            return false;
+        }
+        
+        // File must be in a selected transmittal folder
+        if (!window.app.selectedTransmittalFolders.has(file.folderPath)) {
+            return false;
+        }
+        
+        // Outstanding files: actualPath must be under a selected grouping folder that is
+        // itself visible (not hidden by folder type toggles).
+        if (file.folderPath === '__outstanding__') {
+            if (!window.app.modules.app.outstandingFileIsVisible(file)) return false;
+        }
+        
+        // If grouping folders exist and are selected, the file's transmittal folder must be within one.
+        // Outstanding files are exempt — their grouping scope is enforced by the actualPath check above.
+        if (file.folderPath !== '__outstanding__' && window.app.groupingFolders.length > 0 && window.app.selectedGroupingFolders.size > 0) {
+            const inSelectedGrouping = Array.from(window.app.selectedGroupingFolders).some(groupingPath => 
+                file.folderPath.startsWith(groupingPath + '/')
+            );
+            if (!inSelectedGrouping) {
+                return false;
+            }
+        }
+        
+        return true;
+    });
+    
+
+    
+    // Apply column filters
+    filtered = applyColumnFilters(filtered);
+    
+    // Apply modifier filter
+    if (window.app.selectedModifiers.size < window.app.availableModifiers.size) {
+        filtered = filtered.filter(file => window.app.modules.app.filePassesModifierFilter(file));
+    }
+    
+    updateResetFiltersBtn();
+    
+    // Apply selected-only filter
+    if (window.app.showSelectedOnly) {
+        filtered = filtered.filter(file => window.app.selectedFiles.has(file.id));
+    }
+    
+    window.app.filteredFiles = filtered;
+    window.app.modules.table.updateFileTable();
+    window.app.modules.app.updateStatusBar();
+    window.app.modules.table.updateSelectAllVisibleCheckbox();
+}
+
+
+
+// Apply column filters using stored ASTs
+function applyColumnFilters(files) {
+    const asts = window.app.columnFilterASTs;
+    
+    if (asts.trackingNumber && asts.trackingNumber.length > 0) {
+        files = files.filter(file =>
+            zddc.filter.matches(file.trackingNumber || '', asts.trackingNumber)
+        );
+    }
+    
+    if (asts.title && asts.title.length > 0) {
+        files = files.filter(file =>
+            zddc.filter.matches(file.title || '', asts.title)
+        );
+    }
+    
+    if (asts.revisions && asts.revisions.length > 0) {
+        files = files.filter(file => {
+            const revisionText = [
+                file.revision,
+                file.status,
+                file.extension
+            ].join(' ');
+            return zddc.filter.matches(revisionText, asts.revisions);
+        });
+    }
+    
+    return files;
+}
+
+// Clear all filters
+function clearFilters() {
+    window.app.columnFilters = {
+        trackingNumber: '',
+        title: '',
+        revisions: ''
+    };
+    window.app.columnFilterASTs = {
+        trackingNumber: null,
+        title: null,
+        revisions: null
+    };
+    window.app.groupingFilter = '';
+    window.app.transmittalFilter = '';
+    
+    // Clear UI inputs
+    const groupingFilterEl = document.getElementById('groupingFilter');
+    groupingFilterEl.value = '';
+    groupingFilterEl.classList.remove('filter-active');
+    const transmittalFilterEl = document.getElementById('transmittalFilter');
+    transmittalFilterEl.value = '';
+    transmittalFilterEl.classList.remove('filter-active');
+    document.querySelectorAll('.column-filter').forEach(input => {
+        input.value = '';
+        input.classList.remove('filter-active');
+    });
+    
+    window.app.modules.app.toggleAllModifiers(true);
+    updateResetFiltersBtn();
+    applyFilters();
+    window.app.modules.urlState.push();
+}
+
+// Update reset filters button visibility
+function updateResetFiltersBtn() {
+    // Button is always visible — no show/hide logic needed
+}
+
+// Register filtering module
+window.app.modules.filtering = {
+    applyFilters,
+    applyColumnFilters,
+    clearFilters,
+    updateResetFiltersBtn
+};
+
+// Table management functionality
+
+(function() {
+    'use strict';
+
+
+    // FileBlobCache, processedLinks, preview state, and utilities
+    const fileBlobCache = new Map();
+    const processedLinks = new WeakSet();
+    let fileLinkHandlersAttached = false;
+    let filePreviewWindow = null;
+    const PREVIEW_EXTENSIONS = ['pdf', 'docx', 'xlsx', 'xls'];
+    const loadedLibraries = new Map();
+    let resizing = null;
+
+
+    /**
+     * Get or create a blob URL for a file.
+     * - Local files: reads via File System Access API, caches the blob URL.
+     * - HTTP files: fetches the remote URL, caches the blob URL.
+     * Returns a Promise<string> resolving to a blob: URL.
+     */
+    async function getFileBlobUrl(file) {
+        if (fileBlobCache.has(file.id)) {
+            return fileBlobCache.get(file.id);
+        }
+        let blob;
+        if (file.handle) {
+            // Local file via File System Access API
+            const f = await file.handle.getFile();
+            blob = f;
+        } else if (file.url) {
+            // HTTP file — fetch and convert to blob
+            const resp = await fetch(file.url);
+            if (!resp.ok) throw new Error('HTTP ' + resp.status + ' fetching ' + file.url);
+            blob = await resp.blob();
+        } else {
+            throw new Error('File has neither a handle nor a URL');
+        }
+        const url = URL.createObjectURL(blob);
+        fileBlobCache.set(file.id, url);
+        return url;
+    }
+
+    /**
+     * Clean up blob URLs for files no longer displayed
+     */
+    function cleanupUnusedBlobUrls() {
+        const displayedFileIds = new Set(window.app.filteredFiles.map(f => f.id));
+        for (const [fileId, url] of fileBlobCache.entries()) {
+            if (!displayedFileIds.has(fileId)) {
+                URL.revokeObjectURL(url);
+                fileBlobCache.delete(fileId);
+            }
+        }
+    }
+
+    /**
+     * Revoke all blob URLs and clear cache
+     */
+    function cleanupAllBlobUrls() {
+        for (const url of fileBlobCache.values()) {
+            URL.revokeObjectURL(url);
+        }
+        fileBlobCache.clear();
+    }
+
+    // Update file table
+    function updateFileTable() {
+        const tbody = document.getElementById('filesTableBody');
+        
+        if (window.app.filteredFiles.length === 0) {
+            tbody.innerHTML = `
+                <tr>
+                    <td colspan="3" class="empty-table">
+                        No files found matching the current filters.
+                    </td>
+                </tr>
+            `;
+            cleanupUnusedBlobUrls(); // Clean up all blob URLs
+            return;
+        }
+        
+        // Group and sort files
+        const grouped = window.app.modules.parser.groupFilesByTrackingNumber(window.app.filteredFiles);
+        const sorted = window.app.modules.parser.sortGroupedFiles(grouped);
+        
+        // Build table rows
+        const rows = [];
+        sorted.forEach(group => {
+            rows.push(createFileGroupRow(group));
+        });
+        
+        tbody.innerHTML = rows.join('');
+        
+        // Clean up blob URLs for files no longer visible
+        cleanupUnusedBlobUrls();
+    }
+
+    // Create row for a file group
+    function createFileGroupRow(group) {
+        // Generate one <tr> per revision; last row gets class group-last for border
+        const lastIndex = group.sortedRevisions.length - 1;
+        return group.sortedRevisions.map((revision, i) => {
+            const titleClass = revision.hasModifier ? 'revision-title-modifier' : 'revision-title-base';
+            const titleHtml = `<div class="${titleClass}">${window.app.modules.app.escapeHtml(revision.title)}</div>`;
+            const revisionHtml = createRevisionHtml(group.trackingNumber, revision);
+            const lastClass = i === lastIndex ? ' group-last' : '';
+
+            // First row includes trackingNumber cell with rowspan
+            if (i === 0) {
+                return `
+                    <tr class="group-row${lastClass}">
+                        <td data-field="trackingNumber" rowspan="${group.sortedRevisions.length}">${window.app.modules.app.escapeHtml(group.trackingNumber)}</td>
+                        <td data-field="title">${titleHtml}</td>
+                        <td data-field="revisions">${revisionHtml}</td>
+                    </tr>
+                `;
+            }
+            // Subsequent rows omit trackingNumber cell
+            return `
+                <tr class="group-row${lastClass}">
+                    <td data-field="title">${titleHtml}</td>
+                    <td data-field="revisions">${revisionHtml}</td>
+                </tr>
+            `;
+        }).join('');
+    }
+
+    // Create HTML for a revision
+    function createRevisionHtml(trackingNumber, revision) {
+        const filesHtml = revision.files.map(file => 
+            createFileHtml(file)
+        ).join(' ');
+        
+        return `
+            <div class="revision-group">
+                <div class="revision-item">
+                    <span class="revision-info">
+                        <span class="revision-id">${window.app.modules.app.escapeHtml(revision.revision)}</span>
+                        <span class="revision-status">(${window.app.modules.app.escapeHtml(revision.status)})</span>
+                    </span>
+                    ${filesHtml}
+                </div>
+            </div>
+        `;
+    }
+
+    // Create HTML for a file
+    function createFileHtml(file) {
+        const checked = window.app.selectedFiles.has(file.id) ? 'checked' : '';
+        const fullPath = file.path || file.folderPath + '/' + file.name;
+        
+        // Handle files with path errors (Windows 260-char limit)
+        if (file.hasPathError) {
+            const errorTitle = `⚠️ Cannot access: Microsoft Windows path length limit (260 chars)\n\nPath: ${fullPath}\n\nUse 'subst' to map archive to a drive letter, or shorten folder names.`;
+            return `
+                <span class="revision-file">
+                    <input type="checkbox" 
+                           data-file-id="${file.id}"
+                           ${checked}
+                           onchange="toggleFileSelection('${file.id}')">
+                    <span class="path-error-indicator" title="${window.app.modules.app.escapeHtml(errorTitle)}">⚠️</span>
+                    <span class="file-link-disabled"
+                          title="${window.app.modules.app.escapeHtml(errorTitle)}">
+                        <span class="file-ext">${window.app.modules.app.escapeHtml(file.extension.toUpperCase())}</span>
+                        ${file.size != null ? `<span class="file-size">${window.app.modules.export.formatFileSize(file.size)}</span>` : ''}
+                    </span>
+                </span>
+            `;
+        }
+        
+        return `
+            <span class="revision-file">
+                <input type="checkbox" 
+                       data-file-id="${file.id}"
+                       ${checked}
+                       onchange="toggleFileSelection('${file.id}')">
+                <a href="#" 
+                   class="file-link"
+                   data-file-id="${file.id}"
+                   data-file-name="${window.app.modules.app.escapeHtml(file.name)}"
+                   title="${window.app.modules.app.escapeHtml(fullPath)}">
+                    <span class="file-ext">${window.app.modules.app.escapeHtml(file.extension.toUpperCase())}</span>
+                    ${file.size != null ? `<span class="file-size">${window.app.modules.export.formatFileSize(file.size)}</span>` : ''}
+                </a>
+            </span>
+        `;
+    }
+
+    // Toggle file selection
+    function toggleFileSelection(fileId) {
+        if (window.app.selectedFiles.has(fileId)) {
+            window.app.selectedFiles.delete(fileId);
+        } else {
+            window.app.selectedFiles.add(fileId);
+        }
+        window.app.modules.app.updateStatusBar();
+        updateSelectAllVisibleCheckbox();
+    }
+
+    // Toggle selection of all visible files based on checkbox state
+    function toggleSelectAllVisible(selectAll) {
+        window.app.filteredFiles.forEach(file => {
+            if (selectAll) {
+                window.app.selectedFiles.add(file.id);
+            } else {
+                window.app.selectedFiles.delete(file.id);
+            }
+        });
+        
+        updateFileTable();
+        window.app.modules.app.updateStatusBar();
+        updateSelectAllVisibleCheckbox();
+    }
+
+    // Update the select all visible checkbox to reflect current state
+    function updateSelectAllVisibleCheckbox() {
+        const checkbox = document.getElementById('selectAllVisibleCheckbox');
+        if (!checkbox) return;
+        
+        const visibleCount = window.app.filteredFiles.length;
+        if (visibleCount === 0) {
+            checkbox.checked = false;
+            checkbox.indeterminate = false;
+            return;
+        }
+        
+        const selectedVisibleCount = window.app.filteredFiles.filter(f => 
+            window.app.selectedFiles.has(f.id)
+        ).length;
+        
+        if (selectedVisibleCount === 0) {
+            checkbox.checked = false;
+            checkbox.indeterminate = false;
+        } else if (selectedVisibleCount === visibleCount) {
+            checkbox.checked = true;
+            checkbox.indeterminate = false;
+        } else {
+            checkbox.checked = false;
+            checkbox.indeterminate = true;
+        }
+    }
+
+    /**
+     * Memory-efficient blob URL management
+     * 
+     * fileBlobCache: Maps file IDs to blob URLs for reuse
+     * processedLinks: WeakSet tracks DOM elements that already have blob URLs
+     *   - Automatically garbage collected when DOM elements are removed
+     *   - Prevents redundant async operations on mouseover
+     */
+
+    /**
+     * Lazily load a script from CDN. Returns a promise that resolves when loaded.
+     * Caches the promise so subsequent calls return immediately.
+     */
+    function loadLibrary(url) {
+        if (loadedLibraries.has(url)) return loadedLibraries.get(url);
+        const promise = new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = url;
+            script.onload = resolve;
+            script.onerror = () => reject(new Error(`Failed to load library: ${url}`));
+            document.head.appendChild(script);
+        });
+        loadedLibraries.set(url, promise);
+        return promise;
+    }
+
+    /**
+     * Check if file preview mode is enabled
+     */
+    function isFilePreviewEnabled() {
+        const toggle = document.getElementById('filePreviewToggle');
+        return toggle && toggle.checked;
+    }
+
+    /**
+     * Show file preview in a separate popup window
+     * Supports PDF (iframe), DOCX (docx-preview), XLSX/XLS (SheetJS)
+     */
+    async function showFilePreview(file) {
+        const ext = file.extension.toLowerCase();
+        
+        try {
+            const url = await getFileBlobUrl(file);
+            
+            // Mirror the parent window's theme in the popup
+            const parentTheme = document.documentElement.getAttribute('data-theme') || '';
+            const themeAttr = parentTheme ? ` data-theme="${parentTheme}"` : '';
+
+            // Base HTML shell for the preview window
+            const previewHtml = `
+<!DOCTYPE html>
+<html${themeAttr}>
+<head>
+    <title>${window.app.modules.app.escapeHtml(file.name)} - Preview</title>
+    <style>
+        :root {
+            --bg: #ffffff;
+            --bg-secondary: #f5f5f5;
+            --bg-hover: #e8e8e8;
+            --text: #212529;
+            --text-muted: #666666;
+            --border: #dddddd;
+            --primary: #2a5a8a;
+        }
+        @media (prefers-color-scheme: dark) {
+            :root:not([data-theme="light"]) {
+                --bg: #1e1e1e;
+                --bg-secondary: #252526;
+                --bg-hover: #2d2d30;
+                --text: #d4d4d4;
+                --text-muted: #9d9d9d;
+                --border: #3e3e42;
+                --primary: #4a90c4;
+            }
+        }
+        [data-theme="dark"] {
+            --bg: #1e1e1e;
+            --bg-secondary: #252526;
+            --bg-hover: #2d2d30;
+            --text: #d4d4d4;
+            --text-muted: #9d9d9d;
+            --border: #3e3e42;
+            --primary: #4a90c4;
+        }
+        [data-theme="light"] {
+            --bg: #ffffff;
+            --bg-secondary: #f5f5f5;
+            --bg-hover: #e8e8e8;
+            --text: #212529;
+            --text-muted: #666666;
+            --border: #dddddd;
+            --primary: #2a5a8a;
+        }
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            display: flex;
+            flex-direction: column;
+            height: 100vh;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: var(--bg);
+            color: var(--text);
+        }
+        .toolbar {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.5rem 1rem;
+            background: var(--bg-secondary);
+            border-bottom: 1px solid var(--border);
+            flex-shrink: 0;
+        }
+        .toolbar h1 {
+            flex: 1;
+            font-size: 0.95rem;
+            font-weight: 500;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+            color: var(--text);
+        }
+        .btn {
+            padding: 0.4rem 0.8rem;
+            font-size: 0.85rem;
+            border: 1px solid var(--border);
+            border-radius: 4px;
+            background: var(--bg);
+            color: var(--text);
+            cursor: pointer;
+        }
+        .btn:hover { background: var(--bg-hover); }
+        iframe {
+            flex: 1;
+            width: 100%;
+            border: none;
+        }
+        #previewContent {
+            flex: 1;
+            overflow: auto;
+            background: var(--bg);
+        }
+        .loading {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: var(--text-muted);
+            font-size: 1.1rem;
+        }
+        /* docx-preview container */
+        .docx-wrapper { padding: 1rem; }
+        /* xlsx table styling */
+        .xlsx-table { border-collapse: collapse; width: 100%; font-size: 0.85rem; }
+        .xlsx-table th, .xlsx-table td {
+            border: 1px solid var(--border);
+            padding: 0.35rem 0.5rem;
+            text-align: left;
+            white-space: nowrap;
+            color: var(--text);
+        }
+        .xlsx-table th { background: var(--bg-secondary); font-weight: 600; position: sticky; top: 0; }
+        .xlsx-table tr:nth-child(even) { background: var(--bg-secondary); }
+        .xlsx-table tr:hover { background: var(--bg-hover); }
+        .sheet-tabs { display: flex; gap: 0; border-bottom: 1px solid var(--border); background: var(--bg-secondary); }
+        .sheet-tab {
+            padding: 0.4rem 1rem;
+            cursor: pointer;
+            border: 1px solid transparent;
+            border-bottom: none;
+            font-size: 0.85rem;
+            background: transparent;
+            color: var(--text);
+        }
+        .sheet-tab:hover { background: var(--bg-hover); }
+        .sheet-tab.active {
+            background: var(--bg);
+            border-color: var(--border);
+            border-bottom-color: var(--bg);
+            margin-bottom: -1px;
+            font-weight: 500;
+        }
+    </style>
+</head>
+<body>
+    <div class="toolbar">
+        <h1>${window.app.modules.app.escapeHtml(file.name)}</h1>
+        <button class="btn" onclick="downloadFile()">Download</button>
+    </div>
+    ${ext === 'pdf' ? '<iframe src="' + url + '"></iframe>' : '<div id="previewContent"><div class="loading">Loading preview...</div></div>'}
+    <script>
+        var blobUrl = "${url}";
+        var fileName = "${window.app.modules.app.escapeHtml(file.name).replace(/"/g, '\\"')}";
+        
+        function downloadFile() {
+            const a = document.createElement('a');
+            a.href = blobUrl;
+            a.download = fileName;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+        }
+    <\/script>
+</body>
+</html>`;
+            
+            // Open or reuse the preview window
+            if (filePreviewWindow && !filePreviewWindow.closed) {
+                filePreviewWindow.document.open();
+                filePreviewWindow.document.write(previewHtml);
+                filePreviewWindow.document.close();
+                filePreviewWindow.focus();
+            } else {
+                const width = Math.round(screen.width * 0.6);
+                const height = Math.round(screen.height * 0.8);
+                const left = Math.round((screen.width - width) / 2);
+                const top = Math.round((screen.height - height) / 2);
+                
+                filePreviewWindow = window.open('', 'filePreview', 
+                    `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`);
+                
+                if (!filePreviewWindow) {
+                    window.open(url, '_blank');
+                    return;
+                }
+                
+                filePreviewWindow.document.write(previewHtml);
+                filePreviewWindow.document.close();
+                filePreviewWindow.focus();
+            }
+            
+            // For non-PDF types, render content into the preview window
+            if (ext === 'docx') {
+                await renderDocxInWindow(file);
+            } else if (ext === 'xlsx' || ext === 'xls') {
+                await renderXlsxInWindow(file);
+            }
+            
+        } catch (err) {
+            console.error('Error loading file preview:', err);
+            alert(`Error loading preview: ${err.message}`);
+        }
+    }
+
+    /**
+     * Render a DOCX file in the preview window using docx-preview library
+     */
+    async function renderDocxInWindow(file) {
+        const container = filePreviewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js');
+            await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+            
+            const arrayBuffer = await (file.handle
+                ? file.handle.getFile().then(f => f.arrayBuffer())
+                : fetch(file.url).then(r => r.arrayBuffer()));
+            
+            container.innerHTML = '';
+            await window.docx.renderAsync(arrayBuffer, container);
+        } catch (err) {
+            console.error('Error rendering DOCX:', err);
+            container.innerHTML = `<div class="loading">Error rendering DOCX: ${err.message}<br>Click Download to view in Word.</div>`;
+        }
+    }
+
+    /**
+     * Render an XLSX/XLS file in the preview window using SheetJS
+     */
+    async function renderXlsxInWindow(file) {
+        const container = filePreviewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+            
+            const arrayBuffer = await (file.handle
+                ? file.handle.getFile().then(f => f.arrayBuffer())
+                : fetch(file.url).then(r => r.arrayBuffer()));
+            const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+            
+            container.innerHTML = '';
+            
+            // Build sheet tabs if multiple sheets
+            if (workbook.SheetNames.length > 1) {
+                const tabs = filePreviewWindow.document.createElement('div');
+                tabs.className = 'sheet-tabs';
+                workbook.SheetNames.forEach((name, i) => {
+                    const tab = filePreviewWindow.document.createElement('button');
+                    tab.className = 'sheet-tab' + (i === 0 ? ' active' : '');
+                    tab.textContent = name;
+                    tab.onclick = () => {
+                        tabs.querySelectorAll('.sheet-tab').forEach(t => t.classList.remove('active'));
+                        tab.classList.add('active');
+                        renderSheet(workbook, name, tableContainer);
+                    };
+                    tabs.appendChild(tab);
+                });
+                container.appendChild(tabs);
+            }
+            
+            const tableContainer = filePreviewWindow.document.createElement('div');
+            tableContainer.style.flex = '1';
+            tableContainer.style.overflow = 'auto';
+            container.appendChild(tableContainer);
+            
+            renderSheet(workbook, workbook.SheetNames[0], tableContainer);
+        } catch (err) {
+            console.error('Error rendering XLSX:', err);
+            container.innerHTML = `<div class="loading">Error rendering spreadsheet: ${err.message}<br>Click Download to view in Excel.</div>`;
+        }
+    }
+
+    /**
+     * Render a single sheet as an HTML table
+     */
+    function renderSheet(workbook, sheetName, container) {
+        const sheet = workbook.Sheets[sheetName];
+        const html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+        container.innerHTML = html;
+        // Apply styling to the generated table
+        const table = container.querySelector('table');
+        if (table) table.className = 'xlsx-table';
+    }
+
+    /**
+     * Setup event delegation for file links
+     * Left-click: Download file (or preview if PDF and preview mode enabled)
+     * Right-click: Allow "Open in new tab" with blob URL
+     */
+    function setupFileLinkHandlers() {
+        if (fileLinkHandlersAttached) return;
+        
+        const table = document.getElementById('filesTable');
+        if (!table) {
+            console.warn('Files table not found');
+            return;
+        }
+        
+        // Handle clicks - download file or show preview
+        table.addEventListener('click', async (e) => {
+            const link = e.target.closest('.file-link');
+            if (!link) return;
+            
+            e.preventDefault();
+            e.stopPropagation();
+            
+            const fileId = link.getAttribute('data-file-id');
+            const fileName = link.getAttribute('data-file-name');
+            
+            if (!fileId || !fileName) {
+                console.error('Invalid link data');
+                return;
+            }
+            
+            const file = window.app.files.find(f => f.id === fileId);
+            
+            if (!file) {
+                console.error(`File not found: ${fileId}`);
+                alert('File not found. Please refresh and try again.');
+                return;
+            }
+            
+            // Check if file preview is enabled and file type is previewable
+            if (isFilePreviewEnabled() && PREVIEW_EXTENSIONS.includes(file.extension.toLowerCase())) {
+                await showFilePreview(file);
+                return;
+            }
+            
+            try {
+                if (!file.handle && file.url) {
+                    // HTTP mode: open the file URL directly in a new tab
+                    window.open(file.url, '_blank');
+                } else {
+                    // Local mode: create blob URL and trigger download
+                    const url = await getFileBlobUrl(file);
+                    const downloadLink = document.createElement('a');
+                    downloadLink.href = url;
+                    downloadLink.download = fileName;
+                    document.body.appendChild(downloadLink);
+                    downloadLink.click();
+                    document.body.removeChild(downloadLink);
+                }
+            } catch (err) {
+                console.error('Error opening file:', err);
+                alert(`Error opening file: ${err.message}`);
+            }
+        }, true); // Use capture phase
+        
+        // Handle mouseover - pre-load URL for fast right-click / middle-click
+        table.addEventListener('mouseover', async (e) => {
+            const link = e.target.closest('.file-link');
+            if (!link) return;
+            
+            // Skip if already processed (prevents redundant operations)
+            if (processedLinks.has(link)) return;
+            
+            const fileId = link.getAttribute('data-file-id');
+            if (!fileId) return;
+            
+            const file = window.app.files.find(f => f.id === fileId);
+            if (!file) {
+                console.warn(`File not found for pre-load: ${fileId}`);
+                return;
+            }
+            
+            try {
+                if (!file.handle && file.url) {
+                    // HTTP mode: set href directly — no async needed
+                    link.href = file.url;
+                    link.target = '_blank';
+                    processedLinks.add(link);
+                } else {
+                    // Local mode: pre-load blob URL asynchronously
+                    const url = await getFileBlobUrl(file);
+                    link.href = url;
+                    link.target = '_blank';
+                    processedLinks.add(link);
+                }
+            } catch (err) {
+                console.error('Error pre-loading file link:', err);
+                // Don't mark as processed so it can retry
+            }
+        }, true); // Use capture phase
+        
+        // Handle context menu - ensure blob URL is set (fallback if mouseover didn't fire)
+        table.addEventListener('contextmenu', async (e) => {
+            const link = e.target.closest('.file-link');
+            if (!link) return;
+            
+            // If already processed, blob URL is set - allow context menu to work
+            if (processedLinks.has(link)) return;
+            
+            const fileId = link.getAttribute('data-file-id');
+            if (!fileId) return;
+            
+            const file = window.app.files.find(f => f.id === fileId);
+            if (!file) {
+                console.warn(`File not found for context menu: ${fileId}`);
+                return;
+            }
+            
+            try {
+                // Get blob URL and set it as href synchronously as possible
+                const url = await getFileBlobUrl(file);
+                link.href = url;
+                link.target = '_blank';
+                
+                // Mark as processed
+                processedLinks.add(link);
+            } catch (err) {
+                console.error('Error preparing file for context menu:', err);
+                // Don't mark as processed so it can retry
+            }
+        }, true); // Use capture phase
+        
+        fileLinkHandlersAttached = true;
+    }
+
+    // Get MIME type from extension
+    function getMimeType(extension) {
+        const ext = extension.toLowerCase();
+        const mimeTypes = {
+            // Documents
+            'pdf': 'application/pdf',
+            'doc': 'application/msword',
+            'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'xls': 'application/vnd.ms-excel',
+            'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            'ppt': 'application/vnd.ms-powerpoint',
+            'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            
+            // Text
+            'txt': 'text/plain',
+            'csv': 'text/csv',
+            'html': 'text/html',
+            'htm': 'text/html',
+            'xml': 'text/xml',
+            'json': 'application/json',
+            
+            // Code
+            'js': 'text/javascript',
+            'css': 'text/css',
+            'py': 'text/plain',
+            'java': 'text/plain',
+            'cpp': 'text/plain',
+            'c': 'text/plain',
+            'h': 'text/plain',
+            
+            // Images
+            'jpg': 'image/jpeg',
+            'jpeg': 'image/jpeg',
+            'png': 'image/png',
+            'gif': 'image/gif',
+            'bmp': 'image/bmp',
+            'svg': 'image/svg+xml',
+            'webp': 'image/webp',
+            'ico': 'image/x-icon',
+            
+            // Archives
+            'zip': 'application/zip',
+            'rar': 'application/x-rar-compressed',
+            '7z': 'application/x-7z-compressed',
+            'tar': 'application/x-tar',
+            'gz': 'application/gzip',
+            
+            // CAD
+            'dwg': 'application/acad',
+            'dxf': 'application/dxf',
+            'dwf': 'model/vnd.dwf',
+            'dgn': 'application/x-dgn',
+            
+            // Other
+            'mp4': 'video/mp4',
+            'mp3': 'audio/mpeg',
+            'wav': 'audio/wav',
+            'avi': 'video/x-msvideo',
+            'mov': 'video/quicktime',
+            'md': 'text/markdown',
+            'log': 'text/plain',
+            'ini': 'text/plain',
+            'cfg': 'text/plain',
+            'conf': 'text/plain',
+            'yaml': 'text/yaml',
+            'yml': 'text/yaml'
+        };
+        
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+
+    // Sort table
+    function sortTable(field) {
+        if (window.app.sortField === field) {
+            // Toggle direction
+            window.app.sortDirection = window.app.sortDirection === 'asc' ? 'desc' : 'asc';
+        } else {
+            // New field, default to ascending
+            window.app.sortField = field;
+            window.app.sortDirection = 'asc';
+        }
+        
+        updateSortIndicators();
+        window.app.modules.filtering.applyFilters(); // Re-apply filters which will trigger table update
+        window.app.modules.urlState.push();
+    }
+
+    // Update sort indicators
+    function updateSortIndicators() {
+        // Remove all sort indicators
+        document.querySelectorAll('th[data-sort]').forEach(th => {
+            th.removeAttribute('data-sort');
+        });
+        
+        // Add current sort indicator
+        const th = document.querySelector(`th[data-field="${window.app.sortField}"]`);
+        if (th) {
+            th.setAttribute('data-sort', window.app.sortDirection);
+        }
+    }
+
+    // Column resize functionality
+    function initializeColumnResize() {
+        const handles = document.querySelectorAll('.resize-handle');
+        handles.forEach(handle => {
+            handle.addEventListener('mousedown', startResize);
+        });
+        
+        document.addEventListener('mousemove', doResize);
+        document.addEventListener('mouseup', stopResize);
+    }
+
+    function startResize(e) {
+        const th = e.target.parentElement;
+        resizing = {
+            th: th,
+            startX: e.clientX,
+            startWidth: th.offsetWidth
+        };
+        
+        document.body.style.cursor = 'col-resize';
+        document.body.style.userSelect = 'none';
+    }
+
+    function doResize(e) {
+        if (! resizing) return;
+        
+        const diff = e.clientX - resizing.startX;
+        const newWidth = Math.max(100, resizing.startWidth + diff);
+        resizing.th.style.width = newWidth + 'px';
+        
+        // Update corresponding column
+        const field = resizing.th.getAttribute('data-field');
+        const cells = document.querySelectorAll(`td[data-field="${field}"]`);
+        cells.forEach(cell => {
+            cell.style.width = newWidth + 'px';
+        });
+    }
+
+    function stopResize() {
+        if (resizing) {
+            document.body.style.cursor = '';
+            document.body.style.userSelect = '';
+            resizing = null;
+        }
+    }
+
+    // Toggle all files (Ctrl+A shortcut handler)
+    // wrapper around toggleSelectAllVisible for keyboard shortcuts
+    function toggleSelectAll() {
+        toggleSelectAllVisible(true);
+    }
+
+    /**
+     * Clean up resources when page unloads
+     */
+    window.addEventListener('beforeunload', () => {
+        cleanupAllBlobUrls();
+    });
+
+    window.app.modules.table = {
+        updateFileTable,
+        toggleFileSelection,
+        toggleSelectAllVisible,
+        updateSelectAllVisibleCheckbox,
+        setupFileLinkHandlers,
+        updateSortIndicators,
+        sortTable,
+        initializeColumnResize
+    };
+})();
+
+(function() {
+    'use strict';
+    // Export functionality
+
+    // Escape a single value for RFC-4180 CSV
+    function csvCell(value) {
+        const str = String(value == null ? '' : value);
+        if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+            return '"' + str.replace(/"/g, '""') + '"';
+        }
+        return str;
+    }
+
+    // Convert an array of row arrays to a CSV string
+    function rowsToCSV(rows) {
+        return rows.map(row => row.map(csvCell).join(',')).join('\n');
+    }
+
+    // Export selected files to CSV
+    function exportCSV() {
+        if (window.app.selectedFiles.size === 0) {
+            alert('No files selected for export.');
+            return;
+        }
+    
+        const headers = ['Tracking Number', 'Title', 'Revision', 'Status', 'Extension', 'Size', 'Size (bytes)', 'Path', 'Modified'];
+        const rows = [headers];
+    
+        // Add data rows for selected files only
+        window.app.files.forEach(file => {
+            if (!window.app.selectedFiles.has(file.id)) return;
+        
+            rows.push([
+                file.trackingNumber || '',
+                file.title || '',
+                file.revision || '',
+                file.status || '',
+                file.extension || '',
+                formatFileSize(file.size),
+                file.size != null ? file.size : '',
+                file.path,
+                file.modified ? new Date(file.modified).toLocaleString() : '—'
+            ]);
+        });
+    
+        downloadFile(rowsToCSV(rows), 'archive-export.csv', 'text/csv');
+    }
+
+    // Download selected files as ZIP
+    async function downloadSelected() {
+        if (window.app.selectedFiles.size === 0) {
+            alert('No files selected for download.');
+            return;
+        }
+    
+        // Check if JSZip is loaded
+        if (typeof JSZip === 'undefined') {
+            // Dynamically load JSZip
+            await loadJSZip();
+        }
+    
+        const zip = new JSZip();
+        const selectedFiles = [];
+    
+        // Get selected file objects
+        window.app.files.forEach(file => {
+            if (window.app.selectedFiles.has(file.id)) {
+                selectedFiles.push(file);
+            }
+        });
+    
+        // Show progress
+        showProgress('Preparing ZIP file...', 0, selectedFiles.length);
+    
+        try {
+            // Add files to ZIP
+            for (let i = 0; i < selectedFiles.length; i++) {
+                const file = selectedFiles[i];
+                showProgress(`Adding ${file.name}...`, i + 1, selectedFiles.length);
+            
+                try {
+                    let arrayBuffer;
+                    if (file.handle) {
+                        // Local mode: read via File System Access API
+                        const fileData = await file.handle.getFile();
+                        arrayBuffer = await fileData.arrayBuffer();
+                    } else if (file.url) {
+                        // HTTP mode: fetch from server
+                        const resp = await fetch(file.url);
+                        if (!resp.ok) throw new Error('HTTP ' + resp.status);
+                        arrayBuffer = await resp.arrayBuffer();
+                    } else {
+                        throw new Error('No file handle or URL available');
+                    }
+                
+                    // Create folder structure in ZIP
+                    const relativePath = file.path.substring(file.path.indexOf('/') + 1); // Remove root directory
+                    zip.file(relativePath, arrayBuffer);
+                } catch (err) {
+                    console.error(`Error adding file ${file.name}:`, err);
+                }
+            }
+        
+            showProgress('Generating ZIP...', selectedFiles.length, selectedFiles.length);
+        
+            // Generate ZIP
+            const blob = await zip.generateAsync({ 
+                type: 'blob',
+                compression: 'DEFLATE',
+                compressionOptions: { level: 6 }
+            });
+        
+            // Download
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').substring(0, 19);
+            downloadBlob(blob, `archive-${timestamp}.zip`);
+        
+            hideProgress();
+        
+        } catch (err) {
+            hideProgress();
+            console.error('Error creating ZIP:', err);
+            alert('Error creating ZIP file: ' + err.message);
+        }
+    }
+
+    // Load JSZip library dynamically
+    function loadJSZip() {
+        return new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = 'https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js';
+            script.onload = resolve;
+            script.onerror = reject;
+            document.head.appendChild(script);
+        });
+    }
+
+    // Show progress indicator
+    function showProgress(message, current, total) {
+        let progressDiv = document.getElementById('progressIndicator');
+    
+        if (!progressDiv) {
+            progressDiv = document.createElement('div');
+            progressDiv.id = 'progressIndicator';
+            progressDiv.className = 'progress-indicator';
+            document.body.appendChild(progressDiv);
+        }
+    
+        const percentage = Math.round((current / total) * 100);
+    
+        progressDiv.innerHTML =
+            '<div class="progress-indicator__message">' + window.app.modules.app.escapeHtml(message) + '</div>' +
+            '<div class="progress-indicator__track">' +
+                '<div class="progress-indicator__fill" style="width:' + percentage + '%"></div>' +
+            '</div>' +
+            '<div class="progress-indicator__label">' + current + ' / ' + total + '</div>';
+    }
+
+    // Hide progress indicator
+    function hideProgress() {
+        const progressDiv = document.getElementById('progressIndicator');
+        if (progressDiv) {
+            progressDiv.remove();
+        }
+    }
+
+    // Download file utility
+    function downloadFile(content, filename, mimeType) {
+        const blob = new Blob([content], { type: mimeType });
+        downloadBlob(blob, filename);
+    }
+
+    // Download blob utility
+    function downloadBlob(blob, filename) {
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+    }
+
+    // Format file size
+    function formatFileSize(bytes) {
+        if (bytes === 0) return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+
+    // Export to HTML report
+    function exportHTMLReport() {
+        // Group files by tracking number
+        const grouped = window.app.modules.parser.groupFilesByTrackingNumber(window.app.filteredFiles);
+        const sorted = window.app.modules.parser.sortGroupedFiles(grouped);
+    
+        const html = `
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <title>Archive Report - ${new Date().toLocaleDateString()}</title>
+        <style>
+            body { font-family: Arial, sans-serif; margin: 20px; }
+            h1 { color: #333; }
+            table { border-collapse: collapse; width: 100%; margin-top: 20px; }
+            th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+            th { background-color: #f2f2f2; font-weight: bold; }
+            tr:nth-child(even) { background-color: #f9f9f9; }
+            .revision { font-family: monospace; }
+            .status { color: #666; font-size: 0.9em; }
+            @media print {
+                body { margin: 0; }
+                h1 { font-size: 18pt; }
+                table { font-size: 10pt; }
+            }
+        </style>
+    </head>
+    <body>
+        <h1>Archive Report</h1>
+        <p>Generated: ${new Date().toLocaleString()}</p>
+        <p>Total Files: ${window.app.filteredFiles.length}</p>
+    
+        <table>
+            <thead>
+                <tr>
+                    <th>Tracking Number</th>
+                    <th>Title</th>
+                    <th>Revisions</th>
+                </tr>
+            </thead>
+            <tbody>
+                ${sorted.map(group => `
+                    <tr>
+                        <td>${window.app.modules.app.escapeHtml(group.trackingNumber)}</td>
+                        <td>${window.app.modules.app.escapeHtml(group.title)}</td>
+                        <td>
+                            ${group.sortedRevisions.map(rev => `
+                                <div>
+                                    <span class="revision">${window.app.modules.app.escapeHtml(rev.revision)}</span>
+                                    <span class="status">(${window.app.modules.app.escapeHtml(rev.status)})</span>
+                                    ${rev.files.map(f => f.extension.toUpperCase()).join(', ')}
+                                </div>
+                            `).join('')}
+                        </td>
+                    </tr>
+                `).join('')}
+            </tbody>
+        </table>
+    </body>
+    </html>`;
+    
+        downloadFile(html, 'archive-report.html', 'text/html');
+    }
+
+    window.app.modules.export = {
+        csvCell,
+        rowsToCSV,
+        exportCSV,
+        downloadSelected,
+        loadJSZip,
+        showProgress,
+        hideProgress,
+        downloadFile,
+        downloadBlob,
+        formatFileSize,
+        exportHTMLReport
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // Party presets for archive browser — IIFE module
+
+    // State (module scope, NOT on window.app)
+    let presets = [];
+    let activePresetName = null;
+    let isOpen = false;
+    let isNamingMode = false;
+
+    // Get localStorage key based on source mode and directory
+    function getStorageKey() {
+        if (window.app.sourceMode === 'http' && window.app.directories.length > 0) {
+            var u = window.app.directories[0].url || '';
+            return 'zddc-presets:http:' + u;
+        } else if (window.app.sourceMode === 'local' && window.app.directories.length > 0) {
+            return 'zddc-presets:local:' + window.app.directories[0].name;
+        }
+        return 'zddc-presets:default';
+    }
+
+    // Load presets from localStorage
+    function loadFromStorage() {
+        try {
+            var stored = localStorage.getItem(getStorageKey());
+            if (stored) {
+                var parsed = JSON.parse(stored);
+                if (parsed && Array.isArray(parsed.presets)) {
+                    presets = parsed.presets;
+                } else {
+                    presets = [];
+                }
+            } else {
+                presets = [];
+            }
+        } catch (e) {
+            presets = [];
+        }
+    }
+
+    // Save presets to localStorage
+    function saveToStorage() {
+        try {
+            localStorage.setItem(getStorageKey(), JSON.stringify({ presets: presets }));
+        } catch (e) {
+            // Silently fail on storage errors
+        }
+    }
+
+    // Load a preset by name
+    function loadPreset(name) {
+        var preset = presets.find(p => p.name === name);
+        if (!preset) return;
+
+        // Filter paths to only include folders that exist in groupingFolders
+        var validPaths = preset.paths.filter(p =>
+            window.app.groupingFolders.some(f => f.path === p)
+        );
+
+        window.app.selectedGroupingFolders = new Set(validPaths);
+        window.app.selectAllGroupingFolders = false;
+
+        var checkbox = document.getElementById('selectAllGroupingCheckbox');
+        if (checkbox) checkbox.checked = false;
+
+        activePresetName = name;
+
+        // Trigger UI updates
+        window.app.modules.app.updateFolderSelectionState('groupingFoldersList');
+        window.app.modules.app.renderTransmittalFolders();
+        window.app.modules.filtering.applyFilters();
+
+        renderButton();
+        renderDropdown();
+    }
+
+    // Save current selection as a preset
+    function savePreset(name) {
+        // Build paths array from current selection
+        var paths = Array.from(window.app.selectedGroupingFolders);
+
+        // Upsert preset
+        var existingIndex = presets.findIndex(p => p.name === name);
+        if (existingIndex >= 0) {
+            presets[existingIndex] = { name: name, paths: paths };
+        } else {
+            presets.push({ name: name, paths: paths });
+        }
+
+        saveToStorage();
+        activePresetName = name;
+        isNamingMode = false;
+
+        renderButton();
+        renderDropdown();
+    }
+
+    // Delete a preset by name
+    function deletePreset(name) {
+        presets = presets.filter(p => p.name !== name);
+        if (activePresetName === name) {
+            activePresetName = null;
+        }
+        saveToStorage();
+        renderButton();
+        renderDropdown();
+    }
+
+    // Check if current selection differs from active preset
+    function checkDirty() {
+        if (activePresetName === null) return;
+
+        var preset = presets.find(p => p.name === activePresetName);
+        if (!preset) return;
+
+        var currentPaths = new Set(window.app.selectedGroupingFolders);
+        var presetPaths = new Set(preset.paths || []);
+
+        // Compare sets
+        var dirty = currentPaths.size !== presetPaths.size ||
+            !Array.from(currentPaths).every(p => presetPaths.has(p));
+
+        if (dirty) {
+            renderButton();
+        }
+    }
+
+    // Get minimum depth of grouping folders (for top-level Only)
+    function getMinDepth() {
+        if (window.app.groupingFolders.length === 0) return 1;
+        return Math.min.apply(null, window.app.groupingFolders.map(f => f.path.split('/').length));
+    }
+
+    // Render the preset button label
+    function renderButton() {
+        var btn = document.getElementById('presetBtn');
+        if (!btn) return;
+
+        if (activePresetName !== null) {
+            // Check if dirty
+            var preset = presets.find(p => p.name === activePresetName);
+            var dirty = false;
+            if (preset) {
+                var currentPaths = new Set(window.app.selectedGroupingFolders);
+                var presetPaths = new Set(preset.paths || []);
+                dirty = currentPaths.size !== presetPaths.size ||
+                    !Array.from(currentPaths).every(p => presetPaths.has(p));
+            }
+            btn.textContent = '▾ ' + activePresetName + (dirty ? '*' : '');
+        } else {
+            btn.textContent = '▾ Presets';
+        }
+    }
+
+    // Escape HTML for safe insertion
+    function escapeHtml(text) {
+        var div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    // Render the dropdown panel
+    function renderDropdown() {
+        var dropdown = document.getElementById('presetDropdown');
+        if (!dropdown) return;
+
+        var minDepth = getMinDepth();
+
+        // Build presets list HTML
+        var presetsHtml = '';
+        if (presets.length === 0) {
+            presetsHtml = '<div class="preset-no-presets"><i>No saved presets</i></div>';
+        } else {
+            presetsHtml = presets.map(preset => {
+                var escapedName = escapeHtml(preset.name);
+                return (
+                    '<div class="preset-item" data-name="' + escapedName + '">' +
+                        '<span>' + escapedName + '</span>' +
+                        '<button class="preset-delete" data-name="' + escapedName + '">×</button>' +
+                    '</div>'
+                );
+            }).join('');
+        }
+
+        // Build project checkboxes HTML
+        var projectsHtml = '';
+        window.app.groupingFolders.forEach(folder => {
+            // Only include top-level folders (minDepth)
+            var pathParts = folder.path.split('/');
+            if (pathParts.length !== minDepth) return;
+
+            var isSelected = window.app.selectedGroupingFolders.has(folder.path);
+            var escapedPath = escapeHtml(folder.path);
+            var escapedName = escapeHtml(folder.name);
+
+            projectsHtml += (
+                '<div class="preset-project-item">' +
+                    '<label class="preset-project-label">' +
+                        '<input type="checkbox" class="preset-checkbox" data-path="' + escapedPath + '"' +
+                            (isSelected ? ' checked' : '') + '>' +
+                        ' ' + escapedName +
+                    '</label>' +
+                '</div>'
+            );
+        });
+
+        // Footer HTML
+        var footerHtml = '';
+        if (activePresetName !== null) {
+            // Check if dirty
+            var preset = presets.find(p => p.name === activePresetName);
+            var dirty = false;
+            if (preset) {
+                var currentPaths = new Set(window.app.selectedGroupingFolders);
+                var presetPaths = new Set(preset.paths || []);
+                dirty = currentPaths.size !== presetPaths.size ||
+                    !Array.from(currentPaths).every(p => presetPaths.has(p));
+            }
+
+            if (isNamingMode) {
+                footerHtml = (
+                    '<div class="preset-footer-naming">' +
+                        '<input type="text" class="preset-name-input" placeholder="Preset name" autoFocus>' +
+                        '<button class="preset-confirm-name btn btn-sm">✓</button>' +
+                        '<button class="preset-cancel-name btn btn-sm">✗</button>' +
+                    '</div>'
+                );
+            } else if (dirty) {
+                footerHtml = (
+                    '<div class="preset-footer-actions">' +
+                        '<button class="preset-update-btn btn btn-primary btn-sm">Update "' + escapeHtml(activePresetName) + '"</button>' +
+                        '<button class="preset-save-new-btn btn btn-secondary btn-sm">Save as New</button>' +
+                    '</div>'
+                );
+            } else {
+                footerHtml = (
+                    '<div class="preset-footer-actions">' +
+                        '<button class="preset-save-new-btn btn btn-primary btn-sm">Save as New</button>' +
+                    '</div>'
+                );
+            }
+        } else {
+            // No active preset — disabled if nothing selected
+            var selectedCount = window.app.selectedGroupingFolders.size;
+            var disabledAttr = selectedCount === 0 ? ' disabled' : '';
+            footerHtml = (
+                '<div class="preset-footer-actions">' +
+                    '<button class="preset-save-btn btn btn-primary btn-sm' + (selectedCount === 0 ? ' btn-disabled' : '') + '" ' +
+                        'data-disabled="' + (selectedCount === 0 ? 'true' : 'false') + '">Save as Preset</button>' +
+                '</div>'
+            );
+        }
+
+        dropdown.innerHTML = (
+            '<div class="preset-section-top">' +
+                '<div class="preset-section-label">Saved Presets:</div>' +
+                '<div class="preset-list">' + presetsHtml + '</div>' +
+            '</div>' +
+            '<div class="preset-divider"></div>' +
+            '<div class="preset-section-bottom">' +
+                '<div class="preset-section-label">Projects:</div>' +
+                '<div class="preset-projects-list">' + projectsHtml + '</div>' +
+            '</div>' +
+            footerHtml
+        );
+    }
+
+    // Toggle dropdown visibility
+    function toggleDropdown() {
+        var dropdown = document.getElementById('presetDropdown');
+        if (isOpen) {
+            closeDropdown();
+        } else {
+            isOpen = true;
+            if (dropdown) dropdown.classList.remove('hidden');
+            renderDropdown();
+        }
+    }
+
+    // Close dropdown
+    function closeDropdown() {
+        isOpen = false;
+        var dropdown = document.getElementById('presetDropdown');
+        if (dropdown) dropdown.classList.add('hidden');
+        isNamingMode = false;
+    }
+
+    // Set up event delegation on dropdown
+    function setupDropdownDelegation() {
+        var dropdown = document.getElementById('presetDropdown');
+        if (!dropdown) return;
+
+        dropdown.addEventListener('click', function(e) {
+            // Close on clicks inside dropdown
+            e.stopPropagation();
+
+            // Preset item click — load preset (do NOT close dropdown)
+            var presetItem = e.target.closest('.preset-item');
+            if (presetItem && !e.target.classList.contains('preset-delete')) {
+                var name = presetItem.getAttribute('data-name');
+                if (name) loadPreset(name);
+                return;
+            }
+
+            // Delete button
+            var deleteBtn = e.target.closest('.preset-delete');
+            if (deleteBtn) {
+                e.stopPropagation();
+                var name = deleteBtn.getAttribute('data-name');
+                if (name) deletePreset(name);
+                return;
+            }
+
+            // Checkbox click
+            var checkbox = e.target.closest('.preset-checkbox');
+            if (checkbox) {
+                var path = checkbox.getAttribute('data-path');
+                if (path) {
+                    if (checkbox.checked) {
+                        window.app.selectedGroupingFolders.add(path);
+                    } else {
+                        window.app.selectedGroupingFolders.delete(path);
+                    }
+                    window.app.modules.app.updateFolderSelectionState('groupingFoldersList');
+                    window.app.modules.app.renderTransmittalFolders();
+                    window.app.modules.filtering.applyFilters();
+                    checkDirty();
+                    renderButton();
+                    renderDropdown(); // Re-render to update checkbox states and footer
+                }
+                return;
+            }
+
+            // Save button (not in naming mode)
+            var saveBtn = e.target.closest('.preset-save-btn');
+            if (saveBtn && !isNamingMode) {
+                if (saveBtn.getAttribute('data-disabled') !== 'true') {
+                    isNamingMode = true;
+                    renderDropdown();
+                }
+                return;
+            }
+
+            // Update button — save current selection as active preset
+            var updateBtn = e.target.closest('.preset-update-btn');
+            if (updateBtn) {
+                if (activePresetName) savePreset(activePresetName);
+                return;
+            }
+
+            // Save as New button
+            var saveNewBtn = e.target.closest('.preset-save-new-btn');
+            if (saveNewBtn) {
+                isNamingMode = true;
+                renderDropdown();
+                return;
+            }
+
+            // Confirm name input
+            var confirmBtn = e.target.closest('.preset-confirm-name');
+            if (confirmBtn) {
+                var input = dropdown.querySelector('.preset-name-input');
+                if (input && input.value.trim()) {
+                    savePreset(input.value.trim());
+                }
+                return;
+            }
+
+            // Cancel name input
+            var cancelBtn = e.target.closest('.preset-cancel-name');
+            if (cancelBtn) {
+                isNamingMode = false;
+                renderDropdown();
+                return;
+            }
+        });
+
+        // Keydown on name input
+        dropdown.addEventListener('keydown', function(e) {
+            var input = e.target.closest('.preset-name-input');
+            if (!input) return;
+
+            if (e.key === 'Enter') {
+                e.stopPropagation();
+                if (input.value.trim()) {
+                    savePreset(input.value.trim());
+                }
+            } else if (e.key === 'Escape') {
+                e.stopPropagation();
+                isNamingMode = false;
+                renderDropdown();
+            }
+        });
+    }
+
+    // Handle outside click to close dropdown
+    function setupOutsideClickHandler() {
+        document.addEventListener('click', function(e) {
+            var section = document.getElementById('presetSection');
+            var dropdown = document.getElementById('presetDropdown');
+            if (isOpen && section && dropdown && !section.contains(e.target)) {
+                closeDropdown();
+            }
+        });
+    }
+
+    // Initialize presets module — called after first scan completes
+    function init() {
+        // Idempotent: skip if button listener already attached
+        var btn = document.getElementById('presetBtn');
+        if (!btn || btn.dataset.presetInit) return;
+        btn.dataset.presetInit = '1';
+
+        btn.addEventListener('click', function(e) {
+            e.stopPropagation();
+            toggleDropdown();
+        });
+
+        setupDropdownDelegation();
+        setupOutsideClickHandler();
+        loadFromStorage();
+        renderButton();
+    }
+
+    // Register module
+    window.app.modules.presets = {
+        init: init,
+        loadPreset: loadPreset,
+        savePreset: savePreset,
+        deletePreset: deletePreset,
+        checkDirty: checkDirty,
+        renderButton: renderButton,
+        toggleDropdown: toggleDropdown,
+        closeDropdown: closeDropdown
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // URL state sync module for ZDDC Archive
+
+    // Default values for URL params
+    var DEFAULT_SORT_FIELD = 'trackingNumber';
+    var DEFAULT_SORT_DIRECTION = 'asc';
+    var DEFAULT_ENABLED_TYPES = ['issued', 'received'];
+
+    // Map URL param names to state paths
+    var PARAM_MAP = {
+        sort: 'sortField',
+        dir: 'sortDirection',
+        tn: 'columnFilters.trackingNumber',
+        ti: 'columnFilters.title',
+        rv: 'columnFilters.revisions',
+        types: 'enabledFolderTypes',
+        gf: 'groupingFilter',
+        tf: 'transmittalFilter'
+    };
+
+    // Serialize current state to URL query string
+    function serialize() {
+        var params = new URLSearchParams();
+
+        // Sort field
+        if (window.app.sortField !== DEFAULT_SORT_FIELD) {
+            params.set('sort', window.app.sortField);
+        }
+
+        // Sort direction
+        if (window.app.sortDirection !== DEFAULT_SORT_DIRECTION) {
+            params.set('dir', window.app.sortDirection);
+        }
+
+        // Column filters
+        if (window.app.columnFilters.trackingNumber !== '') {
+            params.set('tn', window.app.columnFilters.trackingNumber);
+        }
+        if (window.app.columnFilters.title !== '') {
+            params.set('ti', window.app.columnFilters.title);
+        }
+        if (window.app.columnFilters.revisions !== '') {
+            params.set('rv', window.app.columnFilters.revisions);
+        }
+
+        // Folder types (only if different from default [issued, received])
+        var enabledTypes = Array.from(window.app.enabledFolderTypes).sort();
+        var defaultTypes = DEFAULT_ENABLED_TYPES.slice().sort();
+        if (JSON.stringify(enabledTypes) !== JSON.stringify(defaultTypes)) {
+            params.set('types', enabledTypes.join(','));
+        }
+
+        // Grouping filter
+        if (window.app.groupingFilter !== '') {
+            params.set('gf', window.app.groupingFilter);
+        }
+
+        // Transmittal filter
+        if (window.app.transmittalFilter !== '') {
+            params.set('tf', window.app.transmittalFilter);
+        }
+
+        // Project filter — always preserved if set (for shareable URLs)
+        if (window.app.projectFilter && window.app.projectFilter.size > 0) {
+            params.set('projects', Array.from(window.app.projectFilter).join(','));
+        }
+
+        // Build query string
+        var qs = params.toString();
+        return qs ? '?' + qs : '';
+    }
+
+    // Push state to URL without triggering popstate
+    function push() {
+        var result = serialize();
+        if (result === location.search) {
+            return;
+        }
+        try {
+            history.replaceState(null, '', location.pathname + result);
+        } catch (e) {
+            // Silently swallow errors (e.g., file:// protocol restrictions)
+        }
+    }
+
+    // Restore state from URL query string
+    function restore() {
+        var params = new URLSearchParams(location.search);
+
+        // Restore sort field
+        if (params.has('sort')) {
+            var sortValue = params.get('sort');
+            if (sortValue === 'trackingNumber' || sortValue === 'title') {
+                window.app.sortField = sortValue;
+            }
+        }
+
+        // Restore sort direction
+        if (params.has('dir')) {
+            var dirValue = params.get('dir');
+            if (dirValue === 'asc' || dirValue === 'desc') {
+                window.app.sortDirection = dirValue;
+            }
+        }
+
+        // Restore column filters with AST parsing
+        if (params.has('tn')) {
+            var tnValue = params.get('tn');
+            window.app.columnFilters.trackingNumber = tnValue;
+            window.app.columnFilterASTs.trackingNumber = zddc.filter.parse(tnValue);
+        }
+        if (params.has('ti')) {
+            var tiValue = params.get('ti');
+            window.app.columnFilters.title = tiValue;
+            window.app.columnFilterASTs.title = zddc.filter.parse(tiValue);
+        }
+        if (params.has('rv')) {
+            var rvValue = params.get('rv');
+            window.app.columnFilters.revisions = rvValue;
+            window.app.columnFilterASTs.revisions = zddc.filter.parse(rvValue);
+        }
+
+        // Restore folder types
+        if (params.has('types')) {
+            var typesValue = params.get('types');
+            var typeValues = typesValue.split(',').map(function(t) { return t.trim(); });
+            // Validate against app.FOLDER_TYPE_NAMES
+            var validTypes = typeValues.filter(function(t) {
+                return window.app.FOLDER_TYPE_NAMES.indexOf(t) !== -1;
+            });
+            window.app.enabledFolderTypes = new Set(validTypes);
+        }
+
+        // Restore grouping filter
+        if (params.has('gf')) {
+            window.app.groupingFilter = params.get('gf');
+        }
+
+        // Restore transmittal filter
+        if (params.has('tf')) {
+            window.app.transmittalFilter = params.get('tf');
+        }
+
+        // Restore project filter
+        if (params.has('projects')) {
+            var projValue = params.get('projects');
+            var projNames = projValue.split(',').map(function(p) { return p.trim(); }).filter(Boolean);
+            window.app.projectFilter = new Set(projNames);
+        }
+
+        // Update DOM inputs to reflect restored values
+        updateFilterInputs();
+    }
+
+    // Update DOM filter inputs to match restored state
+    function updateFilterInputs() {
+        // Column filter inputs
+        document.querySelectorAll('.column-filter[data-filter-field]').forEach(function(input) {
+            var field = input.getAttribute('data-filter-field');
+            var filterValue = window.app.columnFilters[field] || '';
+            input.value = filterValue;
+            if (filterValue !== '') {
+                input.classList.add('filter-active');
+            } else {
+                input.classList.remove('filter-active');
+            }
+        });
+
+        // Grouping filter
+        var groupingFilterEl = document.getElementById('groupingFilter');
+        if (groupingFilterEl) {
+            groupingFilterEl.value = window.app.groupingFilter;
+            if (window.app.groupingFilter !== '') {
+                groupingFilterEl.classList.add('filter-active');
+            } else {
+                groupingFilterEl.classList.remove('filter-active');
+            }
+        }
+
+        // Transmittal filter
+        var transmittalFilterEl = document.getElementById('transmittalFilter');
+        if (transmittalFilterEl) {
+            transmittalFilterEl.value = window.app.transmittalFilter;
+            if (window.app.transmittalFilter !== '') {
+                transmittalFilterEl.classList.add('filter-active');
+            } else {
+                transmittalFilterEl.classList.remove('filter-active');
+            }
+        }
+    }
+
+    // Register module
+    window.app.modules.urlState = {
+        serialize: serialize,
+        push: push,
+        restore: restore
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // Event handling
+
+    // Set up all event listeners
+    function setupEventListeners() {
+        // Header buttons
+        document.getElementById('addDirectoryBtn').addEventListener('click', () => window.app.modules.directory.addDirectory());
+        document.getElementById('refreshHeaderBtn').addEventListener('click', () => window.app.modules.directory.refreshDirectories());
+    
+        // Content area buttons
+        document.getElementById('filterSelectedBtn').addEventListener('click', () => window.app.modules.app.toggleFilterSelected());
+        document.getElementById('downloadSelectedBtn').addEventListener('click', () => window.app.modules.export.downloadSelected());
+        document.getElementById('exportCsvBtn').addEventListener('click', () => window.app.modules.export.exportCSV());
+    
+        // Search and filter inputs
+        document.getElementById('groupingFilter').addEventListener('input', (e) => {
+            window.app.groupingFilter = e.target.value;
+            e.target.classList.toggle('filter-active', e.target.value.length > 0);
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters();
+            window.app.modules.urlState.push();
+        });
+
+        document.getElementById('transmittalFilter').addEventListener('input', (e) => {
+            window.app.transmittalFilter = e.target.value;
+            e.target.classList.toggle('filter-active', e.target.value.length > 0);
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters(); // Re-filter files when transmittal filter changes
+            window.app.modules.urlState.push();
+        });
+    
+        // Select All Grouping Folders checkbox
+        document.getElementById('selectAllGroupingCheckbox').addEventListener('change', (e) => {
+            window.app.selectAllGroupingFolders = e.target.checked;
+            window.app.modules.app.renderGroupingFolders();
+            window.app.modules.app.renderTransmittalFolders();
+            window.app.modules.filtering.applyFilters();
+        });
+    
+        // Folder type toggle bar — global click delegation
+        document.addEventListener('click', (e) => {
+            const btn = e.target.closest('.folder-type-toggle');
+            if (btn) {
+                const type = btn.getAttribute('data-type');
+                if (type) window.app.modules.app.toggleFolderType(type);
+            }
+        });
+    
+        // Select All Transmittals checkbox
+        document.getElementById('selectAllTransmittalsCheckbox').addEventListener('change', (e) => {
+            window.app.selectAllTransmittals = e.target.checked;
+            window.app.modules.app.renderTransmittalFolders();
+            window.app.modules.filtering.applyFilters();
+        });
+    
+        // Modifier filter dropdown
+        document.getElementById('modifierFilterBtn').addEventListener('click', () => window.app.modules.app.toggleModifierDropdown());
+        document.getElementById('modifierSelectAll').addEventListener('change', (e) => {
+            window.app.modules.app.toggleAllModifiers(e.target.checked);
+        });
+    
+        // Close modifier dropdown when clicking outside
+        document.addEventListener('click', (e) => {
+            const container = document.querySelector('.modifier-filter-container');
+            const dropdown = document.getElementById('modifierFilterDropdown');
+            if (container && dropdown && !container.contains(e.target)) {
+                dropdown.classList.add('hidden');
+            }
+        });
+    
+        // Select all visible files checkbox
+        document.getElementById('selectAllVisibleCheckbox').addEventListener('change', (e) => {
+            e.stopPropagation();
+            window.app.modules.table.toggleSelectAllVisible(e.target.checked);
+        });
+        
+        // Reset filters button
+        document.getElementById('resetFiltersBtn').addEventListener('click', () => window.app.modules.filtering.clearFilters());
+    
+        // Column filters — delegated from thead
+        const thead = document.querySelector('thead');
+        if (thead) {
+            thead.addEventListener('input', (e) => {
+                if (e.target.matches('.column-filter[data-filter-field]')) {
+                    const field = e.target.getAttribute('data-filter-field');
+                    const raw = e.target.value.trim();
+                    window.app.columnFilters[field] = raw;
+                    window.app.columnFilterASTs[field] = zddc.filter.parse(raw);
+                    
+                    // Add/remove filter-active class based on non-empty value
+                    if (raw) {
+                        e.target.classList.add('filter-active');
+                    } else {
+                        e.target.classList.remove('filter-active');
+                    }
+                    
+                    window.app.modules.filtering.applyFilters();
+                    window.app.modules.urlState.push();
+                }
+            });
+            thead.addEventListener('keydown', (e) => {
+                if (!e.target.matches('.column-filter[data-filter-field]')) return;
+                if (e.key === 'Escape') {
+                    e.target.value = '';
+                    e.target.classList.remove('filter-active');
+                    const field = e.target.getAttribute('data-filter-field');
+                    window.app.columnFilters[field] = '';
+                    window.app.columnFilterASTs[field] = null;
+                    window.app.modules.filtering.applyFilters();
+                    window.app.modules.urlState.push();
+                    e.preventDefault();
+                } else if (e.key === 'Enter') {
+                    e.preventDefault();
+                    const inputs = Array.from(thead.querySelectorAll('.column-filter'));
+                    const idx = inputs.indexOf(e.target);
+                    if (idx !== -1) {
+                        inputs[(idx + 1) % inputs.length].focus();
+                    }
+                }
+            });
+            thead.addEventListener('click', (e) => {
+                if (e.target.matches('.column-filter')) {
+                    e.stopPropagation();
+                }
+            });
+        }
+    
+        // Table sorting
+        document.querySelectorAll('.sortable').forEach(th => {
+            th.querySelector('.th-content').addEventListener('click', () => {
+                const field = th.getAttribute('data-field');
+                window.app.modules.table.sortTable(field);
+            });
+        });
+    
+        // Initialize column resize
+        window.app.modules.table.initializeColumnResize();
+    
+        // Modal close buttons
+        document.querySelectorAll('.modal-close').forEach(btn => {
+            btn.addEventListener('click', closeModal);
+        });
+    
+        // Modal backdrop clicks
+        document.querySelectorAll('.modal-backdrop').forEach(backdrop => {
+            backdrop.addEventListener('click', closeModal);
+        });
+    
+        // Drop modal buttons
+        const dropModal = document.getElementById('dropModal');
+        dropModal.querySelector('.modal-cancel').addEventListener('click', closeModal);
+        dropModal.querySelector('.modal-confirm').addEventListener('click', () => window.app.modules.dragDrop.confirmTransmittal());
+    
+        // Drag and drop (local mode only — requires write access)
+        if (window.app.sourceMode === 'local') {
+            window.app.modules.dragDrop.setupDragAndDrop();
+        }
+    
+        // Multi-select for folders
+        setupFolderMultiSelect();
+    
+        // Date group toggle handlers
+        setupDateGroupToggles();
+    
+        // Grouping section collapse toggle
+        setupGroupingToggle();
+    
+        // Resizable panes
+        setupResizablePanes();
+    
+        // Keyboard shortcuts
+        document.addEventListener('keydown', handleKeyboardShortcuts);
+    }
+
+
+
+    // Handle grouping filter
+    function handleGroupingFilter(e) {
+        window.app.groupingFilter = e.target.value;
+        window.app.modules.app.renderGroupingFolders();
+        // Re-render transmittal folders as they depend on grouping selection
+        window.app.modules.app.renderTransmittalFolders();
+        // Re-filter files based on updated folder selections
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Handle transmittal filter
+    function handleTransmittalFilter(e) {
+        window.app.transmittalFilter = e.target.value;
+        window.app.modules.app.renderTransmittalFolders();
+        // Re-filter files based on updated folder selections
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Close modal
+    function closeModal(e) {
+        const modal = e.target.closest('.modal');
+        if (modal) {
+            modal.classList.add('hidden');
+        }
+    }
+
+    // Handle keyboard shortcuts
+    function handleKeyboardShortcuts(e) {
+        // Escape closes modals
+        if (e.key === 'Escape') {
+            document.querySelectorAll('.modal:not(.hidden)').forEach(modal => {
+                modal.classList.add('hidden');
+            });
+        }
+    
+        // Ctrl+A selects all visible files
+        if (e.ctrlKey && e.key === 'a' && e.target.tagName !== 'INPUT') {
+            e.preventDefault();
+            toggleSelectAll();
+        }
+    
+        // F5 refreshes
+        if (e.key === 'F5') {
+            e.preventDefault();
+            window.app.modules.directory.refreshDirectories();
+        }
+    }
+
+    // Utility: Debounce function
+    function debounce(func, wait) {
+        let timeout;
+        return function executedFunction(...args) {
+            const later = () => {
+                clearTimeout(timeout);
+                func(...args);
+            };
+            clearTimeout(timeout);
+            timeout = setTimeout(later, wait);
+        };
+    }
+
+    // Multi-select handling for folder lists
+    function setupFolderMultiSelect() {
+        let lastSelectedGroupingIndex = -1;
+        let lastSelectedTransmittalIndex = -1;
+    
+        // Handle grouping folders
+        const groupingList = document.getElementById('groupingFoldersList');
+        groupingList.addEventListener('click', (e) => {
+            const result = handleFolderClick(e, window.app.selectedGroupingFolders, lastSelectedGroupingIndex);
+            if (result !== undefined) {
+                lastSelectedGroupingIndex = result;
+                // Turn off "Select All" mode when user manually selects
+                if (window.app.selectAllGroupingFolders) {
+                    window.app.selectAllGroupingFolders = false;
+                    document.getElementById('selectAllGroupingCheckbox').checked = false;
+                }
+                // Update selection state first
+                window.app.modules.app.updateFolderSelectionState('groupingFoldersList');
+                // Then update transmittal folder list based on new selection
+                window.app.modules.app.renderTransmittalFolders();
+                window.app.modules.filtering.applyFilters(); // Re-filter files
+                // Check presets dirty state
+                if (window.app.modules.presets) {
+                    window.app.modules.presets.checkDirty();
+                }
+                // Reset transmittal index since list may have changed
+                lastSelectedTransmittalIndex = -1;
+            }
+        });
+    
+        // Handle transmittal folders
+        const transmittalList = document.getElementById('transmittalFoldersList');
+        transmittalList.addEventListener('click', (e) => {
+            const result = handleFolderClick(e, window.app.selectedTransmittalFolders, lastSelectedTransmittalIndex);
+            if (result !== undefined) {
+                lastSelectedTransmittalIndex = result;
+                // Turn off "Select All" mode when user manually selects
+                if (window.app.selectAllTransmittals) {
+                    window.app.selectAllTransmittals = false;
+                    document.getElementById('selectAllTransmittalsCheckbox').checked = false;
+                }
+                // Update selection state without rebuilding DOM
+                window.app.modules.app.updateFolderSelectionState('transmittalFoldersList');
+                window.app.modules.filtering.applyFilters(); // Update file display
+            }
+        });
+    
+        // Handle Ctrl+A for folder lists
+        groupingList.addEventListener('keydown', (e) => {
+            if (e.ctrlKey && e.key === 'a') {
+                e.preventDefault();
+                selectAllVisibleFolders('grouping');
+            }
+        });
+    
+        transmittalList.addEventListener('keydown', (e) => {
+            if (e.ctrlKey && e.key === 'a') {
+                e.preventDefault();
+                selectAllVisibleFolders('transmittal');
+            }
+        });
+    
+        // Make lists focusable
+        groupingList.setAttribute('tabindex', '0');
+        transmittalList.setAttribute('tabindex', '0');
+    }
+
+    /**
+     * Handle folder click with multi-select support (Shift/Ctrl)
+     * @param {Event} e - Click event
+     * @param {Set} selectedSet - Set of selected folder paths
+     * @param {number} lastIndex - Index of last clicked item
+     * @returns {number|undefined} Current index if valid click, undefined otherwise
+     */
+    function handleFolderClick(e, selectedSet, lastIndex) {
+        const folderItem = e.target.closest('.folder-item');
+        if (!folderItem) return undefined;
+    
+        const path = folderItem.getAttribute('data-path');
+        if (!path) return undefined;
+    
+        const container = folderItem.parentElement;
+        const items = Array.from(container.children);
+        const currentIndex = items.indexOf(folderItem);
+    
+        if (e.shiftKey && lastIndex !== -1 && lastIndex < items.length) {
+            // Shift+click: select range from last to current
+            e.preventDefault();
+            const start = Math.min(lastIndex, currentIndex);
+            const end = Math.max(lastIndex, currentIndex);
+        
+            if (!e.ctrlKey) {
+                selectedSet.clear();
+            }
+        
+            for (let i = start; i <= end; i++) {
+                const itemPath = items[i]?.getAttribute('data-path');
+                if (itemPath) {
+                    selectedSet.add(itemPath);
+                }
+            }
+        } else if (e.ctrlKey || e.metaKey) {
+            // Ctrl+click: toggle individual selection
+            e.preventDefault();
+            if (selectedSet.has(path)) {
+                selectedSet.delete(path);
+            } else {
+                selectedSet.add(path);
+            }
+        } else {
+            // Regular click: clear and select single item
+            selectedSet.clear();
+            selectedSet.add(path);
+        }
+    
+        return currentIndex;
+    }
+
+    /**
+     * Toggle expand/collapse state of a grouping folder
+     * @param {string} path - Folder path to toggle
+     * @param {boolean} recursive - If true, also toggle all descendants
+     */
+    function toggleGroupingFolder(path, recursive) {
+        const isCurrentlyCollapsed = window.app.collapsedGroupingFolders.has(path);
+    
+        if (recursive) {
+            // Get all descendant folder paths
+            const descendants = window.app.groupingFolders
+                .filter(f => f.path.startsWith(path + '/'))
+                .map(f => f.path);
+        
+            if (isCurrentlyCollapsed) {
+                // Expand this folder and all descendants
+                window.app.collapsedGroupingFolders.delete(path);
+                descendants.forEach(p => window.app.collapsedGroupingFolders.delete(p));
+            } else {
+                // Collapse this folder and all descendants
+                window.app.collapsedGroupingFolders.add(path);
+                descendants.forEach(p => window.app.collapsedGroupingFolders.add(p));
+            }
+        } else {
+            // Just toggle this folder
+            if (isCurrentlyCollapsed) {
+                window.app.collapsedGroupingFolders.delete(path);
+            } else {
+                window.app.collapsedGroupingFolders.add(path);
+            }
+        }
+    
+        window.app.modules.app.renderGroupingFolders();
+    }
+
+    // Select all visible folders
+    function selectAllVisibleFolders(folderType) {
+        const container = folderType === 'grouping' ? 
+            document.getElementById('groupingFoldersList') : 
+            document.getElementById('transmittalFoldersList');
+    
+        const selectedSet = folderType === 'grouping' ? 
+            window.app.selectedGroupingFolders : 
+            window.app.selectedTransmittalFolders;
+    
+        selectedSet.clear();
+    
+        const items = container.querySelectorAll('.folder-item');
+        items.forEach(item => {
+            const path = item.getAttribute('data-path');
+            if (path) {
+                selectedSet.add(path);
+            }
+        });
+    
+        if (folderType === 'grouping') {
+            // Update UI to reflect grouping changes
+            window.app.modules.app.updateUI();
+            window.app.modules.filtering.applyFilters();
+        } else {
+            // For transmittal folders, just update selection state
+            window.app.modules.app.updateFolderSelectionState('transmittalFoldersList');
+            window.app.modules.filtering.applyFilters();
+        }
+    }
+
+    // Setup date group toggle handlers
+    function setupDateGroupToggles() {
+        // Toggle all dates button
+        const toggleAllBtn = document.getElementById('toggleAllDatesBtn');
+        if (toggleAllBtn) {
+            toggleAllBtn.addEventListener('click', toggleAllDateGroups);
+        }
+    
+        // Individual date group headers (using event delegation)
+        const transmittalList = document.getElementById('transmittalFoldersList');
+        transmittalList.addEventListener('click', (e) => {
+            const header = e.target.closest('.date-group-header');
+            if (header) {
+                const date = header.getAttribute('data-date');
+                if (date) {
+                    toggleDateGroup(date);
+                }
+            }
+        });
+    }
+
+    // Toggle a single date group
+    function toggleDateGroup(date) {
+        if (window.app.collapsedDateGroups.has(date)) {
+            window.app.collapsedDateGroups.delete(date);
+        } else {
+            window.app.collapsedDateGroups.add(date);
+        }
+        window.app.modules.app.renderTransmittalFolders();
+        updateToggleAllIcon();
+    }
+
+    // Toggle all date groups
+    function toggleAllDateGroups() {
+        const headers = document.querySelectorAll('.date-group-header');
+        const allDates = Array.from(headers).map(h => h.getAttribute('data-date')).filter(Boolean);
+    
+        // If all are collapsed, expand all. Otherwise, collapse all.
+        const allCollapsed = allDates.length > 0 && allDates.every(date => window.app.collapsedDateGroups.has(date));
+    
+        if (allCollapsed) {
+            // Expand all
+            window.app.collapsedDateGroups.clear();
+        } else {
+            // Collapse all
+            allDates.forEach(date => window.app.collapsedDateGroups.add(date));
+        }
+    
+        window.app.modules.app.renderTransmittalFolders();
+        updateToggleAllIcon();
+    }
+
+    // Update the toggle all icon based on current state
+    function updateToggleAllIcon() {
+        const icon = document.getElementById('toggleAllDatesIcon');
+        if (!icon) return;
+    
+        const headers = document.querySelectorAll('.date-group-header');
+        const allDates = Array.from(headers).map(h => h.getAttribute('data-date')).filter(Boolean);
+        const allCollapsed = allDates.length > 0 && allDates.every(date => window.app.collapsedDateGroups.has(date));
+    
+        icon.textContent = allCollapsed ? '▶' : '▼';
+    }
+
+    // Setup grouping section collapse toggle
+    function setupGroupingToggle() {
+        const toggleBtn = document.getElementById('toggleGroupingBtn');
+        const groupingSection = document.getElementById('groupingSection');
+        const icon = document.getElementById('toggleGroupingIcon');
+    
+        if (toggleBtn && groupingSection && icon) {
+            toggleBtn.addEventListener('click', () => {
+                groupingSection.classList.toggle('collapsed');
+                icon.textContent = groupingSection.classList.contains('collapsed') ? '▶' : '▼';
+            });
+        }
+    }
+
+    // Setup resizable panes
+    function setupResizablePanes() {
+        // Resize nav sections (vertical divider between grouping and transmittal)
+        const navSectionsHandle = document.querySelector('[data-resize="nav-sections"]');
+        if (navSectionsHandle) {
+            let isResizing = false;
+            let startY = 0;
+            let startHeight = 0;
+            let groupingSection = null;
+        
+            navSectionsHandle.addEventListener('mousedown', (e) => {
+                isResizing = true;
+                startY = e.clientY;
+                groupingSection = document.getElementById('groupingSection');
+                startHeight = groupingSection.offsetHeight;
+                navSectionsHandle.classList.add('resizing');
+                e.preventDefault();
+            });
+        
+            document.addEventListener('mousemove', (e) => {
+                if (!isResizing) return;
+            
+                const deltaY = e.clientY - startY;
+                const newHeight = startHeight + deltaY;
+            
+                // Set min/max heights
+                if (newHeight >= 100 && newHeight <= window.innerHeight - 250) {
+                    groupingSection.style.flex = 'none';
+                    groupingSection.style.height = newHeight + 'px';
+                }
+            });
+        
+            document.addEventListener('mouseup', () => {
+                if (isResizing) {
+                    isResizing = false;
+                    navSectionsHandle.classList.remove('resizing');
+                }
+            });
+        }
+    
+        // Resize nav pane (horizontal divider between nav and content)
+        const navPaneHandle = document.querySelector('[data-resize="nav-pane"]');
+        if (navPaneHandle) {
+            let isResizing = false;
+            let startX = 0;
+            let startWidth = 0;
+            let navPane = null;
+        
+            navPaneHandle.addEventListener('mousedown', (e) => {
+                isResizing = true;
+                startX = e.clientX;
+                navPane = document.getElementById('navigationPane');
+                startWidth = navPane.offsetWidth;
+                navPaneHandle.classList.add('resizing');
+                e.preventDefault();
+            });
+        
+            document.addEventListener('mousemove', (e) => {
+                if (!isResizing) return;
+            
+                const deltaX = e.clientX - startX;
+                const newWidth = startWidth + deltaX;
+            
+                // Set min/max widths
+                if (newWidth >= 200 && newWidth <= window.innerWidth - 400) {
+                    navPane.style.width = newWidth + 'px';
+                }
+            });
+        
+            document.addEventListener('mouseup', () => {
+                if (isResizing) {
+                    isResizing = false;
+                    navPaneHandle.classList.remove('resizing');
+                }
+            });
+        }
+    }
+
+    window.app.modules.events = {
+        setupEventListeners,
+        handleFolderClick,
+        toggleGroupingFolder,
+        selectAllVisibleFolders,
+        setupDateGroupToggles,
+        toggleDateGroup,
+        toggleAllDateGroups,
+        updateToggleAllIcon,
+        setupGroupingToggle,
+        setupResizablePanes
+    };
+
+})();
+
+(function() {
+    'use strict';
+    // window.app is initialized in init.js. Reference shape (read-only docs):
+    //   directories[], groupingFolders[], transmittalFolders[], files[],
+    //   filteredFiles[], selectedFiles:Set, sourceMode ('local'|'http'),
+    //   isScanning, scanProgress,
+    //   columnFilters {trackingNumber,title,revisions}, columnFilterASTs {...},
+    //   groupingFilter, transmittalFilter,
+    //   enabledFolderTypes:Set('issued','received'),
+    //   sortField ('trackingNumber'), sortDirection ('asc'|'desc'),
+    //   selectedGroupingFolders:Set, selectedTransmittalFolders:Set,
+    //   collapsedDateGroups:Set, collapsedGroupingFolders:Set,
+    //   selectAllGroupingFolders:bool, selectAllTransmittals:bool,
+    //   availableModifiers:Set, selectedModifiers:Set, showSelectedOnly:bool
+
+    // Parse search terms from filter string
+    function parseSearchTerms(filter) {
+        if (!filter || !filter.trim()) return [];
+        return filter.trim().toLowerCase().split(/\s+/);
+    }
+
+    // Check if text matches all search terms (AND logic)
+    function matchesSearchTerms(text, terms) {
+        if (!terms || terms.length === 0) return true;
+        return terms.every(term => text.includes(term));
+    }
+
+    // Initialize application
+    function initApp() {
+        // Detect source mode from protocol
+        window.app.sourceMode = (location.protocol === 'file:') ? 'local' : 'http';
+    
+        if (window.app.sourceMode === 'local') {
+            // Check File System Access API support (local mode only)
+            if (!('showDirectoryPicker' in window)) {
+                showUnsupportedBrowserMessage();
+                return;
+            }
+        }
+    
+        // Set up event listeners
+        window.app.modules.events.setupEventListeners();
+    
+        // Set up file link handlers (event delegation)
+        window.app.modules.table.setupFileLinkHandlers();
+    
+        // Apply source-mode-specific UI adjustments
+        applySourceModeUI();
+    
+        // Restore filter/sort state from URL query string
+        window.app.modules.urlState.restore();
+    
+        // Initialize UI
+        updateUI();
+    
+        // Show initial sort indicator
+        window.app.modules.table.updateSortIndicators();
+    
+        if (window.app.sourceMode === 'http') {
+            // Auto-connect to the server in HTTP mode
+            autoConnectHttpSource();
+        } else {
+            // Show empty state if no directories (local mode)
+            if (window.app.directories.length === 0) {
+                showEmptyState();
+            }
+        }
+    }
+
+    // Apply UI differences based on source mode
+    function applySourceModeUI() {
+        // "Add Local Directory" button is always visible in both modes —
+        // in HTTP mode the user can augment the online archive with local directories.
+    }
+
+    // Auto-connect to the HTTP server
+    // Derives the base URL from the current page's location
+    async function autoConnectHttpSource() {
+        var href = window.location.href;
+        // Strip query string and fragment
+        href = href.split('?')[0].split('#')[0];
+        // Strip the filename to get the directory
+        var lastSlash = href.lastIndexOf('/');
+        var baseUrl = (lastSlash >= 0) ? href.substring(0, lastSlash + 1) : href + '/';
+
+        // Check for projects that are in the URL filter but not accessible on the server
+        if (window.app.projectFilter && window.app.projectFilter.size > 0) {
+            try {
+                var resp = await fetch(baseUrl, { headers: { 'Accept': 'application/json' } });
+                if (resp.ok) {
+                    var serverProjects = await resp.json();
+                    var accessibleNames = new Set(serverProjects.map(function(p) { return p.name; }));
+                    var missing = Array.from(window.app.projectFilter).filter(function(p) {
+                        return !accessibleNames.has(p);
+                    });
+                    if (missing.length > 0) {
+                        showProjectWarning(missing);
+                    }
+                }
+            } catch (e) {
+                // Silently ignore — server may not support the project list API
+            }
+        }
+
+        await addHttpSource(baseUrl);
+    }
+
+    // Add an HTTP source root (analogous to addDirectory() for local mode)
+    async function addHttpSource(baseUrl) {
+        // Derive a display name from the URL path
+        var urlPath = baseUrl.replace(/\/$/, '');
+        var rootName = urlPath.substring(urlPath.lastIndexOf('/') + 1) || urlPath;
+    
+        // Check if already added
+        var exists = window.app.directories.some(function(d) { return d.url === baseUrl; });
+        if (exists) return;
+    
+        window.app.directories.push({
+            handle: null,
+            name: rootName,
+            path: rootName,
+            url: baseUrl
+        });
+    
+        if (window.app.directories.length === 1) {
+            hideEmptyState();
+        }
+    
+        await scanHttpSource(baseUrl, rootName);
+        updateUI();
+    }
+
+    // Scan an HTTP source root
+    async function scanHttpSource(baseUrl, rootName) {
+        window.app.isScanning = true;
+        window.app.scanProgress = 'Connecting to server...';
+        updateStatusBar();
+    
+        var source = window.app.modules.source.createSource('http', { baseUrl: baseUrl });
+    
+        var fileCount = 0;
+        var callbacks = {
+            onGroupingFolder: function(folder) {
+                window.app.groupingFolders.push(folder);
+            },
+            onTransmittalFolder: function(folder) {
+                window.app.transmittalFolders.push(folder);
+            },
+            onFile: function(file) {
+                window.app.files.push(file);
+                fileCount++;
+                // Throttled progress update — don't update DOM on every file
+                if (fileCount % 10 === 0) {
+                    window.app.scanProgress = 'Scanning\u2026 ' + fileCount + ' files found';
+                    updateStatusBar();
+                }
+            },
+            onProgress: function() { /* no-op: parallel scan — spinner is enough */ }
+        };
+    
+        try {
+            await source.scan(baseUrl, callbacks);
+        
+            // Auto-select top-level party folders (shallowest depth)
+            var groupingDepths = window.app.groupingFolders.map(function(f) { return f.path.split('/').length; });
+            var minGroupingDepth = groupingDepths.length > 0 ? Math.min.apply(null, groupingDepths) : 1;
+            window.app.groupingFolders.forEach(function(folder) {
+                if (folder.path.split('/').length === minGroupingDepth) {
+                    window.app.selectedGroupingFolders.add(folder.path);
+                }
+            });
+        
+            window.app.transmittalFolders.forEach(function(folder) {
+                if (!isUnderHiddenFolderType(folder.path)) {
+                    window.app.selectedTransmittalFolders.add(folder.path);
+                }
+            });
+        
+            ensureOutstandingTransmittal();
+            // Auto-select Outstanding if selectAllTransmittals is active
+            if (window.app.selectAllTransmittals) {
+                window.app.selectedTransmittalFolders.add('__outstanding__');
+            }
+        
+            collectModifiers();
+            updateUI();
+            window.app.modules.filtering.applyFilters();
+            if (window.app.modules.presets) {
+                window.app.modules.presets.init();
+            }
+        } catch (err) {
+            console.error('Error scanning HTTP source:', err);
+            showHttpErrorState(err.message);
+        } finally {
+            window.app.isScanning = false;
+            window.app.scanProgress = '';
+            updateStatusBar();
+        }
+    }
+
+    // Ensure the Outstanding virtual transmittal exists if there are any outstanding files.
+    // Called after each scan completes. Idempotent — safe to call multiple times.
+    function ensureOutstandingTransmittal() {
+        const hasOutstanding = window.app.files.some(f => f.folderPath === '__outstanding__');
+        const alreadyExists = window.app.transmittalFolders.some(f => f.path === '__outstanding__');
+        if (hasOutstanding && !alreadyExists) {
+            window.app.transmittalFolders.push({
+                name: 'Outstanding',
+                path: '__outstanding__',
+                displayPath: 'Outstanding',
+                handle: null,
+                url: null,
+                isVirtual: true
+            });
+        }
+    }
+
+    // Show error state when HTTP server is unreachable
+    function showHttpErrorState(message) {
+        var el = document.getElementById('noDirectoryMessage');
+        if (!el) return;
+        var content = el.querySelector('.empty-state-content');
+        if (content) {
+            content.innerHTML =
+                '<h2>Could not connect to server</h2>' +
+                '<p>The archive browser could not retrieve the directory listing from the server.</p>' +
+                '<p><strong>Error:</strong> ' + escapeHtml(message || 'Unknown error') + '</p>' +
+                '<p>Ensure the server is running, CORS is not blocking the request, and Caddy\'s file browsing is enabled.</p>';
+        }
+        el.classList.remove('hidden');
+    }
+
+    // Show a warning banner listing projects in the URL filter that the user cannot access
+    function showProjectWarning(missingProjects) {
+        var el = document.getElementById('projectWarningBanner');
+        if (!el || missingProjects.length === 0) return;
+        var list = missingProjects.map(function(p) { return escapeHtml(p); }).join(', ');
+        el.querySelector('.project-warning-text').innerHTML =
+            'This link includes projects you don\'t have access to: <strong>' + list + '</strong>';
+        el.classList.remove('hidden');
+    }
+
+    function dismissProjectWarning() {
+        var el = document.getElementById('projectWarningBanner');
+        if (el) el.classList.add('hidden');
+    }
+
+    // Show unsupported browser message
+    function showUnsupportedBrowserMessage() {
+        const app = document.getElementById('app');
+        app.innerHTML = `
+            <div class="empty-state">
+                <div class="empty-state-content">
+                    <h2>Browser Not Supported</h2>
+                    <p>This application requires a Chromium-based browser (Chrome, Edge, Brave) with File System Access API support.</p>
+                    <p>Please use one of these browsers to access the Archive Browser.</p>
+                </div>
+            </div>
+        `;
+    }
+
+    // Show empty state
+    function showEmptyState() {
+        document.getElementById('noDirectoryMessage').classList.remove('hidden');
+        document.querySelector('.main-container').style.display = 'none';
+        // Keep header visible
+        document.querySelector('.app-header').style.display = '';
+        var refreshBtn = document.getElementById('refreshHeaderBtn');
+        if (refreshBtn) { refreshBtn.classList.add('hidden'); }
+    }
+
+    // Hide empty state
+    function hideEmptyState() {
+        document.getElementById('noDirectoryMessage').classList.add('hidden');
+        document.querySelector('.main-container').style.display = '';
+        var refreshBtn = document.getElementById('refreshHeaderBtn');
+        if (refreshBtn) { refreshBtn.classList.remove('hidden'); }
+    }
+
+    // Update UI based on current state
+    function updateUI() {
+        renderFolderTypeBar();
+        renderFolderLists();
+        window.app.modules.table.updateFileTable();
+        updateStatusBar();
+    }
+
+    // Render folder lists (rebuilds DOM)
+    function renderFolderLists() {
+        renderGroupingFolders();
+        renderTransmittalFolders();
+    }
+
+    // Check if a folder path is under a hidden folder type
+    // Returns true if any path segment is a known folder type that is NOT currently enabled
+    function isUnderHiddenFolderType(path) {
+        const parts = path.toLowerCase().split('/');
+        return parts.some(part =>
+            window.app.FOLDER_TYPE_NAMES.includes(part) && !window.app.enabledFolderTypes.has(part)
+        );
+    }
+
+    // Get filtered grouping folders (single source of truth for filtering logic)
+    function getFilteredGroupingFolders() {
+        const filter = window.app.groupingFilter;
+    
+        return window.app.groupingFolders.filter(folder => {
+            if (isUnderHiddenFolderType(folder.path)) {
+                return false;
+            }
+        
+            if (!filter) return true;
+        
+            const terms = parseSearchTerms(filter);
+            return matchesSearchTerms(folder.name.toLowerCase(), terms);
+        });
+    }
+
+    // Render grouping folders as a flat list of party names (depth 1 only)
+    function renderGroupingFolders() {
+        const container = document.getElementById('groupingFoldersList');
+
+        // Get filtered grouping folders (uses shared filtering logic)
+        const filteredFolders = getFilteredGroupingFolders();
+
+        // Only show top-level party folders (the shallowest depth among all grouping folders)
+        const allDepths = window.app.groupingFolders.map(f => f.path.split('/').length);
+        const minDepth = allDepths.length > 0 ? Math.min(...allDepths) : 1;
+        const partyFolders = filteredFolders.filter(f => f.path.split('/').length === minDepth);
+
+        // Sort alphabetically
+        partyFolders.sort((a, b) => a.path.localeCompare(b.path));
+
+        // Build set of paths for quick lookup
+        const partyPaths = new Set(partyFolders.map(f => f.path));
+
+        // If "Select All" mode is active, auto-select all visible party folders
+        if (window.app.selectAllGroupingFolders) {
+            window.app.selectedGroupingFolders.clear();
+            partyFolders.forEach(f => window.app.selectedGroupingFolders.add(f.path));
+        } else {
+            // Remove selections for folders that are no longer visible
+            for (const selectedPath of window.app.selectedGroupingFolders) {
+                if (!partyPaths.has(selectedPath)) {
+                    window.app.selectedGroupingFolders.delete(selectedPath);
+                }
+            }
+        }
+
+        // Sync checkbox state
+        const checkbox = document.getElementById('selectAllGroupingCheckbox');
+        if (checkbox) checkbox.checked = window.app.selectAllGroupingFolders;
+
+        if (partyFolders.length === 0 && window.app.groupingFilter) {
+            container.innerHTML = '<div class="folder-list-empty">No parties match your filter</div>';
+            updateFolderSelectionState('groupingFoldersList');
+            return;
+        }
+
+        container.innerHTML = partyFolders.map(folder => `
+            <div class="folder-item ${window.app.selectedGroupingFolders.has(folder.path) ? 'selected' : ''}"
+                 data-path="${escapeHtml(folder.path)}"
+                 data-folder-type="grouping">
+                <span class="folder-item-name" title="${escapeHtml(folder.path)}">${escapeHtml(folder.name)}</span>
+            </div>
+        `).join('');
+
+        updateFolderSelectionState('groupingFoldersList');
+    }
+
+    // Render the global folder type toggle bar
+    function renderFolderTypeBar() {
+        const bar = document.getElementById('folderTypeBar');
+        if (!bar) return;
+
+        const FOLDER_TYPE_LABELS = { mdl: 'MDL', incoming: 'Incoming', issued: 'Issued', received: 'Received' };
+        bar.innerHTML = window.app.FOLDER_TYPE_NAMES.map(type => {
+            const active = window.app.enabledFolderTypes.has(type);
+            const label = FOLDER_TYPE_LABELS[type] || (type.charAt(0).toUpperCase() + type.slice(1));
+            return `<button class="folder-type-toggle ${active ? 'active' : ''}"
+                            data-type="${type}"
+                            title="Toggle ${label} folders">${label}</button>`;
+        }).join('');
+    }
+
+    // Toggle a folder type on/off globally
+    function toggleFolderType(type) {
+        if (window.app.enabledFolderTypes.has(type)) {
+            window.app.enabledFolderTypes.delete(type);
+        } else {
+            window.app.enabledFolderTypes.add(type);
+        }
+        renderFolderTypeBar();
+        renderGroupingFolders();
+        renderTransmittalFolders();
+        window.app.modules.filtering.applyFilters();
+        window.app.modules.urlState.push();
+    }
+
+    // Returns true if an outstanding file's actualPath is under a selected grouping folder
+    // that is itself visible (not hidden by folder type toggles).
+    function outstandingFileIsVisible(file) {
+        const selectedGrouping = window.app.selectedGroupingFolders;
+        if (selectedGrouping.size === 0) return false;
+        // The actualPath must not be under a hidden folder type
+        if (isUnderHiddenFolderType(file.actualPath)) return false;
+        // The actualPath must be at or under one of the selected grouping folder paths
+        return Array.from(selectedGrouping).some(function(gPath) {
+            return file.actualPath === gPath || file.actualPath.startsWith(gPath + '/');
+        });
+    }
+
+    // Returns true if any outstanding (non-transmittal) files exist under the currently
+    // selected and visible grouping folders.
+    function hasVisibleOutstandingFiles() {
+        return window.app.files.some(function(f) {
+            if (f.folderPath !== '__outstanding__') return false;
+            return outstandingFileIsVisible(f);
+        });
+    }
+
+    // Returns true if a transmittal folder is under a selected party and an enabled folder type.
+    // Handles both HTTP paths (party at depth 0) and local paths (party at depth 1+ due to root dir prefix).
+    function transmittalIsUnderVisibleParty(folder) {
+        const parts = folder.path.split('/');
+
+        // Find which segment is the party (the one that matches a selected grouping folder path prefix).
+        // The party path is the selected grouping folder path, so check prefix matches.
+        for (const partyPath of window.app.selectedGroupingFolders) {
+            const partyParts = partyPath.split('/');
+            const partyDepth = partyParts.length; // e.g. 1 for HTTP ("ACME"), 2 for local ("RootDir/ACME")
+
+            // Check that folder path starts with partyPath
+            if (!folder.path.startsWith(partyPath + '/') && folder.path !== partyPath) continue;
+
+            // The segment immediately after partyPath is either a folder type or the transmittal itself
+            const remainder = folder.path.substring(partyPath.length + 1); // e.g. "Issued/2025-01-01_..." or "2025-01-01_..."
+            const remainderParts = remainder.split('/');
+
+            if (remainderParts.length >= 2) {
+                // There's a folder type segment before the transmittal
+                const folderType = remainderParts[0].toLowerCase();
+                if (window.app.FOLDER_TYPE_NAMES.includes(folderType)) {
+                    // Must be an enabled type
+                    return window.app.enabledFolderTypes.has(folderType);
+                }
+                // Unknown folder type — treat as visible
+                return true;
+            }
+
+            // Transmittal is directly under the party (no folder type level) — always show
+            return true;
+        }
+
+        // Party not selected
+        return false;
+    }
+
+    // Render transmittal folders (rebuilds DOM)
+    function renderTransmittalFolders() {
+        const container = document.getElementById('transmittalFoldersList');
+        const filter = window.app.transmittalFilter;
+    
+        // Filter transmittal folders based on grouping selection and name filter
+        const filteredFolders = window.app.transmittalFolders.filter(folder => {
+            // Outstanding virtual transmittal: include if there are visible outstanding files
+            if (folder.path === '__outstanding__') {
+                if (!hasVisibleOutstandingFiles()) return false;
+                // Apply name filter to "Outstanding" label too
+                if (filter && filter.trim()) {
+                    const terms = parseSearchTerms(filter.trim());
+                    if (!matchesSearchTerms('outstanding', terms)) return false;
+                }
+                return true;
+            }
+        
+            // Check name filter
+            let matchesFilter = true;
+            if (filter && filter.trim()) {
+                const terms = parseSearchTerms(filter.trim());
+                const folderText = folder.name.toLowerCase();
+                matchesFilter = matchesSearchTerms(folderText, terms);
+            }
+        
+            // If no grouping folders exist at all, show all transmittal folders (flat structure)
+            if (window.app.groupingFolders.length === 0) {
+                return matchesFilter;
+            }
+        
+            // If grouping folders exist but none are selected, show nothing
+            if (window.app.selectedGroupingFolders.size === 0) {
+                return false;
+            }
+        
+            // Check party + folder type visibility
+            return matchesFilter && transmittalIsUnderVisibleParty(folder);
+        });
+    
+        // Sort regular transmittal folders by date (newest first); Outstanding handled separately
+        const regularFolders = filteredFolders.filter(f => f.path !== '__outstanding__');
+        regularFolders.sort((a, b) => b.name.localeCompare(a.name));
+    
+        const showOutstanding = filteredFolders.some(f => f.path === '__outstanding__');
+    
+        // Build set of visible folder paths (for Select All and deselection logic)
+        const filteredPaths = new Set(filteredFolders.map(f => f.path));
+    
+        // If "Select All" mode is active, auto-select all visible transmittal folders
+        if (window.app.selectAllTransmittals) {
+            window.app.selectedTransmittalFolders.clear();
+            filteredFolders.forEach(f => window.app.selectedTransmittalFolders.add(f.path));
+        } else {
+            // Remove selections for folders that are now filtered out
+            for (const selectedPath of window.app.selectedTransmittalFolders) {
+                if (!filteredPaths.has(selectedPath)) {
+                    window.app.selectedTransmittalFolders.delete(selectedPath);
+                }
+            }
+        }
+    
+        // Sync checkbox state
+        const checkbox = document.getElementById('selectAllTransmittalsCheckbox');
+        if (checkbox) checkbox.checked = window.app.selectAllTransmittals;
+    
+        // Group regular folders by date
+        const foldersByDate = new Map();
+        regularFolders.forEach(folder => {
+            const match = folder.name.match(/^(\d{4}-\d{2}-\d{2})/);
+            const date = match ? match[1] : 'Unknown';
+            if (!foldersByDate.has(date)) {
+                foldersByDate.set(date, []);
+            }
+            foldersByDate.get(date).push(folder);
+        });
+    
+        // Build HTML
+        let html = '';
+    
+        // Outstanding virtual transmittal — pinned at top
+        if (showOutstanding) {
+            const isSelected = window.app.selectedTransmittalFolders.has('__outstanding__');
+            html += `
+                <div class="folder-item outstanding-transmittal ${isSelected ? 'selected' : ''}"
+                     data-path="__outstanding__"
+                     data-folder-type="transmittal"
+                     title="Files in non-transmittal folders under selected grouping folders">
+                    <div class="transmittal-folder-content">
+                        <div class="transmittal-first-line outstanding-label">⋯ Outstanding</div>
+                    </div>
+                </div>
+            `;
+        }
+    
+        // Regular date-grouped folders
+        for (const [date, folders] of foldersByDate) {
+            const isCollapsed = window.app.collapsedDateGroups.has(date);
+            const folderCount = folders.length;
+        
+            html += `
+                <div class="date-group-header" data-date="${escapeHtml(date)}">
+                    <span class="date-group-toggle">${isCollapsed ? '▶' : '▼'}</span>
+                    <span class="date-group-date">${escapeHtml(date)}</span>
+                    <span class="date-group-count">(${folderCount})</span>
+                </div>
+            `;
+        
+            if (!isCollapsed) {
+                for (const folder of folders) {
+                    const match = folder.name.match(/^\d{4}-\d{2}-\d{2}_([^_\s]+)\s*\(([^)]+)\)\s*-\s*(.+)$/);
+                    let firstLine = folder.name;
+                    let secondLine = '';
+                
+                    if (match) {
+                        const [, tracking, status, title] = match;
+                        firstLine = `${tracking} • ${status}`;
+                        secondLine = title;
+                    }
+                
+                    html += `
+                        <div class="folder-item ${window.app.selectedTransmittalFolders.has(folder.path) ? 'selected' : ''}"
+                             data-path="${escapeHtml(folder.path)}"
+                             data-folder-type="transmittal"
+                             title="${escapeHtml(folder.path)}">
+                            <div class="transmittal-folder-content">
+                                <div class="transmittal-first-line">${escapeHtml(firstLine)}</div>
+                                ${secondLine ? `<div class="transmittal-second-line">${escapeHtml(secondLine)}</div>` : ''}
+                            </div>
+                        </div>
+                    `;
+                }
+            }
+        }
+    
+        if (filteredFolders.length === 0 && window.app.transmittalFilter) {
+            container.innerHTML = '<div class="folder-list-empty">No folders match your filter</div>';
+            updateFolderSelectionState('transmittalFoldersList');
+            window.app.modules.events.updateToggleAllIcon();
+            return;
+        }
+
+        container.innerHTML = html;
+    
+        // Ensure selection state is visually reflected after DOM rebuild
+        updateFolderSelectionState('transmittalFoldersList');
+    
+        // Update the toggle all icon to reflect current state
+        window.app.modules.events.updateToggleAllIcon();
+    }
+
+
+    // Update status bar
+    function updateStatusBar() {
+        const fileCountEl = document.getElementById('fileCount');
+        const selectedCountEl = document.getElementById('selectedCount');
+
+        // Before any directory is loaded, show a hint instead of "0 files"
+        if (window.app.directories.length === 0 && !window.app.isScanning) {
+            fileCountEl.textContent = 'Select a directory to begin';
+            selectedCountEl.textContent = '';
+            document.getElementById('scanStatus').textContent = '';
+            var spinner2 = document.getElementById('scanSpinner');
+            if (spinner2) spinner2.classList.add('hidden');
+            document.getElementById('downloadSelectedBtn').disabled = true;
+            document.getElementById('exportCsvBtn').disabled = true;
+            return;
+        }
+
+        // Count unique tracking numbers
+        const trackingNumbers = new Set(window.app.filteredFiles.map(f => f.trackingNumber));
+        const trackingCount = trackingNumbers.size;
+        const fileCount = window.app.filteredFiles.length;
+    
+        // Count files with path errors
+        const pathErrorCount = window.app.filteredFiles.filter(f => f.hasPathError).length;
+    
+        // Format: "X tracking numbers, Y files" + optional path error warning
+        let countText = `${trackingCount} tracking number${trackingCount !== 1 ? 's' : ''}, ${fileCount} file${fileCount !== 1 ? 's' : ''}`;
+        if (pathErrorCount > 0) {
+            countText += ` (⚠️ ${pathErrorCount} inaccessible)`;
+        }
+    
+        fileCountEl.textContent = countText;
+        selectedCountEl.textContent = `${window.app.selectedFiles.size} selected`;
+        document.getElementById('scanStatus').textContent = window.app.scanProgress;
+        var spinner = document.getElementById('scanSpinner');
+        if (spinner) { spinner.classList.toggle('hidden', !window.app.isScanning); }
+
+        // Disable action buttons when nothing is selected
+        const noneSelected = window.app.selectedFiles.size === 0;
+        document.getElementById('downloadSelectedBtn').disabled = noneSelected;
+        document.getElementById('exportCsvBtn').disabled = noneSelected;
+    }
+
+    // Escape HTML for safe insertion
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    /**
+     * Update folder selection visual state without rebuilding DOM
+     * This is more efficient than re-rendering when only selection changes
+     * @param {string} containerId - 'groupingFoldersList' or 'transmittalFoldersList'
+     */
+    function updateFolderSelectionState(containerId) {
+        const container = document.getElementById(containerId);
+        if (!container) {
+            console.warn(`Container not found: ${containerId}`);
+            return;
+        }
+    
+        const selectedSet = containerId === 'groupingFoldersList' ? 
+            window.app.selectedGroupingFolders : 
+            window.app.selectedTransmittalFolders;
+    
+        // Update selected class on existing elements
+        container.querySelectorAll('.folder-item').forEach(item => {
+            const path = item.getAttribute('data-path');
+            if (path) {
+                item.classList.toggle('selected', selectedSet.has(path));
+            }
+        });
+    }
+
+    // Extract modifier type from revision string (e.g., "2+B1" -> "+B", "2" -> "base")
+    function getModifierType(revision) {
+        if (!revision) return 'base';
+        const match = revision.match(/\+([A-Za-z])/);
+        return match ? '+' + match[1].toUpperCase() : 'base';
+    }
+
+    // Collect all unique modifiers from files
+    function collectModifiers() {
+        window.app.availableModifiers.clear();
+    
+        window.app.files.forEach(file => {
+            const modType = getModifierType(file.revision);
+            window.app.availableModifiers.add(modType);
+        });
+    
+        // Select all by default
+        window.app.selectedModifiers = new Set(window.app.availableModifiers);
+    
+        // Update the dropdown UI
+        renderModifierDropdown();
+    }
+
+    // Render the modifier dropdown options
+    function renderModifierDropdown() {
+        const list = document.getElementById('modifierFilterList');
+        if (!list) return;
+    
+        // Sort modifiers: "base" first, then alphabetically
+        const sorted = Array.from(window.app.availableModifiers).sort((a, b) => {
+            if (a === 'base') return -1;
+            if (b === 'base') return 1;
+            return a.localeCompare(b);
+        });
+    
+        let html = '';
+        sorted.forEach(mod => {
+            const checked = window.app.selectedModifiers.has(mod) ? 'checked' : '';
+            const label = mod === 'base' ? 'Base (no modifier)' : mod;
+            const labelClass = mod === 'base' ? 'modifier-base' : 'modifier-type';
+            html += `
+                <div class="modifier-filter-item">
+                    <label>
+                        <input type="checkbox" 
+                               data-modifier="${mod}" 
+                               ${checked}
+                               onchange="toggleModifierFilter('${mod}')">
+                        <span class="${labelClass}">${label}</span>
+                    </label>
+                </div>
+            `;
+        });
+    
+        list.innerHTML = html;
+        updateModifierSelectAll();
+        updateModifierButtonLabel();
+    }
+
+    // Toggle a specific modifier filter
+    function toggleModifierFilter(mod) {
+        if (window.app.selectedModifiers.has(mod)) {
+            window.app.selectedModifiers.delete(mod);
+        } else {
+            window.app.selectedModifiers.add(mod);
+        }
+        updateModifierSelectAll();
+        updateModifierButtonLabel();
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Toggle all modifiers
+    function toggleAllModifiers(selectAll) {
+        if (selectAll) {
+            window.app.selectedModifiers = new Set(window.app.availableModifiers);
+        } else {
+            window.app.selectedModifiers.clear();
+        }
+        renderModifierDropdown();
+        window.app.modules.filtering.applyFilters();
+    }
+
+    // Update the "Select All" checkbox state
+    function updateModifierSelectAll() {
+        const selectAllCheckbox = document.getElementById('modifierSelectAll');
+        if (selectAllCheckbox) {
+            selectAllCheckbox.checked = window.app.selectedModifiers.size === window.app.availableModifiers.size;
+            selectAllCheckbox.indeterminate = window.app.selectedModifiers.size > 0 && 
+                                              window.app.selectedModifiers.size < window.app.availableModifiers.size;
+        }
+    }
+
+    // Update button label to show filter status
+    function updateModifierButtonLabel() {
+        const btn = document.getElementById('modifierFilterBtn');
+        if (!btn) return;
+    
+        const total = window.app.availableModifiers.size;
+        const selected = window.app.selectedModifiers.size;
+    
+        if (selected === total) {
+            btn.textContent = 'Modifiers ▼';
+        } else if (selected === 0) {
+            btn.textContent = 'Modifiers (none) ▼';
+        } else {
+            btn.textContent = `Modifiers (${selected}/${total}) ▼`;
+        }
+    }
+
+    // Toggle modifier dropdown visibility
+    function toggleModifierDropdown() {
+        const dropdown = document.getElementById('modifierFilterDropdown');
+        dropdown.classList.toggle('hidden');
+    }
+
+    // Update the Folders icon button state based on active visibility toggles
+    function updateFolderVisibilityBtnLabel() {
+        // replaced by renderFolderTypeBar()
+    }
+
+    // Check if a file passes the modifier filter
+    function filePassesModifierFilter(file) {
+        const modType = getModifierType(file.revision);
+        return window.app.selectedModifiers.has(modType);
+    }
+
+    // Toggle filter to show only selected files
+    function toggleFilterSelected() {
+        window.app.showSelectedOnly = !window.app.showSelectedOnly;
+    
+        // Update button visual state and label
+        const btn = document.getElementById('filterSelectedBtn');
+        if (window.app.showSelectedOnly) {
+            btn.classList.add('btn-active');
+            btn.textContent = 'Show All';
+        } else {
+            btn.classList.remove('btn-active');
+            btn.textContent = 'Filter Selected';
+        }
+    
+        window.app.modules.filtering.applyFilters();
+    }
+    // Register with module system
+    window.app.modules.app = {
+        updateUI,
+        updateStatusBar,
+        escapeHtml,
+        updateFolderSelectionState,
+        getModifierType,
+        collectModifiers,
+        renderModifierDropdown,
+        toggleModifierFilter,
+        toggleAllModifiers,
+        updateModifierSelectAll,
+        updateModifierButtonLabel,
+        toggleModifierDropdown,
+        updateFolderVisibilityBtnLabel,
+        filePassesModifierFilter,
+        toggleFilterSelected,
+        isUnderHiddenFolderType,
+        ensureOutstandingTransmittal,
+        showHttpErrorState,
+        showUnsupportedBrowserMessage,
+        showProjectWarning,
+        dismissProjectWarning,
+        showEmptyState,
+        hideEmptyState,
+        addHttpSource,
+        scanHttpSource,
+        renderGroupingFolders,
+        renderTransmittalFolders,
+        renderFolderTypeBar,
+        toggleFolderType,
+        outstandingFileIsVisible,
+        hasVisibleOutstandingFiles,
+        transmittalIsUnderVisibleParty,
+        renderFolderLists,
+        getFilteredGroupingFolders,
+        showProjectWarning,
+        dismissProjectWarning,
+    };
+
+    // Expose key functions on window for inline HTML handlers
+    window.initApp = initApp;
+    window.toggleFileSelection = function(id) { window.app.modules.table.toggleFileSelection(id); };
+    window.sortTable = function(f) { window.app.modules.table.sortTable(f); };
+    window.confirmTransmittal = function() { window.app.modules.dragDrop.confirmTransmittal(); };
+    window.toggleModifierFilter = toggleModifierFilter;
+    window.toggleFilterSelected = toggleFilterSelected;
+    window.toggleFolderType = toggleFolderType;
+    window.toggleGroupingFolder = function(p, r) { window.app.modules.events.toggleGroupingFolder(p, r); };
+    window.toggleDateGroup = function(d) { window.app.modules.events.toggleDateGroup(d); };
+    window.toggleAllDateGroups = function() { window.app.modules.events.toggleAllDateGroups(); };
+    window.selectAllVisibleFolders = function(t) { window.app.modules.events.selectAllVisibleFolders(t); };
+    window.removeDirectory = function(n) { window.app.modules.directory.removeDirectory(n); };
+    window.dismissProjectWarning = dismissProjectWarning;
+    window.verifyFileIntegrity = function(id) { window.app.modules.hash.verifyFileIntegrity(id); };
+    window.showProjectWarning = showProjectWarning;
+    window.dismissProjectWarning = dismissProjectWarning;
+
+    // Initialize on DOM ready
+    document.addEventListener('DOMContentLoaded', initApp);
+
+})();
+
+/**
+ * ZDDC shared help panel — open/close logic.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #help-btn, #help-panel, #help-panel-close in the DOM.
+ */
+(function () {
+    'use strict';
+
+    function init() {
+        var helpBtn   = document.getElementById('help-btn');
+        var panel     = document.getElementById('help-panel');
+        var closeBtn  = document.getElementById('help-panel-close');
+
+        if (!helpBtn || !panel) { return; }
+
+        function isOpen() { return !panel.hidden; }
+
+        function openPanel() {
+            panel.hidden = false;
+            document.body.classList.add('help-open');
+        }
+
+        function closePanel() {
+            panel.hidden = true;
+            document.body.classList.remove('help-open');
+        }
+
+        helpBtn.addEventListener('click', function () {
+            if (isOpen()) { closePanel(); } else { openPanel(); }
+        });
+
+        if (closeBtn) {
+            closeBtn.addEventListener('click', closePanel);
+        }
+
+        document.addEventListener('keydown', function (e) {
+            if (e.key === 'Escape' && isOpen()) { closePanel(); }
+        });
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+    </script>
+</body>
+</html>
diff --git a/website/releases/classifier_latest.html b/website/releases/classifier_latest.html
new file mode 120000
index 0000000..3fb3d18
--- /dev/null
+++ b/website/releases/classifier_latest.html
@@ -0,0 +1 @@
+classifier_v0.0.1.html
\ No newline at end of file
diff --git a/website/releases/classifier_v0.0.1.html b/website/releases/classifier_v0.0.1.html
new file mode 100644
index 0000000..b02ed36
--- /dev/null
+++ b/website/releases/classifier_v0.0.1.html
@@ -0,0 +1,6971 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Classifier</title>
+    <style>
+/* ==========================================================================
+   ZDDC Shared Base — single source of truth for tokens and primitives
+   Included first by every tool's build.sh via ../shared/base.css
+   ========================================================================== */
+
+/* ── CSS custom properties ────────────────────────────────────────────────── */
+:root {
+    /* Brand / accent (matches zddc.varasys.io website --accent) */
+    --primary:        #2a5a8a;
+    --primary-hover:  #1d4060;
+    --primary-active: #163352;
+    --primary-light:  #e8f0f7;
+
+    /* Semantic colours */
+    --success: #28a745;
+    --warning: #d97706;
+    --danger:  #dc3545;
+    --info:    #17a2b8;
+
+    /* Backgrounds */
+    --bg:           #ffffff;
+    --bg-secondary: #f8f9fa;
+    --bg-hover:     #f0f4f8;
+    --bg-selected:  var(--primary-light);
+
+    /* Text */
+    --text:       #212529;
+    --text-muted: #6c757d;
+    --text-light: #ffffff;
+
+    /* Borders */
+    --border:      #dee2e6;
+    --border-dark: #adb5bd;
+
+    /* Shape */
+    --radius: 4px;
+
+    /* Typography */
+    --font:      -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    --font-mono: 'SF Mono', 'Fira Code', 'Consolas', 'Courier New', monospace;
+}
+
+/* ── Dark mode tokens ─────────────────────────────────────────────────────── */
+/* Applied via: OS preference (auto) or [data-theme="dark"] on <html>          */
+/* The [data-theme="light"] selector locks light mode regardless of OS pref.   */
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+        --primary:        #4a90c4;
+        --primary-hover:  #5ba3d9;
+        --primary-active: #6ab5e8;
+        --primary-light:  #1a3550;
+
+        --bg:           #1e1e1e;
+        --bg-secondary: #252526;
+        --bg-hover:     #2d2d30;
+        --bg-selected:  #1a3550;
+
+        --text:       #d4d4d4;
+        --text-muted: #9d9d9d;
+        --text-light: #ffffff;
+
+        --border:      #3e3e42;
+        --border-dark: #6e6e72;
+    }
+}
+
+/* Manual dark override — wins over media query */
+[data-theme="dark"] {
+    --primary:        #4a90c4;
+    --primary-hover:  #5ba3d9;
+    --primary-active: #6ab5e8;
+    --primary-light:  #1a3550;
+
+    --bg:           #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover:     #2d2d30;
+    --bg-selected:  #1a3550;
+
+    --text:       #d4d4d4;
+    --text-muted: #9d9d9d;
+    --text-light: #ffffff;
+
+    --border:      #3e3e42;
+    --border-dark: #6e6e72;
+}
+
+/* ── Reset ────────────────────────────────────────────────────────────────── */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* ── Base document ────────────────────────────────────────────────────────── */
+html, body {
+    height: 100%;
+    font-family: var(--font);
+    font-size: 16px;
+    line-height: 1.5;
+    color: var(--text);
+    background-color: var(--bg-secondary);
+}
+
+/* ── Typography ───────────────────────────────────────────────────────────── */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 600;
+    line-height: 1.2;
+}
+
+a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+/* ── Utility ──────────────────────────────────────────────────────────────── */
+.hidden {
+    display: none !important;
+}
+
+.truncate {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* ── Scrollbars (webkit) ──────────────────────────────────────────────────── */
+::-webkit-scrollbar {
+    width: 7px;
+    height: 7px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a0a0a0;
+}
+
+/* ── Button primitive ─────────────────────────────────────────────────────── */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.4rem 0.85rem;
+    font-family: var(--font);
+    font-size: 0.875rem;
+    font-weight: 500;
+    line-height: 1.4;
+    text-align: center;
+    text-decoration: none;
+    white-space: nowrap;
+    vertical-align: middle;
+    cursor: pointer;
+    border: 1px solid transparent;
+    border-radius: var(--radius);
+    transition: background 0.15s, box-shadow 0.15s, border-color 0.15s, color 0.15s;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.btn:disabled,
+.btn[disabled] {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:not(:disabled):hover {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.12);
+}
+
+.btn:not(:disabled):active {
+    box-shadow: none;
+}
+
+/* Variants */
+.btn-primary {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-primary:not(:disabled):hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+    color: var(--text-light);
+}
+
+.btn-primary:not(:disabled):active {
+    background: var(--primary-active);
+    border-color: var(--primary-active);
+}
+
+.btn-secondary {
+    background: var(--bg);
+    color: var(--text);
+    border-color: var(--border);
+}
+
+.btn-secondary:not(:disabled):hover {
+    background: var(--bg-secondary);
+}
+
+.btn-success {
+    background: var(--success);
+    color: var(--text-light);
+    border-color: var(--success);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: var(--text-light);
+    border-color: var(--danger);
+}
+
+/* Sizes */
+.btn-sm {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.75rem;
+}
+
+.btn-lg {
+    padding: 0.6rem 1.4rem;
+    font-size: 1rem;
+}
+
+.btn-link {
+    background: transparent;
+    border-color: transparent;
+    color: var(--primary);
+    padding-left: 0;
+    padding-right: 0;
+}
+
+.btn-link:not(:disabled):hover {
+    text-decoration: underline;
+    box-shadow: none;
+}
+
+/* ── App header chrome ────────────────────────────────────────────────────── */
+.app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.35rem 1rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+/* Tool name inside the header */
+.app-header__title {
+    font-size: 17px;
+    font-weight: 600;
+    color: var(--text);
+    letter-spacing: 0.01em;
+    white-space: nowrap;
+}
+
+/* ── Build timestamp ──────────────────────────────────────────────────────── */
+.build-timestamp {
+    font-size: 0.55rem;
+    color: var(--text-muted);
+    opacity: 0.7;
+    font-weight: 300;
+    white-space: nowrap;
+    padding-top: 0.15rem;
+}
+
+/* Title + timestamp stacked vertically on the left side of the header */
+.header-title-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    line-height: 1;
+}
+
+/* ── Icon buttons (help, theme, refresh) ─────────────────────────────────── */
+/* Square, centered — overrides the asymmetric text-button padding/line-height */
+#help-btn,
+#theme-btn,
+#refreshHeaderBtn {
+    width: 2rem;
+    height: 2rem;
+    padding: 0;
+    line-height: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1rem;
+}
+
+/* Toast CSS lives in classifier/css/base.css — only that tool uses toasts. */
+
+/* ── Theme and help icon buttons ─────────────────────────────────────────── */
+#theme-btn,
+#help-btn {
+    font-size: 1rem;
+}
+
+/* ── Help panel (shared slide-out drawer) ─────────────────────────────────── */
+/* Used by all four tools. Toggle open/close via shared/help.js.               */
+
+.help-panel {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: min(420px, 85vw);
+    height: 100vh;
+    z-index: 1000;
+    background: var(--bg);
+    border-left: 1px solid var(--border);
+    box-shadow: -2px 0 12px rgba(0, 0, 0, 0.08);
+    display: flex;
+    flex-direction: column;
+    transform: translateX(100%);
+    transition: transform 0.25s ease;
+}
+
+.help-panel:not([hidden]) {
+    transform: translateX(0);
+}
+
+.help-panel[hidden] {
+    display: flex;
+    transform: translateX(100%);
+    pointer-events: none;
+}
+
+.help-panel__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+    background: var(--bg);
+}
+
+.help-panel__title {
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.help-panel__close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1.35rem;
+    cursor: pointer;
+    padding: 0.25rem 0.5rem;
+    border-radius: var(--radius);
+    line-height: 1;
+    transition: background 0.15s, color 0.15s;
+}
+
+.help-panel__close:hover {
+    color: var(--text);
+    background: var(--bg-secondary);
+}
+
+.help-panel__body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem 1rem 2rem;
+    font-size: 0.85rem;
+    line-height: 1.6;
+    color: var(--text);
+}
+
+.help-panel__body h3 {
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin: 1.25rem 0 0.35rem;
+    color: var(--text);
+    border-bottom: 1px solid var(--border);
+    padding-bottom: 0.15rem;
+}
+
+.help-panel__body h3:first-child {
+    margin-top: 0;
+}
+
+.help-panel__body h4 {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    margin: 1.25rem 0 0.3rem;
+    padding-left: 0.5rem;
+    border-left: 3px solid var(--border-dark);
+    color: var(--text-muted);
+}
+
+.help-panel__body p {
+    margin: 0 0 0.5rem;
+}
+
+.help-panel__body ol,
+.help-panel__body ul {
+    padding-left: 1.5rem;
+    margin: 0.3rem 0 0.5rem;
+}
+
+.help-panel__body li {
+    margin-bottom: 0.3rem;
+}
+
+.help-panel__body dl {
+    margin: 0.3rem 0;
+}
+
+.help-panel__body dt {
+    font-weight: 600;
+    color: var(--text);
+}
+
+.help-panel__body dd {
+    margin: 0 0 0.5rem 1rem;
+    color: var(--text-muted);
+}
+
+.help-panel__body code {
+    font-family: var(--font-mono);
+    font-size: 0.8em;
+    background: var(--bg-secondary);
+    padding: 0.1em 0.3em;
+    border-radius: 3px;
+}
+
+.help-badge {
+    font-size: 0.7rem;
+    font-weight: 600;
+    padding: 0.1rem 0.35rem;
+    border-radius: var(--radius);
+    vertical-align: middle;
+    letter-spacing: 0.02em;
+}
+
+.help-badge--draft {
+    color: #2563eb;
+    background: #eff6ff;
+}
+
+.help-badge--published {
+    color: #7c3aed;
+    background: #f5f3ff;
+}
+
+/* Shrink main content when help panel is open */
+body.help-open .app-header {
+    margin-right: min(420px, 85vw);
+}
+
+/* ── Column filter inputs (shared across archive, classifier, transmittal) ─── */
+.column-filter {
+    display: block;
+    width: 100%;
+    box-sizing: border-box;
+    margin-top: 0.25rem;
+    padding: 0.2rem 0.4rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.15s;
+}
+
+.column-filter:focus {
+    border-color: var(--primary);
+    outline: none;
+    box-shadow: 0 0 0 1px rgba(42, 90, 138, 0.35);
+}
+
+.column-filter::placeholder {
+    color: var(--text-muted);
+}
+
+/* Classifier-specific base overrides
+   Reset, tokens, buttons, and font are provided by shared/base.css */
+
+#app {
+    width: 100vw;
+    height: 100vh;
+    display: flex;
+    flex-direction: column;
+}
+
+/* Utility */
+.text-muted    { color: var(--text-muted); }
+.text-success  { color: var(--success); }
+.text-warning  { color: var(--warning); }
+.text-danger   { color: var(--danger); }
+
+/* Checkbox label */
+.checkbox-label {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+    user-select: none;
+    font-size: 0.875rem;
+}
+
+.checkbox-label input[type="checkbox"] {
+    cursor: pointer;
+}
+
+/* ── Toast notifications (classifier-only) ───────────────────────────────── */
+/* shared/base.css intentionally omits toast CSS; only classifier uses toasts. */
+.toast {
+    position: fixed;
+    bottom: 2rem;
+    right: 2rem;
+    background: var(--bg);
+    color: var(--text);
+    padding: 0.875rem 1.25rem;
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    z-index: 9000;
+    max-width: 400px;
+    font-size: 0.875rem;
+    animation: zddc-toast-in 0.3s ease-out;
+}
+
+.toast-success { border-left: 4px solid var(--success); }
+.toast-error   { border-left: 4px solid var(--danger); }
+.toast-info    { border-left: 4px solid var(--info); }
+.toast-warning { border-left: 4px solid var(--warning); }
+
+.toast-fade {
+    animation: zddc-toast-out 0.3s ease-out forwards;
+}
+
+@keyframes zddc-toast-in {
+    from { transform: translateX(100%); opacity: 0; }
+    to   { transform: translateX(0);   opacity: 1; }
+}
+
+@keyframes zddc-toast-out {
+    from { transform: translateX(0);   opacity: 1; }
+    to   { transform: translateX(100%); opacity: 0; }
+}
+
+/* Classifier layout — tokens from shared/base.css */
+
+/* Empty State — positioned below the app header */
+.empty-state {
+    position: absolute;
+    top: 50px; /* clear the header */
+    left: 0;
+    right: 0;
+    bottom: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--bg);
+    z-index: 10;
+}
+
+.empty-state-content {
+    text-align: center;
+    max-width: 500px;
+    padding: 2rem;
+}
+
+.empty-state-content h2 {
+    color: var(--text);
+    margin-bottom: 1rem;
+}
+
+.empty-state-content p {
+    margin-bottom: 1rem;
+    color: var(--text-muted);
+}
+
+.empty-state-content .note {
+    font-size: 0.85rem;
+    font-style: italic;
+}
+
+.welcome-list {
+    text-align: left;
+    margin: 0.5rem auto;
+    max-width: 400px;
+}
+
+.empty-state.drag-over {
+    background: var(--primary-light);
+    outline: 2px dashed var(--primary);
+    outline-offset: -4px;
+}
+
+/* Browser Warning */
+.browser-warning {
+    background-color: rgba(217, 119, 6, 0.08);
+    border: 2px solid var(--warning);
+    border-radius: var(--radius);
+    padding: 1.5rem;
+    margin: 1.5rem 0;
+    text-align: left;
+}
+
+.browser-warning h3 {
+    color: var(--warning);
+    margin-top: 0;
+}
+
+.browser-warning ul {
+    margin: 0.5rem 0;
+    padding-left: 1.5rem;
+}
+
+/* Main App */
+.main-app {
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    background-color: var(--bg);
+    position: relative;
+}
+
+/* Header — shared/base.css provides .app-header base */
+.app-header {
+    padding: 0.5rem 1rem;
+}
+
+.header-left,
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.header-divider {
+    color: var(--border);
+    margin: 0 0.25rem;
+}
+
+/* Main Content */
+.main-content {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+}
+
+/* Folder Tree Pane */
+.folder-tree-pane {
+    width: 300px;
+    min-width: 150px;
+    display: flex;
+    flex-direction: column;
+    background-color: var(--bg-secondary);
+    border-right: 1px solid var(--border);
+    flex-shrink: 0;
+    position: relative;
+    transition: width 0.2s ease, min-width 0.2s ease;
+}
+
+.folder-tree-pane.collapsed {
+    width: 40px !important;
+    min-width: 40px !important;
+    max-width: 40px !important;
+    overflow: hidden;
+}
+
+.folder-tree-pane.collapsed .pane-header-controls,
+.folder-tree-pane.collapsed .folder-tree,
+.folder-tree-pane.collapsed .pane-header h3 {
+    display: none;
+}
+
+.folder-tree-pane.collapsed .pane-header {
+    padding: 0.5rem;
+    justify-content: center;
+}
+
+.folder-tree-pane.collapsed .pane-header-title {
+    flex-direction: column;
+}
+
+.pane-header-title {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.collapse-tree-btn {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.8rem;
+}
+
+/* Resize Handle */
+.resize-handle {
+    position: absolute;
+    right: 0;
+    top: 0;
+    bottom: 0;
+    width: 5px;
+    cursor: col-resize;
+    background-color: transparent;
+    z-index: 10;
+}
+
+.resize-handle:hover {
+    background-color: var(--primary);
+}
+
+.pane-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    background-color: var(--bg);
+    border-bottom: 1px solid var(--border);
+}
+
+.pane-header-left,
+.pane-header-right {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.pane-header h3 {
+    font-size: 1rem;
+    font-weight: 600;
+    margin: 0;
+}
+
+.pane-header-controls {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    align-items: flex-end;
+}
+
+.folder-stats,
+.file-stats {
+    display: flex;
+    gap: 1rem;
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.folder-tree {
+    flex: 1;
+    overflow-y: auto;
+    padding: 0.5rem;
+}
+
+/* Folder Item */
+.folder-item {
+    display: flex;
+    align-items: center;
+    padding: 0.5rem;
+    cursor: pointer;
+    border-radius: var(--radius);
+    user-select: none;
+    transition: background-color 0.15s;
+}
+
+.folder-item:hover {
+    background-color: var(--bg-hover);
+}
+
+.folder-item.selected {
+    background-color: var(--bg-selected);
+    font-weight: 500;
+}
+
+.folder-item.folder-hover-highlight {
+    background-color: rgba(217, 119, 6, 0.12);
+    border-left: 3px solid var(--warning);
+    transition: background-color 0.2s, border-left 0.2s;
+}
+
+.folder-item.has-unsaved {
+    border-left: 3px solid var(--warning);
+}
+
+.folder-toggle {
+    width: 20px;
+    height: 20px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    cursor: pointer;
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.folder-icon {
+    margin-right: 0.5rem;
+    color: var(--text-muted);
+}
+
+.folder-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.folder-count {
+    font-size: 11px;
+    color: var(--text-muted);
+    margin-left: 0.5rem;
+}
+
+.folder-children {
+    margin-left: 1.5rem;
+}
+
+/* Spreadsheet Pane */
+.spreadsheet-pane {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    overflow: hidden;
+}
+
+.spreadsheet-container {
+    flex: 1;
+    overflow: auto;
+    background-color: var(--bg);
+}
+
+/* ZIP Extract Button in Tree */
+.zip-extract-btn {
+    margin-left: auto;
+    padding: 0.15rem 0.4rem;
+    font-size: 0.7rem;
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.folder-item:hover .zip-extract-btn {
+    opacity: 1;
+}
+
+.zip-extract-btn:disabled {
+    opacity: 0.5;
+    cursor: wait;
+}
+
+/* ZIP Extract All Button */
+.zip-extract-all-btn {
+    margin-left: auto;
+    padding: 0.15rem 0.4rem;
+    font-size: 0.7rem;
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.folder-item:hover .zip-extract-all-btn {
+    opacity: 1;
+}
+
+.zip-extract-all-btn:disabled {
+    opacity: 0.5;
+    cursor: wait;
+}
+
+/**
+ * Spreadsheet Styles
+ * Table, cells, editing, and row states
+ */
+
+.spreadsheet {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.875rem;
+    background-color: var(--bg);
+}
+
+/* Selected cells */
+.selected-cell {
+    background-color: rgba(0, 123, 255, 0.2) !important;
+    outline: 1px solid var(--primary);
+}
+
+/* Auto-populated cells (gray text to indicate matches filename) */
+.cell-editable.auto-populated {
+    color: var(--text-muted);
+}
+
+/* Changed fields (blue text to indicate value differs from original filename) */
+.cell-editable.field-changed {
+    color: var(--primary);
+    font-weight: 500;
+}
+
+.spreadsheet thead {
+    position: sticky;
+    top: 0;
+    z-index: 10;
+    background-color: var(--bg-secondary);
+}
+
+.spreadsheet th {
+    padding: 0.75rem 0.5rem;
+    text-align: left;
+    font-weight: 600;
+    border-bottom: 2px solid var(--border);
+    background-color: var(--bg-secondary);
+    position: relative;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.spreadsheet th:hover:not(.col-row-num) {
+    background-color: var(--border);
+}
+
+/* Sort indicator */
+.sort-indicator {
+    display: inline-block;
+    font-size: 0.75rem;
+    color: var(--primary);
+    margin-left: 0.25rem;
+    margin-right: 0.25rem;
+    font-weight: bold;
+    vertical-align: middle;
+}
+
+.spreadsheet td {
+    padding: 0.5rem;
+    border-bottom: 1px solid var(--border);
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+/* Column resizer */
+.column-resizer {
+    position: absolute;
+    top: 0;
+    right: 0;
+    width: 5px;
+    height: 100%;
+    cursor: col-resize;
+    user-select: none;
+    z-index: 1;
+}
+
+.column-resizer:hover {
+    background-color: var(--primary);
+}
+
+/* Column Widths */
+.col-row-num {
+    width: 50px;
+    text-align: center;
+    background-color: var(--bg-secondary);
+    font-weight: 600;
+    color: var(--text-muted);
+    user-select: none;
+    -webkit-user-select: none;
+}
+
+.col-original {
+    min-width: 250px;
+}
+
+.col-extension {
+    width: 60px;
+    text-align: center;
+}
+
+.col-new {
+    min-width: 250px;
+}
+
+.col-trackingNumber {
+    min-width: 200px;
+    width: 200px;
+}
+
+.col-revision {
+    width: 80px;
+}
+
+.col-status {
+    width: 100px;
+}
+
+.col-title {
+    min-width: 200px;
+}
+
+.col-sha256 {
+    min-width: 150px;
+    font-family: var(--font-mono);
+    font-size: 11px;
+}
+
+.col-actions {
+    width: 100px;
+    text-align: center;
+}
+
+/* Row States */
+.spreadsheet tbody tr {
+    transition: background-color 0.15s;
+}
+
+.spreadsheet tbody tr:hover {
+    background-color: var(--bg-hover);
+}
+
+.spreadsheet tbody tr.modified {
+    border-left: 3px solid var(--warning);
+}
+
+.spreadsheet tbody tr.error {
+    border-left: 3px solid var(--danger);
+    background-color: rgba(220, 53, 69, 0.08);
+}
+
+.spreadsheet tbody tr.saving {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+/* Cell Content */
+.cell-content {
+    display: block;
+    width: 100%;
+}
+
+.cell-link {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+.cell-link:hover {
+    text-decoration: underline;
+}
+
+.cell-extension {
+    font-family: var(--font-mono);
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.cell-computed {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+/* Editable Cells */
+.cell-editable {
+    cursor: text;
+    position: relative;
+}
+
+.cell-editable:hover {
+    background-color: var(--bg-hover);
+}
+
+.cell-content[contenteditable="true"] {
+    outline: 2px solid var(--primary);
+    outline-offset: 0;
+    background-color: var(--bg);
+    min-height: 1.5em;
+}
+
+.cell-content[contenteditable="true"]:focus {
+    outline: 2px solid var(--primary);
+    outline-offset: 0;
+}
+
+.cell-content.editing {
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+/* Computed cells */
+.cell-editable.computed {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+.cell-editable.computed:hover {
+    font-style: normal;
+    color: var(--text);
+}
+
+/* Validation states */
+.validation-error {
+    background-color: rgba(220, 53, 69, 0.1);
+    border-left: 3px solid var(--danger);
+}
+
+.validation-warning {
+    background-color: rgba(255, 193, 7, 0.1);
+    border-left: 3px solid #ffc107;
+}
+
+/* Inline Actions */
+.inline-actions {
+    position: absolute;
+    right: 0.25rem;
+    top: 50%;
+    transform: translateY(-50%);
+    display: flex;
+    gap: 0.25rem;
+    background-color: var(--bg);
+    padding: 0.125rem;
+    border-radius: 3px;
+}
+
+.cell-editable {
+    position: relative;
+    padding-right: 3.5rem; /* Space for buttons */
+}
+
+.btn-inline {
+    border: none;
+    background: rgba(255, 255, 255, 0.9);
+    cursor: pointer;
+    font-size: 14px;
+    padding: 0.25rem 0.5rem;
+    border-radius: 3px;
+    transition: all 0.15s;
+    font-weight: bold;
+    box-shadow: 0 1px 2px rgba(0,0,0,0.1);
+}
+
+.btn-save {
+    color: var(--success);
+}
+
+.btn-save:hover {
+    background-color: var(--success);
+    color: white;
+}
+
+.btn-cancel {
+    color: var(--danger);
+}
+
+.btn-cancel:hover {
+    background-color: var(--danger);
+    color: white;
+}
+
+/* Formula Preview */
+.formula-preview {
+    position: absolute;
+    bottom: 100%;
+    left: 0;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 4px;
+    padding: 0.5rem;
+    font-size: 12px;
+    min-width: 200px;
+    z-index: 100;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.formula-preview-label {
+    font-weight: 600;
+    color: var(--text-muted);
+    margin-bottom: 0.25rem;
+}
+
+.formula-preview-value {
+    color: var(--text);
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.formula-preview-value.valid {
+    color: var(--success);
+}
+
+.formula-preview-value.invalid {
+    color: var(--danger);
+}
+
+.preview-check {
+    color: var(--success);
+    font-size: 16px;
+    cursor: pointer;
+    padding: 0.25rem;
+    border-radius: 3px;
+    transition: background-color 0.15s;
+}
+
+.preview-check:hover {
+    background-color: rgba(40, 167, 69, 0.1);
+}
+
+.preview-error {
+    color: var(--danger);
+    font-size: 16px;
+}
+
+.formula-preview-errors {
+    margin-top: 0.25rem;
+    font-size: 11px;
+    color: var(--danger);
+    white-space: normal;
+}
+
+/* Validation States */
+.cell-warning {
+    background-color: rgba(255, 193, 7, 0.08);
+    border-left: 3px solid var(--warning);
+}
+
+.cell-error {
+    background-color: rgba(220, 53, 69, 0.08);
+    border-left: 3px solid var(--danger);
+}
+
+.validation-icon {
+    display: inline-block;
+    margin-left: 0.25rem;
+    cursor: help;
+}
+
+/* SHA256 Column */
+.sha256-hash {
+    font-family: var(--font-mono);
+    font-size: 11px;
+    color: var(--text-muted);
+}
+
+.sha256-calculating {
+    font-style: italic;
+    color: var(--text-muted);
+}
+
+/* Action Buttons */
+.row-actions {
+    display: flex;
+    gap: 0.25rem;
+    justify-content: center;
+}
+
+.btn-icon {
+    width: 28px;
+    height: 28px;
+    padding: 0;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    border: 1px solid var(--border);
+    border-radius: 4px;
+    background-color: var(--bg);
+    cursor: pointer;
+    transition: all 0.15s;
+}
+
+.btn-icon:hover:not(:disabled) {
+    background-color: var(--bg-hover);
+    transform: scale(1.1);
+}
+
+.btn-icon:disabled {
+    opacity: 0.3;
+    cursor: not-allowed;
+}
+
+.btn-save {
+    color: var(--success);
+}
+
+.btn-cancel {
+    color: var(--danger);
+}
+
+/* Empty State */
+.empty-state {
+    padding: 3rem;
+    text-align: center;
+    color: var(--text-muted);
+}
+
+.empty-state h3 {
+    margin-bottom: 0.5rem;
+}
+
+/* Spreadsheet Empty State */
+.spreadsheet-empty {
+    text-align: center;
+    color: var(--text-muted);
+    padding: 1.5rem;
+}
+
+/* Selection Highlight */
+.cell-selected {
+    outline: 2px solid var(--primary);
+    outline-offset: -2px;
+    z-index: 1;
+}
+
+/* Scrollbar Styling */
+.spreadsheet-container::-webkit-scrollbar {
+    width: 12px;
+    height: 12px;
+}
+
+.spreadsheet-container::-webkit-scrollbar-track {
+    background-color: var(--bg-secondary);
+}
+
+.spreadsheet-container::-webkit-scrollbar-thumb {
+    background-color: var(--border-dark);
+    border-radius: 6px;
+}
+
+.spreadsheet-container::-webkit-scrollbar-thumb:hover {
+    background-color: var(--text-muted);
+}
+
+/* Preview button active state */
+#togglePreviewBtn.preview-active {
+    background-color: var(--primary);
+    color: white;
+    border-color: var(--primary);
+}
+
+    </style>
+</head>
+<body>
+    <div id="app">
+        <!-- Main Application -->
+        <div id="mainApp" class="main-app">
+            <!-- Header -->
+            <header class="app-header">
+                <div class="header-left">
+                    <div class="header-title-group">
+                        <span class="app-header__title">ZDDC Classifier</span>
+                        <span class="build-timestamp">v0.0.1</span>
+                    </div>
+                    <button id="selectDirectoryBtn" class="btn btn-primary">Select Directory</button>
+                    <button id="refreshBtn" class="btn btn-secondary hidden" title="Refresh and rescan directory">Refresh</button>
+                </div>
+                <div class="header-right">
+                    <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+                    <button id="help-btn" class="btn btn-secondary" title="Help">?</button>
+                </div>
+            </header>
+
+            <!-- Main Content -->
+            <div class="main-content">
+                <!-- Folder Tree -->
+                <aside class="folder-tree-pane" id="folderTreePane">
+                    <div class="pane-header">
+                        <div class="pane-header-title">
+                            <button class="btn btn-sm collapse-tree-btn" id="collapseTreeBtn" title="Collapse folder tree">◀</button>
+                            <h3>Folder Tree</h3>
+                        </div>
+                        <div class="pane-header-controls">
+                            <label class="checkbox-label" title="Auto-scroll folder tree when hovering files">
+                                <input type="checkbox" id="autoScrollCheckbox" checked>
+                                Auto-scroll
+                            </label>
+                            <label class="checkbox-label">
+                                <input type="checkbox" id="hideCompliantCheckbox">
+                                Hide Compliant
+                            </label>
+                            <span id="selectedFoldersCount" class="folder-count">0 folders selected</span>
+                        </div>
+                    </div>
+                    <div id="folderTree" class="folder-tree">
+                        <!-- Dynamically populated -->
+                    </div>
+                    <div class="resize-handle" id="treeResizeHandle"></div>
+                </aside>
+
+                <!-- Spreadsheet Table -->
+                <main class="spreadsheet-pane">
+                    <div class="pane-header">
+                        <div class="pane-header-left">
+                            <h3>Files</h3>
+                            <div class="file-stats">
+                                <span id="totalFiles">0 files</span>
+                                <span id="modifiedFiles">0 modified</span>
+                                <span id="errorFiles" class="hidden">0 errors</span>
+                            </div>
+                        </div>
+                        <div class="pane-header-right">
+                            <button id="saveAllBtn" class="btn btn-success btn-sm" disabled>Save All</button>
+                            <button id="cancelAllBtn" class="btn btn-secondary btn-sm" disabled>Cancel All</button>
+                            <span class="header-divider">|</span>
+                            <label class="checkbox-label">
+                                <input type="checkbox" id="sha256Checkbox">
+                                SHA256
+                            </label>
+                            <button id="exportHashesBtn" class="btn btn-secondary btn-sm" disabled title="Export SHA256 hashes in sha256sum format">💾 Export Hashes</button>
+                            <span class="header-divider">|</span>
+                            <button id="togglePreviewBtn" class="btn btn-secondary btn-sm" title="Toggle file preview panel">👁 Preview</button>
+                        </div>
+                    </div>
+                    <div class="spreadsheet-container">
+                        <table id="spreadsheet" class="spreadsheet">
+                            <thead>
+                                <tr>
+                                    <th class="col-row-num">#</th>
+                                    <th class="col-original">Original Filename
+                                        <input type="text" class="column-filter" data-filter-field="original" placeholder="filter…" spellcheck="false" aria-label="Filter by original filename">
+                                    </th>
+                                    <th class="col-extension">Ext
+                                        <input type="text" class="column-filter" data-filter-field="extension" placeholder="filter…" spellcheck="false" aria-label="Filter by extension">
+                                    </th>
+                                    <th class="col-new">New Filename
+                                        <input type="text" class="column-filter" data-filter-field="newFilename" placeholder="filter…" spellcheck="false" aria-label="Filter by new filename">
+                                    </th>
+                                    <th class="col-trackingNumber">Tracking
+                                        <input type="text" class="column-filter" data-filter-field="trackingNumber" placeholder="filter…" spellcheck="false" aria-label="Filter by tracking number">
+                                    </th>
+                                    <th class="col-revision">Rev
+                                        <input type="text" class="column-filter" data-filter-field="revision" placeholder="filter…" spellcheck="false" aria-label="Filter by revision">
+                                    </th>
+                                    <th class="col-status">Status
+                                        <input type="text" class="column-filter" data-filter-field="status" placeholder="filter…" spellcheck="false" aria-label="Filter by status">
+                                    </th>
+                                    <th class="col-title">Title
+                                        <input type="text" class="column-filter" data-filter-field="title" placeholder="filter…" spellcheck="false" aria-label="Filter by title">
+                                    </th>
+                                    <th class="col-sha256 hidden" id="sha256Column">SHA256
+                                        <input type="text" class="column-filter" data-filter-field="sha256" placeholder="filter…" spellcheck="false" aria-label="Filter by SHA256">
+                                    </th>
+                                </tr>
+                            </thead>
+                            <tbody id="spreadsheetBody">
+                                <!-- Dynamically populated -->
+                            </tbody>
+                        </table>
+                    </div>
+                </main>
+
+            </div>
+
+            <!-- Empty State — shown until a directory is selected -->
+            <div id="welcomeScreen" class="empty-state">
+                <div class="empty-state-content">
+                    <h2>ZDDC Classifier</h2>
+                    <p>Rename a folder of files to ZDDC format using a spreadsheet interface.</p>
+                    <p>Open a directory, fill in tracking number, revision, status, and title for each file, then save — the files are renamed on disk.</p>
+
+                    <!-- Browser Compatibility Warning -->
+                    <div id="browserWarning" class="browser-warning hidden">
+                        <h3>⚠️ Browser Not Supported</h3>
+                        <p>This application requires the File System Access API, available only in Chromium-based browsers (Chrome, Edge, Brave, Opera).</p>
+                    </div>
+
+                    <ul class="welcome-list">
+                        <li>Files already named to ZDDC format are parsed automatically</li>
+                        <li>Edit cells directly, or copy columns to and from Excel</li>
+                        <li>Real-time validation highlights non-compliant names</li>
+                        <li>Rename one file or all modified files at once</li>
+                    </ul>
+
+                    <p>Click <strong>Select Directory</strong> to begin.</p>
+
+                    <p class="note">This application works entirely in your browser. No data is transmitted to any server.</p>
+                </div>
+            </div>
+        </div>
+
+        <!-- Help Panel -->
+        <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+            <div class="help-panel__header">
+                <h2 id="help-panel-title" class="help-panel__title">Help — ZDDC Classifier</h2>
+                <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+            </div>
+            <div class="help-panel__body">
+                <h3>What is the Classifier?</h3>
+                <p>The Classifier is a spreadsheet-based tool for renaming files to ZDDC naming conventions. It reads a folder of files and presents them in an editable grid where you can set tracking number, revision, status, and title — then saves the renamed files back to disk.</p>
+
+                <h3>Getting Started</h3>
+                <ol>
+                    <li>Click <strong>Select Directory</strong> to open a folder containing files to rename.</li>
+                    <li>The folder tree on the left shows all sub-folders. Click a folder to load its files.</li>
+                    <li>Edit cells in the spreadsheet to set the new filename components.</li>
+                    <li>Click <strong>Save All</strong> (or save individual rows) to rename the files on disk.</li>
+                </ol>
+
+                <h3>Folder Tree</h3>
+                <dl>
+                    <dt>Multi-select</dt>
+                    <dd>Hold <kbd>Ctrl</kbd> and click to select multiple folders. Hold <kbd>Shift</kbd> to select a range. Files from all selected folders are shown together.</dd>
+                    <dt>Hide Compliant</dt>
+                    <dd>Hides folders where all files already have valid ZDDC names, letting you focus on work remaining.</dd>
+                    <dt>Auto-scroll</dt>
+                    <dd>When enabled, the folder tree scrolls to highlight the folder containing the row you are editing.</dd>
+                </dl>
+
+                <h3>Spreadsheet Editing</h3>
+                <dl>
+                    <dt>Direct cell editing</dt>
+                    <dd>Click any cell in the New Filename, Tracking, Rev, Status, or Title columns to edit it. Press <kbd>Enter</kbd> to confirm, <kbd>Escape</kbd> to cancel.</dd>
+                    <dt>RC References</dt>
+                    <dd>Type a formula like <code>=R[-1]C</code> to copy the value from the cell one row above in the same column — similar to Excel relative references.</dd>
+                    <dt>Regex capture groups</dt>
+                    <dd>Type a formula like <code>=RE(RC[-3], "(\w+)-(\d+)", "$1")</code> to extract a pattern from another cell using a regular expression.</dd>
+                    <dt>Validation</dt>
+                    <dd>Cells are validated automatically. Invalid values are highlighted in red. The New Filename column shows the composed result.</dd>
+                    <dt>Column Filters</dt>
+                    <dd>Each column header has a filter input. Supported syntax:</dd>
+                </dl>
+                <dl>
+                    <dt><code>term</code></dt>
+                    <dd>Contains "term" (case-insensitive)</dd>
+                    <dt><code>!term</code></dt>
+                    <dd>Does not contain "term"</dd>
+                    <dt><code>^term</code></dt>
+                    <dd>Starts with "term"</dd>
+                    <dt><code>term$</code></dt>
+                    <dd>Ends with "term"</dd>
+                    <dt><code>a b</code></dt>
+                    <dd>Matches both (AND)</dd>
+                    <dt><code>a | b</code></dt>
+                    <dd>Matches either (OR)</dd>
+                    <dt><code>^IFA | ^IFB</code></dt>
+                    <dd>Starts with IFA or IFB</dd>
+                    <dt><code>!^~</code></dt>
+                    <dd>Does not start with ~ (excludes drafts)</dd>
+                    <dt><code>el.*spc</code></dt>
+                    <dd>Regex: contains "el" followed by "spc" (use <code>.</code> for any char, <code>.*</code> for any sequence)</dd>
+                    <dt><code>[ei]fa</code></dt>
+                    <dd>Regex character class: matches "efa" or "ifa"</dd>
+                </dl>
+
+                <h3>Saving Files</h3>
+                <dl>
+                    <dt>Save All</dt>
+                    <dd>Renames all modified files in one operation. Confirms before proceeding.</dd>
+                    <dt>Cancel All</dt>
+                    <dd>Reverts all unsaved edits back to the original filenames.</dd>
+                    <dt>SHA256</dt>
+                    <dd>Enable to compute a cryptographic hash of each file. Use <strong>Export Hashes</strong> to save a <code>sha256sum</code>-compatible file.</dd>
+                </dl>
+
+                <h3>ZDDC Filename Format</h3>
+                <p>The required format is:</p>
+                <p><code>TRACKINGNUMBER_REVISION (STATUS) - Title.ext</code></p>
+                <p>Example: <code>123456-EL-SPC-2623_A (IFR) - Electrical Specification.pdf</code></p>
+                <p>Valid statuses: IFA, IFB, IFC, IFD, IFI, IFP, IFR, IFU, REC, RSA, RSB, RSC, RSD, RSI, ---</p>
+            </div>
+        </aside>
+    </div>
+
+    <script>
+/**
+ * ZDDC — shared naming convention library
+ *
+ * Canonical implementation of all ZDDC filename, folder name, tracking number,
+ * revision, and status logic.  Included in every tool's build via shared/zddc.js.
+ *
+ * Exposed as window.zddc (plain global) so it works with every tool's module
+ * pattern (archive globals, classifier IIFE, transmittal IIFE, mdedit globals).
+ *
+ * Public API
+ * ----------
+ *   zddc.parseFilename(str)        → ParsedFile | null
+ *   zddc.parseFolder(str)          → ParsedFolder | null
+ *   zddc.parseRevision(str)        → ParsedRevision
+ *   zddc.formatFilename(parts)     → string
+ *   zddc.formatFolder(parts)       → string
+ *   zddc.compareRevisions(a, b)    → number  (-1 | 0 | 1)
+ *   zddc.isValidStatus(str)        → boolean
+ *   zddc.STATUSES                  → string[]
+ *
+ * ParsedFile   { trackingNumber, revision, status, title, extension }
+ * ParsedFolder { date, trackingNumber, status, title }
+ * ParsedRevision { base, modifier, modifierType, modifierNumber, isDraft, full }
+ */
+
+(function (root) {
+    'use strict';
+
+    // ── Valid status codes ───────────────────────────────────────────────────
+
+    /**
+     * Complete list of valid ZDDC document status codes.
+     * '---' denotes an unknown or not-yet-assigned status.
+     */
+    var STATUSES = [
+        '---',
+        'IFA', 'IFB', 'IFC', 'IFD', 'IFI', 'IFP', 'IFR', 'IFU',
+        'REC',
+        'RSA', 'RSB', 'RSC', 'RSD', 'RSI',
+    ];
+
+    var STATUS_SET = {};
+    for (var _i = 0; _i < STATUSES.length; _i++) {
+        STATUS_SET[STATUSES[_i]] = true;
+    }
+
+    function isValidStatus(str) {
+        return !!STATUS_SET[str];
+    }
+
+    // ── Filename parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Canonical file regex.
+     * Matches: TRACKING_REVISION (STATUS) - TITLE.EXT
+     *
+     * Tracking number: no underscores, no whitespace.
+     * Revision:        no whitespace, no parentheses.
+     * Status:          anything inside parentheses (validated separately).
+     * Title:           everything up to the last dot.
+     * Extension:       after the last dot (lowercased by parseFilename).
+     */
+    var FILE_RE = /^([^_\s]+)_([^\s()_]+)\s*\(([^)]+)\)\s*-\s*(\S.*\S|\S)\.\s*([^\s.]+)$/;
+
+    /**
+     * Parse a ZDDC filename.
+     *
+     * @param {string} filename
+     * @returns {{ trackingNumber: string, revision: string, status: string,
+     *             title: string, extension: string, valid: boolean } | null}
+     *   null only if filename is falsy.
+     *   `valid` is true when all fields matched the ZDDC pattern.
+     */
+    function parseFilename(filename) {
+        if (!filename) { return null; }
+
+        var match = filename.match(FILE_RE);
+
+        if (!match) {
+            var lastDot = filename.lastIndexOf('.');
+            return {
+                trackingNumber: '',
+                revision:       '',
+                status:         '',
+                title:          lastDot > 0 ? filename.substring(0, lastDot) : filename,
+                extension:      lastDot > 0 ? filename.substring(lastDot + 1).toLowerCase() : '',
+                valid:          false,
+            };
+        }
+
+        return {
+            trackingNumber: match[1].trim(),
+            revision:       match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            extension:      match[5].toLowerCase(),
+            valid:          true,
+        };
+    }
+
+    // ── Folder name parsing ──────────────────────────────────────────────────
+
+    /**
+     * Transmittal folder regex.
+     * Matches: YYYY-MM-DD_TRACKING (STATUS) - TITLE
+     */
+    var FOLDER_RE = /^(\d{4}-\d{2}-\d{2})_([^_\s(]+)\s*\(([^)]+)\)\s*-\s*(.+)$/;
+
+    /**
+     * Parse a ZDDC transmittal folder name.
+     *
+     * @param {string} foldername
+     * @returns {{ date: string, trackingNumber: string, status: string,
+     *             title: string, valid: boolean } | null}
+     *   null only if foldername is falsy.
+     */
+    function parseFolder(foldername) {
+        if (!foldername) { return null; }
+
+        var match = foldername.match(FOLDER_RE);
+
+        if (!match) {
+            return {
+                date:            '',
+                trackingNumber:  '',
+                status:          '',
+                title:           foldername,
+                valid:           false,
+            };
+        }
+
+        return {
+            date:           match[1],
+            trackingNumber: match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            valid:          true,
+        };
+    }
+
+    // ── Revision parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Modifier sub-regex: +LETTER DIGITS  e.g. +C1, +B2, +N1, +Q1
+     * The draft prefix (~) may appear inside the modifier: A+~C1
+     */
+    var MODIFIER_RE = /^\+(~?)([A-Za-z])(\d+)$/;
+
+    /**
+     * Parse a ZDDC revision string.
+     *
+     * Revision grammar:
+     *   revision     = ['~'] base ['+' ['~'] modifier_letter modifier_number]
+     *   base         = letter(s) | digit(s) | date(YYYY-MM-DD)
+     *   modifier     = letter + digits   e.g. C1, B2, N1, Q1
+     *
+     * @param {string} revision
+     * @returns {{
+     *   base: string,
+     *   modifier: string,       full modifier string e.g. '+C1', '' if none
+     *   modifierType: string,   modifier letter e.g. 'C', '' if none
+     *   modifierNumber: number, modifier number e.g. 1, 0 if none
+     *   modifierIsDraft: boolean,
+     *   isDraft: boolean,       true if base revision starts with ~
+     *   full: string,           original input
+     * }}
+     */
+    function parseRevision(revision) {
+        var raw = (revision || '').toString();
+
+        // Split on '+' to separate base from optional modifier
+        var plusIdx = raw.indexOf('+');
+        var basePart     = plusIdx === -1 ? raw : raw.substring(0, plusIdx);
+        var modifierPart = plusIdx === -1 ? ''  : raw.substring(plusIdx);
+
+        // Draft flag on the base part
+        var isDraft = basePart.startsWith('~');
+        var base    = isDraft ? basePart.substring(1) : basePart;
+
+        // Parse modifier
+        var modifier        = '';
+        var modifierType    = '';
+        var modifierNumber  = 0;
+        var modifierIsDraft = false;
+
+        if (modifierPart) {
+            var mMatch = modifierPart.match(MODIFIER_RE);
+            if (mMatch) {
+                modifierIsDraft = mMatch[1] === '~';
+                modifierType    = mMatch[2].toUpperCase();
+                modifierNumber  = parseInt(mMatch[3], 10);
+                modifier        = modifierPart;
+            } else {
+                // Unrecognised modifier — preserve as-is
+                modifier = modifierPart;
+            }
+        }
+
+        return {
+            base:           base,
+            modifier:       modifier,
+            modifierType:   modifierType,
+            modifierNumber: modifierNumber,
+            modifierIsDraft: modifierIsDraft,
+            isDraft:        isDraft,
+            full:           raw,
+        };
+    }
+
+    // ── Revision comparison ──────────────────────────────────────────────────
+
+    /**
+     * Classify a base revision string into a sort tier:
+     *   0 = date (YYYY-MM-DD)
+     *   1 = letter(s)   A, B, AA …
+     *   2 = number(s)   0, 1, 2, 1.5 …
+     *   3 = other
+     */
+    function _baseTier(base) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(base)) { return 0; }
+        if (/^[A-Za-z]+$/.test(base))          { return 1; }
+        if (/^\d+(\.\d+)?$/.test(base))         { return 2; }
+        return 3;
+    }
+
+    /**
+     * Compare two base revision strings.
+     * Sort order: dates < letters < numbers < other.
+     */
+    function _compareBase(a, b) {
+        var ta = _baseTier(a);
+        var tb = _baseTier(b);
+        if (ta !== tb) { return ta - tb; }
+
+        if (ta === 0) { return a < b ? -1 : a > b ? 1 : 0; }       // date lexicographic = chronological
+        if (ta === 1) { return a.toUpperCase() < b.toUpperCase() ? -1 : a.toUpperCase() > b.toUpperCase() ? 1 : 0; }
+        if (ta === 2) { return parseFloat(a) - parseFloat(b); }
+        return a.localeCompare(b);
+    }
+
+    /**
+     * Compare two ZDDC revision strings for sort ordering.
+     *
+     * Canonical order (ascending = older → newer):
+     *   ~A  <  A  <  A+B1  <  A+C1  <  A+~C2  <  A+C2  <  A+N1  <  A+Q1
+     *   <  ~B  <  B  < … < 0 < 1 < 2
+     *
+     * Rules:
+     *   1. Compare base revisions first (dates < letters < numbers).
+     *   2. For equal bases, draft (isDraft=true) comes before final.
+     *   3. For equal base+draft, no-modifier < has-modifier.
+     *   4. For equal base+draft+modifier presence:
+     *      a. modifier draft comes before modifier final (modifierIsDraft).
+     *      b. Sort modifier by type letter then by number.
+     *
+     * @param {string} a
+     * @param {string} b
+     * @returns {number}  negative if a < b, 0 if equal, positive if a > b
+     */
+    function compareRevisions(a, b) {
+        var pa = parseRevision(a);
+        var pb = parseRevision(b);
+
+        // 1. Base revision
+        var baseCmp = _compareBase(pa.base, pb.base);
+        if (baseCmp !== 0) { return baseCmp; }
+
+        // 2. Draft before final (for same base)
+        if (pa.isDraft !== pb.isDraft) { return pa.isDraft ? -1 : 1; }
+
+        // 3. No modifier before any modifier
+        var aHasMod = pa.modifier !== '';
+        var bHasMod = pb.modifier !== '';
+        if (aHasMod !== bHasMod) { return aHasMod ? 1 : -1; }
+
+        if (!aHasMod) { return 0; } // both have no modifier
+
+        // 4. Compare modifiers: type → number → draft (draft is a tie-breaker only)
+        // 4a. Modifier type letter (B < C < N < Q …)
+        if (pa.modifierType !== pb.modifierType) {
+            return pa.modifierType < pb.modifierType ? -1 : 1;
+        }
+
+        // 4b. Modifier number (1 < 2 …)
+        if (pa.modifierNumber !== pb.modifierNumber) {
+            return pa.modifierNumber - pb.modifierNumber;
+        }
+
+        // 4c. Draft of a modifier comes before the final modifier (same type+number)
+        if (pa.modifierIsDraft !== pb.modifierIsDraft) {
+            return pa.modifierIsDraft ? -1 : 1;
+        }
+
+        return 0;
+    }
+
+    // ── Filename / folder formatting ─────────────────────────────────────────
+
+    /**
+     * Build a ZDDC filename from its components.
+     *
+     * @param {{ trackingNumber: string, revision: string, status: string,
+     *           title: string, extension: string }} parts
+     * @returns {string}  e.g. "123456-EL-SPC-2623_A (IFR) - Specification.pdf"
+     */
+    function formatFilename(parts) {
+        var tn  = (parts.trackingNumber || '').trim();
+        var rev = (parts.revision       || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+        var ext = (parts.extension      || '').replace(/^\./, '');
+
+        if (!tn || !rev || !st || !ttl) { return ''; }
+
+        var name = tn + '_' + rev + ' (' + st + ') - ' + ttl;
+        return ext ? name + '.' + ext : name;
+    }
+
+    /**
+     * Build a ZDDC transmittal folder name from its components.
+     *
+     * @param {{ date: string, trackingNumber: string, status: string,
+     *           title: string }} parts
+     * @returns {string}  e.g. "2025-10-31_123456-EM-SUB-0001 (IFR) - Title"
+     */
+    function formatFolder(parts) {
+        var dt  = (parts.date           || '').trim();
+        var tn  = (parts.trackingNumber || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+
+        if (!dt || !tn || !st || !ttl) { return ''; }
+
+        return dt + '_' + tn + ' (' + st + ') - ' + ttl;
+    }
+
+    // ── Filename / extension splitting ───────────────────────────────────────
+
+    /**
+     * Split a filename into its base name and extension (no leading dot).
+     * Treats leading dot ('.gitignore') as no extension.
+     *
+     * @param {string} filename
+     * @returns {{ name: string, extension: string }}
+     */
+    function splitExtension(filename) {
+        if (!filename) { return { name: '', extension: '' }; }
+        var lastDot = filename.lastIndexOf('.');
+        if (lastDot <= 0) { return { name: filename, extension: '' }; }
+        return {
+            name:      filename.substring(0, lastDot),
+            extension: filename.substring(lastDot + 1).toLowerCase(),
+        };
+    }
+
+    /**
+     * Join a base name and extension. Tolerant of either form ('pdf' or '.pdf').
+     * Returns just the name when extension is empty.
+     */
+    function joinExtension(name, extension) {
+        var ext = (extension || '').replace(/^\./, '');
+        return ext ? name + '.' + ext : name;
+    }
+
+    // ── Public API ───────────────────────────────────────────────────────────
+
+    root.zddc = {
+        STATUSES:         STATUSES,
+        isValidStatus:    isValidStatus,
+        parseFilename:    parseFilename,
+        parseFolder:      parseFolder,
+        parseRevision:    parseRevision,
+        formatFilename:   formatFilename,
+        formatFolder:     formatFolder,
+        compareRevisions: compareRevisions,
+        splitExtension:   splitExtension,
+        joinExtension:    joinExtension,
+    };
+
+}(typeof window !== 'undefined' ? window : this));
+
+/**
+ * ZDDC — shared SHA-256 helpers
+ *
+ * Attaches to window.zddc.crypto. Must load AFTER shared/zddc.js (which creates
+ * the window.zddc object).
+ *
+ * Exports:
+ *   zddc.crypto.sha256Hex(buffer)       → Promise<string>  hex digest of ArrayBuffer/Uint8Array
+ *   zddc.crypto.sha256String(str)       → Promise<string>  hex digest of UTF-8 encoded string
+ *   zddc.crypto.sha256File(file, onProgress?) → Promise<string>
+ *       chunked streaming digest for File/Blob; for files >= 4 MB, streams 2 MB chunks
+ *       and invokes onProgress(loaded, total) every ~8 MB.
+ *   zddc.crypto.bytesToHex(buffer)      → string  (hex of ArrayBuffer/Uint8Array, no digest)
+ *
+ * Throws if Web Crypto SubtleCrypto is not available.
+ */
+(function (root) {
+    'use strict';
+
+    if (!root.zddc) {
+        throw new Error('shared/hash.js: window.zddc must be loaded first');
+    }
+
+    var HASH_CHUNK_SIZE = 2 * 1024 * 1024; // 2 MB
+
+    function requireSubtle() {
+        if (!root.crypto || !root.crypto.subtle || typeof root.crypto.subtle.digest !== 'function') {
+            throw new Error('Web Crypto SubtleCrypto is required');
+        }
+    }
+
+    function bytesToHex(buffer) {
+        return Array.from(new Uint8Array(buffer), function (byte) {
+            return byte.toString(16).padStart(2, '0');
+        }).join('');
+    }
+
+    async function sha256Hex(buffer) {
+        requireSubtle();
+        var input = (buffer instanceof Uint8Array) ? buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength) : buffer;
+        var hash = await root.crypto.subtle.digest('SHA-256', input);
+        return bytesToHex(hash);
+    }
+
+    async function sha256String(str) {
+        requireSubtle();
+        var bytes = new TextEncoder().encode(str);
+        var hash = await root.crypto.subtle.digest('SHA-256', bytes);
+        return bytesToHex(hash);
+    }
+
+    async function sha256File(file, onProgress) {
+        requireSubtle();
+        // Single-shot for small files or environments without ReadableStream
+        if (file.size < HASH_CHUNK_SIZE * 2 || typeof file.stream !== 'function') {
+            if (onProgress) { onProgress(file.size, file.size); }
+            var buf = await file.arrayBuffer();
+            var hash = await root.crypto.subtle.digest('SHA-256', buf);
+            return bytesToHex(hash);
+        }
+        // Chunked streaming for large files
+        var reader = file.stream().getReader();
+        var loaded = 0;
+        var chunks = [];
+        var yieldCounter = 0;
+        while (true) {
+            var result = await reader.read();
+            if (result.done) { break; }
+            chunks.push(result.value);
+            loaded += result.value.byteLength;
+            yieldCounter++;
+            if (onProgress && yieldCounter % 4 === 0) {
+                onProgress(loaded, file.size);
+                await new Promise(function (r) { setTimeout(r, 0); });
+            }
+        }
+        var total = new Uint8Array(loaded);
+        var offset = 0;
+        for (var i = 0; i < chunks.length; i++) {
+            total.set(chunks[i], offset);
+            offset += chunks[i].byteLength;
+        }
+        var digest = await root.crypto.subtle.digest('SHA-256', total.buffer);
+        if (onProgress) { onProgress(file.size, file.size); }
+        return bytesToHex(digest);
+    }
+
+    root.zddc.crypto = {
+        sha256Hex:    sha256Hex,
+        sha256String: sha256String,
+        sha256File:   sha256File,
+        bytesToHex:   bytesToHex,
+    };
+})(typeof window !== 'undefined' ? window : globalThis);
+
+/**
+ * ZDDC shared theme toggle — light / dark / auto.
+ * Persists choice to localStorage under 'zddc-theme'.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #theme-btn in the DOM (optional — skips gracefully if absent).
+ *
+ * Theme cycle: auto → light → dark → auto …
+ * 'auto' honours the OS prefers-color-scheme media query (CSS handles it).
+ * 'light' sets data-theme="light" on <html> (overrides dark media query).
+ * 'dark'  sets data-theme="dark"  on <html>.
+ */
+(function () {
+    'use strict';
+
+    var STORAGE_KEY = 'zddc-theme';
+    var THEMES = ['auto', 'light', 'dark'];
+
+    var LABELS = {
+        auto:  '◐',
+        light: '☀',
+        dark:  '☾'
+    };
+
+    var TITLES = {
+        auto:  'Theme: auto (follows OS)',
+        light: 'Theme: light',
+        dark:  'Theme: dark'
+    };
+
+    function load() {
+        var stored = localStorage.getItem(STORAGE_KEY);
+        return THEMES.indexOf(stored) !== -1 ? stored : 'auto';
+    }
+
+    function apply(theme) {
+        if (theme === 'dark') {
+            document.documentElement.setAttribute('data-theme', 'dark');
+        } else if (theme === 'light') {
+            document.documentElement.setAttribute('data-theme', 'light');
+        } else {
+            document.documentElement.removeAttribute('data-theme');
+        }
+    }
+
+    function save(theme) {
+        try { localStorage.setItem(STORAGE_KEY, theme); } catch (e) {}
+    }
+
+    function updateButton(btn, theme) {
+        btn.textContent = LABELS[theme];
+        btn.title = TITLES[theme];
+        btn.setAttribute('aria-label', TITLES[theme]);
+    }
+
+    function next(theme) {
+        return THEMES[(THEMES.indexOf(theme) + 1) % THEMES.length];
+    }
+
+    function init() {
+        var current = load();
+        apply(current);
+
+        var btn = document.getElementById('theme-btn');
+        if (!btn) { return; }
+
+        updateButton(btn, current);
+
+        btn.addEventListener('click', function () {
+            current = next(current);
+            apply(current);
+            save(current);
+            updateButton(btn, current);
+        });
+    }
+
+    /* Apply theme immediately (before DOM ready) to avoid flash */
+    apply(load());
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+/**
+ * ZDDC Classifier - Main Application
+ * Spreadsheet-based file renaming with Excel-like formulas
+ */
+(function() {
+    'use strict';
+
+    // Global application state
+    window.app = {
+        // File System
+        rootHandle: null,
+        
+        // Data
+        folderTree: [],
+        selectedFolders: new Set(), // Multi-select support
+        lastSelectedFolderPath: null,
+        hideCompliant: false,
+        calculateSha256: false,
+        
+        // DOM elements (populated on init)
+        dom: {},
+        
+        // Modules (populated by other files)
+        modules: {}
+    };
+
+    /**
+     * Initialize the application
+     */
+    function init() {
+
+        
+        // Check browser compatibility
+        if (!checkBrowserCompatibility()) {
+            showBrowserWarning();
+            return;
+        }
+        
+        // Cache DOM elements
+        cacheDOMElements();
+        
+        // Set up event listeners
+        setupEventListeners();
+        
+        // Show welcome screen
+        showWelcomeScreen();
+        
+
+    }
+
+    /**
+     * Check if browser supports File System Access API
+     */
+    function checkBrowserCompatibility() {
+        return 'showDirectoryPicker' in window;
+    }
+
+    /**
+     * Show browser compatibility warning
+     */
+    function showBrowserWarning() {
+        const warning = document.getElementById('browserWarning');
+        const selectBtn = document.getElementById('selectDirectoryBtn');
+        if (warning) {
+            warning.classList.remove('hidden');
+        }
+        if (selectBtn) {
+            selectBtn.disabled = true;
+            selectBtn.textContent = 'Browser Not Supported';
+        }
+    }
+
+    /**
+     * Cache DOM element references
+     */
+    function cacheDOMElements() {
+        app.dom = {
+            // Screens
+            welcomeScreen: document.getElementById('welcomeScreen'),
+            mainApp: document.getElementById('mainApp'),
+            
+            // Header buttons
+            selectDirectoryBtn: document.getElementById('selectDirectoryBtn'),
+            refreshBtn: document.getElementById('refreshBtn'),
+            saveAllBtn: document.getElementById('saveAllBtn'),
+            cancelAllBtn: document.getElementById('cancelAllBtn'),
+            exportHashesBtn: document.getElementById('exportHashesBtn'),
+            sha256Checkbox: document.getElementById('sha256Checkbox'),
+            hideCompliantCheckbox: document.getElementById('hideCompliantCheckbox'),
+            
+            // Folder tree
+            folderTree: document.getElementById('folderTree'),
+            folderTreePane: document.getElementById('folderTreePane'),
+            collapseTreeBtn: document.getElementById('collapseTreeBtn'),
+            autoScrollCheckbox: document.getElementById('autoScrollCheckbox'),
+            selectedFoldersCount: document.getElementById('selectedFoldersCount'),
+            
+            // Spreadsheet
+            spreadsheet: document.getElementById('spreadsheet'),
+            spreadsheetBody: document.getElementById('spreadsheetBody'),
+            sha256Column: document.getElementById('sha256Column'),
+            
+            // Stats
+            totalFiles: document.getElementById('totalFiles'),
+            modifiedFiles: document.getElementById('modifiedFiles'),
+            errorFiles: document.getElementById('errorFiles'),
+            
+            // Preview
+            togglePreviewBtn: document.getElementById('togglePreviewBtn')
+        };
+    }
+
+    /**
+     * Set up event listeners
+     */
+    function setupEventListeners() {
+        // Directory selection
+        app.dom.selectDirectoryBtn.addEventListener('click', handleSelectDirectory);
+        app.dom.refreshBtn.addEventListener('click', handleRefresh);
+        
+        // Drag and drop on welcome screen
+        setupWelcomeDragDrop();
+        
+        // Bulk actions
+        app.dom.saveAllBtn.addEventListener('click', handleSaveAll);
+        app.dom.cancelAllBtn.addEventListener('click', handleCancelAll);
+        
+        // Export hashes
+        app.dom.exportHashesBtn.addEventListener('click', handleExportHashes);
+        
+        // SHA256 toggle
+        app.dom.sha256Checkbox.addEventListener('change', handleSha256Toggle);
+        
+        // Hide compliant toggle
+        app.dom.hideCompliantCheckbox.addEventListener('change', handleHideCompliantToggle);
+        
+        // Collapse tree button
+        app.dom.collapseTreeBtn.addEventListener('click', handleCollapseTree);
+        
+        // Keyboard shortcuts
+        document.addEventListener('keydown', handleKeyDown);
+        
+        // Resize handle
+        setupResizeHandle();
+    }
+    
+    /**
+     * Handle collapse/expand folder tree pane
+     */
+    function handleCollapseTree() {
+        const pane = app.dom.folderTreePane;
+        const btn = app.dom.collapseTreeBtn;
+        
+        pane.classList.toggle('collapsed');
+        
+        if (pane.classList.contains('collapsed')) {
+            // Clear any inline width from resize handle
+            pane.style.width = '';
+            btn.textContent = '▶';
+            btn.title = 'Expand folder tree';
+        } else {
+            btn.textContent = '◀';
+            btn.title = 'Collapse folder tree';
+        }
+    }
+
+    /**
+     * Set up folder tree resize handle
+     */
+    function setupResizeHandle() {
+        const handle = document.getElementById('treeResizeHandle');
+        const pane = document.getElementById('folderTreePane');
+        
+        if (!handle || !pane) return;
+        
+        let isResizing = false;
+        let startX = 0;
+        let startWidth = 0;
+        
+        handle.addEventListener('mousedown', (e) => {
+            isResizing = true;
+            startX = e.clientX;
+            startWidth = pane.offsetWidth;
+            document.body.style.cursor = 'col-resize';
+            e.preventDefault();
+        });
+        
+        document.addEventListener('mousemove', (e) => {
+            if (!isResizing) return;
+            
+            const delta = e.clientX - startX;
+            const newWidth = startWidth + delta;
+            
+            // Respect min width only
+            if (newWidth >= 150) {
+                pane.style.width = newWidth + 'px';
+            }
+        });
+        
+        document.addEventListener('mouseup', () => {
+            if (isResizing) {
+                isResizing = false;
+                document.body.style.cursor = '';
+            }
+        });
+    }
+
+    /**
+     * Set up drag-and-drop on the welcome screen
+     */
+    function setupWelcomeDragDrop() {
+        const screen = app.dom.welcomeScreen;
+        if (!screen) return;
+        
+        ['dragenter', 'dragover'].forEach(evt => {
+            screen.addEventListener(evt, (e) => {
+                e.preventDefault();
+                screen.classList.add('drag-over');
+            });
+        });
+        
+        ['dragleave', 'drop'].forEach(evt => {
+            screen.addEventListener(evt, (e) => {
+                e.preventDefault();
+                screen.classList.remove('drag-over');
+            });
+        });
+        
+        screen.addEventListener('drop', async (e) => {
+            const item = e.dataTransfer.items && e.dataTransfer.items[0];
+            if (!item) return;
+            
+            const handle = await item.getAsFileSystemHandle();
+            if (!handle || handle.kind !== 'directory') {
+                alert('Please drop a folder, not a file.');
+                return;
+            }
+            
+            await openDirectory(handle);
+        });
+    }
+
+    /**
+     * Handle directory selection via button click
+     */
+    async function handleSelectDirectory() {
+        try {
+            const dirHandle = await window.showDirectoryPicker();
+            await openDirectory(dirHandle);
+        } catch (err) {
+            if (err.name !== 'AbortError') {
+                console.error('Error selecting directory:', err);
+                alert('Error selecting directory: ' + err.message);
+            }
+        }
+    }
+
+    /**
+     * Open a directory handle and initialize the application
+     */
+    async function openDirectory(dirHandle) {
+        app.rootHandle = dirHandle;
+        
+        // Hide welcome screen and show main UI
+        hideWelcomeScreen();
+        showMainUI();
+        
+        // Initialize modules BEFORE scanning (so they're ready for store updates)
+        app.modules.spreadsheet.init();  // Subscribe to store
+        app.modules.selection.init();
+        app.modules.preview.init();  // After selection so it can listen for rowfocused
+        app.modules.resize.init();
+        app.modules.filter.init();
+        app.modules.sort.init();
+        app.modules.tree.setupKeyboardShortcuts();
+        
+        // Now scan directory (this will trigger store updates and renders)
+        await app.modules.scanner.scanDirectory(dirHandle);
+        
+        // Show refresh button now that a directory is loaded
+        if (app.dom.refreshBtn) { app.dom.refreshBtn.classList.remove('hidden'); }
+    }
+
+    /**
+     * Handle Refresh button - rescan current directory
+     */
+    async function handleRefresh() {
+        if (!app.rootHandle) {
+            alert('No directory selected');
+            return;
+        }
+
+        try {
+            // Clear current data
+            app.folderTree = [];
+            app.selectedFolders.clear();
+            app.lastSelectedFolderPath = null;
+            
+            // Reset store
+            app.modules.store.reset();
+
+            // Rescan directory (modules already initialized, just rescan)
+            await app.modules.scanner.scanDirectory(app.rootHandle);
+
+        } catch (err) {
+            console.error('Error refreshing directory:', err);
+            alert('Error refreshing directory: ' + err.message);
+        }
+    }
+
+    /**
+     * Handle Save All button
+     */
+    async function handleSaveAll() {
+        if (!confirm('Save all modified files?')) return;
+        
+        try {
+            app.dom.saveAllBtn.disabled = true;
+            await app.modules.spreadsheet.saveAllFiles();
+        } catch (err) {
+            console.error('Error saving files:', err);
+            alert('Error saving files: ' + err.message);
+        } finally {
+            app.dom.saveAllBtn.disabled = false;
+        }
+    }
+
+    /**
+     * Handle Cancel All button
+     */
+    function handleCancelAll() {
+        if (!confirm('Cancel all changes?')) return;
+        app.modules.spreadsheet.cancelAllChanges();
+    }
+
+    /**
+     * Handle Export Hashes button
+     */
+    function handleExportHashes() {
+        app.modules.excel.exportHashes();
+    }
+
+    /**
+     * Handle SHA256 checkbox toggle
+     */
+    function handleSha256Toggle() {
+        app.calculateSha256 = app.dom.sha256Checkbox.checked;
+        
+        // Show/hide SHA256 column
+        if (app.calculateSha256) {
+            app.dom.sha256Column.classList.remove('hidden');
+        } else {
+            app.dom.sha256Column.classList.add('hidden');
+        }
+        
+        // Re-render table
+        app.modules.spreadsheet.render();
+    }
+
+    /**
+     * Handle Hide Compliant checkbox toggle
+     */
+    function handleHideCompliantToggle() {
+        app.hideCompliant = app.dom.hideCompliantCheckbox.checked;
+        app.modules.store.setHideCompliant(app.hideCompliant);
+    }
+
+    /**
+     * Handle keyboard shortcuts
+     */
+    function handleKeyDown(e) {
+        // Ctrl+S - Save All
+        if (e.ctrlKey && e.key === 's') {
+            e.preventDefault();
+            if (!app.dom.saveAllBtn.disabled) {
+                handleSaveAll();
+            }
+        }
+        
+        // Escape - Cancel editing
+        if (e.key === 'Escape') {
+            app.modules.spreadsheet.cancelEditing();
+        }
+    }
+
+    /**
+     * Show welcome screen (empty-state overlay)
+     */
+    function showWelcomeScreen() {
+        if (app.dom.welcomeScreen) {
+            app.dom.welcomeScreen.classList.remove('hidden');
+        }
+    }
+
+    /**
+     * Hide welcome screen (empty-state overlay)
+     */
+    function hideWelcomeScreen() {
+        if (app.dom.welcomeScreen) {
+            app.dom.welcomeScreen.classList.add('hidden');
+        }
+    }
+
+    /**
+     * Show main UI (no-op: main UI is always rendered)
+     */
+    function showMainUI() {
+        // Main app is always visible; only the empty-state overlay is toggled
+    }
+
+    /**
+     * Update stats display
+     */
+    function updateStats() {
+        const files = app.modules.store.getDisplayFiles();
+        const totalFiles = files.length;
+        const modifiedFiles = files.filter(f => f.isDirty).length;
+        const errorFiles = files.filter(f => f.error).length;
+        
+        app.dom.totalFiles.textContent = `${totalFiles} file${totalFiles !== 1 ? 's' : ''}`;
+        app.dom.modifiedFiles.textContent = `${modifiedFiles} modified`;
+        
+        if (errorFiles > 0) {
+            app.dom.errorFiles.textContent = `${errorFiles} error${errorFiles !== 1 ? 's' : ''}`;
+            app.dom.errorFiles.classList.remove('hidden');
+        } else {
+            app.dom.errorFiles.classList.add('hidden');
+        }
+        
+        // Enable/disable bulk action buttons
+        app.dom.saveAllBtn.disabled = modifiedFiles === 0;
+        app.dom.cancelAllBtn.disabled = modifiedFiles === 0;
+        
+        // Enable/disable export hashes button
+        app.dom.exportHashesBtn.disabled = totalFiles === 0 || !app.calculateSha256;
+    }
+
+    // Export functions for use by other modules
+    app.modules.app = {
+        updateStats
+    };
+
+    // Initialize when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+})();
+
+/**
+ * Classifier utilities — thin convenience layer over window.zddc.
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Compute new filename from file fields.
+     * ZDDC format: trackingNumber_revision (status) - title.ext
+     * Falls back to original filename if any required ZDDC field is missing.
+     */
+    function computeNewFilename(file) {
+        if (file.manualFilename) {
+            return file.manualFilename;
+        }
+
+        const formatted = zddc.formatFilename({
+            trackingNumber: file.trackingNumber || '',
+            revision:       file.revision || '',
+            status:         file.status   || '',
+            title:          file.title    || '',
+            extension:      file.extension || '',
+        });
+
+        return formatted || zddc.joinExtension(file.originalFilename, file.extension);
+    }
+
+    /**
+     * Get column value from file object.
+     */
+    function getColumnValue(file, columnName) {
+        switch (columnName) {
+            case 'original':       return file.originalFilename || '';
+            case 'extension':      return file.extension || '';
+            case 'new':
+            case 'newFilename':    return file.manualFilename || computeNewFilename(file);
+            case 'trackingNumber': return file.trackingNumber || '';
+            case 'revision':       return file.revision || '';
+            case 'status':         return file.status || '';
+            case 'title':          return file.title || '';
+            case 'sha256':         return file.sha256 || '';
+            default:               return '';
+        }
+    }
+
+    /**
+     * Get MIME type from file extension (no leading dot).
+     */
+    const MIME_TYPES = {
+        pdf:  'application/pdf',
+        jpg:  'image/jpeg',
+        jpeg: 'image/jpeg',
+        png:  'image/png',
+        gif:  'image/gif',
+        svg:  'image/svg+xml',
+        webp: 'image/webp',
+        bmp:  'image/bmp',
+        ico:  'image/x-icon',
+        txt:  'text/plain',
+        md:   'text/markdown',
+        json: 'application/json',
+        xml:  'application/xml',
+        csv:  'text/csv',
+        html: 'text/html',
+        css:  'text/css',
+        js:   'text/javascript',
+    };
+
+    function getMimeType(extension) {
+        return MIME_TYPES[(extension || '').toLowerCase()] || 'application/octet-stream';
+    }
+
+    window.app.modules.utils = {
+        computeNewFilename,
+        getColumnValue,
+        getMimeType,
+    };
+})();
+
+(function() {
+    'use strict';
+
+    // Escape a string for use in a RegExp (literal match)
+    function escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
+    // Build regex pattern at parse time based on anchors
+    function compilePattern(raw, anchorStart, anchorEnd) {
+        var src = (anchorStart ? '^' : '') + raw + (anchorEnd ? '$' : '');
+        try {
+            return new RegExp(src, 'i');
+        } catch (e) {
+            // Invalid regex — escape and retry (always succeeds)
+            var safe = (anchorStart ? '^' : '') + escapeRegex(raw) + (anchorEnd ? '$' : '');
+            return new RegExp(safe, 'i');
+        }
+    }
+
+    // Parse a single token string into a node
+    function parseToken(token) {
+        var s = token;
+        var negate = false;
+        var anchorStart = false;
+        var anchorEnd = false;
+
+        if (s.charAt(0) === '!') {
+            negate = true;
+            s = s.slice(1);
+        }
+        if (s.charAt(0) === '^') {
+            anchorStart = true;
+            s = s.slice(1);
+        }
+        if (s.length > 0 && s.charAt(s.length - 1) === '$') {
+            anchorEnd = true;
+            s = s.slice(0, -1);
+        }
+
+        if (s === '') return null;
+
+        // bare * (possibly after stripping !) → wildcard-all or wildcard-none
+        if (s === '*' && !anchorStart && !anchorEnd) {
+            return negate ? null : { type: 'wildcard-all' };
+        }
+
+        var re = compilePattern(s, anchorStart, anchorEnd);
+        return { type: negate ? 'no-match' : 'match', re: re };
+    }
+
+    // Parse expression string into AST array
+    function parse(expression) {
+        if (!expression || typeof expression !== 'string') return [];
+        var trimmed = expression.trim();
+        if (trimmed === '') return [];
+        if (trimmed === '*') return [{ type: 'wildcard-all' }];
+
+        var ast = [];
+        var i = 0;
+        var len = trimmed.length;
+
+        while (i < len) {
+            var ch = trimmed.charAt(i);
+
+            if (ch === '(') {
+                var depth = 1;
+                var j = i + 1;
+                while (j < len && depth > 0) {
+                    if (trimmed.charAt(j) === '(') depth++;
+                    else if (trimmed.charAt(j) === ')') depth--;
+                    j++;
+                }
+                var innerAst = parse(trimmed.slice(i + 1, j - 1));
+                if (innerAst.length === 1) {
+                    ast.push(innerAst[0]);
+                } else if (innerAst.length > 1) {
+                    for (var k = 0; k < innerAst.length; k++) ast.push(innerAst[k]);
+                }
+                i = j;
+            } else if (ch === '|') {
+                ast.push({ type: 'pipe' });
+                i++;
+            } else if (ch === ' ') {
+                i++;
+            } else {
+                var j = i;
+                while (j < len) {
+                    var c = trimmed.charAt(j);
+                    if (c === ' ' || c === '(' || c === '|' || c === ')') break;
+                    j++;
+                }
+                var token = trimmed.slice(i, j);
+                if (token.length > 0) {
+                    var node = parseToken(token);
+                    if (node !== null) ast.push(node);
+                }
+                i = j;
+            }
+        }
+
+        // Group pipes into OR nodes
+        var hasPipe = false;
+        var branches = [[]];
+        for (var l = 0; l < ast.length; l++) {
+            if (ast[l].type === 'pipe') {
+                hasPipe = true;
+                branches.push([]);
+            } else {
+                branches[branches.length - 1].push(ast[l]);
+            }
+        }
+        branches = branches.filter(function(b) { return b.length > 0; });
+
+        if (!hasPipe) {
+            return ast.filter(function(n) { return n.type !== 'pipe'; });
+        }
+
+        var orNodes = branches.map(function(branch) {
+            if (branch.length === 1) return branch[0];
+            return { type: 'and', nodes: branch };
+        });
+        return [{ type: 'or', nodes: orNodes }];
+    }
+
+    // Check if a single node matches the value
+    function nodeMatches(node, value) {
+        switch (node.type) {
+            case 'wildcard-all': return true;
+            case 'match':    return node.re.test(value);
+            case 'no-match': return !node.re.test(value);
+            case 'or':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (nodeMatches(node.nodes[i], value)) return true;
+                }
+                return false;
+            case 'and':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (!nodeMatches(node.nodes[i], value)) return false;
+                }
+                return true;
+            default: return false;
+        }
+    }
+
+    // Evaluate AST against value
+    function matches(value, ast) {
+        if (!ast || ast.length === 0) return true;
+        var v = String(value); // no forced lowercase — regex has 'i' flag
+        for (var i = 0; i < ast.length; i++) {
+            if (!nodeMatches(ast[i], v)) return false;
+        }
+        return true;
+    }
+
+    if (!window.zddc) {
+        throw new Error('shared/zddc-filter.js: window.zddc must be loaded first');
+    }
+    window.zddc.filter = { parse: parse, matches: matches };
+})();
+
+/**
+ * Store Module
+ * Single source of truth for all application state
+ * Manages files, folders, sorting, filtering
+ */
+(function() {
+    'use strict';
+
+    // State
+    const state = {
+        // Directory structure
+        rootHandle: null,
+        folderTree: [],
+        selectedFolders: new Set(),
+        
+        // Files
+        allFiles: [],           // All files from selected folders
+        displayFiles: [],       // After sorting and filtering
+        
+        // Sort state
+        sortColumns: [],        // [{column: 'original', direction: 'asc'}]
+        
+        // Filter state
+        filters: {},            // {columnName: AST (from zddc.filter.parse)}
+        
+        // UI state
+        hideCompliant: false,
+        calculateSha256: false
+    };
+
+    // Listeners for state changes
+    const listeners = {
+        'files': [],
+        'folders': [],
+        'sort': [],
+        'filter': []
+    };
+
+    /**
+     * Set sort columns
+     */
+    function on(event, callback) {
+        if (listeners[event]) {
+            listeners[event].push(callback);
+        }
+    }
+
+    /**
+     * Notify listeners of state change
+     */
+    function notify(event) {
+        if (listeners[event]) {
+            listeners[event].forEach(cb => cb());
+        }
+    }
+
+    /**
+     * Set root directory handle
+     */
+    function setRootHandle(handle) {
+        state.rootHandle = handle;
+    }
+
+    /**
+     * Set folder tree
+     */
+    function setFolderTree(tree) {
+        state.folderTree = tree;
+        notify('folders');
+    }
+
+    /**
+     * Select/deselect folder
+     */
+    function toggleFolder(folderPath) {
+        if (state.selectedFolders.has(folderPath)) {
+            state.selectedFolders.delete(folderPath);
+        } else {
+            state.selectedFolders.add(folderPath);
+        }
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Select multiple folders
+     */
+    function setSelectedFolders(folderPaths) {
+        state.selectedFolders.clear();
+        folderPaths.forEach(path => state.selectedFolders.add(path));
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Load files from selected folders
+     */
+    function loadFilesFromSelectedFolders() {
+        state.allFiles = [];
+
+        if (state.selectedFolders.size === 0) {
+            updateDisplayFiles();
+            return;
+        }
+
+        // Collect files from selected folders
+        for (const folderPath of state.selectedFolders) {
+            const folder = findFolderByPath(folderPath);
+            if (folder && folder.files) {
+                const files = folder.files.filter(f => !f.isDirectory);
+                state.allFiles.push(...files);
+            }
+        }
+
+        // Apply default sort if no sort set
+        if (state.sortColumns.length === 0) {
+            state.sortColumns = [{ column: 'original', direction: 'asc' }];
+        }
+
+        updateDisplayFiles();
+    }
+
+    /**
+     * Find folder by path in tree
+     */
+    function findFolderByPath(path) {
+        function search(folders) {
+            for (const folder of folders) {
+                if (folder.path === path) return folder;
+                if (folder.children) {
+                    const found = search(folder.children);
+                    if (found) return found;
+                }
+            }
+            return null;
+        }
+        return search(state.folderTree);
+    }
+
+    /**
+     * Update display files (apply sort, filter, hide compliant)
+     */
+    function updateDisplayFiles() {
+        let files = [...state.allFiles];
+
+        // Apply filters
+        files = applyFilters(files);
+
+        // Apply hide compliant
+        if (state.hideCompliant) {
+            files = files.filter(file => {
+                const newFilename = computeNewFilename(file);
+                const validation = validateFilename(newFilename);
+                return !validation.isValid;
+            });
+        }
+
+        // Apply sort
+        files = applySort(files);
+
+        state.displayFiles = files;
+        notify('files');
+    }
+
+    /**
+     * Apply filters to files using zddc.filter ASTs
+     */
+    function applyFilters(files) {
+        if (Object.keys(state.filters).length === 0) {
+            return files;
+        }
+
+        return files.filter(file => {
+            for (const [columnName, ast] of Object.entries(state.filters)) {
+                const value = getColumnValue(file, columnName);
+                if (!window.zddc.filter.matches(value, ast)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+
+    /**
+     * Apply sort to files
+     */
+    function applySort(files) {
+        if (state.sortColumns.length === 0) {
+            return files;
+        }
+
+        return files.sort((a, b) => {
+            for (const sort of state.sortColumns) {
+                const result = compareValues(a, b, sort.column, sort.direction);
+                if (result !== 0) return result;
+            }
+            return 0;
+        });
+    }
+
+    /**
+     * Compare two values for sorting
+     */
+    function compareValues(a, b, columnName, direction) {
+        let aVal = getColumnValue(a, columnName);
+        let bVal = getColumnValue(b, columnName);
+
+        const comparison = String(aVal).localeCompare(String(bVal), undefined, {
+            numeric: true,
+            sensitivity: 'base'
+        });
+
+        return direction === 'asc' ? comparison : -comparison;
+    }
+
+    /**
+     * Get column value from file (delegates to utils)
+     */
+    function getColumnValue(file, columnName) {
+        return window.app.modules.utils.getColumnValue(file, columnName);
+    }
+
+    function computeNewFilename(file) {
+        return window.app.modules.utils.computeNewFilename(file);
+    }
+
+    /**
+     * Validate filename
+     */
+    function validateFilename(filename) {
+        // Use existing validator module
+        if (window.app.modules.validator) {
+            return window.app.modules.validator.validateFilename(filename);
+        }
+        return { isValid: true, errors: [], warnings: [] };
+    }
+
+    /**
+     * Match filter text against value
+     */
+    function matchesFilter(value, filterText) {
+        // Simple contains for now - can enhance later
+        return String(value).toLowerCase().includes(filterText.toLowerCase());
+    }
+
+    /**
+     * Set sort columns
+     */
+    function setSortColumns(columns) {
+        state.sortColumns = columns;
+        updateDisplayFiles();
+    }
+
+    /**
+     * Toggle sort on column
+     */
+    function toggleSort(columnName, multiSort) {
+        if (!multiSort) {
+            state.sortColumns = [];
+        }
+
+        const existingIndex = state.sortColumns.findIndex(s => s.column === columnName);
+
+        if (existingIndex >= 0) {
+            const current = state.sortColumns[existingIndex];
+            if (current.direction === 'asc') {
+                current.direction = 'desc';
+            } else {
+                state.sortColumns.splice(existingIndex, 1);
+            }
+        } else {
+            state.sortColumns.push({ column: columnName, direction: 'asc' });
+        }
+
+        updateDisplayFiles();
+        notify('sort');
+    }
+
+    /**
+     * Set filter for column. ast is the pre-parsed zddc.filter AST.
+     */
+    function setFilter(columnName, filterText, ast) {
+        if (filterText && ast && ast.length > 0) {
+            state.filters[columnName] = ast;
+        } else {
+            delete state.filters[columnName];
+        }
+        updateDisplayFiles();
+    }
+
+    /**
+     * Replace all filters at once. filtersObj is {columnName: rawString}.
+     * Parses each value. Pass {} to clear all filters.
+     */
+    function setAllFilters(filtersObj) {
+        state.filters = {};
+        for (const [columnName, raw] of Object.entries(filtersObj)) {
+            if (raw) {
+                const ast = window.zddc.filter.parse(raw);
+                if (ast && ast.length > 0) {
+                    state.filters[columnName] = ast;
+                }
+            }
+        }
+        updateDisplayFiles();
+    }
+
+    /**
+     * Set hide compliant flag
+     */
+    function setHideCompliant(hide) {
+        state.hideCompliant = hide;
+        updateDisplayFiles();
+    }
+
+    /**
+     * Update file data
+     */
+    function updateFile(index, updates) {
+        const file = state.displayFiles[index];
+        if (!file) return;
+
+        // Apply updates
+        Object.assign(file, updates);
+        
+        // Mark as dirty unless explicitly set to false
+        if (updates.isDirty !== false) {
+            file.isDirty = true;
+        }
+
+        // Notify listeners (will trigger re-render)
+        notify('files');
+    }
+    
+    /**
+     * Update file field (for editing)
+     */
+    function updateFileField(index, fieldName, value) {
+        const file = state.displayFiles[index];
+        if (!file) return;
+        
+        file[fieldName] = value;
+        file.autoPopulated = false; // Clear auto-populated flag
+
+        // Re-evaluate dirty: if every field still matches the parsed original,
+        // and there is no manual filename override, the file is clean again.
+        file.isDirty = _isFileDirty(file);
+        
+        // Notify listeners
+        notify('files');
+    }
+
+    /**
+     * A file is dirty if its computed filename differs from the original,
+     * or if it has a manual filename override.
+     */
+    function _isFileDirty(file) {
+        if (file.manualFilename) return true;
+        const computed = zddc.formatFilename({
+            trackingNumber: file.trackingNumber || '',
+            revision:       file.revision || '',
+            status:         file.status   || '',
+            title:          file.title    || '',
+            extension:      file.extension || '',
+        });
+        const original = zddc.joinExtension(file.originalFilename, file.extension);
+        // If formatFilename returns '' (missing fields) fall back to original — not dirty
+        return computed !== '' && computed !== original;
+    }
+
+    /**
+     * Get display files (what should be shown in table)
+     */
+    function getDisplayFiles() {
+        return state.displayFiles;
+    }
+
+    /**
+     * Get all files (unfiltered)
+     */
+    function getAllFiles() {
+        return state.allFiles;
+    }
+
+    /**
+     * Get sort columns
+     */
+    function getSortColumns() {
+        return state.sortColumns;
+    }
+
+    /**
+     * Get selected folder count
+     */
+    function getSelectedFolderCount() {
+        return state.selectedFolders.size;
+    }
+
+    /**
+     * Get state (read-only)
+     */
+    function getState() {
+        return {
+            rootHandle: state.rootHandle,
+            folderTree: state.folderTree,
+            selectedFolders: Array.from(state.selectedFolders),
+            allFiles: state.allFiles,
+            displayFiles: state.displayFiles,
+            sortColumns: state.sortColumns,
+            filters: state.filters,
+            hideCompliant: state.hideCompliant
+        };
+    }
+
+    /**
+     * Reset all state
+     */
+    function reset() {
+        state.rootHandle = null;
+        state.folderTree = [];
+        state.selectedFolders.clear();
+        state.allFiles = [];
+        state.displayFiles = [];
+        state.sortColumns = [];
+        state.filters = {};
+        state.hideCompliant = false;
+        
+        notify('files');
+        notify('folders');
+    }
+
+    // Export
+    window.app.modules.store = {
+        on,
+        notify,
+        setRootHandle,
+        setFolderTree,
+        toggleFolder,
+        setSelectedFolders,
+        toggleSort,
+        setFilter,
+        setAllFilters,
+        setHideCompliant,
+        updateFile,
+        updateFileField,
+        getDisplayFiles,
+        getAllFiles,
+        getSortColumns,
+        getSelectedFolderCount,
+        getState,
+        reset
+    };
+})();
+
+/**
+ * ZDDC Validation Module
+ * Validates file names against ZDDC conventions using the shared zddc library.
+ */
+
+(function() {
+    'use strict';
+
+    /**
+     * Validate a filename and return a detailed result.
+     * Delegates ZDDC pattern checking to the shared zddc.parseFilename() library.
+     */
+    function validateFilename(filename) {
+        const errors = [];
+        const warnings = [];
+
+        if (!filename) {
+            errors.push('Filename is empty.');
+            return { isValid: false, warnings, errors };
+        }
+
+        const parsed = zddc.parseFilename(filename);
+        if (!parsed || !parsed.valid) {
+            errors.push('Filename does not match ZDDC format: trackingNumber_revision (status) - title.ext');
+        } else if (!zddc.isValidStatus(parsed.status)) {
+            errors.push('Invalid status code "' + parsed.status + '". Valid codes: ' + zddc.STATUSES.join(', '));
+        }
+
+        if (filename.length > 255) {
+            warnings.push('Filename is very long (>255 characters)');
+        }
+
+        const invalidChars = /[<>:"|?*]/;
+        if (invalidChars.test(filename)) {
+            errors.push('Filename contains invalid characters: < > : " | ? *');
+        }
+
+        return {
+            isValid: errors.length === 0,
+            warnings,
+            errors
+        };
+    }
+
+    window.app.modules.validator = {
+        validateFilename
+    };
+})();
+
+/**
+ * Directory Scanner Module
+ * Scans directories and collects files
+ */
+(function() {
+    'use strict';
+    
+    // Store ZIP data for later access
+    const zipCache = new Map();  // path -> { zip: JSZip, fileHandle: FileSystemFileHandle }
+
+    /**
+     * Scan directory and build folder tree with files
+     */
+    async function scanDirectory(dirHandle, preserveState = false) {
+
+        
+        // Save current state if preserving
+        let savedExpanded = new Set();
+        let savedSelected = new Set();
+        if (preserveState) {
+            savedExpanded = getExpandedPaths(window.app.folderTree);
+            savedSelected = new Set(window.app.selectedFolders);
+        }
+        
+        // Clear ZIP cache
+        zipCache.clear();
+        
+        // Map to store files by folder handle (or ZIP path for virtual folders)
+        const foldersMap = new Map();
+        
+        // Recursively scan
+        await scanFolder(dirHandle, foldersMap, dirHandle.name);
+        
+        // Build tree structure
+        window.app.folderTree = window.app.modules.tree.buildTree(dirHandle, foldersMap);
+        
+        // Set in store
+        window.app.modules.store.setFolderTree(window.app.folderTree);
+        
+        if (preserveState) {
+            // Restore expanded state
+            restoreExpandedPaths(window.app.folderTree, savedExpanded);
+            // Restore selection
+            window.app.selectedFolders = savedSelected;
+            // Render without changing selection
+            window.app.modules.tree.render();
+            window.app.modules.store.setSelectedFolders(savedSelected);
+        } else {
+            // Render tree
+            window.app.modules.tree.render();
+            // Auto-expand and select all folders
+            window.app.modules.tree.expandAll();
+            window.app.modules.tree.selectAll();
+        }
+        
+
+    }
+    
+    /**
+     * Get all expanded folder paths from tree
+     */
+    function getExpandedPaths(folders, paths = new Set()) {
+        for (const folder of folders) {
+            if (folder.expanded) {
+                paths.add(folder.path);
+            }
+            if (folder.children) {
+                getExpandedPaths(folder.children, paths);
+            }
+        }
+        return paths;
+    }
+    
+    /**
+     * Restore expanded state to tree
+     */
+    function restoreExpandedPaths(folders, expandedPaths) {
+        for (const folder of folders) {
+            folder.expanded = expandedPaths.has(folder.path);
+            if (folder.children) {
+                restoreExpandedPaths(folder.children, expandedPaths);
+            }
+        }
+    }
+
+    /**
+     * Recursively scan a folder
+     */
+    async function scanFolder(dirHandle, foldersMap, currentPath) {
+        const items = [];
+        
+        try {
+            for await (const entry of dirHandle.values()) {
+                if (entry.kind === 'file') {
+                    // Create file object
+                    const file = await createFileObject(entry, dirHandle);
+                    if (file) {
+                        items.push(file);
+                        
+                        // Check if it's a ZIP file - scan its contents
+                        if (file.extension === 'zip' && typeof JSZip !== 'undefined') {
+                            await scanZipFile(file, foldersMap, currentPath, items);
+                        }
+                    }
+                } else if (entry.kind === 'directory') {
+                    // Add directory reference
+                    items.push({
+                        handle: entry,
+                        isDirectory: true
+                    });
+                    
+                    // Recursively scan subdirectory
+                    const childPath = currentPath + '/' + entry.name;
+                    await scanFolder(entry, foldersMap, childPath);
+                }
+            }
+        } catch (err) {
+            console.error('Error scanning folder:', dirHandle.name, err);
+        }
+        
+        // Store files for this folder
+        foldersMap.set(dirHandle, items);
+    }
+    
+    /**
+     * Scan a ZIP file and add its contents as virtual folders
+     */
+    async function scanZipFile(zipFileObj, foldersMap, parentPath, parentItems) {
+        try {
+            const fileObj = await zipFileObj.handle.getFile();
+            const arrayBuffer = await fileObj.arrayBuffer();
+            const zip = await JSZip.loadAsync(arrayBuffer);
+            
+            const zipPath = parentPath + '/' + zddc.joinExtension(zipFileObj.originalFilename, zipFileObj.extension);
+            
+            // Cache the ZIP for later extraction
+            zipCache.set(zipPath, {
+                zip: zip,
+                fileHandle: zipFileObj.handle,
+                folderHandle: zipFileObj.folderHandle
+            });
+            
+            // Mark the file as a ZIP container
+            zipFileObj.isZipContainer = true;
+            zipFileObj.zipPath = zipPath;
+            
+            // Build virtual folder structure from ZIP contents
+            const virtualFolders = new Map();  // path -> { files: [], subdirs: Set }
+            virtualFolders.set(zipPath, { files: [], subdirs: new Set() });
+            
+            zip.forEach((relativePath, zipEntry) => {
+                if (zipEntry.dir) {
+                    // It's a directory
+                    const dirPath = zipPath + '/' + relativePath.replace(/\/$/, '');
+                    if (!virtualFolders.has(dirPath)) {
+                        virtualFolders.set(dirPath, { files: [], subdirs: new Set() });
+                    }
+                    // Add to parent's subdirs
+                    const parentDir = dirPath.substring(0, dirPath.lastIndexOf('/'));
+                    if (virtualFolders.has(parentDir)) {
+                        virtualFolders.get(parentDir).subdirs.add(dirPath);
+                    }
+                } else {
+                    // It's a file
+                    const fileName = relativePath.split('/').pop();
+                    const fileDir = relativePath.includes('/') 
+                        ? zipPath + '/' + relativePath.substring(0, relativePath.lastIndexOf('/'))
+                        : zipPath;
+                    
+                    // Ensure parent directories exist
+                    ensureVirtualPath(virtualFolders, zipPath, fileDir);
+                    
+                    // Create virtual file object
+                    const split = zddc.splitExtension(fileName);
+
+                    const virtualFile = {
+                        originalFilename: split.name,
+                        extension: split.extension,
+                        size: zipEntry._data ? zipEntry._data.uncompressedSize : 0,
+                        lastModified: zipEntry.date ? zipEntry.date.getTime() : Date.now(),
+                        
+                        // Virtual file markers
+                        isVirtual: true,
+                        zipPath: zipPath,
+                        zipEntryPath: relativePath,
+                        
+                        // Editable fields
+                        trackingNumber: '',
+                        revision: '',
+                        status: '',
+                        title: '',
+                        
+                        // State
+                        isDirty: false,
+                        error: false,
+                        errorMessage: '',
+                        validation: null,
+                        sha256: null
+                    };
+                    
+                    virtualFolders.get(fileDir).files.push(virtualFile);
+                }
+            });
+            
+            // Convert virtual folders to format compatible with tree builder
+            // Create a virtual handle for the ZIP root
+            const zipVirtualHandle = {
+                name: zddc.joinExtension(zipFileObj.originalFilename, zipFileObj.extension),
+                kind: 'directory',
+                isZipRoot: true,
+                zipPath: zipPath
+            };
+            
+            // Store virtual folder data
+            buildVirtualFolderMap(virtualFolders, zipPath, foldersMap, zipVirtualHandle);
+            
+            // Add ZIP as a virtual directory in parent
+            parentItems.push({
+                handle: zipVirtualHandle,
+                isDirectory: true,
+                isZipRoot: true
+            });
+            
+        } catch (err) {
+            console.error('Error scanning ZIP file:', zipFileObj.originalFilename, err);
+        }
+    }
+    
+    /**
+     * Ensure all parent directories exist in virtual folder map
+     */
+    function ensureVirtualPath(virtualFolders, zipPath, targetPath) {
+        if (virtualFolders.has(targetPath)) return;
+        
+        const parts = targetPath.substring(zipPath.length + 1).split('/').filter(p => p);
+        let currentPath = zipPath;
+        
+        for (const part of parts) {
+            const parentPath = currentPath;
+            currentPath = currentPath + '/' + part;
+            
+            if (!virtualFolders.has(currentPath)) {
+                virtualFolders.set(currentPath, { files: [], subdirs: new Set() });
+            }
+            
+            if (virtualFolders.has(parentPath)) {
+                virtualFolders.get(parentPath).subdirs.add(currentPath);
+            }
+        }
+    }
+    
+    /**
+     * Build virtual folder entries for the foldersMap
+     * Uses path strings as keys for virtual folders to avoid object reference issues
+     */
+    function buildVirtualFolderMap(virtualFolders, zipPath, foldersMap, zipVirtualHandle) {
+        const rootData = virtualFolders.get(zipPath);
+        if (!rootData) return;
+        
+        // Create items array for ZIP root
+        const rootItems = [...rootData.files];
+        
+        // Add subdirectories
+        for (const subdirPath of rootData.subdirs) {
+            const subdirName = subdirPath.split('/').pop();
+            const subdirHandle = {
+                name: subdirName,
+                kind: 'directory',
+                isVirtualDir: true,
+                virtualPath: subdirPath,
+                zipPath: zipPath
+            };
+            rootItems.push({
+                handle: subdirHandle,
+                isDirectory: true,
+                isVirtualDir: true
+            });
+            
+            // Recursively add subdir contents
+            buildVirtualSubfolder(virtualFolders, subdirPath, foldersMap, zipPath);
+        }
+        
+        // Store with both the handle object AND the path string as keys
+        // This ensures lookup works regardless of which reference is used
+        foldersMap.set(zipVirtualHandle, rootItems);
+        foldersMap.set(zipPath, rootItems);  // Path-based key for tree building
+    }
+    
+    /**
+     * Recursively build virtual subfolder entries
+     */
+    function buildVirtualSubfolder(virtualFolders, folderPath, foldersMap, zipPath) {
+        const folderData = virtualFolders.get(folderPath);
+        if (!folderData) return;
+        
+        const folderName = folderPath.split('/').pop();
+        const folderHandle = {
+            name: folderName,
+            kind: 'directory',
+            isVirtualDir: true,
+            virtualPath: folderPath,
+            zipPath: zipPath
+        };
+        
+        const items = [...folderData.files];
+        
+        // Store with path string key for tree building lookup
+        foldersMap.set(folderPath, items);
+        
+        // Add subdirectories
+        for (const subdirPath of folderData.subdirs) {
+            const subdirName = subdirPath.split('/').pop();
+            const subdirHandle = {
+                name: subdirName,
+                kind: 'directory',
+                isVirtualDir: true,
+                virtualPath: subdirPath,
+                zipPath: zipPath
+            };
+            items.push({
+                handle: subdirHandle,
+                isDirectory: true,
+                isVirtualDir: true
+            });
+            
+            // Recursively add subdir contents
+            buildVirtualSubfolder(virtualFolders, subdirPath, foldersMap, zipPath);
+        }
+        
+        foldersMap.set(folderHandle, items);
+    }
+    
+    /**
+     * Get cached ZIP data
+     */
+    function getZipCache(zipPath) {
+        return zipCache.get(zipPath);
+    }
+    
+    /**
+     * Extract a ZIP file to its parent directory
+     */
+    async function extractZip(zipPath) {
+        const cached = zipCache.get(zipPath);
+        if (!cached) {
+            throw new Error('ZIP not found in cache');
+        }
+        
+        const { zip, folderHandle } = cached;
+        
+        // Get the ZIP filename without extension for the extract folder name
+        const zipName = zipPath.split('/').pop();
+        const extractFolderName = zipName.replace(/\.zip$/i, '');
+        
+        // Create extraction folder
+        const extractFolder = await folderHandle.getDirectoryHandle(extractFolderName, { create: true });
+        
+        // Extract all files
+        const entries = [];
+        zip.forEach((relativePath, zipEntry) => {
+            if (!zipEntry.dir) {
+                entries.push({ path: relativePath, entry: zipEntry });
+            }
+        });
+        
+        for (const { path, entry } of entries) {
+            try {
+                // Create subdirectories if needed
+                const parts = path.split('/');
+                const fileName = parts.pop();
+                
+                let currentDir = extractFolder;
+                for (const part of parts) {
+                    if (part) {
+                        currentDir = await currentDir.getDirectoryHandle(part, { create: true });
+                    }
+                }
+                
+                // Write file
+                const content = await entry.async('arraybuffer');
+                const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
+                const writable = await fileHandle.createWritable();
+                await writable.write(content);
+                await writable.close();
+            } catch (err) {
+                console.error('Error extracting file:', path, err);
+            }
+        }
+        
+        return extractFolderName;
+    }
+
+    /**
+     * Create file object with metadata
+     */
+    async function createFileObject(fileHandle, folderHandle) {
+        try {
+            const file = await fileHandle.getFile();
+            const split = zddc.splitExtension(file.name);
+
+            return {
+                handle: fileHandle,
+                folderHandle: folderHandle,
+                originalFilename: split.name,
+                extension: split.extension,
+                size: file.size,
+                lastModified: file.lastModified,
+                
+                // Editable fields
+                trackingNumber: '',
+                revision: '',
+                status: '',
+                title: '',
+                
+                // State
+                isDirty: false,
+                error: false,
+                errorMessage: '',
+                validation: null,
+                sha256: null
+                // folderPath will be added later in buildTree
+            };
+        } catch (err) {
+            console.error('Error reading file:', fileHandle.name, err);
+            return null;
+        }
+    }
+
+    // Export module
+    window.app.modules.scanner = {
+        scanDirectory,
+        getZipCache,
+        extractZip
+    };
+})();
+
+
+/**
+ * Folder Tree Module
+ * Handles folder tree rendering and multi-select
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Render the folder tree
+     */
+    function render() {
+        const container = window.app.dom.folderTree;
+        container.innerHTML = '';
+
+        if (window.app.folderTree.length === 0) {
+            container.innerHTML = '<div class="empty-state">No folders found</div>';
+            return;
+        }
+
+        window.app.folderTree.forEach(folder => {
+            const element = createFolderElement(folder);
+            container.appendChild(element);
+        });
+
+        updateSelectedCount();
+    }
+
+    /**
+     * Create a folder element
+     */
+    function createFolderElement(folder, level = 0) {
+        const div = document.createElement('div');
+        
+        const item = document.createElement('div');
+        item.className = 'folder-item';
+        item.dataset.path = folder.path;
+        item.style.paddingLeft = `${level * 1.5}rem`;
+
+        // Check if selected
+        if (window.app.selectedFolders.has(folder.path)) {
+            item.classList.add('selected');
+        }
+
+        // Toggle button (if has children)
+        const toggle = document.createElement('span');
+        toggle.className = 'folder-toggle';
+        if (folder.children && folder.children.length > 0) {
+            toggle.textContent = folder.expanded ? '▼' : '▶';
+            toggle.addEventListener('click', (e) => {
+                e.stopPropagation();
+                const recursive = e.ctrlKey || e.metaKey;
+                toggleFolder(folder, recursive);
+            });
+        } else {
+            toggle.textContent = ' ';
+        }
+        item.appendChild(toggle);
+
+        // Folder icon (different for ZIP files)
+        const icon = document.createElement('span');
+        icon.className = 'folder-icon';
+        if (folder.isZipRoot) {
+            icon.innerHTML = '&#128230;';  // 📦
+        } else if (folder.isVirtualDir) {
+            icon.innerHTML = '&#128194;';  // 📂
+        } else {
+            icon.innerHTML = '&#128193;';  // 📁
+        }
+        item.appendChild(icon);
+
+        // Folder name
+        const name = document.createElement('span');
+        name.className = 'folder-name';
+        name.textContent = folder.name;
+        item.appendChild(name);
+
+        // File count
+        const count = document.createElement('span');
+        count.className = 'folder-count';
+        count.textContent = `(${folder.fileCount || 0})`;
+        item.appendChild(count);
+        
+        // Extract button for ZIP roots
+        if (folder.isZipRoot) {
+            const extractBtn = document.createElement('button');
+            extractBtn.className = 'btn btn-sm zip-extract-btn';
+            extractBtn.textContent = '📤 Extract';
+            extractBtn.title = 'Extract ZIP contents to folder';
+            extractBtn.addEventListener('click', async (e) => {
+                e.stopPropagation();
+                await handleExtractZip(folder);
+            });
+            item.appendChild(extractBtn);
+        }
+        
+        // Extract All button for folders with ZIP descendants (but not ZIP roots themselves)
+        if (!folder.isZipRoot && !folder.isVirtualDir) {
+            const zipCount = countZipDescendants(folder);
+            if (zipCount > 0) {
+                const extractAllBtn = document.createElement('button');
+                extractAllBtn.className = 'btn btn-sm zip-extract-all-btn';
+                extractAllBtn.textContent = `📤 Extract All (${zipCount})`;
+                extractAllBtn.title = `Extract all ${zipCount} ZIP file(s) in this folder`;
+                extractAllBtn.addEventListener('click', async (e) => {
+                    e.stopPropagation();
+                    await handleExtractAllZips(folder);
+                });
+                item.appendChild(extractAllBtn);
+            }
+        }
+
+        // Click handler for selection
+        item.addEventListener('click', (e) => {
+            handleFolderClick(folder, e);
+        });
+
+        div.appendChild(item);
+
+        // Children (if expanded)
+        if (folder.expanded && folder.children && folder.children.length > 0) {
+            const childrenDiv = document.createElement('div');
+            childrenDiv.className = 'folder-children';
+            folder.children.forEach(child => {
+                const childElement = createFolderElement(child, level + 1);
+                childrenDiv.appendChild(childElement);
+            });
+            div.appendChild(childrenDiv);
+        }
+
+        return div;
+    }
+
+    /**
+     * Handle folder click with multi-select support
+     */
+    function handleFolderClick(folder, event) {
+        if (event.ctrlKey || event.metaKey) {
+            // Ctrl+Click: Toggle selection
+            if (window.app.selectedFolders.has(folder.path)) {
+                window.app.selectedFolders.delete(folder.path);
+            } else {
+                window.app.selectedFolders.add(folder.path);
+            }
+        } else if (event.shiftKey) {
+            // Shift+Click: Range selection
+            const visibleFolders = getVisibleFolders();
+            const currentIndex = visibleFolders.findIndex(f => f.path === folder.path);
+            
+            if (currentIndex >= 0 && window.app.lastSelectedFolderPath) {
+                const lastIndex = visibleFolders.findIndex(f => f.path === window.app.lastSelectedFolderPath);
+                
+                if (lastIndex >= 0) {
+                    const start = Math.min(currentIndex, lastIndex);
+                    const end = Math.max(currentIndex, lastIndex);
+                    
+                    // Select range
+                    for (let i = start; i <= end; i++) {
+                        window.app.selectedFolders.add(visibleFolders[i].path);
+                    }
+                }
+            } else {
+                window.app.selectedFolders.add(folder.path);
+            }
+        } else {
+            // Normal click: Single selection
+            window.app.selectedFolders.clear();
+            window.app.selectedFolders.add(folder.path);
+        }
+
+        // Remember last selected for shift-click
+        window.app.lastSelectedFolderPath = folder.path;
+
+        // Re-render tree
+        render();
+
+        // Load files from selected folders
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Handle ZIP extraction
+     */
+    async function handleExtractZip(folder) {
+        if (!folder.isZipRoot || !folder.zipPath) return;
+        
+        try {
+            const confirmed = confirm(`Extract "${folder.name}" to a new folder?\n\nThis will create a folder named "${folder.name.replace(/\.zip$/i, '')}" with the ZIP contents.`);
+            if (!confirmed) return;
+            
+            // Show extracting state
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-btn`);
+            if (btn) {
+                btn.textContent = '⏳ Extracting...';
+                btn.disabled = true;
+            }
+            
+            await window.app.modules.scanner.extractZip(folder.zipPath);
+            
+            // Auto-refresh preserving tree state
+            await window.app.modules.scanner.scanDirectory(window.app.rootHandle, true);
+        } catch (err) {
+            console.error('Error extracting ZIP:', err);
+            alert('Error extracting ZIP: ' + err.message);
+            
+            // Reset button
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-btn`);
+            if (btn) {
+                btn.textContent = '📤 Extract';
+                btn.disabled = false;
+            }
+        }
+    }
+    
+    /**
+     * Count ZIP descendants in a folder
+     */
+    function countZipDescendants(folder) {
+        let count = 0;
+        if (folder.children) {
+            for (const child of folder.children) {
+                if (child.isZipRoot) {
+                    count++;
+                }
+                count += countZipDescendants(child);
+            }
+        }
+        return count;
+    }
+    
+    /**
+     * Get all ZIP folders as flat list
+     */
+    function getZipDescendants(folder, zips = []) {
+        if (folder.children) {
+            for (const child of folder.children) {
+                if (child.isZipRoot) {
+                    zips.push(child);
+                }
+                getZipDescendants(child, zips);
+            }
+        }
+        return zips;
+    }
+    
+    /**
+     * Handle extracting all ZIPs in a folder
+     */
+    async function handleExtractAllZips(folder) {
+        const zips = getZipDescendants(folder);
+        if (zips.length === 0) return;
+        
+        const confirmed = confirm(`Extract ${zips.length} ZIP file(s)?\n\nThis will create folders for each ZIP with their contents.`);
+        if (!confirmed) return;
+        
+        try {
+            // Show extracting state on button
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-all-btn`);
+            if (btn) {
+                btn.textContent = '⏳ Extracting...';
+                btn.disabled = true;
+            }
+            
+            // Extract all ZIPs
+            for (const zip of zips) {
+                if (zip.zipPath) {
+                    await window.app.modules.scanner.extractZip(zip.zipPath);
+                }
+            }
+            
+            // Auto-refresh preserving tree state
+            await window.app.modules.scanner.scanDirectory(window.app.rootHandle, true);
+        } catch (err) {
+            console.error('Error extracting ZIPs:', err);
+            alert('Error extracting ZIPs: ' + err.message);
+            
+            // Reset button
+            const btn = document.querySelector(`.folder-item[data-path="${folder.path}"] .zip-extract-all-btn`);
+            if (btn) {
+                btn.textContent = `📤 Extract All (${zips.length})`;
+                btn.disabled = false;
+            }
+        }
+    }
+
+    /**
+     * Toggle folder expansion
+     */
+    function toggleFolder(folder, recursive = false) {
+        folder.expanded = !folder.expanded;
+        
+        if (recursive && folder.children) {
+            // Recursively expand/collapse all children
+            const newState = folder.expanded;
+            function setAllExpanded(f) {
+                f.expanded = newState;
+                if (f.children) {
+                    f.children.forEach(setAllExpanded);
+                }
+            }
+            folder.children.forEach(setAllExpanded);
+        }
+        
+        render();
+    }
+
+    /**
+     * Load files from all selected folders
+     */
+    async function loadFilesFromSelectedFolders() {
+        // Use store to manage files
+        window.app.modules.store.setSelectedFolders(Array.from(window.app.selectedFolders));
+    }
+
+    /**
+     * Find folder by path in tree
+     */
+    function findFolderByPath(path) {
+        function search(folders) {
+            for (const folder of folders) {
+                if (folder.path === path) {
+                    return folder;
+                }
+                if (folder.children) {
+                    const found = search(folder.children);
+                    if (found) return found;
+                }
+            }
+            return null;
+        }
+        return search(window.app.folderTree);
+    }
+
+    /**
+     * Update selected folders count
+     */
+    function updateSelectedCount() {
+        const count = window.app.selectedFolders.size;
+        window.app.dom.selectedFoldersCount.textContent = 
+            `${count} folder${count !== 1 ? 's' : ''} selected`;
+    }
+
+    /**
+     * Build folder tree from scanned data
+     */
+    function buildTree(rootHandle, foldersMap) {
+        const tree = [];
+        
+        // Convert flat map to tree structure
+        function buildNode(handle, path) {
+            // For virtual folders, look up by path string; for real folders, use handle
+            let files;
+            if (handle.isVirtualDir || handle.isZipRoot) {
+                files = foldersMap.get(handle.virtualPath || handle.zipPath) || [];
+            } else {
+                files = foldersMap.get(handle) || [];
+            }
+            
+            // Add folderPath to each file for folder highlighting (filter out null files)
+            files.filter(file => file !== null).forEach(file => {
+                if (!file.isDirectory) {
+                    file.folderPath = path;
+                }
+            });
+            
+            // Filter out null files for the node
+            const validFiles = files.filter(f => f !== null);
+            
+            const node = {
+                name: handle.name,
+                path: path,
+                handle: handle,
+                files: validFiles,
+                fileCount: validFiles.length,
+                children: [],
+                expanded: false
+            };
+            
+            // Mark ZIP-related nodes
+            if (handle.isZipRoot) {
+                node.isZipRoot = true;
+                node.zipPath = handle.zipPath;
+            }
+            if (handle.isVirtualDir) {
+                node.isVirtualDir = true;
+                node.zipPath = handle.zipPath;
+            }
+            
+            return node;
+        }
+
+        // Recursively build tree
+        function addChildren(node) {
+            // Get subdirectories (filter out null files first)
+            // For virtual folders, look up by path string
+            let files;
+            if (node.handle.isVirtualDir || node.handle.isZipRoot) {
+                files = foldersMap.get(node.handle.virtualPath || node.handle.zipPath) || [];
+            } else {
+                files = foldersMap.get(node.handle) || [];
+            }
+            const validFiles = files.filter(f => f !== null);
+            const subdirs = validFiles.filter(f => f.isDirectory);
+            
+            subdirs.forEach(subdir => {
+                const childPath = node.path + '/' + subdir.handle.name;
+                const childNode = buildNode(subdir.handle, childPath);
+                addChildren(childNode);
+                node.children.push(childNode);
+            });
+            
+            // Update file count to exclude directories and null files
+            node.files = validFiles.filter(f => !f.isDirectory);
+            node.fileCount = node.files.length;
+        }
+
+        // Build root
+        const root = buildNode(rootHandle, rootHandle.name);
+        addChildren(root);
+        
+        // Expand root by default
+        root.expanded = true;
+        
+        tree.push(root);
+        return tree;
+    }
+
+    /**
+     * Get all currently visible folders (expanded tree)
+     */
+    function getVisibleFolders() {
+        const visible = [];
+        
+        function traverse(folders) {
+            for (const folder of folders) {
+                visible.push(folder);
+                if (folder.expanded && folder.children) {
+                    traverse(folder.children);
+                }
+            }
+        }
+        
+        traverse(window.app.folderTree);
+        return visible;
+    }
+
+    /**
+     * Select all visible folders
+     */
+    function selectAllVisible() {
+        const visible = getVisibleFolders();
+        window.app.selectedFolders.clear();
+        visible.forEach(f => window.app.selectedFolders.add(f.path));
+        render();
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Expand all folders in tree
+     */
+    function expandAll() {
+        function setAllExpanded(folder) {
+            folder.expanded = true;
+            if (folder.children) {
+                folder.children.forEach(setAllExpanded);
+            }
+        }
+        
+        window.app.folderTree.forEach(setAllExpanded);
+        render();
+    }
+
+    /**
+     * Select all folders in tree
+     */
+    function selectAll() {
+        function collectAllPaths(folders, paths = []) {
+            folders.forEach(folder => {
+                paths.push(folder.path);
+                if (folder.children) {
+                    collectAllPaths(folder.children, paths);
+                }
+            });
+            return paths;
+        }
+        
+        const allPaths = collectAllPaths(window.app.folderTree);
+        allPaths.forEach(path => window.app.selectedFolders.add(path));
+        
+        render();
+        loadFilesFromSelectedFolders();
+    }
+
+    /**
+     * Set up keyboard shortcuts for folder tree
+     */
+    function setupKeyboardShortcuts() {
+        const container = window.app.dom.folderTree;
+        
+        container.addEventListener('keydown', (e) => {
+            // Ctrl+A: Select all visible
+            if ((e.ctrlKey || e.metaKey) && e.key === 'a') {
+                e.preventDefault();
+                selectAllVisible();
+            }
+        });
+        
+        // Make container focusable
+        container.tabIndex = 0;
+    }
+
+    // Export module
+    window.app.modules.tree = {
+        render,
+        buildTree,
+        loadFilesFromSelectedFolders,
+        setupKeyboardShortcuts,
+        expandAll,
+        selectAll
+    };
+})();
+
+/**
+ * Spreadsheet Module
+ * Handles table rendering, cell editing, and file operations
+ */
+(function() {
+    'use strict';
+
+    let editingCell = null;
+    let editingInput = null;
+
+    /**
+     * Render spreadsheet from store
+     */
+    function render() {
+        const tbody = window.app.dom.spreadsheetBody;
+        tbody.innerHTML = '';
+
+        // Get files from store (already filtered and sorted)
+        const files = window.app.modules.store.getDisplayFiles();
+
+        // Render rows
+        if (files.length === 0) {
+            const message = window.app.modules.store.getDisplayFiles().length === 0 
+                ? '<h3>No files to display</h3><p>Select one or more folders from the tree to view files</p>'
+                : '<h3>No files match filters</h3><p>Adjust or clear filters to see files</p>';
+            
+            tbody.innerHTML = `
+                <tr>
+                    <td colspan="10" class="spreadsheet-empty">
+                        ${message}
+                    </td>
+                </tr>
+            `;
+            return;
+        }
+
+        files.forEach((file, index) => {
+            const row = createRow(file, index);
+            tbody.appendChild(row);
+        });
+
+        // Update UI
+        window.app.modules.app.updateStats();
+        updateSortIndicators();
+
+        // Calculate SHA256 if enabled
+        if (window.app.calculateSha256) {
+            calculateSha256ForAll();
+        }
+    }
+
+    /**
+     * Update sort indicators
+     */
+    function updateSortIndicators() {
+        const sortColumns = window.app.modules.store.getSortColumns();
+        const headers = window.app.dom.spreadsheet.querySelectorAll('thead th');
+
+        headers.forEach(th => {
+            const indicator = th.querySelector('.sort-indicator');
+            if (!indicator) return;
+
+            const columnName = th.className.replace('col-', '');
+            const sortIndex = sortColumns.findIndex(s => s.column === columnName);
+
+            if (sortIndex >= 0) {
+                const sort = sortColumns[sortIndex];
+                const arrow = sort.direction === 'asc' ? '▲' : '▼';
+                const priority = sortColumns.length > 1 ? (sortIndex + 1) : '';
+                indicator.textContent = ` ${arrow}${priority}`;
+                indicator.style.display = 'inline';
+            } else {
+                indicator.textContent = '';
+                indicator.style.display = 'none';
+            }
+        });
+    }
+
+    /**
+     * Create a table row for a file
+     */
+    function createRow(file, index) {
+        const row = document.createElement('tr');
+        row.dataset.index = index;
+        row.dataset.folderPath = file.folderPath; // Store folder path for highlighting
+
+        // Add state classes
+        if (file.isDirty) row.classList.add('modified');
+        if (file.error) row.classList.add('error');
+        
+        // Highlight folder on hover
+        row.addEventListener('mouseenter', () => {
+            highlightFolder(file.folderPath);
+        });
+        
+        row.addEventListener('mouseleave', () => {
+            clearFolderHighlight();
+        });
+
+        // Row number
+        row.appendChild(createCell('row-num', index + 1, false));
+
+        // Original filename — plain text (selectable/copyable, no link)
+        const originalCell = createCell('original', file.originalFilename, false);
+        row.appendChild(originalCell);
+
+        // Extension — hyperlink to open the file
+        const extCell = createCell('extension', '', false);
+        const extLink = document.createElement('a');
+        extLink.className = 'cell-link';
+        extLink.textContent = file.extension;
+        extLink.title = 'Click to open file';
+        extLink.style.cursor = 'pointer';
+        extLink.addEventListener('click', async (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            openFile(file);
+        });
+        extCell.appendChild(extLink);
+        row.appendChild(extCell);
+
+        // Parse original filename to get ZDDC components (always)
+        // Pass full filename (name + extension) so the regex can match the .ext suffix
+        const parsed = zddc.parseFilename(zddc.joinExtension(file.originalFilename, file.extension)) || {};
+
+        // Fill any empty fields from parsed filename (per-field, not all-or-nothing)
+        // Must happen before computeNewFilename so all fields are available
+        if (!file.trackingNumber) file.trackingNumber = parsed.trackingNumber || '';
+        if (!file.revision) file.revision = parsed.revision || '';
+        if (!file.status)   file.status   = parsed.status   || '';
+        if (!file.title)    file.title    = parsed.title    || '';
+
+        // New filename: show only if it would actually change the file
+        const computedFilename = file.manualFilename || computeNewFilename(file, index);
+        const originalFullName = zddc.joinExtension(file.originalFilename, file.extension);
+        const wouldChange = computedFilename !== originalFullName;
+        const newFilenameDisplay = wouldChange ? computedFilename : '';
+        const newFilenameCell = createEditableCell('newFilename', newFilenameDisplay, index);
+        // Use computedFilename (not newFilenameDisplay) for validation
+        const newFilename = computedFilename;
+        if (!file.manualFilename) {
+            newFilenameCell.classList.add('computed');
+        }
+        
+        // Validate and show errors
+        const validation = window.app.modules.validator.validateFilename(newFilename);
+        if (!validation.isValid) {
+            newFilenameCell.classList.add('validation-error');
+            newFilenameCell.title = validation.errors.join('; ');
+        } else if (validation.warnings.length > 0) {
+            newFilenameCell.classList.add('validation-warning');
+            newFilenameCell.title = validation.warnings.join('; ');
+        }
+        
+        // Only show action buttons if row is dirty
+        if (file.isDirty) {
+            const actions = document.createElement('span');
+            actions.className = 'inline-actions';
+            
+            const saveBtn = document.createElement('button');
+            saveBtn.className = 'btn-inline btn-save';
+            saveBtn.textContent = '✓';
+            saveBtn.title = 'Save';
+            saveBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                saveFile(index);
+            });
+            
+            const cancelBtn = document.createElement('button');
+            cancelBtn.className = 'btn-inline btn-cancel';
+            cancelBtn.textContent = '✗';
+            cancelBtn.title = 'Clear all fields';
+            cancelBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                cancelFile(index);
+            });
+            
+            actions.appendChild(saveBtn);
+            actions.appendChild(cancelBtn);
+            newFilenameCell.appendChild(actions);
+        }
+        
+        row.appendChild(newFilenameCell);
+
+        // For each field: use file value (already populated above) for display
+        const displayTracking = file.trackingNumber || '';
+        const displayRevision = file.revision || '';
+        const displayStatus   = file.status   || '';
+        const displayTitle    = file.title    || '';
+
+        const trackingCell = createEditableCell('trackingNumber', displayTracking, index);
+        const revisionCell = createEditableCell('revision', displayRevision, index);
+        const statusCell   = createEditableCell('status',   displayStatus,   index);
+        const titleCell    = createEditableCell('title',    displayTitle,    index);
+
+        // Gray = field value matches what the original filename parses to (no change)
+        // Blue = field value differs from the parsed original (would produce a different filename)
+        if (displayTracking === (parsed.trackingNumber || '')) trackingCell.classList.add('auto-populated');
+        else trackingCell.classList.add('field-changed');
+        if (displayRevision === (parsed.revision || '')) revisionCell.classList.add('auto-populated');
+        else revisionCell.classList.add('field-changed');
+        if (displayStatus === (parsed.status || '')) statusCell.classList.add('auto-populated');
+        else statusCell.classList.add('field-changed');
+        if (displayTitle === (parsed.title || '')) titleCell.classList.add('auto-populated');
+        else titleCell.classList.add('field-changed');
+        
+        row.appendChild(trackingCell);
+        row.appendChild(revisionCell);
+        row.appendChild(statusCell);
+        row.appendChild(titleCell);
+
+        // SHA256 (if enabled)
+        if (window.app.calculateSha256) {
+            const sha256Cell = createCell('sha256', file.sha256 || 'calculating...', false);
+            if (!file.sha256) {
+                sha256Cell.classList.add('sha256-calculating');
+            }
+            row.appendChild(sha256Cell);
+        }
+
+        return row;
+    }
+
+    /**
+     * Create a table cell
+     */
+    function createCell(className, content, editable = false) {
+        const td = document.createElement('td');
+        td.className = `col-${className}`;
+        td.textContent = content;
+        return td;
+    }
+
+    /**
+     * Create an editable cell
+     */
+    function createEditableCell(columnName, value, rowIndex) {
+        const td = document.createElement('td');
+        td.className = `col-${columnName} cell-editable`;
+        td.textContent = value;
+        
+        // Double-click to edit
+        td.addEventListener('dblclick', (e) => {
+            e.stopPropagation();
+            startEditing(td, columnName, rowIndex);
+        });
+        
+        return td;
+    }
+
+
+    /**
+     * Start editing a cell
+     */
+    function startEditing(cell, columnName, rowIndex) {
+        // Cancel any existing edit
+        if (editingCell) {
+            cancelEditing();
+        }
+
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        if (!file) return;
+        
+        const currentValue = file[columnName] || '';
+
+        // Clear any cell selection
+        if (window.app.modules.selection) {
+            window.app.modules.selection.clearSelection();
+        }
+
+        // Store references
+        editingCell = { cell, columnName, rowIndex, originalValue: currentValue };
+
+        // Save original content and make cell contenteditable
+        cell.dataset.originalContent = cell.innerHTML;
+        cell.contentEditable = 'true';
+        cell.classList.add('editing');
+        editingInput = cell;
+
+        // Set content (text only for editing)
+        cell.textContent = currentValue;
+
+        // Focus and select all
+        cell.focus();
+        
+        // Select all text — guard against cell being detached from document
+        // (can happen if a re-render fires between dblclick and this point)
+        if (document.contains(cell)) {
+            const range = document.createRange();
+            range.selectNodeContents(cell);
+            const selection = window.getSelection();
+            selection.removeAllRanges();
+            selection.addRange(range);
+        }
+
+        // Event listeners
+        cell.addEventListener('blur', handleBlur, { once: true });
+        cell.addEventListener('keydown', handleKeyDown);
+    }
+
+    /**
+     * Handle blur event
+     */
+    function handleBlur() {
+        // Small delay to allow click events to fire first
+        setTimeout(() => finishEditing(), 100);
+    }
+
+    /**
+     * Handle keydown in contenteditable
+     */
+    function handleKeyDown(e) {
+        if (e.key === 'Enter') {
+            // Enter exits edit mode
+            e.preventDefault();
+            finishEditing();
+        } else if (e.key === 'Escape') {
+            // Escape undoes and exits edit mode
+            e.preventDefault();
+            cancelEditing();
+        } else if (e.key === 'Tab') {
+            // Tab/Shift+Tab moves to next/prev cell
+            e.preventDefault();
+            const { rowIndex, columnName } = editingCell || {};
+            const shiftKey = e.shiftKey;
+            finishEditingQuiet();  // Don't trigger store update
+            if (rowIndex !== undefined) {
+                if (shiftKey) {
+                    moveToPreviousCell(rowIndex, columnName);
+                } else {
+                    moveToNextCell(rowIndex, columnName);
+                }
+            }
+        } else if (e.key === 'ArrowUp') {
+            e.preventDefault();
+            const { rowIndex, columnName } = editingCell || {};
+            finishEditingQuiet();
+            if (rowIndex !== undefined) {
+                moveUpRow(rowIndex, columnName);
+            }
+        } else if (e.key === 'ArrowDown') {
+            e.preventDefault();
+            const { rowIndex, columnName } = editingCell || {};
+            finishEditingQuiet();
+            if (rowIndex !== undefined) {
+                moveDownRow(rowIndex, columnName);
+            }
+        } else if (e.key === 'ArrowLeft' || e.key === 'ArrowRight') {
+            // Allow normal cursor movement within cell
+            e.stopPropagation();
+        }
+    }
+
+    /**
+     * Finish editing and save value
+     */
+    function finishEditing() {
+        if (!editingCell || !editingInput) return;
+
+        const { cell, columnName, rowIndex } = editingCell;
+        const newValue = editingInput.textContent.trim();
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        if (!file) return;
+        
+        const oldValue = file[columnName] || '';
+
+        // Remove contenteditable
+        editingInput.contentEditable = 'false';
+        editingInput.classList.remove('editing');
+        editingInput.removeEventListener('keydown', handleKeyDown);
+
+        // Update file data if changed
+        if (newValue !== oldValue) {
+            // Special handling for newFilename column
+            if (columnName === 'newFilename') {
+                if (newValue) {
+                    window.app.modules.store.updateFileField(rowIndex, 'manualFilename', newValue);
+                } else {
+                    window.app.modules.store.updateFile(rowIndex, { manualFilename: null });
+                }
+            } else {
+                window.app.modules.store.updateFileField(rowIndex, columnName, newValue);
+            }
+
+            const updatedFile = window.app.modules.store.getDisplayFiles()[rowIndex];
+            validateFile(updatedFile);
+        }
+
+        editingCell = null;
+        editingInput = null;
+    }
+    
+    /**
+     * Finish editing without triggering store update (for Tab/Arrow navigation)
+     */
+    function finishEditingQuiet() {
+        if (!editingCell || !editingInput) return;
+
+        const { columnName, rowIndex } = editingCell;
+        const newValue = editingInput.textContent.trim();
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        
+        // Remove contenteditable
+        editingInput.contentEditable = 'false';
+        editingInput.classList.remove('editing');
+        editingInput.removeEventListener('keydown', handleKeyDown);
+
+        // Update file object directly (no store notification)
+        if (file) {
+            if (columnName === 'newFilename') {
+                file.manualFilename = newValue || null;
+            } else {
+                file[columnName] = newValue;
+            }
+            file.isDirty = true;
+        }
+
+        editingCell = null;
+        editingInput = null;
+    }
+
+    /**
+     * Cancel editing without saving
+     */
+    function cancelEditing() {
+        if (!editingCell) return;
+
+        const { rowIndex } = editingCell;
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        if (!file) return;
+
+        // Clear editing state
+        editingCell = null;
+        editingInput = null;
+
+        // Re-render the row
+        const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex}"]`);
+        if (row) {
+            const newRow = createRow(file, rowIndex);
+            row.replaceWith(newRow);
+        }
+    }
+
+    /**
+     * Move to next editable cell
+     */
+    function moveToNextCell(rowIndex, currentColumn) {
+        const columns = ['newFilename', 'trackingNumber', 'revision', 'status', 'title'];
+        const currentIndex = columns.indexOf(currentColumn);
+        
+        if (currentIndex < columns.length - 1) {
+            // Next column in same row
+            const nextColumn = columns[currentIndex + 1];
+            const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex}"]`);
+            const nextCell = row.querySelector(`.col-${nextColumn}`);
+            if (nextCell) {
+                startEditing(nextCell, nextColumn, rowIndex);
+            }
+        } else if (rowIndex < window.app.modules.store.getDisplayFiles().length - 1) {
+            // First column of next row
+            const nextColumn = columns[0];
+            const nextRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex + 1}"]`);
+            const nextCell = nextRow.querySelector(`.col-${nextColumn}`);
+            if (nextCell) {
+                startEditing(nextCell, nextColumn, rowIndex + 1);
+            }
+        }
+    }
+
+    /**
+     * Move to previous editable cell
+     */
+    function moveToPreviousCell(rowIndex, currentColumn) {
+        const columns = ['newFilename', 'trackingNumber', 'revision', 'status', 'title'];
+        const currentIndex = columns.indexOf(currentColumn);
+        
+        if (currentIndex > 0) {
+            // Previous column in same row
+            const prevColumn = columns[currentIndex - 1];
+            const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex}"]`);
+            const prevCell = row.querySelector(`.col-${prevColumn}`);
+            if (prevCell) {
+                startEditing(prevCell, prevColumn, rowIndex);
+            }
+        } else if (rowIndex > 0) {
+            // Last column of previous row
+            const prevColumn = columns[columns.length - 1];
+            const prevRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex - 1}"]`);
+            const prevCell = prevRow.querySelector(`.col-${prevColumn}`);
+            if (prevCell) {
+                startEditing(prevCell, prevColumn, rowIndex - 1);
+            }
+        }
+    }
+
+    /**
+     * Move up one row, same column
+     */
+    function moveUpRow(rowIndex, currentColumn) {
+        if (rowIndex > 0) {
+            const prevRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex - 1}"]`);
+            const cell = prevRow.querySelector(`.col-${currentColumn}`);
+            if (cell) {
+                startEditing(cell, currentColumn, rowIndex - 1);
+            }
+        }
+    }
+
+    /**
+     * Move down one row, same column
+     */
+    function moveDownRow(rowIndex, currentColumn) {
+        if (rowIndex < window.app.modules.store.getDisplayFiles().length - 1) {
+            const nextRow = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${rowIndex + 1}"]`);
+            const cell = nextRow.querySelector(`.col-${currentColumn}`);
+            if (cell) {
+                startEditing(cell, currentColumn, rowIndex + 1);
+            }
+        }
+    }
+
+    function computeNewFilename(file) {
+        return window.app.modules.utils.computeNewFilename(file);
+    }
+
+    /**
+     * Validate a file
+     */
+    function validateFile(file) {
+        const newFilename = computeNewFilename(file, 0);
+        const validation = window.app.modules.validator.validateFilename(newFilename);
+        
+        file.validation = validation;
+        file.error = !validation.isValid;
+    }
+
+    /**
+     * Open file in new tab
+     */
+    async function openFile(file) {
+        try {
+            let blob;
+            if (file.isVirtual) {
+                // Virtual file from ZIP - get from cache
+                const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+                if (!cached) throw new Error('ZIP not found in cache');
+                const zipEntry = cached.zip.file(file.zipEntryPath);
+                if (!zipEntry) throw new Error('File not found in ZIP');
+                const arrayBuffer = await zipEntry.async('arraybuffer');
+                const mimeType = getMimeType(file.extension);
+                blob = new Blob([arrayBuffer], { type: mimeType });
+            } else {
+                blob = await file.handle.getFile();
+            }
+            const url = URL.createObjectURL(blob);
+            window.open(url, '_blank');
+            
+            // Clean up URL after a delay
+            setTimeout(() => URL.revokeObjectURL(url), 60000);
+        } catch (err) {
+            console.error('Error opening file:', err);
+            alert('Cannot open file: ' + err.message);
+        }
+    }
+    
+    function getMimeType(extension) {
+        return window.app.modules.utils.getMimeType(extension);
+    }
+
+    /**
+     * Save a single file
+     */
+    async function saveFile(index, skipValidation = false) {
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[index];
+        if (!file.isDirty) {
+
+            return;
+        }
+        
+        // Virtual files (from ZIPs) cannot be renamed - must extract first
+        if (file.isVirtual) {
+            alert('Cannot rename files inside ZIP archives.\nExtract the ZIP first to rename files.');
+            return;
+        }
+
+        const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${index}"]`);
+        if (!row) {
+            console.error(`Row not found for index ${index}`);
+            return;
+        }
+        row.classList.add('saving');
+
+        try {
+            const newFilename = computeNewFilename(file, index);
+            const currentFilename = zddc.joinExtension(file.originalFilename, file.extension);
+            
+            // Check if already has correct name
+            if (currentFilename === newFilename) {
+
+                row.classList.remove('saving');
+                
+                // Just clear dirty flag and fields
+                file.isDirty = false;
+                file.error = false;
+                delete file.manualFilename;
+                file.trackingNumber = '';
+                file.revision = '';
+                file.status = '';
+                file.title = '';
+                
+                const newRow = createRow(file, index);
+                row.replaceWith(newRow);
+                window.app.modules.app.updateStats();
+                return;
+            }
+            
+            // Validate filename
+            if (!skipValidation) {
+                const validation = window.app.modules.validator.validateFilename(newFilename);
+                if (!validation.isValid) {
+                    const errors = validation.errors.join('\n');
+                    const confirmed = confirm(
+                        `⚠️ Warning: Filename is not ZDDC compliant!\n\n` +
+                        `Errors:\n${errors}\n\n` +
+                        `Current filename: ${newFilename}\n\n` +
+                        `Do you want to save it anyway?`
+                    );
+                    
+                    if (!confirmed) {
+                        row.classList.remove('saving');
+                        return;
+                    }
+                }
+            }
+            
+            // Request write permission for the folder
+            const folderPermission = await file.folderHandle.queryPermission({ mode: 'readwrite' });
+            if (folderPermission !== 'granted') {
+                const granted = await file.folderHandle.requestPermission({ mode: 'readwrite' });
+                if (granted !== 'granted') {
+                    throw new Error('Write permission denied');
+                }
+            }
+            
+            // Rename by copying to new name and deleting old (more reliable than move)
+            const oldFilename = zddc.joinExtension(file.originalFilename, file.extension);
+
+            
+            try {
+                // Get fresh handle for old file
+                const oldHandle = await file.folderHandle.getFileHandle(oldFilename);
+                
+                // Read the file content
+                const fileData = await oldHandle.getFile();
+                
+                // Create new file with new name
+                const newHandle = await file.folderHandle.getFileHandle(newFilename, { create: true });
+                const writable = await newHandle.createWritable();
+                await writable.write(fileData);
+                await writable.close();
+                
+                // Delete old file
+                await file.folderHandle.removeEntry(oldFilename);
+                
+                // Update file handle
+                file.handle = newHandle;
+
+            } catch (err) {
+                console.error(`Failed to rename file:`, err);
+                throw err;
+            }
+            
+            // Update file data directly (don't trigger store notification during batch save)
+            file.originalFilename = zddc.splitExtension(newFilename).name;
+            file.isDirty = false;
+            file.error = false;
+            file.manualFilename = null;
+            file.trackingNumber = '';
+            file.revision = '';
+            file.status = '';
+            file.title = '';
+            file.autoPopulated = false;
+            
+            // Update row UI
+            row.classList.remove('saving');
+            const newRow = createRow(file, index);
+            row.replaceWith(newRow);
+            
+        } catch (err) {
+            console.error('Error saving file:', err);
+            file.error = true;
+            file.errorMessage = err.message;
+            row.classList.remove('saving');
+            row.classList.add('error');
+            // Re-throw so caller can handle
+            throw err;
+        }
+    }
+
+    /**
+     * Cancel/Clear all fields for a single file
+     */
+    function cancelFile(index) {
+        // Clear all fields through store
+        window.app.modules.store.updateFile(index, {
+            trackingNumber: '',
+            revision: '',
+            status: '',
+            title: '',
+            manualFilename: null,
+            isDirty: false,
+            error: false,
+            validation: null,
+            autoPopulated: false
+        });
+    }
+
+    /**
+     * Save all modified files (only ZDDC-compliant ones)
+     */
+    async function saveAllFiles() {
+        const files = window.app.modules.store.getDisplayFiles();
+        const modifiedFiles = files
+            .map((file, index) => ({ file, index }))
+            .filter(({ file }) => file.isDirty);
+
+        if (modifiedFiles.length === 0) {
+            alert('No modified files to save.');
+            return;
+        }
+
+        let successCount = 0;
+        let skippedCount = 0;
+        let errorCount = 0;
+        const errors = [];
+        const skipped = [];
+
+        for (let i = 0; i < modifiedFiles.length; i++) {
+            const { file, index } = modifiedFiles[i];
+            
+            try {
+                // Add small delay between operations to prevent race conditions
+                if (i > 0) {
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                }
+                
+                // Validate before saving
+                const newFilename = computeNewFilename(file, index);
+                const currentFilename = zddc.joinExtension(file.originalFilename, file.extension);
+                
+
+                
+                const validation = window.app.modules.validator.validateFilename(newFilename);
+                
+                if (!validation.isValid) {
+                    // Skip non-compliant files in Save All
+                    skippedCount++;
+                    skipped.push(`${zddc.joinExtension(file.originalFilename, file.extension)}: ${validation.errors[0]}`);
+
+                    continue;
+                }
+                
+                // Check if already has correct name
+                if (currentFilename === newFilename) {
+
+                    // Just clear dirty flag
+                    file.isDirty = false;
+                    file.error = false;
+                    delete file.manualFilename;
+                    file.trackingNumber = '';
+                    file.revision = '';
+                    file.status = '';
+                    file.title = '';
+                    successCount++;
+                    continue;
+                }
+                
+                // Save with validation already done - ensure properly awaited
+                try {
+                    await saveFile(index, true);
+                    successCount++;
+
+                } catch (saveErr) {
+                    console.error(`Error saving file ${index}:`, saveErr);
+                    errorCount++;
+                    errors.push(`${zddc.joinExtension(file.originalFilename, file.extension)}: ${saveErr.message}`);
+                    
+                    // Add delay after errors to let filesystem stabilize
+                    await new Promise(resolve => setTimeout(resolve, 300));
+                }
+            } catch (err) {
+                console.error(`Error processing file ${index}:`, err);
+                errorCount++;
+                errors.push(`${file.originalFilename}${file.extension}: ${err.message}`);
+            }
+        }
+
+        // Trigger store notification to update UI after all saves
+        window.app.modules.store.notify('files');
+        
+        let message = `Saved ${successCount} compliant file(s).`;
+        
+        if (skippedCount > 0) {
+            message += `\n\n⚠️ Skipped ${skippedCount} non-compliant file(s):`;
+            message += `\n${skipped.slice(0, 3).join('\n')}`;
+            if (skipped.length > 3) {
+                message += `\n... and ${skipped.length - 3} more`;
+            }
+            message += `\n\nUse individual save buttons (✓) to save non-compliant files.`;
+        }
+        
+        if (errorCount > 0) {
+            message += `\n\n❌ ${errorCount} error(s):`;
+            message += `\n${errors.slice(0, 3).join('\n')}`;
+            if (errors.length > 3) {
+                message += `\n... and ${errors.length - 3} more`;
+            }
+        }
+        
+        alert(message);
+    }
+
+    /**
+     * Cancel all changes
+     */
+    function cancelAllChanges() {
+        const files = window.app.modules.store.getDisplayFiles();
+        files.forEach((file, index) => {
+            if (file.isDirty) {
+                cancelFile(index);
+            }
+        });
+    }
+
+    /**
+     * Calculate SHA256 for all files
+     */
+    async function calculateSha256ForAll() {
+        const files = window.app.modules.store.getDisplayFiles();
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            if (!file.sha256) {
+                calculateSha256(file, i);
+            }
+        }
+    }
+
+    /**
+     * Calculate SHA256 for a single file
+     */
+    async function calculateSha256(file, index) {
+        try {
+            let hashHex;
+            if (file.isVirtual) {
+                // Virtual file from ZIP
+                const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+                if (!cached) throw new Error('ZIP not found in cache');
+                const zipEntry = cached.zip.file(file.zipEntryPath);
+                if (!zipEntry) throw new Error('File not found in ZIP');
+                const buffer = await zipEntry.async('arraybuffer');
+                hashHex = await zddc.crypto.sha256Hex(buffer);
+            } else {
+                const fileObj = await file.handle.getFile();
+                hashHex = await zddc.crypto.sha256File(fileObj);
+            }
+
+            file.sha256 = hashHex;
+            
+            // Update cell
+            const row = window.app.dom.spreadsheetBody.querySelector(`tr[data-index="${index}"]`);
+            if (row) {
+                const sha256Cell = row.querySelector('.col-sha256');
+                if (sha256Cell) {
+                    sha256Cell.textContent = hashHex.substring(0, 16) + '...';
+                    sha256Cell.title = hashHex;
+                    sha256Cell.classList.remove('sha256-calculating');
+                }
+            }
+        } catch (err) {
+            console.error('Error calculating SHA256:', err);
+        }
+    }
+
+    /**
+     * Highlight folder in tree when hovering over file
+     */
+    function highlightFolder(folderPath) {
+        if (!folderPath) return;
+        
+        // Find folder in tree
+        const folderTree = document.getElementById('folderTree');
+        if (!folderTree) return;
+        
+        // Find the folder item by data-path attribute
+        const folderItem = folderTree.querySelector(`[data-path="${folderPath}"]`);
+        if (!folderItem) return;
+        
+        // Add highlight class
+        folderItem.classList.add('folder-hover-highlight');
+        
+        // Scroll into view if autoscroll is enabled
+        const autoScrollCheckbox = document.getElementById('autoScrollCheckbox');
+        if (autoScrollCheckbox && autoScrollCheckbox.checked) {
+            folderItem.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+        }
+    }
+    
+    /**
+     * Clear folder highlight
+     */
+    function clearFolderHighlight() {
+        const folderTree = document.getElementById('folderTree');
+        if (!folderTree) return;
+        
+        // Remove all highlights
+        const highlighted = folderTree.querySelectorAll('.folder-hover-highlight');
+        highlighted.forEach(el => el.classList.remove('folder-hover-highlight'));
+    }
+
+    /**
+     * Initialize spreadsheet - subscribe to store
+     */
+    function init() {
+        // Subscribe to store changes (only call this after DOM is ready)
+        window.app.modules.store.on('files', render);
+    }
+
+    // Export module
+    window.app.modules.spreadsheet = {
+        init,
+        render,
+        computeNewFilename,
+        saveAllFiles,
+        cancelAllChanges,
+        cancelEditing
+    };
+})();
+
+/**
+ * Selection Module
+ * Handles Excel-style cell selection and copy/paste
+ */
+(function() {
+    'use strict';
+
+    let selectionStart = null;
+    let selectionEnd = null;
+    let isSelecting = false;
+    let initialized = false;
+    let autoScrollInterval = null;
+    let lastMouseY = 0;
+    let startMouseX = 0;
+    let startMouseY = 0;
+    let dragDistance = 0;
+
+    /**
+     * Initialize selection handlers
+     */
+    function init() {
+        // Only initialize once
+        if (initialized) return;
+        initialized = true;
+        
+        const table = window.app.dom.spreadsheet;
+        
+        // Make table focusable so clipboard events fire
+        if (!table.hasAttribute('tabindex')) {
+            table.setAttribute('tabindex', '-1');
+            table.style.outline = 'none';
+        }
+        
+        // Mouse down on cell - start selection
+        table.addEventListener('mousedown', handleMouseDown);
+        
+        // Mouse move - extend selection
+        document.addEventListener('mousemove', handleMouseMove);
+        
+        // Mouse up - end selection
+        document.addEventListener('mouseup', handleMouseUp);
+        
+        // Selectstart handler - prevent only when dragging (multi-cell selection)
+        document.addEventListener('selectstart', (e) => {
+            if (isSelecting && dragDistance > 4) {
+                e.preventDefault();
+            }
+        });
+        
+        // Copy/paste handlers
+        document.addEventListener('copy', handleCopy);
+        document.addEventListener('paste', handlePaste);
+        document.addEventListener('cut', handleCut);
+    }
+
+    /**
+     * Handle mouse down on cell
+     */
+    function handleMouseDown(e) {
+        const cell = e.target.closest('td');
+        if (!cell) return;
+        
+        // Ignore if clicking action buttons
+        if (e.target.closest('.inline-actions')) return;
+        
+        // Ignore if cell is being edited (contenteditable)
+        if (cell.isContentEditable || cell.classList.contains('editing')) return;
+        
+        // Don't start selection if double-clicking to edit
+        if (e.detail === 2) return;
+        
+        const row = cell.closest('tr');
+        if (!row) return;
+        
+        const rowIndex = parseInt(row.dataset.index);
+        const colIndex = Array.from(row.children).indexOf(cell);
+        
+        // Shift+Click: extend selection from existing start to clicked cell
+        if (e.shiftKey && selectionStart) {
+            selectionEnd = { row: rowIndex, col: colIndex };
+            updateSelection();
+            updateButtonStates();
+            e.preventDefault();
+            return;
+        }
+        
+        // Clear previous selection
+        clearSelection();
+        
+        // Start new selection
+        selectionStart = { row: rowIndex, col: colIndex };
+        selectionEnd = { row: rowIndex, col: colIndex };
+        isSelecting = true;
+        dragDistance = 0;
+        startMouseX = e.clientX;
+        startMouseY = e.clientY;
+        
+        // Highlight cell
+        updateSelection();
+        updateButtonStates();
+        
+        // Focus the table so clipboard events (Ctrl+V) fire
+        window.app.dom.spreadsheet.focus();
+        
+        // Only prevent default for shift-click (extending selection)
+        // Single click should allow text selection to work normally
+        if (e.shiftKey) {
+            e.preventDefault();
+        }
+    }
+
+    /**
+     * Handle mouse move during selection
+     */
+    function handleMouseMove(e) {
+        if (!isSelecting) return;
+        
+        // Store mouse position for auto-scroll
+        lastMouseY = e.clientY;
+        
+        // Track drag distance from mousedown
+        const dx = e.clientX - startMouseX;
+        const dy = e.clientY - startMouseY;
+        dragDistance = Math.sqrt(dx*dx + dy*dy);
+        
+        const cell = e.target.closest('td');
+        if (!cell) return;
+        
+        const row = cell.closest('tr');
+        if (!row) return;
+        
+        const rowIndex = parseInt(row.dataset.index);
+        const colIndex = Array.from(row.children).indexOf(cell);
+        
+        if (rowIndex === undefined || colIndex === -1) return;
+        
+        // Update selection end
+        selectionEnd = { row: rowIndex, col: colIndex };
+        
+        // Highlight selected cells
+        updateSelection();
+        
+        // Start auto-scroll if not already running
+        if (!autoScrollInterval) {
+            startAutoScroll();
+        }
+    }
+
+    /**
+     * Start continuous auto-scroll
+     */
+    function startAutoScroll() {
+        const scrollThreshold = 50; // pixels from edge
+        const scrollSpeed = 5; // pixels per frame
+        
+        const scroll = () => {
+            if (!isSelecting) {
+                autoScrollInterval = null;
+                return;
+            }
+            
+            const viewport = document.querySelector('.spreadsheet-pane');
+            if (!viewport) {
+                autoScrollInterval = null;
+                return;
+            }
+            
+            const rect = viewport.getBoundingClientRect();
+            
+            // Determine scroll direction based on last mouse position
+            if (lastMouseY > rect.bottom - scrollThreshold) {
+                viewport.scrollTop += scrollSpeed; // Scroll down
+            } else if (lastMouseY < rect.top + scrollThreshold) {
+                viewport.scrollTop -= scrollSpeed; // Scroll up
+            }
+            
+            // Continue scrolling
+            autoScrollInterval = requestAnimationFrame(scroll);
+        };
+        
+        autoScrollInterval = requestAnimationFrame(scroll);
+    }
+
+    /**
+     * Handle mouse up - end selection
+     */
+    function handleMouseUp(e) {
+        isSelecting = false;
+        dragDistance = 0;
+        
+        // Stop auto-scrolling
+        if (autoScrollInterval) {
+            cancelAnimationFrame(autoScrollInterval);
+            autoScrollInterval = null;
+        }
+        
+        updateButtonStates();
+    }
+
+    /**
+     * Update visual selection highlighting
+     */
+    function updateSelection() {
+        if (!selectionStart || !selectionEnd) return;
+        
+        // Clear all previous highlights
+        document.querySelectorAll('.selected-cell').forEach(cell => {
+            cell.classList.remove('selected-cell');
+        });
+        
+        // Calculate selection bounds
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        // Highlight selected cells
+        const tbody = window.app.dom.spreadsheetBody;
+        const rows = tbody.querySelectorAll('tr');
+        
+        for (let r = minRow; r <= maxRow; r++) {
+            const row = rows[r];
+            if (!row) continue;
+            
+            const cells = row.children;
+            for (let c = minCol; c <= maxCol; c++) {
+                const cell = cells[c];
+                if (cell) {
+                    cell.classList.add('selected-cell');
+                }
+            }
+        }
+        
+        // Emit rowfocused event for preview pane
+        emitRowFocused(minRow);
+    }
+    
+    /**
+     * Emit row focused event for preview pane
+     */
+    function emitRowFocused(rowIndex) {
+        const files = window.app.modules.store.getDisplayFiles();
+        const file = files[rowIndex];
+        
+        if (file) {
+            const event = new CustomEvent('rowfocused', {
+                detail: { rowIndex, file }
+            });
+            document.dispatchEvent(event);
+        }
+    }
+
+    /**
+     * Clear selection
+     */
+    function clearSelection() {
+        selectionStart = null;
+        selectionEnd = null;
+        document.querySelectorAll('.selected-cell').forEach(cell => {
+            cell.classList.remove('selected-cell');
+        });
+        updateButtonStates();
+    }
+
+    /**
+     * Check if there is an active selection
+     */
+    function hasSelection() {
+        return selectionStart !== null && selectionEnd !== null;
+    }
+
+    /**
+     * Update Copy/Paste button enabled states
+     */
+    function updateButtonStates() {
+        const copyBtn = document.getElementById('copyBtn');
+        const pasteBtn = document.getElementById('pasteBtn');
+        const active = hasSelection();
+        if (copyBtn) copyBtn.disabled = !active;
+        if (pasteBtn) pasteBtn.disabled = !active;
+    }
+
+    /**
+     * Get column headers for selected columns
+     */
+    function getColumnHeaders(minCol, maxCol) {
+        const headerCells = window.app.dom.spreadsheet.querySelectorAll('thead th');
+        const headers = [];
+        for (let c = minCol; c <= maxCol; c++) {
+            const th = headerCells[c];
+            if (th) {
+                // Get the text content, excluding filter inputs
+                const text = th.childNodes[0]?.textContent?.trim() || th.textContent.trim();
+                headers.push(text);
+            } else {
+                headers.push('');
+            }
+        }
+        return headers;
+    }
+
+    /**
+     * Check if first row looks like a header row
+     */
+    function isHeaderRow(row) {
+        const headerPatterns = ['#', 'Original', 'Ext', 'New', 'Tracking', 'Rev', 'Status', 'Title', 'SHA256'];
+        return row.some(cell => headerPatterns.includes(cell.trim()));
+    }
+
+    /**
+     * Convert 2D array of rows to an HTML table string.
+     * Excel prefers text/html over text/plain, so providing a
+     * proper <table> ensures cell boundaries are preserved.
+     */
+    function rowsToHtml(allRows) {
+        const esc = s => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        const headerRow = allRows[0];
+        const dataRows = allRows.slice(1);
+        let html = '<table>';
+        html += '<tr>' + headerRow.map(c => '<th>' + esc(c) + '</th>').join('') + '</tr>';
+        for (const row of dataRows) {
+            html += '<tr>' + row.map(c => '<td>' + esc(c) + '</td>').join('') + '</tr>';
+        }
+        html += '</table>';
+        return html;
+    }
+
+    /**
+     * Handle copy event
+     */
+    function handleCopy(e) {
+        if (!selectionStart || !selectionEnd) return;
+        
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        // Get column headers for selected range
+        const headers = getColumnHeaders(minCol, maxCol);
+        
+        const data = getSelectionData();
+        if (!data) return;
+        
+        // Prepend header row
+        const allRows = [headers, ...data];
+        
+        // Convert to TSV and HTML table
+        const tsv = allRows.map(row => row.join('\t')).join('\n');
+        
+        e.clipboardData.setData('text/plain', tsv);
+        e.clipboardData.setData('text/html', rowsToHtml(allRows));
+        e.preventDefault();
+    }
+
+    /**
+     * Handle cut event
+     */
+    function handleCut(e) {
+        if (!selectionStart || !selectionEnd) return;
+        
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        // Get column headers for selected range
+        const headers = getColumnHeaders(minCol, maxCol);
+        
+        const data = getSelectionData();
+        if (!data) return;
+        
+        // Prepend header row
+        const allRows = [headers, ...data];
+        
+        // Convert to TSV
+        const tsv = allRows.map(row => row.join('\t')).join('\n');
+        
+        e.clipboardData.setData('text/plain', tsv);
+        e.clipboardData.setData('text/html', rowsToHtml(allRows));
+        
+        // Clear selected cells (only editable ones)
+        clearSelectionData();
+        
+        e.preventDefault();
+    }
+
+    /**
+     * Handle paste event
+     */
+    function handlePaste(e) {
+        // Don't intercept paste in input fields
+        if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA' || e.target.isContentEditable) {
+            return;
+        }
+        
+        if (!selectionStart) return;
+        
+        const tsv = e.clipboardData.getData('text/plain');
+        if (!tsv) return;
+        
+        e.preventDefault();
+        executePaste(tsv);
+    }
+
+    /**
+     * Execute paste from TSV string into the selected range.
+     * - If pasted cols > selected cols, right-align (user likely copied all but only pastes back editable cols).
+     * - If pasted data includes the first two columns (#, Original), validate they match.
+     * - If pasted row count != selected row count, abort with error.
+     */
+    function executePaste(tsv) {
+        if (!selectionStart || !selectionEnd) return;
+
+        // Parse TSV
+        let rows = tsv.split('\n').map(row => row.split('\t'));
+
+        // Filter out empty trailing rows
+        while (rows.length > 0 && rows[rows.length - 1].every(cell => !cell.trim())) {
+            rows.pop();
+        }
+        if (rows.length === 0) return;
+
+        // Check if first row is a header row and skip it
+        if (rows.length > 1 && isHeaderRow(rows[0])) {
+            rows = rows.slice(1);
+        }
+        if (rows.length === 0) return;
+
+        // Selection bounds
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        const selectedRowCount = maxRow - minRow + 1;
+        const selectedColCount = maxCol - minCol + 1;
+        const pastedColCount = rows[0].length;
+
+        // Row count validation: must match
+        if (rows.length !== selectedRowCount) {
+            alert(`Paste aborted: row count mismatch.\n` +
+                  `Selected ${selectedRowCount} row(s), but clipboard has ${rows.length} row(s).`);
+            return;
+        }
+
+        // Determine column offset for right-alignment
+        let colOffset = 0;
+        if (pastedColCount > selectedColCount) {
+            colOffset = pastedColCount - selectedColCount;
+        }
+
+        // Get column names from header
+        const headerCells = window.app.dom.spreadsheet.querySelectorAll('thead th');
+        const columnNames = Array.from(headerCells).map(th => {
+            const match = th.className.match(/col-(\w+)/);
+            return match ? match[1] : '';
+        });
+
+        // If pasted data includes first two columns (row-num, original), validate they match
+        if (colOffset === 0 && pastedColCount >= selectedColCount) {
+            // Check if pasted range starts at col 0 or col 1 (row-num or original)
+            const files = window.app.modules.store.getDisplayFiles();
+            const startsAtRowNum = (minCol === 0);
+            const startsAtOriginal = (minCol === 1);
+
+            if (startsAtRowNum || startsAtOriginal) {
+                for (let r = 0; r < rows.length; r++) {
+                    const targetRowIndex = minRow + r;
+                    const file = files[targetRowIndex];
+                    if (!file) continue;
+
+                    if (startsAtRowNum) {
+                        // Validate col 0 = row number, col 1 = original filename
+                        const expectedNum = String(targetRowIndex + 1);
+                        const pastedNum = rows[r][0]?.trim();
+                        const pastedOriginal = rows[r][1]?.trim();
+                        if (pastedNum && pastedNum !== expectedNum) {
+                            alert(`Paste aborted: row number mismatch at row ${targetRowIndex + 1}.\n` +
+                                  `Expected "${expectedNum}", got "${pastedNum}".\n` +
+                                  `Data may be shuffled.`);
+                            return;
+                        }
+                        if (pastedOriginal && pastedOriginal !== file.originalFilename) {
+                            alert(`Paste aborted: filename mismatch at row ${targetRowIndex + 1}.\n` +
+                                  `Expected "${file.originalFilename}", got "${pastedOriginal}".\n` +
+                                  `Data may be shuffled.`);
+                            return;
+                        }
+                    } else if (startsAtOriginal) {
+                        // Validate col 0 of paste = original filename
+                        const pastedOriginal = rows[r][0]?.trim();
+                        if (pastedOriginal && pastedOriginal !== file.originalFilename) {
+                            alert(`Paste aborted: filename mismatch at row ${targetRowIndex + 1}.\n` +
+                                  `Expected "${file.originalFilename}", got "${pastedOriginal}".\n` +
+                                  `Data may be shuffled.`);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        // Editable columns
+        const editableColumns = ['newFilename', 'trackingNumber', 'revision', 'status', 'title'];
+        const files = window.app.modules.store.getDisplayFiles();
+        let updatedCount = 0;
+
+        for (let r = 0; r < rows.length; r++) {
+            const targetRowIndex = minRow + r;
+            if (targetRowIndex >= files.length) continue;
+            const file = files[targetRowIndex];
+            if (!file) continue;
+
+            const rowData = rows[r];
+
+            for (let c = 0; c < selectedColCount; c++) {
+                const pasteIdx = c + colOffset; // right-align: skip leading pasted cols
+                if (pasteIdx >= rowData.length) continue;
+
+                const targetColIndex = minCol + c;
+                if (targetColIndex >= columnNames.length) continue;
+
+                const columnName = columnNames[targetColIndex];
+                if (!editableColumns.includes(columnName)) continue;
+
+                const value = rowData[pasteIdx]?.trim() || '';
+
+                if (columnName === 'newFilename') {
+                    if (value) {
+                        file.manualFilename = value;
+                    } else {
+                        delete file.manualFilename;
+                    }
+                } else {
+                    file[columnName] = value;
+                    if (file.manualFilename) {
+                        delete file.manualFilename;
+                    }
+                }
+
+                file.isDirty = true;
+                file.autoPopulated = false;
+                updatedCount++;
+            }
+        }
+
+        // Re-render and restore selection
+        if (updatedCount > 0) {
+            window.app.modules.spreadsheet.render();
+            // Restore selection highlight
+            updateSelection();
+            showToast(`Pasted ${updatedCount} cell(s)`, 'success');
+        }
+    }
+
+    /**
+     * Show a brief toast notification
+     */
+    function showToast(message, type) {
+        if (window.app.modules.excel && window.app.modules.excel.showToast) {
+            window.app.modules.excel.showToast(message, type);
+            return;
+        }
+        // Fallback: simple toast
+        const toast = document.createElement('div');
+        toast.textContent = message;
+        toast.style.cssText = 'position:fixed;bottom:20px;right:20px;padding:8px 16px;' +
+            'background:' + (type === 'success' ? '#28a745' : '#dc3545') + ';color:#fff;' +
+            'border-radius:4px;z-index:9999;font-size:14px;';
+        document.body.appendChild(toast);
+        setTimeout(() => toast.remove(), 3000);
+    }
+
+    /**
+     * Get data from selected cells
+     */
+    function getSelectionData() {
+        if (!selectionStart || !selectionEnd) return null;
+        
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        const data = [];
+        const tbody = window.app.dom.spreadsheetBody;
+        const rows = tbody.querySelectorAll('tr');
+        
+        for (let r = minRow; r <= maxRow; r++) {
+            const row = rows[r];
+            if (!row) continue;
+            
+            const rowData = [];
+            const cells = row.children;
+            
+            for (let c = minCol; c <= maxCol; c++) {
+                const cell = cells[c];
+                if (cell) {
+                    rowData.push(cell.textContent.trim());
+                } else {
+                    rowData.push('');
+                }
+            }
+            
+            data.push(rowData);
+        }
+        
+        return data;
+    }
+
+    /**
+     * Clear data from selected cells (only editable ones)
+     */
+    function clearSelectionData() {
+        if (!selectionStart || !selectionEnd) return;
+        
+        const minRow = Math.min(selectionStart.row, selectionEnd.row);
+        const maxRow = Math.max(selectionStart.row, selectionEnd.row);
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        
+        const tbody = window.app.dom.spreadsheetBody;
+        const rows = tbody.querySelectorAll('tr');
+        
+        // Get column names from header
+        const headerCells = window.app.dom.spreadsheet.querySelectorAll('thead th');
+        const columnNames = Array.from(headerCells).map(th => {
+            const className = th.className.replace('col-', '');
+            return className;
+        });
+        
+        for (let r = minRow; r <= maxRow; r++) {
+            const row = rows[r];
+            if (!row) continue;
+            
+            const rowIndex = parseInt(row.dataset.index);
+            const files = window.app.modules.store.getDisplayFiles();
+            const file = files[rowIndex];
+            if (!file) continue;
+            
+            const cells = row.children;
+            
+            for (let c = minCol; c <= maxCol; c++) {
+                const cell = cells[c];
+                if (!cell || !cell.classList.contains('cell-editable')) continue;
+                
+                const columnName = columnNames[c];
+                
+                // Clear the data
+                if (columnName === 'newFilename') {
+                    delete file.manualFilename;
+                } else {
+                    file[columnName] = '';
+                }
+                
+                file.isDirty = true;
+            }
+        }
+        
+        // Re-render
+        window.app.modules.spreadsheet.render();
+    }
+
+    /**
+     * Copy selection to clipboard via button click
+     */
+    function doCopy() {
+        if (!selectionStart || !selectionEnd) return;
+
+        const minCol = Math.min(selectionStart.col, selectionEnd.col);
+        const maxCol = Math.max(selectionStart.col, selectionEnd.col);
+        const headers = getColumnHeaders(minCol, maxCol);
+        const data = getSelectionData();
+        if (!data) return;
+
+        const allRows = [headers, ...data];
+        const tsv = allRows.map(row => row.join('\t')).join('\n');
+        const html = rowsToHtml(allRows);
+
+        // Write both plain text and HTML to clipboard
+        const htmlBlob = new Blob([html], { type: 'text/html' });
+        const textBlob = new Blob([tsv], { type: 'text/plain' });
+        const item = new ClipboardItem({ 'text/html': htmlBlob, 'text/plain': textBlob });
+
+        navigator.clipboard.write([item]).then(() => {
+            showToast(`Copied ${data.length} row(s)`, 'success');
+        }).catch(err => {
+            // Fallback to plain text if ClipboardItem not supported
+            navigator.clipboard.writeText(tsv).then(() => {
+                showToast(`Copied ${data.length} row(s)`, 'success');
+            }).catch(err2 => {
+                console.error('Copy failed:', err2);
+            });
+        });
+    }
+
+    /**
+     * Paste from clipboard via button click
+     */
+    function doPaste() {
+        if (!selectionStart || !selectionEnd) return;
+
+        navigator.clipboard.readText().then(tsv => {
+            if (tsv) executePaste(tsv);
+        }).catch(err => {
+            console.error('Paste failed:', err);
+            alert('Cannot read clipboard. Use Ctrl+V instead, or grant clipboard permission.');
+        });
+    }
+
+    // Export module
+    window.app.modules.selection = {
+        init,
+        clearSelection,
+        hasSelection,
+        doCopy,
+        doPaste
+    };
+})();
+
+/**
+ * Preview Module
+ * Opens file preview in a separate popup window
+ */
+(function() {
+    'use strict';
+
+    let currentBlobUrl = null;
+    let currentFile = null;
+    let currentRowIndex = null;
+    let previewWindow = null;
+
+    // File type mappings (extensions stored without leading dot, matching shared/zddc.js)
+    const IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'gif', 'svg', 'webp', 'bmp', 'ico'];
+    const TEXT_EXTENSIONS = ['txt', 'md', 'json', 'xml', 'csv', 'log', 'html', 'css', 'js', 'ts', 'py', 'sh', 'bat', 'yaml', 'yml', 'ini', 'cfg', 'conf'];
+    const PDF_EXTENSIONS = ['pdf'];
+    const ZIP_EXTENSIONS = ['zip'];
+
+    // Cache for lazily loaded CDN libraries
+    const loadedLibraries = new Map();
+
+    /**
+     * Lazily load a script from CDN. Returns a promise that resolves when loaded.
+     * Caches the promise so subsequent calls return immediately.
+     */
+    function loadLibrary(url) {
+        if (loadedLibraries.has(url)) return loadedLibraries.get(url);
+        const promise = new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = url;
+            script.onload = resolve;
+            script.onerror = () => reject(new Error(`Failed to load library: ${url}`));
+            document.head.appendChild(script);
+        });
+        loadedLibraries.set(url, promise);
+        return promise;
+    }
+
+    /**
+     * Initialize preview module
+     */
+    function init() {
+        // Listen for row focused events from selection module
+        document.addEventListener('rowfocused', handleRowFocused);
+        
+        // Set up toggle button to open/close preview window
+        const toggleBtn = document.getElementById('togglePreviewBtn');
+        if (toggleBtn) {
+            toggleBtn.addEventListener('click', () => {
+                if (previewWindow && !previewWindow.closed) {
+                    // Close preview window
+                    previewWindow.close();
+                    previewWindow = null;
+                    toggleBtn.classList.remove('preview-active');
+                } else if (currentFile) {
+                    openPreviewWindow(currentFile);
+                    toggleBtn.classList.add('preview-active');
+                }
+            });
+        }
+    }
+
+    /**
+     * Handle row focused event
+     */
+    function handleRowFocused(e) {
+        const { rowIndex, file } = e.detail;
+        
+        currentRowIndex = rowIndex;
+        
+        if (file && file !== currentFile) {
+            currentFile = file;
+            
+            // Update preview window if open
+            if (previewWindow && !previewWindow.closed) {
+                openPreviewWindow(file);
+            }
+        }
+    }
+
+    /**
+     * Open preview in a separate popup window
+     */
+    async function openPreviewWindow(file) {
+        if (!file) return;
+        
+        currentFile = file;
+        
+        try {
+            const blob = await getFileBlob(file);
+            
+            // Clean up previous blob URL
+            if (currentBlobUrl) {
+                URL.revokeObjectURL(currentBlobUrl);
+            }
+            currentBlobUrl = URL.createObjectURL(blob);
+            
+            const fileName = zddc.joinExtension(file.originalFilename, file.extension);
+            
+            // Build preview HTML with toolbar
+            const previewHtml = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>${escapeHtml(fileName)} - Preview</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { 
+            display: flex; 
+            flex-direction: column; 
+            height: 100vh; 
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        }
+        .toolbar {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.5rem 1rem;
+            background: #f5f5f5;
+            border-bottom: 1px solid #ddd;
+        }
+        .toolbar h1 {
+            flex: 1;
+            font-size: 0.95rem;
+            font-weight: 500;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+        .btn {
+            padding: 0.4rem 0.8rem;
+            font-size: 0.85rem;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            background: white;
+            cursor: pointer;
+        }
+        .btn:hover { background: #e8e8e8; }
+        iframe, img {
+            flex: 1;
+            width: 100%;
+            border: none;
+        }
+        img {
+            object-fit: contain;
+            background: #f0f0f0;
+        }
+        pre {
+            flex: 1;
+            padding: 1rem;
+            overflow: auto;
+            background: #fafafa;
+            font-family: 'Consolas', 'Monaco', monospace;
+            font-size: 0.9rem;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+        .unsupported {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            color: #666;
+        }
+        .unsupported .icon { font-size: 3rem; margin-bottom: 1rem; }
+        #previewContent {
+            flex: 1;
+            overflow: auto;
+        }
+        .loading {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100%;
+            color: #666;
+            font-size: 1.1rem;
+        }
+        .docx-wrapper { padding: 1rem; }
+        .xlsx-table { border-collapse: collapse; width: 100%; font-size: 0.85rem; }
+        .xlsx-table th, .xlsx-table td {
+            border: 1px solid #ddd;
+            padding: 0.35rem 0.5rem;
+            text-align: left;
+            white-space: nowrap;
+        }
+        .xlsx-table th { background: #f0f0f0; font-weight: 600; position: sticky; top: 0; }
+        .xlsx-table tr:nth-child(even) { background: #fafafa; }
+        .xlsx-table tr:hover { background: #f0f7ff; }
+        .sheet-tabs { display: flex; gap: 0; border-bottom: 1px solid #ddd; background: #f5f5f5; }
+        .sheet-tab {
+            padding: 0.4rem 1rem;
+            cursor: pointer;
+            border: 1px solid transparent;
+            border-bottom: none;
+            font-size: 0.85rem;
+            background: transparent;
+        }
+        .sheet-tab:hover { background: #e8e8e8; }
+        .sheet-tab.active {
+            background: white;
+            border-color: #ddd;
+            border-bottom-color: white;
+            margin-bottom: -1px;
+            font-weight: 500;
+        }
+    </style>
+</head>
+<body>
+    <div class="toolbar">
+        <h1>${escapeHtml(fileName)}</h1>
+        <button class="btn" onclick="downloadFile()">Download</button>
+    </div>
+    ${await getPreviewContent(file, currentBlobUrl)}
+    <script>
+        var blobUrl = "${currentBlobUrl}";
+        var fileName = "${escapeHtml(fileName).replace(/"/g, '\\"')}";
+        
+        function downloadFile() {
+            const a = document.createElement('a');
+            a.href = blobUrl;
+            a.download = fileName;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+        }
+    <\/script>
+</body>
+</html>`;
+            
+            // Reuse existing window if open, otherwise create new one
+            if (previewWindow && !previewWindow.closed) {
+                previewWindow.document.open();
+                previewWindow.document.write(previewHtml);
+                previewWindow.document.close();
+                previewWindow.focus();
+            } else {
+                // Calculate window size
+                const width = Math.round(screen.width * 0.6);
+                const height = Math.round(screen.height * 0.8);
+                const left = Math.round((screen.width - width) / 2);
+                const top = Math.round((screen.height - height) / 2);
+                
+                previewWindow = window.open('', 'classifierPreview', 
+                    `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`);
+                
+                if (!previewWindow) {
+                    // Popup blocked - fall back to new tab
+                    window.open(currentBlobUrl, '_blank');
+                    return;
+                }
+                
+                // Poll for window close — beforeunload is unreliable for popup close buttons
+                const closePoll = setInterval(() => {
+                    if (previewWindow && previewWindow.closed) {
+                        clearInterval(closePoll);
+                        previewWindow = null;
+                        const btn = document.getElementById('togglePreviewBtn');
+                        if (btn) btn.classList.remove('preview-active');
+                    }
+                }, 500);
+                
+                previewWindow.document.write(previewHtml);
+                previewWindow.document.close();
+                previewWindow.focus();
+            }
+            
+            // For office types, render content after window is ready
+            const ext = (file.extension || '').toLowerCase();
+            if (ext === 'docx') {
+                await renderDocxInWindow(file);
+            } else if (ext === 'xlsx' || ext === 'xls') {
+                await renderXlsxInWindow(file);
+            }
+        } catch (err) {
+            console.error('Error opening preview:', err);
+            alert(`Error opening preview: ${err.message}`);
+        }
+    }
+    
+    /**
+     * Get preview content HTML based on file type
+     */
+    async function getPreviewContent(file, blobUrl) {
+        const ext = file.extension.toLowerCase();
+        const previewType = getPreviewType(ext);
+        
+        switch (previewType) {
+            case 'pdf':
+                return `<iframe src="${blobUrl}#view=FitV"></iframe>`;
+            case 'image':
+                return `<img src="${blobUrl}" alt="${escapeHtml(file.originalFilename)}" />`;
+            case 'text':
+                const text = await getFileText(file);
+                const maxLength = 100000;
+                const displayText = text.length > maxLength 
+                    ? text.substring(0, maxLength) + '\n\n... (truncated)'
+                    : text;
+                return `<pre>${escapeHtml(displayText)}</pre>`;
+            case 'docx':
+            case 'xlsx':
+                return `<div id="previewContent"><div class="loading">Loading preview...</div></div>`;
+            default:
+                return `
+                    <div class="unsupported">
+                        <div class="icon">📄</div>
+                        <p>Preview not available for ${ext} files</p>
+                        <p style="margin-top: 0.5rem;">Click Download to view in external application</p>
+                    </div>
+                `;
+        }
+    }
+    
+    /**
+     * Get preview type from extension
+     */
+    function getPreviewType(ext) {
+        if (PDF_EXTENSIONS.includes(ext)) return 'pdf';
+        if (IMAGE_EXTENSIONS.includes(ext)) return 'image';
+        if (TEXT_EXTENSIONS.includes(ext)) return 'text';
+        if (ext === 'docx') return 'docx';
+        if (ext === 'xlsx' || ext === 'xls') return 'xlsx';
+        if (ZIP_EXTENSIONS.includes(ext)) return 'zip';
+        return 'none';
+    }
+
+    function getMimeType(ext) {
+        return window.app.modules.utils.getMimeType(ext);
+    }
+    
+    /**
+     * Get file content as blob (handles both real and virtual files)
+     */
+    async function getFileBlob(file) {
+        if (file.isVirtual) {
+            // Get from ZIP cache
+            const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+            if (!cached) throw new Error('ZIP not found in cache');
+            
+            const zipEntry = cached.zip.file(file.zipEntryPath);
+            if (!zipEntry) throw new Error('File not found in ZIP');
+            
+            // Get as arraybuffer and create blob with correct MIME type
+            const arrayBuffer = await zipEntry.async('arraybuffer');
+            const mimeType = getMimeType(file.extension);
+            return new Blob([arrayBuffer], { type: mimeType });
+        } else {
+            // Get from file handle
+            if (!file.handle) {
+                throw new Error('File handle not available');
+            }
+            return await file.handle.getFile();
+        }
+    }
+    
+    /**
+     * Get file content as text (handles both real and virtual files)
+     */
+    async function getFileText(file) {
+        if (file.isVirtual) {
+            const cached = window.app.modules.scanner.getZipCache(file.zipPath);
+            if (!cached) throw new Error('ZIP not found in cache');
+            
+            const zipEntry = cached.zip.file(file.zipEntryPath);
+            if (!zipEntry) throw new Error('File not found in ZIP');
+            
+            return await zipEntry.async('string');
+        } else {
+            if (!file.handle) {
+                throw new Error('File handle not available');
+            }
+            const fileObj = await file.handle.getFile();
+            return await fileObj.text();
+        }
+    }
+
+    /**
+     * Render a DOCX file in the preview window using docx-preview library
+     */
+    async function renderDocxInWindow(file) {
+        const container = previewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+            await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+            
+            const blob = await getFileBlob(file);
+            const arrayBuffer = await blob.arrayBuffer();
+            
+            container.innerHTML = '';
+            await window.docx.renderAsync(arrayBuffer, container);
+        } catch (err) {
+            console.error('Error rendering DOCX:', err);
+            container.innerHTML = `<div class="loading">Error rendering DOCX: ${err.message}<br>Click Download to view in Word.</div>`;
+        }
+    }
+
+    /**
+     * Render an XLSX/XLS file in the preview window using SheetJS
+     */
+    async function renderXlsxInWindow(file) {
+        const container = previewWindow.document.getElementById('previewContent');
+        if (!container) return;
+        
+        try {
+            await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+            
+            const blob = await getFileBlob(file);
+            const arrayBuffer = await blob.arrayBuffer();
+            const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+            
+            container.innerHTML = '';
+            
+            if (workbook.SheetNames.length > 1) {
+                const tabs = previewWindow.document.createElement('div');
+                tabs.className = 'sheet-tabs';
+                workbook.SheetNames.forEach((name, i) => {
+                    const tab = previewWindow.document.createElement('button');
+                    tab.className = 'sheet-tab' + (i === 0 ? ' active' : '');
+                    tab.textContent = name;
+                    tab.onclick = () => {
+                        tabs.querySelectorAll('.sheet-tab').forEach(t => t.classList.remove('active'));
+                        tab.classList.add('active');
+                        renderSheetInWindow(workbook, name, tableContainer);
+                    };
+                    tabs.appendChild(tab);
+                });
+                container.appendChild(tabs);
+            }
+            
+            const tableContainer = previewWindow.document.createElement('div');
+            tableContainer.style.flex = '1';
+            tableContainer.style.overflow = 'auto';
+            container.appendChild(tableContainer);
+            
+            renderSheetInWindow(workbook, workbook.SheetNames[0], tableContainer);
+        } catch (err) {
+            console.error('Error rendering XLSX:', err);
+            container.innerHTML = `<div class="loading">Error rendering spreadsheet: ${err.message}<br>Click Download to view in Excel.</div>`;
+        }
+    }
+
+    /**
+     * Render a single sheet as an HTML table in the preview window
+     */
+    function renderSheetInWindow(workbook, sheetName, container) {
+        const sheet = workbook.Sheets[sheetName];
+        const html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+        container.innerHTML = html;
+        const table = container.querySelector('table');
+        if (table) table.className = 'xlsx-table';
+    }
+
+    /**
+     * Escape HTML for safe display
+     */
+    function escapeHtml(text) {
+        const div = document.createElement('div');
+        div.textContent = text;
+        return div.innerHTML;
+    }
+
+    /**
+     * Download current file
+     */
+    async function downloadFile() {
+        if (!currentFile) return;
+        
+        try {
+            const blob = await getFileBlob(currentFile);
+            const url = URL.createObjectURL(blob);
+            
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = zddc.joinExtension(currentFile.originalFilename, currentFile.extension);
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            
+            setTimeout(() => URL.revokeObjectURL(url), 1000);
+        } catch (err) {
+            console.error('Error downloading file:', err);
+            alert('Error downloading file: ' + err.message);
+        }
+    }
+
+    // Export module
+    window.app.modules.preview = {
+        init
+    };
+})();
+
+/**
+ * Column Resize Module
+ * Handles resizable table columns
+ */
+(function() {
+    'use strict';
+
+    let resizingColumn = null;
+    let startX = 0;
+    let startWidth = 0;
+
+    /**
+     * Initialize column resizing
+     */
+    function init() {
+        const table = window.app.dom.spreadsheet;
+        const headers = table.querySelectorAll('thead th');
+        
+        headers.forEach(th => {
+            // Skip if resize handle already exists
+            if (th.querySelector('.column-resizer')) return;
+            
+            // Add resize handle
+            const resizer = document.createElement('div');
+            resizer.className = 'column-resizer';
+            th.appendChild(resizer);
+            
+            // Mouse down on resizer
+            resizer.addEventListener('mousedown', (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                
+                resizingColumn = th;
+                startX = e.pageX;
+                startWidth = th.offsetWidth;
+                
+                document.addEventListener('mousemove', handleMouseMove);
+                document.addEventListener('mouseup', handleMouseUp);
+            });
+        });
+    }
+
+    /**
+     * Handle mouse move during resize
+     */
+    function handleMouseMove(e) {
+        if (!resizingColumn) return;
+        
+        const diff = e.pageX - startX;
+        const newWidth = Math.max(50, startWidth + diff);
+        
+        resizingColumn.style.width = newWidth + 'px';
+        resizingColumn.style.minWidth = newWidth + 'px';
+        resizingColumn.style.maxWidth = newWidth + 'px';
+    }
+
+    /**
+     * Handle mouse up - end resize
+     */
+    function handleMouseUp() {
+        resizingColumn = null;
+        document.removeEventListener('mousemove', handleMouseMove);
+        document.removeEventListener('mouseup', handleMouseUp);
+    }
+
+    // Export module
+    window.app.modules.resize = {
+        init
+    };
+})();
+
+/**
+ * Filter Module
+ * Column filter UI: initialises static inputs in thead, wires events.
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Initialize filtering — wire delegated events on thead.
+     * Filter inputs already exist in the static template; no dynamic injection needed.
+     */
+    function init() {
+        const thead = window.app.dom.spreadsheet
+            ? window.app.dom.spreadsheet.querySelector('thead')
+            : document.querySelector('#spreadsheet thead');
+        if (!thead) return;
+
+        thead.addEventListener('input', (e) => {
+            if (e.target.matches('.column-filter[data-filter-field]')) {
+                e.stopPropagation();
+                const field = e.target.getAttribute('data-filter-field');
+                const raw = e.target.value.trim();
+                const ast = window.zddc.filter.parse(raw);
+                window.app.modules.store.setFilter(field, raw, ast);
+            }
+        });
+
+        thead.addEventListener('keydown', (e) => {
+            if (!e.target.matches('.column-filter[data-filter-field]')) return;
+            if (e.key === 'Escape') {
+                e.target.value = '';
+                const field = e.target.getAttribute('data-filter-field');
+                window.app.modules.store.setFilter(field, '', null);
+                e.preventDefault();
+            } else if (e.key === 'Enter') {
+                e.preventDefault();
+                const inputs = Array.from(thead.querySelectorAll('.column-filter'));
+                const idx = inputs.indexOf(e.target);
+                if (idx !== -1) inputs[(idx + 1) % inputs.length].focus();
+            }
+        });
+
+        thead.addEventListener('click', (e) => {
+            if (e.target.matches('.column-filter')) {
+                e.stopPropagation();
+            }
+        });
+    }
+
+    /**
+     * Clear all filters — reset inputs and store.
+     */
+    function clearFilters() {
+        document.querySelectorAll('.column-filter').forEach(input => {
+            input.value = '';
+        });
+        window.app.modules.store.setAllFilters({});
+    }
+
+    window.app.modules.filter = {
+        init,
+        clearFilters
+    };
+})();
+
+/**
+ * Sort Module
+ * Handles multi-column sorting for the spreadsheet
+ */
+(function() {
+    'use strict';
+
+    // Sort state: array of {column, direction}
+    let sortState = [];
+
+    /**
+     * Initialize sorting
+     */
+    function init() {
+        const table = window.app.dom.spreadsheet;
+        const headers = table.querySelectorAll('thead th');
+        
+        headers.forEach((th, index) => {
+            // Skip row number column
+            if (th.classList.contains('col-row-num')) return;
+            
+            // Skip if already initialized
+            if (th.querySelector('.sort-indicator')) return;
+            
+            // Make header clickable
+            th.style.cursor = 'pointer';
+            th.style.userSelect = 'none';
+            
+            // Add sort indicator container
+            const sortIndicator = document.createElement('span');
+            sortIndicator.className = 'sort-indicator';
+            
+            // Insert after the text node (before any br or filter)
+            const firstChild = th.firstChild;
+            if (firstChild && firstChild.nodeType === Node.TEXT_NODE) {
+                // Insert after text node
+                firstChild.after(sortIndicator);
+            } else {
+                // Prepend to header
+                th.insertBefore(sortIndicator, firstChild);
+            }
+            
+            // Click to sort (only add once)
+            const handleClick = (e) => {
+                // Don't sort if clicking on resizer or filter input
+                if (e.target.classList.contains('column-resizer')) return;
+                if (e.target.classList.contains('column-filter')) return;
+                
+                const columnName = th.className.replace('col-', '');
+                handleSort(columnName, e.ctrlKey || e.metaKey);
+            };
+            
+            th.addEventListener('click', handleClick);
+        });
+    }
+
+    /**
+     * Apply default sort (called after initial render)
+     */
+    function applyDefaultSort() {
+        const files = window.app.modules.store.getDisplayFiles();
+        if (files.length > 0) {
+            sortState = [{ column: 'original', direction: 'asc' }];
+            applySorts();
+            updateSortIndicators();
+        }
+    }
+
+    /**
+     * Handle sort click
+     */
+    function handleSort(columnName, multiSort) {
+        // Use store to toggle sort
+        window.app.modules.store.toggleSort(columnName, multiSort);
+    }
+
+    /**
+     * Apply sort to files array (pure function - doesn't mutate)
+     */
+    function applySortToFiles(files) {
+        if (sortState.length === 0) {
+            return files;
+        }
+        
+        return [...files].sort((a, b) => {
+            for (const sort of sortState) {
+                const result = compareValues(a, b, sort.column, sort.direction);
+                if (result !== 0) return result;
+            }
+            return 0;
+        });
+    }
+
+    /**
+     * Apply all sorts (legacy - triggers render)
+     */
+    function applySorts() {
+        window.app.modules.spreadsheet.render();
+    }
+    
+    /**
+     * Apply default sort
+     */
+    function applyDefaultSort() {
+        const files = window.app.modules.store.getDisplayFiles();
+        if (files.length > 0 && sortState.length === 0) {
+            sortState = [{ column: 'original', direction: 'asc' }];
+            window.app.modules.spreadsheet.render();
+        }
+    }
+    
+    /**
+     * Get current sort state
+     */
+    function getSortState() {
+        return sortState;
+    }
+    
+    /**
+     * Update sort indicators in headers
+     */
+    function updateIndicators() {
+        const table = window.app.dom.spreadsheet;
+        const headers = table.querySelectorAll('thead th');
+        
+        headers.forEach(th => {
+            const indicator = th.querySelector('.sort-indicator');
+            if (!indicator) return;
+            
+            const columnName = th.className.replace('col-', '');
+            const sortIndex = sortState.findIndex(s => s.column === columnName);
+            
+            if (sortIndex >= 0) {
+                const sort = sortState[sortIndex];
+                const arrow = sort.direction === 'asc' ? '▲' : '▼';
+                const priority = sortState.length > 1 ? (sortIndex + 1) : '';
+                indicator.textContent = ` ${arrow}${priority}`;
+                indicator.style.display = 'inline';
+            } else {
+                indicator.textContent = '';
+                indicator.style.display = 'none';
+            }
+        });
+    }
+
+    /**
+     * Compare two values for sorting
+     */
+    function compareValues(a, b, columnName, direction) {
+        let aVal, bVal;
+        
+        // Get values based on column
+        switch (columnName) {
+            case 'original':
+                aVal = a.originalFilename || '';
+                bVal = b.originalFilename || '';
+                break;
+            case 'extension':
+                aVal = a.extension || '';
+                bVal = b.extension || '';
+                break;
+            case 'new':
+            case 'newFilename':
+                aVal = a.manualFilename || window.app.modules.spreadsheet.computeNewFilename(a, 0);
+                bVal = b.manualFilename || window.app.modules.spreadsheet.computeNewFilename(b, 0);
+                break;
+            case 'trackingNumber':
+                aVal = a.trackingNumber || '';
+                bVal = b.trackingNumber || '';
+                break;
+            case 'revision':
+                aVal = a.revision || '';
+                bVal = b.revision || '';
+                break;
+            case 'status':
+                aVal = a.status || '';
+                bVal = b.status || '';
+                break;
+            case 'title':
+                aVal = a.title || '';
+                bVal = b.title || '';
+                break;
+            case 'sha256':
+                aVal = a.sha256 || '';
+                bVal = b.sha256 || '';
+                break;
+            default:
+                return 0;
+        }
+        
+        // Natural sort for strings (handles numbers within strings)
+        const comparison = aVal.localeCompare(bVal, undefined, { numeric: true, sensitivity: 'base' });
+        
+        return direction === 'asc' ? comparison : -comparison;
+    }
+
+    /**
+     * Clear all sorts
+     */
+    function clearSorts() {
+        sortState = [];
+        applySorts();
+    }
+
+    // Export module
+    window.app.modules.sort = {
+        init,
+        applyDefaultSort,
+        applySorts,
+        applySortToFiles,
+        updateIndicators,
+        getSortState,
+        clearSorts
+    };
+})();
+
+/**
+ * Excel Integration Module
+ * Toast notifications and hash export
+ */
+(function() {
+    'use strict';
+
+    /**
+     * Show toast notification
+     */
+    function showToast(message, type = 'info') {
+        // Remove existing toast
+        const existing = document.querySelector('.toast');
+        if (existing) {
+            existing.remove();
+        }
+
+        // Create toast
+        const toast = document.createElement('div');
+        toast.className = `toast toast-${type}`;
+        toast.textContent = message;
+        document.body.appendChild(toast);
+
+        // Auto-remove after 5 seconds
+        setTimeout(() => {
+            toast.classList.add('toast-fade');
+            setTimeout(() => toast.remove(), 300);
+        }, 5000);
+    }
+
+    /**
+     * Export SHA256 hashes in sha256sum format
+     */
+    async function exportHashes() {
+        const files = window.app.modules.store.getDisplayFiles();
+        if (files.length === 0) {
+            alert('No files to export');
+            return;
+        }
+
+        // Check if SHA256 is enabled
+        if (!window.app.calculateSha256) {
+            alert('Please enable SHA256 checkbox first and wait for hashes to calculate');
+            return;
+        }
+
+        try {
+            // Build sha256sum format: hash *filepath
+            const lines = [];
+            
+            // Get root path
+            const rootPath = await getFullPath(window.app.rootHandle);
+            
+            for (const file of files) {
+                if (!file.sha256 || file.sha256 === 'calculating...' || file.sha256 === 'error') {
+                    continue; // Skip files without calculated hash
+                }
+                
+                // Get full path from root
+                const folderPath = await getFullPath(file.folderHandle);
+                const fullPath = `${folderPath}/${zddc.joinExtension(file.originalFilename, file.extension)}`;
+                
+                // Format: hash *filepath (asterisk indicates binary mode)
+                lines.push(`${file.sha256} *${fullPath}`);
+            }
+
+            if (lines.length === 0) {
+                alert('No SHA256 hashes available. Enable SHA256 and wait for calculation to complete.');
+                return;
+            }
+
+            // Create output
+            const output = lines.join('\n');
+
+            // Generate filename with timestamp
+            const now = new Date();
+            const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, -5); // YYYY-MM-DDTHH-MM-SS
+            const filename = `sha256sums_${timestamp}.txt`;
+
+            // Download as file
+            const blob = new Blob([output], { type: 'text/plain' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = filename;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+
+            // Show success message
+            showToast(`✓ Downloaded ${lines.length} hash(es) to ${filename}`, 'success');
+
+        } catch (err) {
+            console.error('Error exporting hashes:', err);
+            alert('Error exporting hashes: ' + err.message);
+        }
+    }
+
+    /**
+     * Get full path from directory handle (all the way to root)
+     */
+    async function getFullPath(dirHandle) {
+        const parts = [];
+        let current = dirHandle;
+        
+        // Walk up to root - collect ALL parent folders
+        while (current) {
+            parts.unshift(current.name);
+            
+            try {
+                // Try to get parent
+                if (typeof current.getParent === 'function') {
+                    const parent = await current.getParent();
+                    if (parent && parent !== current) {
+                        current = parent;
+                        continue;
+                    }
+                }
+                break;
+            } catch {
+                break;
+            }
+        }
+        
+        return parts.join('/');
+    }
+
+    // Export module
+    window.app.modules.excel = {
+        showToast,
+        exportHashes
+    };
+})();
+
+/**
+ * ZDDC shared help panel — open/close logic.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #help-btn, #help-panel, #help-panel-close in the DOM.
+ */
+(function () {
+    'use strict';
+
+    function init() {
+        var helpBtn   = document.getElementById('help-btn');
+        var panel     = document.getElementById('help-panel');
+        var closeBtn  = document.getElementById('help-panel-close');
+
+        if (!helpBtn || !panel) { return; }
+
+        function isOpen() { return !panel.hidden; }
+
+        function openPanel() {
+            panel.hidden = false;
+            document.body.classList.add('help-open');
+        }
+
+        function closePanel() {
+            panel.hidden = true;
+            document.body.classList.remove('help-open');
+        }
+
+        helpBtn.addEventListener('click', function () {
+            if (isOpen()) { closePanel(); } else { openPanel(); }
+        });
+
+        if (closeBtn) {
+            closeBtn.addEventListener('click', closePanel);
+        }
+
+        document.addEventListener('keydown', function (e) {
+            if (e.key === 'Escape' && isOpen()) { closePanel(); }
+        });
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+    </script>
+</body>
+</html>
diff --git a/website/releases/landing_latest.html b/website/releases/landing_latest.html
new file mode 120000
index 0000000..8dc1f55
--- /dev/null
+++ b/website/releases/landing_latest.html
@@ -0,0 +1 @@
+landing_v0.0.1.html
\ No newline at end of file
diff --git a/website/releases/landing_v0.0.1.html b/website/releases/landing_v0.0.1.html
new file mode 100644
index 0000000..e7c0831
--- /dev/null
+++ b/website/releases/landing_v0.0.1.html
@@ -0,0 +1,1029 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Archive — Projects</title>
+    <style>
+/* ==========================================================================
+   ZDDC Shared Base — single source of truth for tokens and primitives
+   Included first by every tool's build.sh via ../shared/base.css
+   ========================================================================== */
+
+/* ── CSS custom properties ────────────────────────────────────────────────── */
+:root {
+    /* Brand / accent (matches zddc.varasys.io website --accent) */
+    --primary:        #2a5a8a;
+    --primary-hover:  #1d4060;
+    --primary-active: #163352;
+    --primary-light:  #e8f0f7;
+
+    /* Semantic colours */
+    --success: #28a745;
+    --warning: #d97706;
+    --danger:  #dc3545;
+    --info:    #17a2b8;
+
+    /* Backgrounds */
+    --bg:           #ffffff;
+    --bg-secondary: #f8f9fa;
+    --bg-hover:     #f0f4f8;
+    --bg-selected:  var(--primary-light);
+
+    /* Text */
+    --text:       #212529;
+    --text-muted: #6c757d;
+    --text-light: #ffffff;
+
+    /* Borders */
+    --border:      #dee2e6;
+    --border-dark: #adb5bd;
+
+    /* Shape */
+    --radius: 4px;
+
+    /* Typography */
+    --font:      -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    --font-mono: 'SF Mono', 'Fira Code', 'Consolas', 'Courier New', monospace;
+}
+
+/* ── Dark mode tokens ─────────────────────────────────────────────────────── */
+/* Applied via: OS preference (auto) or [data-theme="dark"] on <html>          */
+/* The [data-theme="light"] selector locks light mode regardless of OS pref.   */
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+        --primary:        #4a90c4;
+        --primary-hover:  #5ba3d9;
+        --primary-active: #6ab5e8;
+        --primary-light:  #1a3550;
+
+        --bg:           #1e1e1e;
+        --bg-secondary: #252526;
+        --bg-hover:     #2d2d30;
+        --bg-selected:  #1a3550;
+
+        --text:       #d4d4d4;
+        --text-muted: #9d9d9d;
+        --text-light: #ffffff;
+
+        --border:      #3e3e42;
+        --border-dark: #6e6e72;
+    }
+}
+
+/* Manual dark override — wins over media query */
+[data-theme="dark"] {
+    --primary:        #4a90c4;
+    --primary-hover:  #5ba3d9;
+    --primary-active: #6ab5e8;
+    --primary-light:  #1a3550;
+
+    --bg:           #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover:     #2d2d30;
+    --bg-selected:  #1a3550;
+
+    --text:       #d4d4d4;
+    --text-muted: #9d9d9d;
+    --text-light: #ffffff;
+
+    --border:      #3e3e42;
+    --border-dark: #6e6e72;
+}
+
+/* ── Reset ────────────────────────────────────────────────────────────────── */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* ── Base document ────────────────────────────────────────────────────────── */
+html, body {
+    height: 100%;
+    font-family: var(--font);
+    font-size: 16px;
+    line-height: 1.5;
+    color: var(--text);
+    background-color: var(--bg-secondary);
+}
+
+/* ── Typography ───────────────────────────────────────────────────────────── */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 600;
+    line-height: 1.2;
+}
+
+a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+/* ── Utility ──────────────────────────────────────────────────────────────── */
+.hidden {
+    display: none !important;
+}
+
+.truncate {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* ── Scrollbars (webkit) ──────────────────────────────────────────────────── */
+::-webkit-scrollbar {
+    width: 7px;
+    height: 7px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a0a0a0;
+}
+
+/* ── Button primitive ─────────────────────────────────────────────────────── */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.4rem 0.85rem;
+    font-family: var(--font);
+    font-size: 0.875rem;
+    font-weight: 500;
+    line-height: 1.4;
+    text-align: center;
+    text-decoration: none;
+    white-space: nowrap;
+    vertical-align: middle;
+    cursor: pointer;
+    border: 1px solid transparent;
+    border-radius: var(--radius);
+    transition: background 0.15s, box-shadow 0.15s, border-color 0.15s, color 0.15s;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.btn:disabled,
+.btn[disabled] {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:not(:disabled):hover {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.12);
+}
+
+.btn:not(:disabled):active {
+    box-shadow: none;
+}
+
+/* Variants */
+.btn-primary {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-primary:not(:disabled):hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+    color: var(--text-light);
+}
+
+.btn-primary:not(:disabled):active {
+    background: var(--primary-active);
+    border-color: var(--primary-active);
+}
+
+.btn-secondary {
+    background: var(--bg);
+    color: var(--text);
+    border-color: var(--border);
+}
+
+.btn-secondary:not(:disabled):hover {
+    background: var(--bg-secondary);
+}
+
+.btn-success {
+    background: var(--success);
+    color: var(--text-light);
+    border-color: var(--success);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: var(--text-light);
+    border-color: var(--danger);
+}
+
+/* Sizes */
+.btn-sm {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.75rem;
+}
+
+.btn-lg {
+    padding: 0.6rem 1.4rem;
+    font-size: 1rem;
+}
+
+.btn-link {
+    background: transparent;
+    border-color: transparent;
+    color: var(--primary);
+    padding-left: 0;
+    padding-right: 0;
+}
+
+.btn-link:not(:disabled):hover {
+    text-decoration: underline;
+    box-shadow: none;
+}
+
+/* ── App header chrome ────────────────────────────────────────────────────── */
+.app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.35rem 1rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+/* Tool name inside the header */
+.app-header__title {
+    font-size: 17px;
+    font-weight: 600;
+    color: var(--text);
+    letter-spacing: 0.01em;
+    white-space: nowrap;
+}
+
+/* ── Build timestamp ──────────────────────────────────────────────────────── */
+.build-timestamp {
+    font-size: 0.55rem;
+    color: var(--text-muted);
+    opacity: 0.7;
+    font-weight: 300;
+    white-space: nowrap;
+    padding-top: 0.15rem;
+}
+
+/* Title + timestamp stacked vertically on the left side of the header */
+.header-title-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    line-height: 1;
+}
+
+/* ── Icon buttons (help, theme, refresh) ─────────────────────────────────── */
+/* Square, centered — overrides the asymmetric text-button padding/line-height */
+#help-btn,
+#theme-btn,
+#refreshHeaderBtn {
+    width: 2rem;
+    height: 2rem;
+    padding: 0;
+    line-height: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1rem;
+}
+
+/* Toast CSS lives in classifier/css/base.css — only that tool uses toasts. */
+
+/* ── Theme and help icon buttons ─────────────────────────────────────────── */
+#theme-btn,
+#help-btn {
+    font-size: 1rem;
+}
+
+/* ── Help panel (shared slide-out drawer) ─────────────────────────────────── */
+/* Used by all four tools. Toggle open/close via shared/help.js.               */
+
+.help-panel {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: min(420px, 85vw);
+    height: 100vh;
+    z-index: 1000;
+    background: var(--bg);
+    border-left: 1px solid var(--border);
+    box-shadow: -2px 0 12px rgba(0, 0, 0, 0.08);
+    display: flex;
+    flex-direction: column;
+    transform: translateX(100%);
+    transition: transform 0.25s ease;
+}
+
+.help-panel:not([hidden]) {
+    transform: translateX(0);
+}
+
+.help-panel[hidden] {
+    display: flex;
+    transform: translateX(100%);
+    pointer-events: none;
+}
+
+.help-panel__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+    background: var(--bg);
+}
+
+.help-panel__title {
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.help-panel__close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1.35rem;
+    cursor: pointer;
+    padding: 0.25rem 0.5rem;
+    border-radius: var(--radius);
+    line-height: 1;
+    transition: background 0.15s, color 0.15s;
+}
+
+.help-panel__close:hover {
+    color: var(--text);
+    background: var(--bg-secondary);
+}
+
+.help-panel__body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem 1rem 2rem;
+    font-size: 0.85rem;
+    line-height: 1.6;
+    color: var(--text);
+}
+
+.help-panel__body h3 {
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin: 1.25rem 0 0.35rem;
+    color: var(--text);
+    border-bottom: 1px solid var(--border);
+    padding-bottom: 0.15rem;
+}
+
+.help-panel__body h3:first-child {
+    margin-top: 0;
+}
+
+.help-panel__body h4 {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    margin: 1.25rem 0 0.3rem;
+    padding-left: 0.5rem;
+    border-left: 3px solid var(--border-dark);
+    color: var(--text-muted);
+}
+
+.help-panel__body p {
+    margin: 0 0 0.5rem;
+}
+
+.help-panel__body ol,
+.help-panel__body ul {
+    padding-left: 1.5rem;
+    margin: 0.3rem 0 0.5rem;
+}
+
+.help-panel__body li {
+    margin-bottom: 0.3rem;
+}
+
+.help-panel__body dl {
+    margin: 0.3rem 0;
+}
+
+.help-panel__body dt {
+    font-weight: 600;
+    color: var(--text);
+}
+
+.help-panel__body dd {
+    margin: 0 0 0.5rem 1rem;
+    color: var(--text-muted);
+}
+
+.help-panel__body code {
+    font-family: var(--font-mono);
+    font-size: 0.8em;
+    background: var(--bg-secondary);
+    padding: 0.1em 0.3em;
+    border-radius: 3px;
+}
+
+.help-badge {
+    font-size: 0.7rem;
+    font-weight: 600;
+    padding: 0.1rem 0.35rem;
+    border-radius: var(--radius);
+    vertical-align: middle;
+    letter-spacing: 0.02em;
+}
+
+.help-badge--draft {
+    color: #2563eb;
+    background: #eff6ff;
+}
+
+.help-badge--published {
+    color: #7c3aed;
+    background: #f5f3ff;
+}
+
+/* Shrink main content when help panel is open */
+body.help-open .app-header {
+    margin-right: min(420px, 85vw);
+}
+
+/* ── Column filter inputs (shared across archive, classifier, transmittal) ─── */
+.column-filter {
+    display: block;
+    width: 100%;
+    box-sizing: border-box;
+    margin-top: 0.25rem;
+    padding: 0.2rem 0.4rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.15s;
+}
+
+.column-filter:focus {
+    border-color: var(--primary);
+    outline: none;
+    box-shadow: 0 0 0 1px rgba(42, 90, 138, 0.35);
+}
+
+.column-filter::placeholder {
+    color: var(--text-muted);
+}
+
+/* Landing page layout */
+body {
+    margin: 0;
+    font-family: var(--font);
+    font-size: 14px;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.landing-main {
+    max-width: 640px;
+    margin: 32px auto;
+    padding: 0 16px;
+}
+
+/* Access warning banner */
+.access-warning-banner {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 16px;
+    background: #fff3cd;
+    border: 1px solid #ffc107;
+    border-radius: var(--radius);
+    color: #664d03;
+    font-size: 0.875rem;
+    margin-bottom: 16px;
+    gap: 12px;
+}
+.access-warning-banner.hidden { display: none; }
+.warning-dismiss-btn {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #664d03;
+    font-size: 1rem;
+    padding: 0 4px;
+    flex-shrink: 0;
+}
+
+/* Main card */
+.landing-card {
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    overflow: hidden;
+}
+
+.landing-card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 12px 16px;
+    border-bottom: 1px solid var(--border);
+    gap: 12px;
+    flex-wrap: wrap;
+}
+
+.landing-card-header h2 {
+    margin: 0;
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text);
+}
+
+.landing-header-actions {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+/* Project list */
+.project-list {
+    padding: 8px 0;
+    min-height: 80px;
+}
+
+.project-list-empty {
+    padding: 32px 16px;
+    text-align: center;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
+
+.project-item {
+    display: flex;
+    align-items: center;
+    padding: 8px 16px;
+    gap: 10px;
+    cursor: pointer;
+    border-radius: 0;
+    transition: background 0.1s;
+}
+.project-item:hover { background: var(--bg-hover); }
+.project-item input[type="checkbox"] {
+    width: 16px;
+    height: 16px;
+    cursor: pointer;
+    flex-shrink: 0;
+    accent-color: var(--primary);
+}
+.project-item-name {
+    font-size: 0.9375rem;
+    color: var(--text);
+    user-select: none;
+}
+
+/* Footer */
+.landing-card-footer {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 16px;
+    border-top: 1px solid var(--border);
+    gap: 8px;
+}
+
+/* Preset menu */
+.preset-control {
+    position: relative;
+}
+.preset-menu {
+    position: absolute;
+    top: 100%;
+    right: 0;
+    margin-top: 4px;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    box-shadow: 0 4px 12px rgba(0,0,0,0.12);
+    min-width: 200px;
+    z-index: 100;
+    padding: 4px 0;
+}
+.preset-menu.hidden { display: none; }
+.preset-menu-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 12px;
+    cursor: pointer;
+    font-size: 0.875rem;
+    gap: 8px;
+}
+.preset-menu-item:hover { background: var(--bg-hover); }
+.preset-menu-item-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+.preset-delete-btn {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+    padding: 0 2px;
+    flex-shrink: 0;
+}
+.preset-delete-btn:hover { color: var(--danger); }
+.preset-menu-empty {
+    padding: 8px 12px;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
+.preset-menu-divider {
+    border: none;
+    border-top: 1px solid var(--border);
+    margin: 4px 0;
+}
+
+/* Loading state */
+.project-list-loading {
+    padding: 32px 16px;
+    text-align: center;
+    color: var(--text-muted);
+    font-size: 0.875rem;
+}
+
+    </style>
+</head>
+<body>
+    <header class="app-header">
+        <div class="header-left">
+            <span class="app-header__title">ZDDC Archive</span>
+            <span class="build-timestamp">v0.0.1</span>
+        </div>
+        <div class="header-right">
+            <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+        </div>
+    </header>
+
+    <main class="landing-main">
+        <!-- Access warning banner (shown when URL ?projects= contains inaccessible items) -->
+        <div id="accessWarningBanner" class="access-warning-banner hidden" role="alert">
+            <span id="accessWarningText"></span>
+            <button class="warning-dismiss-btn" onclick="LandingApp.dismissWarning()" aria-label="Dismiss">&times;</button>
+        </div>
+
+        <div class="landing-card">
+            <div class="landing-card-header">
+                <h2>Select Projects</h2>
+                <div class="landing-header-actions">
+                    <!-- Presets dropdown -->
+                    <div class="preset-control">
+                        <button id="presetMenuBtn" class="btn btn-secondary btn-sm" onclick="LandingApp.togglePresetMenu()">▾ Presets</button>
+                        <div id="presetMenu" class="preset-menu hidden"></div>
+                    </div>
+                    <button class="btn btn-secondary btn-sm" onclick="LandingApp.selectAll()">Select All</button>
+                    <button class="btn btn-secondary btn-sm" onclick="LandingApp.selectNone()">Select None</button>
+                </div>
+            </div>
+
+            <div id="projectList" class="project-list">
+                <!-- Populated by JS -->
+            </div>
+
+            <div class="landing-card-footer">
+                <button id="savePresetBtn" class="btn btn-secondary" onclick="LandingApp.savePreset()">Save Preset…</button>
+                <button id="openArchiveBtn" class="btn btn-primary" onclick="LandingApp.openArchive()">Open Archive →</button>
+            </div>
+        </div>
+    </main>
+
+    <script>
+/**
+ * ZDDC shared theme toggle — light / dark / auto.
+ * Persists choice to localStorage under 'zddc-theme'.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #theme-btn in the DOM (optional — skips gracefully if absent).
+ *
+ * Theme cycle: auto → light → dark → auto …
+ * 'auto' honours the OS prefers-color-scheme media query (CSS handles it).
+ * 'light' sets data-theme="light" on <html> (overrides dark media query).
+ * 'dark'  sets data-theme="dark"  on <html>.
+ */
+(function () {
+    'use strict';
+
+    var STORAGE_KEY = 'zddc-theme';
+    var THEMES = ['auto', 'light', 'dark'];
+
+    var LABELS = {
+        auto:  '◐',
+        light: '☀',
+        dark:  '☾'
+    };
+
+    var TITLES = {
+        auto:  'Theme: auto (follows OS)',
+        light: 'Theme: light',
+        dark:  'Theme: dark'
+    };
+
+    function load() {
+        var stored = localStorage.getItem(STORAGE_KEY);
+        return THEMES.indexOf(stored) !== -1 ? stored : 'auto';
+    }
+
+    function apply(theme) {
+        if (theme === 'dark') {
+            document.documentElement.setAttribute('data-theme', 'dark');
+        } else if (theme === 'light') {
+            document.documentElement.setAttribute('data-theme', 'light');
+        } else {
+            document.documentElement.removeAttribute('data-theme');
+        }
+    }
+
+    function save(theme) {
+        try { localStorage.setItem(STORAGE_KEY, theme); } catch (e) {}
+    }
+
+    function updateButton(btn, theme) {
+        btn.textContent = LABELS[theme];
+        btn.title = TITLES[theme];
+        btn.setAttribute('aria-label', TITLES[theme]);
+    }
+
+    function next(theme) {
+        return THEMES[(THEMES.indexOf(theme) + 1) % THEMES.length];
+    }
+
+    function init() {
+        var current = load();
+        apply(current);
+
+        var btn = document.getElementById('theme-btn');
+        if (!btn) { return; }
+
+        updateButton(btn, current);
+
+        btn.addEventListener('click', function () {
+            current = next(current);
+            apply(current);
+            save(current);
+            updateButton(btn, current);
+        });
+    }
+
+    /* Apply theme immediately (before DOM ready) to avoid flash */
+    apply(load());
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+(function() {
+    'use strict';
+
+    var accessibleProjects = []; // [{name, url}, ...] from server
+    var presets = [];            // [{name, projects[]}, ...] from localStorage
+    var PRESETS_KEY = 'zddc_landing_presets';
+
+    // ── Initialise ──────────────────────────────────────────────────────────
+
+    async function init() {
+        loadPresets();
+
+        var urlProjects = getUrlProjects();
+
+        var projectList = document.getElementById('projectList');
+        projectList.innerHTML = '<div class="project-list-loading">Loading projects…<\/div>';
+
+        try {
+            var resp = await fetch(location.origin + location.pathname.replace(/\/[^\/]*$/, '/'), {
+                headers: { 'Accept': 'application/json' }
+            });
+            if (!resp.ok) throw new Error('HTTP ' + resp.status);
+            accessibleProjects = await resp.json();
+        } catch (e) {
+            projectList.innerHTML = '<div class="project-list-empty">Could not load project list: ' + escapeHtml(e.message) + '<\/div>';
+            return;
+        }
+
+        // Warn about URL projects that are not accessible
+        if (urlProjects.size > 0) {
+            var missing = Array.from(urlProjects).filter(function(p) {
+                return !accessibleProjects.some(function(ap) { return ap.name === p; });
+            });
+            if (missing.length > 0) {
+                showWarning('This link includes projects you don\'t have access to: ' + missing.map(escapeHtml).join(', '));
+            }
+        }
+
+        renderProjects(urlProjects);
+        renderPresetMenu();
+
+        // Close preset menu on outside click
+        document.addEventListener('click', function(e) {
+            var menu = document.getElementById('presetMenu');
+            var btn = document.getElementById('presetMenuBtn');
+            if (menu && !menu.classList.contains('hidden') && !menu.contains(e.target) && e.target !== btn) {
+                menu.classList.add('hidden');
+            }
+        });
+    }
+
+    function getUrlProjects() {
+        var params = new URLSearchParams(location.search);
+        var val = params.get('projects');
+        if (!val) return new Set();
+        return new Set(val.split(',').map(function(p) { return p.trim(); }).filter(Boolean));
+    }
+
+    // ── Rendering ────────────────────────────────────────────────────────────
+
+    function renderProjects(preCheck) {
+        var container = document.getElementById('projectList');
+        if (accessibleProjects.length === 0) {
+            container.innerHTML = '<div class="project-list-empty">No projects available.<\/div>';
+            return;
+        }
+        var html = accessibleProjects.map(function(p) {
+            var checked = (preCheck.size === 0 || preCheck.has(p.name)) ? ' checked' : '';
+            return '<div class="project-item" onclick="LandingApp.toggleProject(this)">' +
+                '<input type="checkbox" value="' + escapeHtml(p.name) + '"' + checked + ' onclick="event.stopPropagation()">' +
+                '<span class="project-item-name">' + escapeHtml(p.name) + '<\/span>' +
+                '<\/div>';
+        }).join('');
+        container.innerHTML = html;
+    }
+
+    function renderPresetMenu() {
+        var menu = document.getElementById('presetMenu');
+        if (!menu) return;
+        if (presets.length === 0) {
+            menu.innerHTML = '<div class="preset-menu-empty">No presets saved.<\/div>';
+            return;
+        }
+        menu.innerHTML = presets.map(function(preset) {
+            return '<div class="preset-menu-item">' +
+                '<span class="preset-menu-item-name" onclick="LandingApp.applyPreset(' + JSON.stringify(preset.name) + ')">' +
+                escapeHtml(preset.name) + '<\/span>' +
+                '<button class="preset-delete-btn" onclick="LandingApp.deletePreset(' + JSON.stringify(preset.name) + ')" title="Delete preset">&times;<\/button>' +
+                '<\/div>';
+        }).join('');
+    }
+
+    // ── Actions ──────────────────────────────────────────────────────────────
+
+    function selectAll() {
+        document.querySelectorAll('#projectList input[type="checkbox"]').forEach(function(cb) {
+            cb.checked = true;
+        });
+    }
+
+    function selectNone() {
+        document.querySelectorAll('#projectList input[type="checkbox"]').forEach(function(cb) {
+            cb.checked = false;
+        });
+    }
+
+    function toggleProject(row) {
+        var cb = row.querySelector('input[type="checkbox"]');
+        if (cb) cb.checked = !cb.checked;
+    }
+
+    function openArchive() {
+        var checked = Array.from(document.querySelectorAll('#projectList input[type="checkbox"]:checked'))
+            .map(function(cb) { return cb.value; });
+        if (checked.length === 0) {
+            alert('Select at least one project to open.');
+            return;
+        }
+        var base = location.pathname.replace(/\/[^\/]*$/, '/');
+        location.href = base + 'archive.html?projects=' + checked.map(encodeURIComponent).join(',');
+    }
+
+    function savePreset() {
+        var name = prompt('Enter a name for this preset:');
+        if (!name || !name.trim()) return;
+        name = name.trim();
+        var checked = Array.from(document.querySelectorAll('#projectList input[type="checkbox"]:checked'))
+            .map(function(cb) { return cb.value; });
+        // Replace existing preset with same name
+        presets = presets.filter(function(p) { return p.name !== name; });
+        presets.push({ name: name, projects: checked });
+        savePresets();
+        renderPresetMenu();
+    }
+
+    function togglePresetMenu() {
+        var menu = document.getElementById('presetMenu');
+        if (menu) menu.classList.toggle('hidden');
+    }
+
+    function applyPreset(name) {
+        var preset = presets.find(function(p) { return p.name === name; });
+        if (!preset) return;
+        var projectSet = new Set(preset.projects);
+        document.querySelectorAll('#projectList input[type="checkbox"]').forEach(function(cb) {
+            cb.checked = projectSet.has(cb.value);
+        });
+        document.getElementById('presetMenu').classList.add('hidden');
+    }
+
+    function deletePreset(name) {
+        presets = presets.filter(function(p) { return p.name !== name; });
+        savePresets();
+        renderPresetMenu();
+    }
+
+    function dismissWarning() {
+        var el = document.getElementById('accessWarningBanner');
+        if (el) el.classList.add('hidden');
+    }
+
+    // ── Warning ───────────────────────────────────────────────────────────────
+
+    function showWarning(message) {
+        var el = document.getElementById('accessWarningBanner');
+        var txt = document.getElementById('accessWarningText');
+        if (!el || !txt) return;
+        txt.textContent = message;
+        el.classList.remove('hidden');
+    }
+
+    // ── Persistence ───────────────────────────────────────────────────────────
+
+    function loadPresets() {
+        try {
+            var raw = localStorage.getItem(PRESETS_KEY);
+            presets = raw ? JSON.parse(raw) : [];
+            if (!Array.isArray(presets)) presets = [];
+        } catch (e) {
+            presets = [];
+        }
+    }
+
+    function savePresets() {
+        try {
+            localStorage.setItem(PRESETS_KEY, JSON.stringify(presets));
+        } catch (e) { /* quota exceeded or private browsing */ }
+    }
+
+    // ── Utilities ─────────────────────────────────────────────────────────────
+
+    function escapeHtml(text) {
+        var div = document.createElement('div');
+        div.textContent = String(text);
+        return div.innerHTML;
+    }
+
+    // ── Bootstrap ─────────────────────────────────────────────────────────────
+
+    document.addEventListener('DOMContentLoaded', init);
+
+    window.LandingApp = {
+        init: init,
+        selectAll: selectAll,
+        selectNone: selectNone,
+        toggleProject: toggleProject,
+        openArchive: openArchive,
+        savePreset: savePreset,
+        togglePresetMenu: togglePresetMenu,
+        applyPreset: applyPreset,
+        deletePreset: deletePreset,
+        dismissWarning: dismissWarning
+    };
+
+})();
+
+    </script>
+</body>
+</html>
diff --git a/website/releases/mdedit_latest.html b/website/releases/mdedit_latest.html
new file mode 120000
index 0000000..d031563
--- /dev/null
+++ b/website/releases/mdedit_latest.html
@@ -0,0 +1 @@
+mdedit_v0.0.1.html
\ No newline at end of file
diff --git a/website/releases/mdedit_v0.0.1.html b/website/releases/mdedit_v0.0.1.html
new file mode 100644
index 0000000..274ae67
--- /dev/null
+++ b/website/releases/mdedit_v0.0.1.html
@@ -0,0 +1,5064 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Markdown</title>
+    <!-- Toast UI Editor v3.2.2 -->
+<style>
+/*!
+ * @toast-ui/editor
+ * @version 3.2.2 | Fri Feb 17 2023
+ * @author NHN Cloud FE Development Lab <dl_javascript@nhn.com>
+ * @license MIT
+ */.ProseMirror{word-wrap:break-word;font-feature-settings:"liga" 0;-webkit-font-variant-ligatures:none;font-variant-ligatures:none;position:relative;white-space:pre-wrap;white-space:break-spaces}.ProseMirror pre{white-space:pre-wrap}.ProseMirror li{position:relative}.ProseMirror-hideselection ::selection{background:transparent}.ProseMirror-hideselection ::-moz-selection{background:transparent}.ProseMirror-hideselection{caret-color:transparent}.ProseMirror-selectednode{outline:2px solid #8cf}li.ProseMirror-selectednode{outline:none}li.ProseMirror-selectednode:after{border:2px solid #8cf;bottom:-2px;content:"";left:-32px;pointer-events:none;position:absolute;right:-2px;top:-2px}img.ProseMirror-separator{border:none!important;display:inline!important;margin:0!important}.auto-height,.auto-height .toastui-editor-defaultUI{height:auto}.auto-height .toastui-editor-md-container{position:relative}:not(.auto-height)>.toastui-editor-defaultUI,:not(.auto-height)>.toastui-editor-defaultUI>.toastui-editor-main{display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column}:not(.auto-height)>.toastui-editor-defaultUI>.toastui-editor-main{-ms-flex:1;flex:1}.toastui-editor-defaultUI-toolbar:after,.toastui-editor-md-container:after{clear:both;content:"";display:block;height:0}.toastui-editor-main{box-sizing:border-box;height:inherit;min-height:0;position:relative}.toastui-editor-md-container{display:none;height:100%;overflow:hidden}.toastui-editor-md-container .toastui-editor{line-height:1.5;position:relative}.toastui-editor-md-container .toastui-editor,.toastui-editor-md-container .toastui-editor-md-preview{box-sizing:border-box;height:inherit;padding:0}.toastui-editor-md-container .toastui-editor-md-preview{height:100%;overflow:auto;padding:0 25px}.toastui-editor-md-container .toastui-editor-md-preview>p:first-child{margin-top:0!important}.toastui-editor-md-container .toastui-editor-md-preview .toastui-editor-contents{padding-top:8px}.toastui-editor-main .toastui-editor-md-tab-style>.toastui-editor,.toastui-editor-main .toastui-editor-md-tab-style>.toastui-editor-md-preview{display:none;width:100%}.toastui-editor-main .toastui-editor-md-tab-style>.active{display:block}.toastui-editor-main .toastui-editor-md-vertical-style>.toastui-editor-tabs{display:none}.toastui-editor-main .toastui-editor-md-tab-style>.toastui-editor-tabs{display:block}.toastui-editor-main .toastui-editor-md-vertical-style .toastui-editor,.toastui-editor-main .toastui-editor-md-vertical-style .toastui-editor-md-preview{width:50%}.toastui-editor-main .toastui-editor-md-splitter{background-color:#ebedf2;display:none;height:100%;left:50%;position:absolute;width:1px}.toastui-editor-main .toastui-editor-md-vertical-style .toastui-editor-md-splitter{display:block}.toastui-editor-ww-container{background-color:#fff;display:none;height:inherit;overflow:hidden}.auto-height .toastui-editor-main-container{position:relative}.toastui-editor-main-container{color:#222;height:inherit;line-height:1;position:absolute;width:100%}.toastui-editor-ww-container>.toastui-editor{height:inherit;position:relative;width:100%}.toastui-editor-ww-container .toastui-editor-contents{box-sizing:border-box;height:inherit;margin:0;overflow:auto;padding:16px 25px 0}.toastui-editor-ww-container .toastui-editor-contents p{margin:0}.toastui-editor-md-mode .toastui-editor-md-container,.toastui-editor-ww-mode .toastui-editor-ww-container{display:block;z-index:20}.toastui-editor-md-mode .toastui-editor-md-vertical-style{display:-ms-flexbox;display:flex}.toastui-editor-defaultUI.hidden,.toastui-editor-main.hidden{display:none}.toastui-editor-defaultUI .ProseMirror{padding:18px 25px}.toastui-editor-defaultUI{border:1px solid #dadde6;border-radius:4px;font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;height:100%;position:relative}.toastui-editor-defaultUI button{border:none;border-radius:2px;color:#333;cursor:pointer;font-size:13px;height:28px}.toastui-editor-defaultUI .toastui-editor-ok-button{background-color:#00a9ff;color:#fff;height:32px;min-width:63px;outline-color:#009bf2}.toastui-editor-defaultUI .toastui-editor-ok-button:hover{background-color:#009bf2}.toastui-editor-defaultUI .toastui-editor-close-button{background-color:#f7f9fc;border:1px solid #dadde6;height:32px;margin-right:5px;min-width:63px;outline-color:#cbcfdb}.toastui-editor-defaultUI .toastui-editor-close-button:hover{border-color:#cbcfdb}.toastui-editor-mode-switch{background-color:#fff;border-radius:0 0 3px 3px;border-top:1px solid #dadde6;font-size:12px;height:28px;padding-right:10px;text-align:right}.toastui-editor-mode-switch .tab-item{background:#f7f9fc;border:1px solid #dadde6;border-radius:0 0 4px 4px;box-sizing:border-box;color:#969aa5;cursor:pointer;display:inline-block;font-weight:500;height:24px;line-height:24px;margin-right:-1px;margin-top:-1px;text-align:center;width:96px}.toastui-editor-mode-switch .tab-item.active{background-color:#fff;border-top:1px solid #fff;color:#555}.toastui-editor-defaultUI .toastui-editor-md-tab-container{background:#f7f9fc;border-bottom:1px solid #ebedf2;border-top-left-radius:3px;float:left;font-size:13px;height:45px}.toastui-editor-md-tab-container .toastui-editor-tabs{height:100%;margin-left:15px}.toastui-editor-md-tab-container .tab-item{background:#eaedf1;border:1px solid #dadde6;border-radius:4px 4px 0 0;box-sizing:border-box;color:#969aa5;cursor:pointer;display:inline-block;font-size:12px;font-weight:500;height:33px;line-height:33px;margin-top:13px;text-align:center;width:70px}.toastui-editor-md-tab-container .tab-item.active{background-color:#fff;border-bottom:1px solid #fff;color:#555}.toastui-editor-md-tab-container .tab-item:last-child{margin-left:-1px}.toastui-editor-defaultUI-toolbar{background-color:#f7f9fc;border-bottom:1px solid #ebedf2;border-radius:3px 3px 0 0;display:-ms-flexbox;display:flex;height:45px;padding:0 25px}.toastui-editor-toolbar{box-sizing:border-box;height:46px}.toastui-editor-toolbar-divider{background-color:#e1e3e9;display:inline-block;height:18px;margin:14px 12px;width:1px}.toastui-editor-toolbar-group{display:-ms-flexbox;display:flex}.toastui-editor-defaultUI-toolbar button{border:1px solid #f7f9fc;border-radius:3px;box-sizing:border-box;cursor:pointer;height:32px;margin:7px 5px;padding:0;width:32px}.toastui-editor-defaultUI-toolbar button:not(:disabled):hover{background-color:#fff;border:1px solid #e4e7ee}.toastui-editor-defaultUI-toolbar .scroll-sync{color:#81858f;cursor:pointer;display:inline-block;height:10px;line-height:10px;position:relative;text-align:center;width:70px}.toastui-editor-defaultUI-toolbar .scroll-sync:before{content:"Scroll";font-size:14px;left:0;position:absolute}.toastui-editor-defaultUI-toolbar .scroll-sync.active:before{color:#00a9ff}.toastui-editor-defaultUI-toolbar .scroll-sync input{height:0;opacity:0;width:0}.toastui-editor-defaultUI-toolbar .switch{background-color:#d6d8de;border-radius:50px;bottom:0;left:45px;position:absolute;right:0;top:0;-webkit-transition:.4s;transition:.4s}.toastui-editor-defaultUI-toolbar input:checked+.switch{background-color:#acddfa}.toastui-editor-defaultUI-toolbar .switch:before{background-color:#94979f;border-radius:50%;bottom:-2px;content:"";height:14px;left:0;position:absolute;-webkit-transition:.4s;transition:.4s;width:14px}.toastui-editor-defaultUI-toolbar input:checked+.switch:before{background-color:#00a9ff;-webkit-transform:translateX(12px);-moz-transform:translateX(12px);-ms-transform:translateX(12px);transform:translateX(12px)}.toastui-editor-dropdown-toolbar .scroll-sync{margin:0 5px}.toastui-editor-dropdown-toolbar{background-color:#f7f9fc;border:1px solid #dadde6;border-radius:2px;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);display:-ms-flexbox;display:flex;height:46px;position:absolute;z-index:30}.toastui-editor-toolbar-item-wrapper{height:32px;line-height:32px;margin:7px 5px}.toastui-editor-popup{background:#fff;border:1px solid #dadde6;border-radius:2px;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);margin-right:auto;position:absolute;width:400px;z-index:30}.toastui-editor-popup-body{font-size:12px;padding:15px}.toastui-editor-popup-body label{color:#555;display:block;font-weight:600;margin:20px 0 5px}.toastui-editor-popup-body .toastui-editor-button-container{margin-top:20px;text-align:right}.toastui-editor-popup-body input[type=text]{border:1px solid #e1e3e9;border-radius:2px;color:#333;height:30px;padding:0 12px;width:calc(100% - 26px)}.toastui-editor-popup-body input[type=text]:focus{border-color:transparent;outline:1px solid #00a9ff}.toastui-editor-popup-body input[type=text].disabled{background-color:#f7f9fc;border-color:#e1e3e9;color:#969aa5}.toastui-editor-popup-body input[type=file]{border:none;height:1px;left:0;opacity:0;position:absolute;top:0;width:1px}.toastui-editor-popup-body input.wrong,.toastui-editor-popup-body span.wrong{border-color:#fa2828}.toastui-editor-popup-add-image .toastui-editor-popup-body,.toastui-editor-popup-add-link .toastui-editor-popup-body{padding:0 20px 20px}.toastui-editor-popup-add-image .toastui-editor-tabs{margin:5px 0 10px}.toastui-editor-popup-add-image .toastui-editor-tabs .tab-item{border-bottom:1px solid #dadde6;box-sizing:border-box;color:#333;cursor:pointer;display:inline-block;font-size:13px;font-weight:600;height:40px;line-height:40px;text-align:center;width:60px}.toastui-editor-popup-add-image .toastui-editor-tabs .tab-item:hover{border-bottom:1px solid #cbcfdb}.toastui-editor-popup-add-image .toastui-editor-tabs .tab-item.active{border-bottom:2px solid #00a9ff;color:#00a9ff}.toastui-editor-popup-add-image .toastui-editor-file-name{border:1px solid #e1e3e9;border-radius:2px;color:#dadde6;cursor:pointer;display:inline-block;height:30px;line-height:30px;overflow:hidden;padding:0 12px;text-overflow:ellipsis;white-space:nowrap;width:58%}.toastui-editor-popup-add-image .toastui-editor-file-name.has-file{color:#333}.toastui-editor-popup-add-image .toastui-editor-file-select-button{background-color:#f7f9fc;border:1px solid #dadde6;border-radius:2px;height:32px;margin-left:5px;vertical-align:top;width:33%}.toastui-editor-popup-add-image .toastui-editor-file-select-button:hover{border-color:#cbcfdb}.toastui-editor-popup-add-table{width:auto}.toastui-editor-popup-add-table .toastui-editor-table-selection{position:relative}.toastui-editor-popup-add-table .toastui-editor-table-cell{background:#fff;border:1px solid #e1e3e9;box-sizing:border-box;display:table-cell;height:20px;width:20px}.toastui-editor-popup-add-table .toastui-editor-table-cell.header{background:#f7f9fc}.toastui-editor-popup-add-table .toastui-editor-table-row{display:table-row}.toastui-editor-popup-add-table .toastui-editor-table{border-collapse:collapse;display:table}.toastui-editor-popup-add-table .toastui-editor-table-selection-layer{background:rgba(0,169,255,.1);border:1px solid #00a9ff;left:0;position:absolute;top:0;z-index:30}.toastui-editor-popup-add-table .toastui-editor-table-description{color:#333;margin:5px 0 0;text-align:center}.toastui-editor-popup-add-heading{width:auto}.toastui-editor-popup-add-heading .toastui-editor-popup-body{padding:0}.toastui-editor-popup-add-heading h1,.toastui-editor-popup-add-heading h2,.toastui-editor-popup-add-heading h3,.toastui-editor-popup-add-heading h4,.toastui-editor-popup-add-heading h5,.toastui-editor-popup-add-heading h6,.toastui-editor-popup-add-heading p,.toastui-editor-popup-add-heading ul{margin:0;padding:0}.toastui-editor-popup-add-heading ul{list-style:none;padding:5px 0}.toastui-editor-popup-add-heading ul li{cursor:pointer;padding:4px 12px}.toastui-editor-popup-add-heading ul li:hover{background-color:#dff4ff}.toastui-editor-popup-add-heading h1{font-size:24px}.toastui-editor-popup-add-heading h2{font-size:22px}.toastui-editor-popup-add-heading h3{font-size:20px}.toastui-editor-popup-add-heading h4{font-size:18px}.toastui-editor-popup-add-heading h5{font-size:16px}.toastui-editor-popup-add-heading h6{font-size:14px}.toastui-editor-context-menu{background-color:#fff;border:1px solid #dadde6;border-radius:2px;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);color:#333;min-width:197px;padding:5px 0;position:absolute;width:auto;z-index:30}.toastui-editor-context-menu .menu-group{border-bottom:1px solid #ebedf2;font-size:13px;list-style:none;margin:0;padding:0}.toastui-editor-context-menu .menu-group:last-child{border-bottom:none!important}.toastui-editor-context-menu .menu-item{cursor:pointer;height:32px;line-height:32px;padding:0 14px}.toastui-editor-context-menu span{display:inline-block}.toastui-editor-context-menu span:before{background:url(data:image/png;base64,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) no-repeat;background-size:466px 146px;content:"";display:inline-block;height:20px;margin-right:10px;vertical-align:middle;width:20px}.toastui-editor-context-menu .add-row-up:before{background-position:3px -104px}.toastui-editor-context-menu .add-row-down:before{background-position:-19px -104px}.toastui-editor-context-menu .remove-row:before{background-position:-41px -104px}.toastui-editor-context-menu .add-column-left:before{background-position:-63px -104px}.toastui-editor-context-menu .add-column-right:before{background-position:-85px -104px}.toastui-editor-context-menu .remove-column:before{background-position:-111px -104px}.toastui-editor-context-menu .align-column-left:before{background-position:-129px -104px}.toastui-editor-context-menu .align-column-center:before{background-position:-151px -104px}.toastui-editor-context-menu .align-column-right:before{background-position:-173px -104px}.toastui-editor-context-menu .remove-table:before{background-position:-197px -104px}.toastui-editor-context-menu .disabled span:before{opacity:.3}.toastui-editor-context-menu li:not(.disabled):hover{background-color:#dff4ff}.toastui-editor-context-menu li.disabled{color:#c9ccd5}.toastui-editor-tooltip{background-color:#444;border-radius:3px;color:#fff;font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;font-size:12px;padding:4px 7px;position:absolute;z-index:40}.toastui-editor-tooltip .arrow{background-color:#444;content:"";display:inline-block;height:10px;left:6px;position:absolute;top:-3px;-webkit-transform:rotate(45deg);-moz-transform:rotate(45deg);-ms-transform:rotate(45deg);-o-transform:rotate(45deg);transform:rotate(45deg);width:10px;z-index:-1}.toastui-editor-toolbar-icons{background:url(data:image/png;base64,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) no-repeat;background-size:466px 146px}@media only screen and (-o-min-device-pixel-ratio:2/1),only screen and (-webkit-min-device-pixel-ratio:2),only screen and (min--moz-device-pixel-ratio:2),only screen and (min-device-pixel-ratio:2),only screen and (min-resolution:192dpi),only screen and (min-resolution:2dppx){.toastui-editor-context-menu span:before,.toastui-editor-toolbar-icons{background:url(data:image/png;base64,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) no-repeat;background-size:466px 146px}}.toastui-editor-toolbar-icons{background-position-y:3px}.toastui-editor-toolbar-icons:disabled{opacity:.3}.toastui-editor-toolbar-icons.heading{background-position-x:3px}.toastui-editor-toolbar-icons.bold{background-position-x:-23px}.toastui-editor-toolbar-icons.italic{background-position-x:-49px}.toastui-editor-toolbar-icons.strike{background-position-x:-75px}.toastui-editor-toolbar-icons.hrline{background-position-x:-101px}.toastui-editor-toolbar-icons.quote{background-position-x:-127px}.toastui-editor-toolbar-icons.bullet-list{background-position-x:-153px}.toastui-editor-toolbar-icons.ordered-list{background-position-x:-179px}.toastui-editor-toolbar-icons.task-list{background-position-x:-205px}.toastui-editor-toolbar-icons.indent{background-position-x:-231px}.toastui-editor-toolbar-icons.outdent{background-position-x:-257px}.toastui-editor-toolbar-icons.table{background-position-x:-283px}.toastui-editor-toolbar-icons.image{background-position-x:-309px}.toastui-editor-toolbar-icons.link{background-position-x:-334px}.toastui-editor-toolbar-icons.code{background-position-x:-361px}.toastui-editor-toolbar-icons.codeblock{background-position-x:-388px}.toastui-editor-toolbar-icons.more{background-position-x:-412px}.toastui-editor-toolbar-icons:not(:disabled).active{background-position-y:-23px}@media only screen and (max-width:480px){.toastui-editor-popup{margin-left:-150px;max-width:300px}.toastui-editor-dropdown-toolbar{max-width:none}}.ProseMirror{overflow-X:hidden;color:#222;font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;font-size:13px;height:calc(100% - 36px);overflow-y:auto}.ProseMirror .placeholder{color:#999}.ProseMirror-selectednode,.ProseMirror:focus{outline:none}.html-block.ProseMirror-selectednode,table.ProseMirror-selectednode{border-radius:2px;outline:2px solid #00a9ff}.toastui-editor-contents{font-family:Open Sans,Helvetica Neue,Helvetica,Arial,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif;font-size:13px;margin:0;padding:0;z-index:20}.toastui-editor-contents :not(table){box-sizing:content-box;line-height:160%}.toastui-editor-contents address,.toastui-editor-contents cite,.toastui-editor-contents dfn,.toastui-editor-contents em,.toastui-editor-contents i,.toastui-editor-contents var{font-style:italic}.toastui-editor-contents strong{font-weight:700}.toastui-editor-contents p{color:#222;margin:10px 0}.toastui-editor-contents>div>div:first-of-type h1,.toastui-editor-contents>h1:first-of-type{margin-top:14px}.toastui-editor-contents h1,.toastui-editor-contents h2,.toastui-editor-contents h3,.toastui-editor-contents h4,.toastui-editor-contents h5,.toastui-editor-contents h6{color:#222;font-weight:700}.toastui-editor-contents h1{border-bottom:3px double #999;font-size:24px;line-height:28px;margin:52px 0 15px;padding-bottom:7px}.toastui-editor-contents h2{border-bottom:1px solid #dbdbdb;font-size:22px;line-height:23px;margin:20px 0 13px;padding-bottom:7px}.toastui-editor-contents h3{font-size:20px;margin:18px 0 2px}.toastui-editor-contents h4{font-size:18px;margin:10px 0 2px}.toastui-editor-contents h3,.toastui-editor-contents h4{line-height:18px}.toastui-editor-contents h5{font-size:16px}.toastui-editor-contents h6{font-size:14px}.toastui-editor-contents h5,.toastui-editor-contents h6{line-height:17px;margin:9px 0 -4px}.toastui-editor-contents del{color:#999}.toastui-editor-contents blockquote{border-left:4px solid #e5e5e5;color:#999;margin:14px 0;padding:0 16px}.toastui-editor-contents blockquote ol,.toastui-editor-contents blockquote p,.toastui-editor-contents blockquote ul{color:#999}.toastui-editor-contents blockquote>:first-child{margin-top:0}.toastui-editor-contents blockquote>:last-child{margin-bottom:0}.toastui-editor-contents code,.toastui-editor-contents pre{border:0;border-radius:0;font-family:Consolas,Courier,Apple SD 산돌고딕 Neo,-apple-system,Lucida Grande,Apple SD Gothic Neo,맑은 고딕,Malgun Gothic,Segoe UI,돋움,dotum,sans-serif}.toastui-editor-contents pre{background-color:#f4f7f8;margin:2px 0 8px;padding:18px}.toastui-editor-contents code{background-color:#f9f2f4;border-radius:2px;color:#c1798b;letter-spacing:-.3px;padding:2px 3px}.toastui-editor-contents pre code{background-color:transparent;color:inherit;padding:0;white-space:pre-wrap}.toastui-editor-contents img{box-sizing:border-box;margin:4px 0 10px;max-width:100%;vertical-align:top}.toastui-editor-contents table{border:1px solid rgba(0,0,0,.1);border-collapse:collapse;box-sizing:border-box;color:#222;margin:12px 0 14px;width:auto}.toastui-editor-contents table td,.toastui-editor-contents table th{border:1px solid rgba(0,0,0,.1);height:32px;padding:5px 14px 5px 12px}.toastui-editor-contents table th{background-color:#555;color:#fff;font-weight:300;padding-top:6px}.toastui-editor-contents th p{color:#fff;margin:0}.toastui-editor-contents td p{margin:0;padding:0 2px}.toastui-editor-contents td.toastui-editor-cell-selected{background-color:#d8dfec}.toastui-editor-contents th.toastui-editor-cell-selected{background-color:#908f8f}.toastui-editor-contents dir,.toastui-editor-contents menu,.toastui-editor-contents ol,.toastui-editor-contents ul{color:#222;display:block;list-style-type:none;margin:6px 0 10px;padding-left:24px}.toastui-editor-contents ol{counter-reset:li;list-style-type:none}.toastui-editor-contents ol>li{counter-increment:li}.toastui-editor-contents ol>li:before,.toastui-editor-contents ul>li:before{display:inline-block;position:absolute}.toastui-editor-contents ul>li:before{background-color:#ccc;border-radius:50%;content:"";height:5px;margin-left:-17px;margin-top:6px;width:5px}.toastui-editor-contents ol>li:before{color:#aaa;content:"." counter(li);direction:rtl;margin-left:-28px;text-align:right;width:24px}.toastui-editor-contents ol ol,.toastui-editor-contents ol ul,.toastui-editor-contents ul ol,.toastui-editor-contents ul ul{margin-bottom:0!important;margin-top:0!important}.toastui-editor-contents ol li,.toastui-editor-contents ul li{position:relative}.toastui-editor-contents ol p,.toastui-editor-contents ul p{margin:0}.toastui-editor-contents hr{border-top:1px solid #eee;margin:16px 0}.toastui-editor-contents a{color:#4b96e6;text-decoration:underline}.toastui-editor-contents a:hover{color:#1f70de}.toastui-editor-contents .image-link{position:relative}.toastui-editor-contents .image-link:hover:before{background:#fff url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyMCIgaGVpZ2h0PSIyMCI+PGcgc3Ryb2tlPSIjNTU1IiBzdHJva2Utd2lkdGg9IjEuNSIgZmlsbD0ibm9uZSIgZmlsbC1ydWxlPSJldmVub2RkIiBzdHJva2UtbGluZWNhcD0icm91bmQiPjxwYXRoIGQ9Im01LjY4NyAxMC4yOTQtMS4yODUgMS4yODhjLTEuMDUgMS4wNS0xLjAzNSAyLjc3Mi4wMzcgMy44NDRsLjEzNS4xMzVjMS4wNzIgMS4wNzIgMi43OTQgMS4wODggMy44NDQuMDM3bDIuNzItMi43MmMxLjA1MS0xLjA1IDEuMDM0LTIuNzcyLS4wMzctMy44NDNsLS4xMzYtLjEzNiIvPjxwYXRoIGQ9Im0xNC4zMDUgOS43MTMgMS4yODctMS4yOWMxLjA1Mi0xLjA1MSAxLjAzNi0yLjc3My0uMDM2LTMuODQ0bC0uMTM1LS4xMzZjLTEuMDcyLTEuMDcyLTIuNzk0LTEuMDg4LTMuODQ1LS4wMzZMOC44NTcgNy4xMjZjLTEuMDUxIDEuMDUxLTEuMDM0IDIuNzcyLjAzNyAzLjg0M2wuMTM2LjEzNiIvPjwvZz48L3N2Zz4=) no-repeat;background-position:50%;border:1px solid #c9ccd5;border-radius:50%;box-shadow:0 2px 4px 0 rgba(0,0,0,.08);content:"";cursor:pointer;height:30px;position:absolute;right:0;width:30px}.toastui-editor-contents .task-list-item{border:0;list-style:none;margin-left:-24px;padding-left:24px}.toastui-editor-contents .task-list-item:before{background-position:50%;background-repeat:no-repeat;background-size:18px 18px;background:transparent url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxOCIgaGVpZ2h0PSIxOCI+PHJlY3Qgd2lkdGg9IjE3IiBoZWlnaHQ9IjE3IiB4PSIuNSIgeT0iLjUiIHJ4PSIyIiBmaWxsPSIjRkZGIiBzdHJva2U9IiNDQ0MiIGZpbGwtcnVsZT0iZXZlbm9kZCIvPjwvc3ZnPg==);border-radius:2px;content:"";cursor:pointer;height:18px;left:0;margin-left:0;margin-top:0;position:absolute;top:1px;width:18px}.toastui-editor-contents .task-list-item.checked:before{background-image:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxOCIgaGVpZ2h0PSIxOCI+PHBhdGggZD0iTTE2IDBhMiAyIDAgMCAxIDIgMnYxNGEyIDIgMCAwIDEtMiAySDJhMiAyIDAgMCAxLTItMlYyYTIgMiAwIDAgMSAyLTJoMTR6bS0xLjc5MyA1LjI5M2ExIDEgMCAwIDAtMS40MTQgMEw3LjUgMTAuNTg1IDUuMjA3IDguMjkzbC0uMDk0LS4wODNhMSAxIDAgMCAwLTEuMzIgMS40OTdsMyAzIC4wOTQuMDgzYTEgMSAwIDAgMCAxLjMyLS4wODNsNi02IC4wODMtLjA5NGExIDEgMCAwIDAtLjA4My0xLjMyeiIgZmlsbD0iIzRCOTZFNiIgZmlsbC1ydWxlPSJldmVub2RkIi8+PC9zdmc+)}.toastui-editor-custom-block .toastui-editor-custom-block-editor{background:#f9f7fd;border:1px solid #dbd4ea;color:#452d6b}.toastui-editor-custom-block .toastui-editor-custom-block-view{padding:9px 13px 8px 12px;position:relative}.toastui-editor-custom-block.ProseMirror-selectednode .toastui-editor-custom-block-view{border:1px solid #dbd4ea;border-radius:2px}.toastui-editor-custom-block .toastui-editor-custom-block-view .tool{display:none;position:absolute;right:10px;top:7px}.toastui-editor-custom-block.ProseMirror-selectednode .toastui-editor-custom-block-view .tool{display:block}.toastui-editor-custom-block-view button{background:url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMCAzMCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMzAgMzAiIHhtbDpzcGFjZT0icHJlc2VydmUiPjxwYXRoIGQ9Im0xNS41IDEyLjUgMiAyTDEyIDIwaC0ydi0ybDUuNS01LjV6TTE4IDEwbDIgMi0xLjUgMS41LTItMkwxOCAxMHoiIHN0eWxlPSJmaWxsLXJ1bGU6ZXZlbm9kZDtjbGlwLXJ1bGU6ZXZlbm9kZDtmaWxsOiM1NTUiLz48L3N2Zz4=) no-repeat;background-position:50%;background-size:30px 30px;border:1px solid #ccc;height:15px;margin-left:8px;padding:3px;vertical-align:middle;width:15px}.toastui-editor-custom-block-view .info{color:#5200d0;font-size:13px;font-weight:700;vertical-align:middle}.toastui-editor-contents .toastui-editor-ww-code-block{position:relative}.toastui-editor-contents .toastui-editor-ww-code-block:after{background:#e5e9ea url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMCAzMCIgc3R5bGU9ImVuYWJsZS1iYWNrZ3JvdW5kOm5ldyAwIDAgMzAgMzAiIHhtbDpzcGFjZT0icHJlc2VydmUiPjxwYXRoIGQ9Im0xNS41IDEyLjUgMiAyTDEyIDIwaC0ydi0ybDUuNS01LjV6TTE4IDEwbDIgMi0xLjUgMS41LTItMkwxOCAxMHoiIHN0eWxlPSJmaWxsLXJ1bGU6ZXZlbm9kZDtjbGlwLXJ1bGU6ZXZlbm9kZDtmaWxsOiM1NTUiLz48L3N2Zz4=) no-repeat;background-position:100%;background-size:30px 30px;border-radius:2px;color:#333;content:attr(data-language);cursor:pointer;display:inline-block;font-size:13px;font-weight:700;height:24px;padding:3px 35px 0 10px;position:absolute;right:10px;top:10px}.toastui-editor-ww-code-block-language{background-color:#fff;border:1px solid #ccc;border-radius:2px;display:inline-block;height:27px;position:fixed;right:35px;width:100px;z-index:30}.toastui-editor-ww-code-block-language input{background-color:transparent;border:none;box-sizing:border-box;height:100%;margin:0;outline:none;padding:0 10px;width:100%}.toastui-editor-contents-placeholder:before{color:grey;content:attr(data-placeholder);line-height:160%;position:absolute}.toastui-editor-md-preview .toastui-editor-contents h1{min-height:28px}.toastui-editor-md-preview .toastui-editor-contents h2{min-height:23px}.toastui-editor-md-preview .toastui-editor-contents blockquote{min-height:20px}.toastui-editor-md-preview .toastui-editor-contents li{min-height:22px}.toastui-editor-pseudo-clipboard{height:0;left:-1000px;opacity:0;position:fixed;top:-1000px;width:0;z-index:-1}.toastui-editor-contents .toastui-editor-md-preview-highlight{position:relative;z-index:0}.toastui-editor-contents .toastui-editor-md-preview-highlight:after{background-color:rgba(255,245,131,.5);border-radius:4px;bottom:-4px;content:"";left:-4px;position:absolute;right:-4px;top:-4px;z-index:-1}.toastui-editor-contents h1.toastui-editor-md-preview-highlight:after,.toastui-editor-contents h2.toastui-editor-md-preview-highlight:after{bottom:0}.toastui-editor-contents td.toastui-editor-md-preview-highlight:after,.toastui-editor-contents th.toastui-editor-md-preview-highlight:after{display:none}.toastui-editor-contents td.toastui-editor-md-preview-highlight,.toastui-editor-contents th.toastui-editor-md-preview-highlight{background-color:rgba(255,245,131,.5)}.toastui-editor-contents th.toastui-editor-md-preview-highlight{color:#222}.toastui-editor-md-heading1{font-size:24px}.toastui-editor-md-heading2{font-size:22px}.toastui-editor-md-heading3{font-size:20px}.toastui-editor-md-heading4{font-size:18px}.toastui-editor-md-heading5{font-size:16px}.toastui-editor-md-heading6{font-size:14px}.toastui-editor-md-heading.toastui-editor-md-delimiter.setext{line-height:15px}.toastui-editor-md-heading,.toastui-editor-md-list-item .toastui-editor-md-meta,.toastui-editor-md-list-item-style,.toastui-editor-md-strong{font-weight:700}.toastui-editor-md-emph{font-style:italic}.toastui-editor-md-strike{text-decoration:line-through}.toastui-editor-md-strike.toastui-editor-md-delimiter{text-decoration:none}.toastui-editor-md-block-quote,.toastui-editor-md-delimiter,.toastui-editor-md-link,.toastui-editor-md-table,.toastui-editor-md-thematic-break{color:#ccc}.toastui-editor-md-code.toastui-editor-md-delimiter{color:#aaa}.toastui-editor-md-html,.toastui-editor-md-link.toastui-editor-md-link-url.toastui-editor-md-marked-text,.toastui-editor-md-meta{color:#999}.toastui-editor-md-block-quote .toastui-editor-md-marked-text,.toastui-editor-md-list-item .toastui-editor-md-meta{color:#555}.toastui-editor-md-table .toastui-editor-md-table-cell{color:#222}.toastui-editor-md-link.toastui-editor-md-link-desc.toastui-editor-md-marked-text,.toastui-editor-md-list-item-style.toastui-editor-md-list-item-odd{color:#4b96e6}.toastui-editor-md-list-item-style.toastui-editor-md-list-item-even{color:#cb4848}.toastui-editor-md-code.toastui-editor-md-marked-text{color:#c1798b}.toastui-editor-md-code{background-color:rgba(243,229,233,.5);letter-spacing:-.3px;padding:2px 0}.toastui-editor-md-code.toastui-editor-md-start{border-bottom-left-radius:2px;border-top-left-radius:2px;padding-left:2px}.toastui-editor-md-code.toastui-editor-md-end{border-bottom-right-radius:2px;border-top-right-radius:2px;padding-right:2px}.toastui-editor-md-code-block-line-background{background-color:#f5f7f8}.toastui-editor-md-code-block-line-background.start,.toastui-editor-md-custom-block-line-background.start{margin-top:2px}.toastui-editor-md-code,.toastui-editor-md-code-block{font-family:Consolas,Courier,Lucida Grande,나눔바른고딕,Nanum Barun Gothic,맑은고딕,Malgun Gothic,sans-serif}.toastui-editor-md-custom-block{color:#452d6b}.toastui-editor-md-custom-block-line-background{background-color:#f9f7fd}.toastui-editor-md-custom-block .toastui-editor-md-delimiter{color:#b8b3c0}.toastui-editor-md-custom-block .toastui-editor-md-meta{color:#5200d0}
+</style>
+<script>
+/*!
+ * @toast-ui/editor
+ * @version 3.2.2 | Fri Feb 17 2023
+ * @author NHN Cloud FE Development Lab <dl_javascript@nhn.com>
+ * @license MIT
+ */
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.toastui=t():(e.toastui=e.toastui||{},e.toastui.Editor=t())}(self,(function(){return function(){var e={368:function(e){
+/*! @license DOMPurify 2.3.3 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.3.3/LICENSE */
+e.exports=function(){"use strict";function e(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}var t=Object.hasOwnProperty,n=Object.setPrototypeOf,r=Object.isFrozen,o=Object.getPrototypeOf,i=Object.getOwnPropertyDescriptor,s=Object.freeze,a=Object.seal,l=Object.create,c="undefined"!=typeof Reflect&&Reflect,u=c.apply,d=c.construct;u||(u=function(e,t,n){return e.apply(t,n)}),s||(s=function(e){return e}),a||(a=function(e){return e}),d||(d=function(t,n){return new(Function.prototype.bind.apply(t,[null].concat(e(n))))});var p=x(Array.prototype.forEach),h=x(Array.prototype.pop),f=x(Array.prototype.push),m=x(String.prototype.toLowerCase),g=x(String.prototype.match),v=x(String.prototype.replace),y=x(String.prototype.indexOf),b=x(String.prototype.trim),w=x(RegExp.prototype.test),k=C(TypeError);function x(e){return function(t){for(var n=arguments.length,r=Array(n>1?n-1:0),o=1;o<n;o++)r[o-1]=arguments[o];return u(e,t,r)}}function C(e){return function(){for(var t=arguments.length,n=Array(t),r=0;r<t;r++)n[r]=arguments[r];return d(e,n)}}function T(e,t){n&&n(e,null);for(var o=t.length;o--;){var i=t[o];if("string"==typeof i){var s=m(i);s!==i&&(r(t)||(t[o]=s),i=s)}e[i]=!0}return e}function M(e){var n=l(null),r=void 0;for(r in e)u(t,e,[r])&&(n[r]=e[r]);return n}function S(e,t){for(;null!==e;){var n=i(e,t);if(n){if(n.get)return x(n.get);if("function"==typeof n.value)return x(n.value)}e=o(e)}function r(e){return console.warn("fallback value for",e),null}return r}var E=s(["a","abbr","acronym","address","area","article","aside","audio","b","bdi","bdo","big","blink","blockquote","body","br","button","canvas","caption","center","cite","code","col","colgroup","content","data","datalist","dd","decorator","del","details","dfn","dialog","dir","div","dl","dt","element","em","fieldset","figcaption","figure","font","footer","form","h1","h2","h3","h4","h5","h6","head","header","hgroup","hr","html","i","img","input","ins","kbd","label","legend","li","main","map","mark","marquee","menu","menuitem","meter","nav","nobr","ol","optgroup","option","output","p","picture","pre","progress","q","rp","rt","ruby","s","samp","section","select","shadow","small","source","spacer","span","strike","strong","style","sub","summary","sup","table","tbody","td","template","textarea","tfoot","th","thead","time","tr","track","tt","u","ul","var","video","wbr"]),N=s(["svg","a","altglyph","altglyphdef","altglyphitem","animatecolor","animatemotion","animatetransform","circle","clippath","defs","desc","ellipse","filter","font","g","glyph","glyphref","hkern","image","line","lineargradient","marker","mask","metadata","mpath","path","pattern","polygon","polyline","radialgradient","rect","stop","style","switch","symbol","text","textpath","title","tref","tspan","view","vkern"]),O=s(["feBlend","feColorMatrix","feComponentTransfer","feComposite","feConvolveMatrix","feDiffuseLighting","feDisplacementMap","feDistantLight","feFlood","feFuncA","feFuncB","feFuncG","feFuncR","feGaussianBlur","feMerge","feMergeNode","feMorphology","feOffset","fePointLight","feSpecularLighting","feSpotLight","feTile","feTurbulence"]),D=s(["animate","color-profile","cursor","discard","fedropshadow","feimage","font-face","font-face-format","font-face-name","font-face-src","font-face-uri","foreignobject","hatch","hatchpath","mesh","meshgradient","meshpatch","meshrow","missing-glyph","script","set","solidcolor","unknown","use"]),A=s(["math","menclose","merror","mfenced","mfrac","mglyph","mi","mlabeledtr","mmultiscripts","mn","mo","mover","mpadded","mphantom","mroot","mrow","ms","mspace","msqrt","mstyle","msub","msup","msubsup","mtable","mtd","mtext","mtr","munder","munderover"]),L=s(["maction","maligngroup","malignmark","mlongdiv","mscarries","mscarry","msgroup","mstack","msline","msrow","semantics","annotation","annotation-xml","mprescripts","none"]),I=s(["#text"]),R=s(["accept","action","align","alt","autocapitalize","autocomplete","autopictureinpicture","autoplay","background","bgcolor","border","capture","cellpadding","cellspacing","checked","cite","class","clear","color","cols","colspan","controls","controlslist","coords","crossorigin","datetime","decoding","default","dir","disabled","disablepictureinpicture","disableremoteplayback","download","draggable","enctype","enterkeyhint","face","for","headers","height","hidden","high","href","hreflang","id","inputmode","integrity","ismap","kind","label","lang","list","loading","loop","low","max","maxlength","media","method","min","minlength","multiple","muted","name","noshade","novalidate","nowrap","open","optimum","pattern","placeholder","playsinline","poster","preload","pubdate","radiogroup","readonly","rel","required","rev","reversed","role","rows","rowspan","spellcheck","scope","selected","shape","size","sizes","span","srclang","start","src","srcset","step","style","summary","tabindex","title","translate","type","usemap","valign","value","width","xmlns","slot"]),P=s(["accent-height","accumulate","additive","alignment-baseline","ascent","attributename","attributetype","azimuth","basefrequency","baseline-shift","begin","bias","by","class","clip","clippathunits","clip-path","clip-rule","color","color-interpolation","color-interpolation-filters","color-profile","color-rendering","cx","cy","d","dx","dy","diffuseconstant","direction","display","divisor","dur","edgemode","elevation","end","fill","fill-opacity","fill-rule","filter","filterunits","flood-color","flood-opacity","font-family","font-size","font-size-adjust","font-stretch","font-style","font-variant","font-weight","fx","fy","g1","g2","glyph-name","glyphref","gradientunits","gradienttransform","height","href","id","image-rendering","in","in2","k","k1","k2","k3","k4","kerning","keypoints","keysplines","keytimes","lang","lengthadjust","letter-spacing","kernelmatrix","kernelunitlength","lighting-color","local","marker-end","marker-mid","marker-start","markerheight","markerunits","markerwidth","maskcontentunits","maskunits","max","mask","media","method","mode","min","name","numoctaves","offset","operator","opacity","order","orient","orientation","origin","overflow","paint-order","path","pathlength","patterncontentunits","patterntransform","patternunits","points","preservealpha","preserveaspectratio","primitiveunits","r","rx","ry","radius","refx","refy","repeatcount","repeatdur","restart","result","rotate","scale","seed","shape-rendering","specularconstant","specularexponent","spreadmethod","startoffset","stddeviation","stitchtiles","stop-color","stop-opacity","stroke-dasharray","stroke-dashoffset","stroke-linecap","stroke-linejoin","stroke-miterlimit","stroke-opacity","stroke","stroke-width","style","surfacescale","systemlanguage","tabindex","targetx","targety","transform","text-anchor","text-decoration","text-rendering","textlength","type","u1","u2","unicode","values","viewbox","visibility","version","vert-adv-y","vert-origin-x","vert-origin-y","width","word-spacing","wrap","writing-mode","xchannelselector","ychannelselector","x","x1","x2","xmlns","y","y1","y2","z","zoomandpan"]),B=s(["accent","accentunder","align","bevelled","close","columnsalign","columnlines","columnspan","denomalign","depth","dir","display","displaystyle","encoding","fence","frame","height","href","id","largeop","length","linethickness","lspace","lquote","mathbackground","mathcolor","mathsize","mathvariant","maxsize","minsize","movablelimits","notation","numalign","open","rowalign","rowlines","rowspacing","rowspan","rspace","rquote","scriptlevel","scriptminsize","scriptsizemultiplier","selection","separator","separators","stretchy","subscriptshift","supscriptshift","symmetric","voffset","width","xmlns"]),F=s(["xlink:href","xml:id","xlink:title","xml:space","xmlns:xlink"]),H=a(/\{\{[\s\S]*|[\s\S]*\}\}/gm),z=a(/<%[\s\S]*|[\s\S]*%>/gm),q=a(/^data-[\-\w.\u00B7-\uFFFF]/),V=a(/^aria-[\-\w]+$/),j=a(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i),$=a(/^(?:\w+script|data):/i),_=a(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),U="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e};function W(e){if(Array.isArray(e)){for(var t=0,n=Array(e.length);t<e.length;t++)n[t]=e[t];return n}return Array.from(e)}var J=function(){return"undefined"==typeof window?null:window},G=function(e,t){if("object"!==(void 0===e?"undefined":U(e))||"function"!=typeof e.createPolicy)return null;var n=null,r="data-tt-policy-suffix";t.currentScript&&t.currentScript.hasAttribute(r)&&(n=t.currentScript.getAttribute(r));var o="dompurify"+(n?"#"+n:"");try{return e.createPolicy(o,{createHTML:function(e){return e}})}catch(e){return console.warn("TrustedTypes policy "+o+" could not be created."),null}};function K(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:J(),t=function(e){return K(e)};if(t.version="2.3.3",t.removed=[],!e||!e.document||9!==e.document.nodeType)return t.isSupported=!1,t;var n=e.document,r=e.document,o=e.DocumentFragment,i=e.HTMLTemplateElement,a=e.Node,l=e.Element,c=e.NodeFilter,u=e.NamedNodeMap,d=void 0===u?e.NamedNodeMap||e.MozNamedAttrMap:u,x=e.Text,C=e.Comment,Z=e.DOMParser,X=e.trustedTypes,Q=l.prototype,Y=S(Q,"cloneNode"),ee=S(Q,"nextSibling"),te=S(Q,"childNodes"),ne=S(Q,"parentNode");if("function"==typeof i){var re=r.createElement("template");re.content&&re.content.ownerDocument&&(r=re.content.ownerDocument)}var oe=G(X,n),ie=oe&&Fe?oe.createHTML(""):"",se=r,ae=se.implementation,le=se.createNodeIterator,ce=se.createDocumentFragment,ue=se.getElementsByTagName,de=n.importNode,pe={};try{pe=M(r).documentMode?r.documentMode:{}}catch(e){}var he={};t.isSupported="function"==typeof ne&&ae&&void 0!==ae.createHTMLDocument&&9!==pe;var fe=H,me=z,ge=q,ve=V,ye=$,be=_,we=j,ke=null,xe=T({},[].concat(W(E),W(N),W(O),W(A),W(I))),Ce=null,Te=T({},[].concat(W(R),W(P),W(B),W(F))),Me=null,Se=null,Ee=!0,Ne=!0,Oe=!1,De=!1,Ae=!1,Le=!1,Ie=!1,Re=!1,Pe=!1,Be=!0,Fe=!1,He=!0,ze=!0,qe=!1,Ve={},je=null,$e=T({},["annotation-xml","audio","colgroup","desc","foreignobject","head","iframe","math","mi","mn","mo","ms","mtext","noembed","noframes","noscript","plaintext","script","style","svg","template","thead","title","video","xmp"]),_e=null,Ue=T({},["audio","video","img","source","image","track"]),We=null,Je=T({},["alt","class","for","id","label","name","pattern","placeholder","role","summary","title","value","style","xmlns"]),Ge="http://www.w3.org/1998/Math/MathML",Ke="http://www.w3.org/2000/svg",Ze="http://www.w3.org/1999/xhtml",Xe=Ze,Qe=!1,Ye=void 0,et=["application/xhtml+xml","text/html"],tt="text/html",nt=void 0,rt=null,ot=r.createElement("form"),it=function(e){rt&&rt===e||(e&&"object"===(void 0===e?"undefined":U(e))||(e={}),e=M(e),ke="ALLOWED_TAGS"in e?T({},e.ALLOWED_TAGS):xe,Ce="ALLOWED_ATTR"in e?T({},e.ALLOWED_ATTR):Te,We="ADD_URI_SAFE_ATTR"in e?T(M(Je),e.ADD_URI_SAFE_ATTR):Je,_e="ADD_DATA_URI_TAGS"in e?T(M(Ue),e.ADD_DATA_URI_TAGS):Ue,je="FORBID_CONTENTS"in e?T({},e.FORBID_CONTENTS):$e,Me="FORBID_TAGS"in e?T({},e.FORBID_TAGS):{},Se="FORBID_ATTR"in e?T({},e.FORBID_ATTR):{},Ve="USE_PROFILES"in e&&e.USE_PROFILES,Ee=!1!==e.ALLOW_ARIA_ATTR,Ne=!1!==e.ALLOW_DATA_ATTR,Oe=e.ALLOW_UNKNOWN_PROTOCOLS||!1,De=e.SAFE_FOR_TEMPLATES||!1,Ae=e.WHOLE_DOCUMENT||!1,Re=e.RETURN_DOM||!1,Pe=e.RETURN_DOM_FRAGMENT||!1,Be=!1!==e.RETURN_DOM_IMPORT,Fe=e.RETURN_TRUSTED_TYPE||!1,Ie=e.FORCE_BODY||!1,He=!1!==e.SANITIZE_DOM,ze=!1!==e.KEEP_CONTENT,qe=e.IN_PLACE||!1,we=e.ALLOWED_URI_REGEXP||we,Xe=e.NAMESPACE||Ze,Ye=Ye=-1===et.indexOf(e.PARSER_MEDIA_TYPE)?tt:e.PARSER_MEDIA_TYPE,nt="application/xhtml+xml"===Ye?function(e){return e}:m,De&&(Ne=!1),Pe&&(Re=!0),Ve&&(ke=T({},[].concat(W(I))),Ce=[],!0===Ve.html&&(T(ke,E),T(Ce,R)),!0===Ve.svg&&(T(ke,N),T(Ce,P),T(Ce,F)),!0===Ve.svgFilters&&(T(ke,O),T(Ce,P),T(Ce,F)),!0===Ve.mathMl&&(T(ke,A),T(Ce,B),T(Ce,F))),e.ADD_TAGS&&(ke===xe&&(ke=M(ke)),T(ke,e.ADD_TAGS)),e.ADD_ATTR&&(Ce===Te&&(Ce=M(Ce)),T(Ce,e.ADD_ATTR)),e.ADD_URI_SAFE_ATTR&&T(We,e.ADD_URI_SAFE_ATTR),e.FORBID_CONTENTS&&(je===$e&&(je=M(je)),T(je,e.FORBID_CONTENTS)),ze&&(ke["#text"]=!0),Ae&&T(ke,["html","head","body"]),ke.table&&(T(ke,["tbody"]),delete Me.tbody),s&&s(e),rt=e)},st=T({},["mi","mo","mn","ms","mtext"]),at=T({},["foreignobject","desc","title","annotation-xml"]),lt=T({},N);T(lt,O),T(lt,D);var ct=T({},A);T(ct,L);var ut=function(e){var t=ne(e);t&&t.tagName||(t={namespaceURI:Ze,tagName:"template"});var n=m(e.tagName),r=m(t.tagName);if(e.namespaceURI===Ke)return t.namespaceURI===Ze?"svg"===n:t.namespaceURI===Ge?"svg"===n&&("annotation-xml"===r||st[r]):Boolean(lt[n]);if(e.namespaceURI===Ge)return t.namespaceURI===Ze?"math"===n:t.namespaceURI===Ke?"math"===n&&at[r]:Boolean(ct[n]);if(e.namespaceURI===Ze){if(t.namespaceURI===Ke&&!at[r])return!1;if(t.namespaceURI===Ge&&!st[r])return!1;var o=T({},["title","style","font","a","script"]);return!ct[n]&&(o[n]||!lt[n])}return!1},dt=function(e){f(t.removed,{element:e});try{e.parentNode.removeChild(e)}catch(t){try{e.outerHTML=ie}catch(t){e.remove()}}},pt=function(e,n){try{f(t.removed,{attribute:n.getAttributeNode(e),from:n})}catch(e){f(t.removed,{attribute:null,from:n})}if(n.removeAttribute(e),"is"===e&&!Ce[e])if(Re||Pe)try{dt(n)}catch(e){}else try{n.setAttribute(e,"")}catch(e){}},ht=function(e){var t=void 0,n=void 0;if(Ie)e="<remove></remove>"+e;else{var o=g(e,/^[\r\n\t ]+/);n=o&&o[0]}"application/xhtml+xml"===Ye&&(e='<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>'+e+"</body></html>");var i=oe?oe.createHTML(e):e;if(Xe===Ze)try{t=(new Z).parseFromString(i,Ye)}catch(e){}if(!t||!t.documentElement){t=ae.createDocument(Xe,"template",null);try{t.documentElement.innerHTML=Qe?"":i}catch(e){}}var s=t.body||t.documentElement;return e&&n&&s.insertBefore(r.createTextNode(n),s.childNodes[0]||null),Xe===Ze?ue.call(t,Ae?"html":"body")[0]:Ae?t.documentElement:s},ft=function(e){return le.call(e.ownerDocument||e,e,c.SHOW_ELEMENT|c.SHOW_COMMENT|c.SHOW_TEXT,null,!1)},mt=function(e){return!(e instanceof x||e instanceof C||"string"==typeof e.nodeName&&"string"==typeof e.textContent&&"function"==typeof e.removeChild&&e.attributes instanceof d&&"function"==typeof e.removeAttribute&&"function"==typeof e.setAttribute&&"string"==typeof e.namespaceURI&&"function"==typeof e.insertBefore)},gt=function(e){return"object"===(void 0===a?"undefined":U(a))?e instanceof a:e&&"object"===(void 0===e?"undefined":U(e))&&"number"==typeof e.nodeType&&"string"==typeof e.nodeName},vt=function(e,n,r){he[e]&&p(he[e],(function(e){e.call(t,n,r,rt)}))},yt=function(e){var n=void 0;if(vt("beforeSanitizeElements",e,null),mt(e))return dt(e),!0;if(g(e.nodeName,/[\u0080-\uFFFF]/))return dt(e),!0;var r=nt(e.nodeName);if(vt("uponSanitizeElement",e,{tagName:r,allowedTags:ke}),!gt(e.firstElementChild)&&(!gt(e.content)||!gt(e.content.firstElementChild))&&w(/<[/\w]/g,e.innerHTML)&&w(/<[/\w]/g,e.textContent))return dt(e),!0;if("select"===r&&w(/<template/i,e.innerHTML))return dt(e),!0;if(!ke[r]||Me[r]){if(ze&&!je[r]){var o=ne(e)||e.parentNode,i=te(e)||e.childNodes;if(i&&o)for(var s=i.length-1;s>=0;--s)o.insertBefore(Y(i[s],!0),ee(e))}return dt(e),!0}return e instanceof l&&!ut(e)?(dt(e),!0):"noscript"!==r&&"noembed"!==r||!w(/<\/no(script|embed)/i,e.innerHTML)?(De&&3===e.nodeType&&(n=e.textContent,n=v(n,fe," "),n=v(n,me," "),e.textContent!==n&&(f(t.removed,{element:e.cloneNode()}),e.textContent=n)),vt("afterSanitizeElements",e,null),!1):(dt(e),!0)},bt=function(e,t,n){if(He&&("id"===t||"name"===t)&&(n in r||n in ot))return!1;if(Ne&&!Se[t]&&w(ge,t));else if(Ee&&w(ve,t));else{if(!Ce[t]||Se[t])return!1;if(We[t]);else if(w(we,v(n,be,"")));else if("src"!==t&&"xlink:href"!==t&&"href"!==t||"script"===e||0!==y(n,"data:")||!_e[e])if(Oe&&!w(ye,v(n,be,"")));else if(n)return!1}return!0},wt=function(e){var n=void 0,r=void 0,o=void 0,i=void 0;vt("beforeSanitizeAttributes",e,null);var s=e.attributes;if(s){var a={attrName:"",attrValue:"",keepAttr:!0,allowedAttributes:Ce};for(i=s.length;i--;){var l=n=s[i],c=l.name,u=l.namespaceURI;if(r=b(n.value),o=nt(c),a.attrName=o,a.attrValue=r,a.keepAttr=!0,a.forceKeepAttr=void 0,vt("uponSanitizeAttribute",e,a),r=a.attrValue,!a.forceKeepAttr&&(pt(c,e),a.keepAttr))if(w(/\/>/i,r))pt(c,e);else{De&&(r=v(r,fe," "),r=v(r,me," "));var d=nt(e.nodeName);if(bt(d,o,r))try{u?e.setAttributeNS(u,c,r):e.setAttribute(c,r),h(t.removed)}catch(e){}}}vt("afterSanitizeAttributes",e,null)}},kt=function e(t){var n=void 0,r=ft(t);for(vt("beforeSanitizeShadowDOM",t,null);n=r.nextNode();)vt("uponSanitizeShadowNode",n,null),yt(n)||(n.content instanceof o&&e(n.content),wt(n));vt("afterSanitizeShadowDOM",t,null)};return t.sanitize=function(r,i){var s=void 0,l=void 0,c=void 0,u=void 0,d=void 0;if((Qe=!r)&&(r="\x3c!--\x3e"),"string"!=typeof r&&!gt(r)){if("function"!=typeof r.toString)throw k("toString is not a function");if("string"!=typeof(r=r.toString()))throw k("dirty is not a string, aborting")}if(!t.isSupported){if("object"===U(e.toStaticHTML)||"function"==typeof e.toStaticHTML){if("string"==typeof r)return e.toStaticHTML(r);if(gt(r))return e.toStaticHTML(r.outerHTML)}return r}if(Le||it(i),t.removed=[],"string"==typeof r&&(qe=!1),qe);else if(r instanceof a)1===(l=(s=ht("\x3c!----\x3e")).ownerDocument.importNode(r,!0)).nodeType&&"BODY"===l.nodeName||"HTML"===l.nodeName?s=l:s.appendChild(l);else{if(!Re&&!De&&!Ae&&-1===r.indexOf("<"))return oe&&Fe?oe.createHTML(r):r;if(!(s=ht(r)))return Re?null:ie}s&&Ie&&dt(s.firstChild);for(var p=ft(qe?r:s);c=p.nextNode();)3===c.nodeType&&c===u||yt(c)||(c.content instanceof o&&kt(c.content),wt(c),u=c);if(u=null,qe)return r;if(Re){if(Pe)for(d=ce.call(s.ownerDocument);s.firstChild;)d.appendChild(s.firstChild);else d=s;return Be&&(d=de.call(n,d,!0)),d}var h=Ae?s.outerHTML:s.innerHTML;return De&&(h=v(h,fe," "),h=v(h,me," ")),oe&&Fe?oe.createHTML(h):h},t.setConfig=function(e){it(e),Le=!0},t.clearConfig=function(){rt=null,Le=!1},t.isValidAttribute=function(e,t,n){rt||it({});var r=nt(e),o=nt(t);return bt(r,o,n)},t.addHook=function(e,t){"function"==typeof t&&(he[e]=he[e]||[],f(he[e],t))},t.removeHook=function(e){he[e]&&h(he[e])},t.removeHooks=function(e){he[e]&&(he[e]=[])},t.removeAllHooks=function(){he={}},t}return K()}()},928:function(e,t,n){"use strict";var r=n(322);e.exports=function(e,t,n){var o,i;if(n=n||0,!r(t))return-1;if(Array.prototype.indexOf)return Array.prototype.indexOf.call(t,e,n);for(i=t.length,o=n;n>=0&&o<i;o+=1)if(t[o]===e)return o;return-1}},690:function(e,t,n){"use strict";var r=n(322),o=n(893),i=n(956);e.exports=function(e,t,n){r(e)?o(e,t,n):i(e,t,n)}},893:function(e){"use strict";e.exports=function(e,t,n){var r=0,o=e.length;for(n=n||null;r<o&&!1!==t.call(n,e[r],r,e);r+=1);}},956:function(e){"use strict";e.exports=function(e,t,n){var r;for(r in n=n||null,e)if(e.hasOwnProperty(r)&&!1===t.call(n,e[r],r,e))break}},354:function(e,t,n){"use strict";var r=n(893);e.exports=function(e){var t;try{t=Array.prototype.slice.call(e)}catch(n){t=[],r(e,(function(e){t.push(e)}))}return t}},755:function(e){"use strict";var t="_feEventKey";e.exports=function(e,n){var r,o=e[t];return o||(o=e[t]={}),(r=o[n])||(r=o[n]=[]),r}},349:function(e,t,n){"use strict";var r=n(758),o=n(690),i=n(755);function s(e,t,n){var r,s=i(e,t);n?(o(s,(function(o,i){return n!==o.handler||(a(e,t,o.wrappedHandler),r=i,!1)})),s.splice(r,1)):(o(s,(function(n){a(e,t,n.wrappedHandler)})),s.splice(0,s.length))}function a(e,t,n){"removeEventListener"in e?e.removeEventListener(t,n):"detachEvent"in e&&e.detachEvent("on"+t,n)}e.exports=function(e,t,n){r(t)?o(t.split(/\s+/g),(function(t){s(e,t,n)})):o(t,(function(t,n){s(e,n,t)}))}},348:function(e,t,n){"use strict";var r=n(758),o=n(690),i=n(755);function s(e,t,n,r){function s(t){n.call(r||e,t||window.event)}"addEventListener"in e?e.addEventListener(t,s):"attachEvent"in e&&e.attachEvent("on"+t,s),function(e,t,n,r){var s=i(e,t),a=!1;o(s,(function(e){return e.handler!==n||(a=!0,!1)})),a||s.push({handler:n,wrappedHandler:r})}(e,t,n,s)}e.exports=function(e,t,n,i){r(t)?o(t.split(/\s+/g),(function(t){s(e,t,n,i)})):o(t,(function(t,r){s(e,r,t,n)}))}},24:function(e,t,n){"use strict";var r=n(322),o=n(929);e.exports=function(e,t){t=(t=r(t)?t.join(" "):t).replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,""),o(e.className.baseVal)?e.className=t:e.className.baseVal=t}},204:function(e,t,n){"use strict";var r=n(690),o=n(928),i=n(902),s=n(24);e.exports=function(e){var t,n=Array.prototype.slice.call(arguments,1),a=e.classList,l=[];a?r(n,(function(t){e.classList.add(t)})):((t=i(e))&&(n=[].concat(t.split(/\s+/),n)),r(n,(function(e){o(e,l)<0&&l.push(e)})),s(e,l))}},522:function(e,t,n){"use strict";var r=n(758),o=n(690);e.exports=function(e,t,n){var i=e.style;r(t)?i[t]=n:o(t,(function(e,t){i[t]=e}))}},902:function(e,t,n){"use strict";var r=n(929);e.exports=function(e){return e&&e.className?r(e.className.baseVal)?e.className:e.className.baseVal:""}},714:function(e,t,n){"use strict";var r=n(928),o=n(902);e.exports=function(e,t){var n;return e.classList?e.classList.contains(t):(n=o(e).split(/\s+/),r(t,n)>-1)}},471:function(e,t,n){"use strict";var r=n(928),o=n(354),i=Element.prototype,s=i.matches||i.webkitMatchesSelector||i.mozMatchesSelector||i.msMatchesSelector||function(e){var t=this.document||this.ownerDocument;return r(this,o(t.querySelectorAll(e)))>-1};e.exports=function(e,t){return s.call(e,t)}},462:function(e,t,n){"use strict";var r=n(893),o=n(928),i=n(902),s=n(24);e.exports=function(e){var t,n,a=Array.prototype.slice.call(arguments,1),l=e.classList;l?r(a,(function(e){l.remove(e)})):(t=i(e).split(/\s+/),n=[],r(t,(function(e){o(e,a)<0&&n.push(e)})),s(e,n))}},969:function(e){"use strict";e.exports=function(e,t){var n,r,o,i,s=Object.prototype.hasOwnProperty;for(o=1,i=arguments.length;o<i;o+=1)for(r in n=arguments[o])s.call(n,r)&&(e[r]=n[r]);return e}},254:function(e,t,n){"use strict";var r=n(956);e.exports=function(e,t){var n=document.createElement("img"),o="";return r(t,(function(e,t){o+="&"+t+"="+e})),o=o.substring(1),n.src=e+"?"+o,n.style.display="none",document.body.appendChild(n),document.body.removeChild(n),n}},391:function(e,t,n){"use strict";var r=n(929),o=n(254);e.exports=function(e,t){var n=location.hostname,i="TOAST UI "+e+" for "+n+": Statistics",s=window.localStorage.getItem(i);(r(window.tui)||!1!==window.tui.usageStatistics)&&(s&&!function(e){return(new Date).getTime()-e>6048e5}(s)||(window.localStorage.setItem(i,(new Date).getTime()),setTimeout((function(){"interactive"!==document.readyState&&"complete"!==document.readyState||o("https://www.google-analytics.com/collect",{v:1,t:"event",tid:t,cid:n,dp:n,dh:e,el:e,ec:"use"})}),1e3)))}},516:function(e){"use strict";e.exports=function(e,t){var n,r;return t=t||0,function(){r=Array.prototype.slice.call(arguments),window.clearTimeout(n),n=window.setTimeout((function(){e.apply(null,r)}),t)}}},423:function(e,t,n){"use strict";var r=n(516);e.exports=function(e,t){var n,o,i,s,a=!0,l=function(t){e.apply(null,t),n=null};function c(){if(s=Array.prototype.slice.call(arguments),a)return l(s),void(a=!1);i=Number(new Date),n=n||i,o(s),i-n>=t&&l(s)}return o=r(l,t=t||0),c.reset=function(){a=!0,n=null},c}},322:function(e){"use strict";e.exports=function(e){return e instanceof Array}},326:function(e){"use strict";e.exports=function(e){return"boolean"==typeof e||e instanceof Boolean}},65:function(e,t,n){"use strict";var r=n(929),o=n(934);e.exports=function(e){return!r(e)&&!o(e)}},404:function(e,t,n){"use strict";var r=n(790);e.exports=function(e){return!r(e)}},294:function(e){"use strict";e.exports=function(e){return e instanceof Function}},934:function(e){"use strict";e.exports=function(e){return null===e}},321:function(e){"use strict";e.exports=function(e){return"number"==typeof e||e instanceof Number}},73:function(e){"use strict";e.exports=function(e){return e===Object(e)}},758:function(e){"use strict";e.exports=function(e){return"string"==typeof e||e instanceof String}},790:function(e,t,n){"use strict";var r=n(65);e.exports=function(e){return r(e)&&!1!==e}},929:function(e){"use strict";e.exports=function(e){return void 0===e}}},t={};function n(r){var o=t[r];if(void 0!==o)return o.exports;var i=t[r]={exports:{}};return e[r].call(i.exports,i,i.exports,n),i.exports}n.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return n.d(t,{a:t}),t},n.d=function(e,t){for(var r in t)n.o(t,r)&&!n.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},n.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),n.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)};var r={};return function(){"use strict";n.d(r,{default:function(){return vy}});
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var e=function(t,n){return e=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n])},e(t,n)};function t(t,n){if("function"!=typeof n&&null!==n)throw new TypeError("Class extends value "+String(n)+" is not a constructor or null");function r(){this.constructor=t}e(t,n),t.prototype=null===n?Object.create(n):(r.prototype=n.prototype,new r)}var o=function(){return o=Object.assign||function(e){for(var t,n=1,r=arguments.length;n<r;n++)for(var o in t=arguments[n])Object.prototype.hasOwnProperty.call(t,o)&&(e[o]=t[o]);return e},o.apply(this,arguments)};Object.create;function i(e,t,n){if(n||2===arguments.length)for(var r,o=0,i=t.length;o<i;o++)!r&&o in t||(r||(r=Array.prototype.slice.call(t,0,o)),r[o]=t[o]);return e.concat(r||Array.prototype.slice.call(t))}function s(e,t){return Object.defineProperty?Object.defineProperty(e,"raw",{value:t}):e.raw=t,e}Object.create;function a(e){this.content=e}a.prototype={constructor:a,find:function(e){for(var t=0;t<this.content.length;t+=2)if(this.content[t]===e)return t;return-1},get:function(e){var t=this.find(e);return-1==t?void 0:this.content[t+1]},update:function(e,t,n){var r=n&&n!=e?this.remove(n):this,o=r.find(e),i=r.content.slice();return-1==o?i.push(n||e,t):(i[o+1]=t,n&&(i[o]=n)),new a(i)},remove:function(e){var t=this.find(e);if(-1==t)return this;var n=this.content.slice();return n.splice(t,2),new a(n)},addToStart:function(e,t){return new a([e,t].concat(this.remove(e).content))},addToEnd:function(e,t){var n=this.remove(e).content.slice();return n.push(e,t),new a(n)},addBefore:function(e,t,n){var r=this.remove(t),o=r.content.slice(),i=r.find(e);return o.splice(-1==i?o.length:i,0,t,n),new a(o)},forEach:function(e){for(var t=0;t<this.content.length;t+=2)e(this.content[t],this.content[t+1])},prepend:function(e){return(e=a.from(e)).size?new a(e.content.concat(this.subtract(e).content)):this},append:function(e){return(e=a.from(e)).size?new a(this.subtract(e).content.concat(e.content)):this},subtract:function(e){var t=this;e=a.from(e);for(var n=0;n<e.content.length;n+=2)t=t.remove(e.content[n]);return t},get size(){return this.content.length>>1}},a.from=function(e){if(e instanceof a)return e;var t=[];if(e)for(var n in e)t.push(n,e[n]);return new a(t)};var l=a;function c(e,t,n){for(let r=0;;r++){if(r==e.childCount||r==t.childCount)return e.childCount==t.childCount?null:n;let o=e.child(r),i=t.child(r);if(o!=i){if(!o.sameMarkup(i))return n;if(o.isText&&o.text!=i.text){for(let e=0;o.text[e]==i.text[e];e++)n++;return n}if(o.content.size||i.content.size){let e=c(o.content,i.content,n+1);if(null!=e)return e}n+=o.nodeSize}else n+=o.nodeSize}}function u(e,t,n,r){for(let o=e.childCount,i=t.childCount;;){if(0==o||0==i)return o==i?null:{a:n,b:r};let s=e.child(--o),a=t.child(--i),l=s.nodeSize;if(s!=a){if(!s.sameMarkup(a))return{a:n,b:r};if(s.isText&&s.text!=a.text){let e=0,t=Math.min(s.text.length,a.text.length);for(;e<t&&s.text[s.text.length-e-1]==a.text[a.text.length-e-1];)e++,n--,r--;return{a:n,b:r}}if(s.content.size||a.content.size){let e=u(s.content,a.content,n-1,r-1);if(e)return e}n-=l,r-=l}else n-=l,r-=l}}class d{constructor(e,t){if(this.content=e,this.size=t||0,null==t)for(let t=0;t<e.length;t++)this.size+=e[t].nodeSize}nodesBetween(e,t,n,r=0,o){for(let i=0,s=0;s<t;i++){let a=this.content[i],l=s+a.nodeSize;if(l>e&&!1!==n(a,r+s,o||null,i)&&a.content.size){let o=s+1;a.nodesBetween(Math.max(0,e-o),Math.min(a.content.size,t-o),n,r+o)}s=l}}descendants(e){this.nodesBetween(0,this.size,e)}textBetween(e,t,n,r){let o="",i=!0;return this.nodesBetween(e,t,((s,a)=>{s.isText?(o+=s.text.slice(Math.max(e,a)-a,t-a),i=!n):s.isLeaf?(r?o+="function"==typeof r?r(s):r:s.type.spec.leafText&&(o+=s.type.spec.leafText(s)),i=!n):!i&&s.isBlock&&(o+=n,i=!0)}),0),o}append(e){if(!e.size)return this;if(!this.size)return e;let t=this.lastChild,n=e.firstChild,r=this.content.slice(),o=0;for(t.isText&&t.sameMarkup(n)&&(r[r.length-1]=t.withText(t.text+n.text),o=1);o<e.content.length;o++)r.push(e.content[o]);return new d(r,this.size+e.size)}cut(e,t=this.size){if(0==e&&t==this.size)return this;let n=[],r=0;if(t>e)for(let o=0,i=0;i<t;o++){let s=this.content[o],a=i+s.nodeSize;a>e&&((i<e||a>t)&&(s=s.isText?s.cut(Math.max(0,e-i),Math.min(s.text.length,t-i)):s.cut(Math.max(0,e-i-1),Math.min(s.content.size,t-i-1))),n.push(s),r+=s.nodeSize),i=a}return new d(n,r)}cutByIndex(e,t){return e==t?d.empty:0==e&&t==this.content.length?this:new d(this.content.slice(e,t))}replaceChild(e,t){let n=this.content[e];if(n==t)return this;let r=this.content.slice(),o=this.size+t.nodeSize-n.nodeSize;return r[e]=t,new d(r,o)}addToStart(e){return new d([e].concat(this.content),this.size+e.nodeSize)}addToEnd(e){return new d(this.content.concat(e),this.size+e.nodeSize)}eq(e){if(this.content.length!=e.content.length)return!1;for(let t=0;t<this.content.length;t++)if(!this.content[t].eq(e.content[t]))return!1;return!0}get firstChild(){return this.content.length?this.content[0]:null}get lastChild(){return this.content.length?this.content[this.content.length-1]:null}get childCount(){return this.content.length}child(e){let t=this.content[e];if(!t)throw new RangeError("Index "+e+" out of range for "+this);return t}maybeChild(e){return this.content[e]||null}forEach(e){for(let t=0,n=0;t<this.content.length;t++){let r=this.content[t];e(r,n,t),n+=r.nodeSize}}findDiffStart(e,t=0){return c(this,e,t)}findDiffEnd(e,t=this.size,n=e.size){return u(this,e,t,n)}findIndex(e,t=-1){if(0==e)return h(0,e);if(e==this.size)return h(this.content.length,e);if(e>this.size||e<0)throw new RangeError(`Position ${e} outside of fragment (${this})`);for(let n=0,r=0;;n++){let o=r+this.child(n).nodeSize;if(o>=e)return o==e||t>0?h(n+1,o):h(n,r);r=o}}toString(){return"<"+this.toStringInner()+">"}toStringInner(){return this.content.join(", ")}toJSON(){return this.content.length?this.content.map((e=>e.toJSON())):null}static fromJSON(e,t){if(!t)return d.empty;if(!Array.isArray(t))throw new RangeError("Invalid input for Fragment.fromJSON");return new d(t.map(e.nodeFromJSON))}static fromArray(e){if(!e.length)return d.empty;let t,n=0;for(let r=0;r<e.length;r++){let o=e[r];n+=o.nodeSize,r&&o.isText&&e[r-1].sameMarkup(o)?(t||(t=e.slice(0,r)),t[t.length-1]=o.withText(t[t.length-1].text+o.text)):t&&t.push(o)}return new d(t||e,n)}static from(e){if(!e)return d.empty;if(e instanceof d)return e;if(Array.isArray(e))return this.fromArray(e);if(e.attrs)return new d([e],e.nodeSize);throw new RangeError("Can not convert "+e+" to a Fragment"+(e.nodesBetween?" (looks like multiple versions of prosemirror-model were loaded)":""))}}d.empty=new d([],0);const p={index:0,offset:0};function h(e,t){return p.index=e,p.offset=t,p}function f(e,t){if(e===t)return!0;if(!e||"object"!=typeof e||!t||"object"!=typeof t)return!1;let n=Array.isArray(e);if(Array.isArray(t)!=n)return!1;if(n){if(e.length!=t.length)return!1;for(let n=0;n<e.length;n++)if(!f(e[n],t[n]))return!1}else{for(let n in e)if(!(n in t)||!f(e[n],t[n]))return!1;for(let n in t)if(!(n in e))return!1}return!0}class m{constructor(e,t){this.type=e,this.attrs=t}addToSet(e){let t,n=!1;for(let r=0;r<e.length;r++){let o=e[r];if(this.eq(o))return e;if(this.type.excludes(o.type))t||(t=e.slice(0,r));else{if(o.type.excludes(this.type))return e;!n&&o.type.rank>this.type.rank&&(t||(t=e.slice(0,r)),t.push(this),n=!0),t&&t.push(o)}}return t||(t=e.slice()),n||t.push(this),t}removeFromSet(e){for(let t=0;t<e.length;t++)if(this.eq(e[t]))return e.slice(0,t).concat(e.slice(t+1));return e}isInSet(e){for(let t=0;t<e.length;t++)if(this.eq(e[t]))return!0;return!1}eq(e){return this==e||this.type==e.type&&f(this.attrs,e.attrs)}toJSON(){let e={type:this.type.name};for(let t in this.attrs){e.attrs=this.attrs;break}return e}static fromJSON(e,t){if(!t)throw new RangeError("Invalid input for Mark.fromJSON");let n=e.marks[t.type];if(!n)throw new RangeError(`There is no mark type ${t.type} in this schema`);return n.create(t.attrs)}static sameSet(e,t){if(e==t)return!0;if(e.length!=t.length)return!1;for(let n=0;n<e.length;n++)if(!e[n].eq(t[n]))return!1;return!0}static setFrom(e){if(!e||Array.isArray(e)&&0==e.length)return m.none;if(e instanceof m)return[e];let t=e.slice();return t.sort(((e,t)=>e.type.rank-t.type.rank)),t}}m.none=[];class g extends Error{}class v{constructor(e,t,n){this.content=e,this.openStart=t,this.openEnd=n}get size(){return this.content.size-this.openStart-this.openEnd}insertAt(e,t){let n=b(this.content,e+this.openStart,t);return n&&new v(n,this.openStart,this.openEnd)}removeBetween(e,t){return new v(y(this.content,e+this.openStart,t+this.openStart),this.openStart,this.openEnd)}eq(e){return this.content.eq(e.content)&&this.openStart==e.openStart&&this.openEnd==e.openEnd}toString(){return this.content+"("+this.openStart+","+this.openEnd+")"}toJSON(){if(!this.content.size)return null;let e={content:this.content.toJSON()};return this.openStart>0&&(e.openStart=this.openStart),this.openEnd>0&&(e.openEnd=this.openEnd),e}static fromJSON(e,t){if(!t)return v.empty;let n=t.openStart||0,r=t.openEnd||0;if("number"!=typeof n||"number"!=typeof r)throw new RangeError("Invalid input for Slice.fromJSON");return new v(d.fromJSON(e,t.content),n,r)}static maxOpen(e,t=!0){let n=0,r=0;for(let r=e.firstChild;r&&!r.isLeaf&&(t||!r.type.spec.isolating);r=r.firstChild)n++;for(let n=e.lastChild;n&&!n.isLeaf&&(t||!n.type.spec.isolating);n=n.lastChild)r++;return new v(e,n,r)}}function y(e,t,n){let{index:r,offset:o}=e.findIndex(t),i=e.maybeChild(r),{index:s,offset:a}=e.findIndex(n);if(o==t||i.isText){if(a!=n&&!e.child(s).isText)throw new RangeError("Removing non-flat range");return e.cut(0,t).append(e.cut(n))}if(r!=s)throw new RangeError("Removing non-flat range");return e.replaceChild(r,i.copy(y(i.content,t-o-1,n-o-1)))}function b(e,t,n,r){let{index:o,offset:i}=e.findIndex(t),s=e.maybeChild(o);if(i==t||s.isText)return r&&!r.canReplace(o,o,n)?null:e.cut(0,t).append(n).append(e.cut(t));let a=b(s.content,t-i-1,n);return a&&e.replaceChild(o,s.copy(a))}function w(e,t,n){if(n.openStart>e.depth)throw new g("Inserted content deeper than insertion position");if(e.depth-n.openStart!=t.depth-n.openEnd)throw new g("Inconsistent open depths");return k(e,t,n,0)}function k(e,t,n,r){let o=e.index(r),i=e.node(r);if(o==t.index(r)&&r<e.depth-n.openStart){let s=k(e,t,n,r+1);return i.copy(i.content.replaceChild(o,s))}if(n.content.size){if(n.openStart||n.openEnd||e.depth!=r||t.depth!=r){let{start:o,end:s}=function(e,t){let n=t.depth-e.openStart,r=t.node(n).copy(e.content);for(let e=n-1;e>=0;e--)r=t.node(e).copy(d.from(r));return{start:r.resolveNoCache(e.openStart+n),end:r.resolveNoCache(r.content.size-e.openEnd-n)}}(n,e);return S(i,E(e,o,s,t,r))}{let r=e.parent,o=r.content;return S(r,o.cut(0,e.parentOffset).append(n.content).append(o.cut(t.parentOffset)))}}return S(i,N(e,t,r))}function x(e,t){if(!t.type.compatibleContent(e.type))throw new g("Cannot join "+t.type.name+" onto "+e.type.name)}function C(e,t,n){let r=e.node(n);return x(r,t.node(n)),r}function T(e,t){let n=t.length-1;n>=0&&e.isText&&e.sameMarkup(t[n])?t[n]=e.withText(t[n].text+e.text):t.push(e)}function M(e,t,n,r){let o=(t||e).node(n),i=0,s=t?t.index(n):o.childCount;e&&(i=e.index(n),e.depth>n?i++:e.textOffset&&(T(e.nodeAfter,r),i++));for(let e=i;e<s;e++)T(o.child(e),r);t&&t.depth==n&&t.textOffset&&T(t.nodeBefore,r)}function S(e,t){if(!e.type.validContent(t))throw new g("Invalid content for node "+e.type.name);return e.copy(t)}function E(e,t,n,r,o){let i=e.depth>o&&C(e,t,o+1),s=r.depth>o&&C(n,r,o+1),a=[];return M(null,e,o,a),i&&s&&t.index(o)==n.index(o)?(x(i,s),T(S(i,E(e,t,n,r,o+1)),a)):(i&&T(S(i,N(e,t,o+1)),a),M(t,n,o,a),s&&T(S(s,N(n,r,o+1)),a)),M(r,null,o,a),new d(a)}function N(e,t,n){let r=[];if(M(null,e,n,r),e.depth>n){T(S(C(e,t,n+1),N(e,t,n+1)),r)}return M(t,null,n,r),new d(r)}v.empty=new v(d.empty,0,0);class O{constructor(e,t,n){this.pos=e,this.path=t,this.parentOffset=n,this.depth=t.length/3-1}resolveDepth(e){return null==e?this.depth:e<0?this.depth+e:e}get parent(){return this.node(this.depth)}get doc(){return this.node(0)}node(e){return this.path[3*this.resolveDepth(e)]}index(e){return this.path[3*this.resolveDepth(e)+1]}indexAfter(e){return e=this.resolveDepth(e),this.index(e)+(e!=this.depth||this.textOffset?1:0)}start(e){return 0==(e=this.resolveDepth(e))?0:this.path[3*e-1]+1}end(e){return e=this.resolveDepth(e),this.start(e)+this.node(e).content.size}before(e){if(!(e=this.resolveDepth(e)))throw new RangeError("There is no position before the top-level node");return e==this.depth+1?this.pos:this.path[3*e-1]}after(e){if(!(e=this.resolveDepth(e)))throw new RangeError("There is no position after the top-level node");return e==this.depth+1?this.pos:this.path[3*e-1]+this.path[3*e].nodeSize}get textOffset(){return this.pos-this.path[this.path.length-1]}get nodeAfter(){let e=this.parent,t=this.index(this.depth);if(t==e.childCount)return null;let n=this.pos-this.path[this.path.length-1],r=e.child(t);return n?e.child(t).cut(n):r}get nodeBefore(){let e=this.index(this.depth),t=this.pos-this.path[this.path.length-1];return t?this.parent.child(e).cut(0,t):0==e?null:this.parent.child(e-1)}posAtIndex(e,t){t=this.resolveDepth(t);let n=this.path[3*t],r=0==t?0:this.path[3*t-1]+1;for(let t=0;t<e;t++)r+=n.child(t).nodeSize;return r}marks(){let e=this.parent,t=this.index();if(0==e.content.size)return m.none;if(this.textOffset)return e.child(t).marks;let n=e.maybeChild(t-1),r=e.maybeChild(t);if(!n){let e=n;n=r,r=e}let o=n.marks;for(var i=0;i<o.length;i++)!1!==o[i].type.spec.inclusive||r&&o[i].isInSet(r.marks)||(o=o[i--].removeFromSet(o));return o}marksAcross(e){let t=this.parent.maybeChild(this.index());if(!t||!t.isInline)return null;let n=t.marks,r=e.parent.maybeChild(e.index());for(var o=0;o<n.length;o++)!1!==n[o].type.spec.inclusive||r&&n[o].isInSet(r.marks)||(n=n[o--].removeFromSet(n));return n}sharedDepth(e){for(let t=this.depth;t>0;t--)if(this.start(t)<=e&&this.end(t)>=e)return t;return 0}blockRange(e=this,t){if(e.pos<this.pos)return e.blockRange(this);for(let n=this.depth-(this.parent.inlineContent||this.pos==e.pos?1:0);n>=0;n--)if(e.pos<=this.end(n)&&(!t||t(this.node(n))))return new I(this,e,n);return null}sameParent(e){return this.pos-this.parentOffset==e.pos-e.parentOffset}max(e){return e.pos>this.pos?e:this}min(e){return e.pos<this.pos?e:this}toString(){let e="";for(let t=1;t<=this.depth;t++)e+=(e?"/":"")+this.node(t).type.name+"_"+this.index(t-1);return e+":"+this.parentOffset}static resolve(e,t){if(!(t>=0&&t<=e.content.size))throw new RangeError("Position "+t+" out of range");let n=[],r=0,o=t;for(let t=e;;){let{index:e,offset:i}=t.content.findIndex(o),s=o-i;if(n.push(t,e,r+i),!s)break;if(t=t.child(e),t.isText)break;o=s-1,r+=i+1}return new O(t,n,o)}static resolveCached(e,t){for(let n=0;n<D.length;n++){let r=D[n];if(r.pos==t&&r.doc==e)return r}let n=D[A]=O.resolve(e,t);return A=(A+1)%L,n}}let D=[],A=0,L=12;class I{constructor(e,t,n){this.$from=e,this.$to=t,this.depth=n}get start(){return this.$from.before(this.depth+1)}get end(){return this.$to.after(this.depth+1)}get parent(){return this.$from.node(this.depth)}get startIndex(){return this.$from.index(this.depth)}get endIndex(){return this.$to.indexAfter(this.depth)}}const R=Object.create(null);class P{constructor(e,t,n,r=m.none){this.type=e,this.attrs=t,this.marks=r,this.content=n||d.empty}get nodeSize(){return this.isLeaf?1:2+this.content.size}get childCount(){return this.content.childCount}child(e){return this.content.child(e)}maybeChild(e){return this.content.maybeChild(e)}forEach(e){this.content.forEach(e)}nodesBetween(e,t,n,r=0){this.content.nodesBetween(e,t,n,r,this)}descendants(e){this.nodesBetween(0,this.content.size,e)}get textContent(){return this.isLeaf&&this.type.spec.leafText?this.type.spec.leafText(this):this.textBetween(0,this.content.size,"")}textBetween(e,t,n,r){return this.content.textBetween(e,t,n,r)}get firstChild(){return this.content.firstChild}get lastChild(){return this.content.lastChild}eq(e){return this==e||this.sameMarkup(e)&&this.content.eq(e.content)}sameMarkup(e){return this.hasMarkup(e.type,e.attrs,e.marks)}hasMarkup(e,t,n){return this.type==e&&f(this.attrs,t||e.defaultAttrs||R)&&m.sameSet(this.marks,n||m.none)}copy(e=null){return e==this.content?this:new P(this.type,this.attrs,e,this.marks)}mark(e){return e==this.marks?this:new P(this.type,this.attrs,this.content,e)}cut(e,t=this.content.size){return 0==e&&t==this.content.size?this:this.copy(this.content.cut(e,t))}slice(e,t=this.content.size,n=!1){if(e==t)return v.empty;let r=this.resolve(e),o=this.resolve(t),i=n?0:r.sharedDepth(t),s=r.start(i),a=r.node(i).content.cut(r.pos-s,o.pos-s);return new v(a,r.depth-i,o.depth-i)}replace(e,t,n){return w(this.resolve(e),this.resolve(t),n)}nodeAt(e){for(let t=this;;){let{index:n,offset:r}=t.content.findIndex(e);if(t=t.maybeChild(n),!t)return null;if(r==e||t.isText)return t;e-=r+1}}childAfter(e){let{index:t,offset:n}=this.content.findIndex(e);return{node:this.content.maybeChild(t),index:t,offset:n}}childBefore(e){if(0==e)return{node:null,index:0,offset:0};let{index:t,offset:n}=this.content.findIndex(e);if(n<e)return{node:this.content.child(t),index:t,offset:n};let r=this.content.child(t-1);return{node:r,index:t-1,offset:n-r.nodeSize}}resolve(e){return O.resolveCached(this,e)}resolveNoCache(e){return O.resolve(this,e)}rangeHasMark(e,t,n){let r=!1;return t>e&&this.nodesBetween(e,t,(e=>(n.isInSet(e.marks)&&(r=!0),!r))),r}get isBlock(){return this.type.isBlock}get isTextblock(){return this.type.isTextblock}get inlineContent(){return this.type.inlineContent}get isInline(){return this.type.isInline}get isText(){return this.type.isText}get isLeaf(){return this.type.isLeaf}get isAtom(){return this.type.isAtom}toString(){if(this.type.spec.toDebugString)return this.type.spec.toDebugString(this);let e=this.type.name;return this.content.size&&(e+="("+this.content.toStringInner()+")"),F(this.marks,e)}contentMatchAt(e){let t=this.type.contentMatch.matchFragment(this.content,0,e);if(!t)throw new Error("Called contentMatchAt on a node with invalid content");return t}canReplace(e,t,n=d.empty,r=0,o=n.childCount){let i=this.contentMatchAt(e).matchFragment(n,r,o),s=i&&i.matchFragment(this.content,t);if(!s||!s.validEnd)return!1;for(let e=r;e<o;e++)if(!this.type.allowsMarks(n.child(e).marks))return!1;return!0}canReplaceWith(e,t,n,r){if(r&&!this.type.allowsMarks(r))return!1;let o=this.contentMatchAt(e).matchType(n),i=o&&o.matchFragment(this.content,t);return!!i&&i.validEnd}canAppend(e){return e.content.size?this.canReplace(this.childCount,this.childCount,e.content):this.type.compatibleContent(e.type)}check(){if(!this.type.validContent(this.content))throw new RangeError(`Invalid content for node ${this.type.name}: ${this.content.toString().slice(0,50)}`);let e=m.none;for(let t=0;t<this.marks.length;t++)e=this.marks[t].addToSet(e);if(!m.sameSet(e,this.marks))throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((e=>e.type.name))}`);this.content.forEach((e=>e.check()))}toJSON(){let e={type:this.type.name};for(let t in this.attrs){e.attrs=this.attrs;break}return this.content.size&&(e.content=this.content.toJSON()),this.marks.length&&(e.marks=this.marks.map((e=>e.toJSON()))),e}static fromJSON(e,t){if(!t)throw new RangeError("Invalid input for Node.fromJSON");let n=null;if(t.marks){if(!Array.isArray(t.marks))throw new RangeError("Invalid mark data for Node.fromJSON");n=t.marks.map(e.markFromJSON)}if("text"==t.type){if("string"!=typeof t.text)throw new RangeError("Invalid text node in JSON");return e.text(t.text,n)}let r=d.fromJSON(e,t.content);return e.nodeType(t.type).create(t.attrs,r,n)}}P.prototype.text=void 0;class B extends P{constructor(e,t,n,r){if(super(e,t,null,r),!n)throw new RangeError("Empty text nodes are not allowed");this.text=n}toString(){return this.type.spec.toDebugString?this.type.spec.toDebugString(this):F(this.marks,JSON.stringify(this.text))}get textContent(){return this.text}textBetween(e,t){return this.text.slice(e,t)}get nodeSize(){return this.text.length}mark(e){return e==this.marks?this:new B(this.type,this.attrs,this.text,e)}withText(e){return e==this.text?this:new B(this.type,this.attrs,e,this.marks)}cut(e=0,t=this.text.length){return 0==e&&t==this.text.length?this:this.withText(this.text.slice(e,t))}eq(e){return this.sameMarkup(e)&&this.text==e.text}toJSON(){let e=super.toJSON();return e.text=this.text,e}}function F(e,t){for(let n=e.length-1;n>=0;n--)t=e[n].type.name+"("+t+")";return t}class H{constructor(e){this.validEnd=e,this.next=[],this.wrapCache=[]}static parse(e,t){let n=new z(e,t);if(null==n.next)return H.empty;let r=q(n);n.next&&n.err("Unexpected trailing text");let o=function(e){let t=Object.create(null);return n(W(e,0));function n(r){let o=[];r.forEach((t=>{e[t].forEach((({term:t,to:n})=>{if(!t)return;let r;for(let e=0;e<o.length;e++)o[e][0]==t&&(r=o[e][1]);W(e,n).forEach((e=>{r||o.push([t,r=[]]),-1==r.indexOf(e)&&r.push(e)}))}))}));let i=t[r.join(",")]=new H(r.indexOf(e.length-1)>-1);for(let e=0;e<o.length;e++){let r=o[e][1].sort(U);i.next.push({type:o[e][0],next:t[r.join(",")]||n(r)})}return i}}(function(e){let t=[[]];return o(i(e,0),n()),t;function n(){return t.push([])-1}function r(e,n,r){let o={term:r,to:n};return t[e].push(o),o}function o(e,t){e.forEach((e=>e.to=t))}function i(e,t){if("choice"==e.type)return e.exprs.reduce(((e,n)=>e.concat(i(n,t))),[]);if("seq"!=e.type){if("star"==e.type){let s=n();return r(t,s),o(i(e.expr,s),s),[r(s)]}if("plus"==e.type){let s=n();return o(i(e.expr,t),s),o(i(e.expr,s),s),[r(s)]}if("opt"==e.type)return[r(t)].concat(i(e.expr,t));if("range"==e.type){let s=t;for(let t=0;t<e.min;t++){let t=n();o(i(e.expr,s),t),s=t}if(-1==e.max)o(i(e.expr,s),s);else for(let t=e.min;t<e.max;t++){let t=n();r(s,t),o(i(e.expr,s),t),s=t}return[r(s)]}if("name"==e.type)return[r(t,void 0,e.value)];throw new Error("Unknown expr type")}for(let r=0;;r++){let s=i(e.exprs[r],t);if(r==e.exprs.length-1)return s;o(s,t=n())}}}(r));return function(e,t){for(let n=0,r=[e];n<r.length;n++){let e=r[n],o=!e.validEnd,i=[];for(let t=0;t<e.next.length;t++){let{type:n,next:s}=e.next[t];i.push(n.name),!o||n.isText||n.hasRequiredAttrs()||(o=!1),-1==r.indexOf(s)&&r.push(s)}o&&t.err("Only non-generatable nodes ("+i.join(", ")+") in a required position (see https://prosemirror.net/docs/guide/#generatable)")}}(o,n),o}matchType(e){for(let t=0;t<this.next.length;t++)if(this.next[t].type==e)return this.next[t].next;return null}matchFragment(e,t=0,n=e.childCount){let r=this;for(let o=t;r&&o<n;o++)r=r.matchType(e.child(o).type);return r}get inlineContent(){return this.next.length&&this.next[0].type.isInline}get defaultType(){for(let e=0;e<this.next.length;e++){let{type:t}=this.next[e];if(!t.isText&&!t.hasRequiredAttrs())return t}return null}compatible(e){for(let t=0;t<this.next.length;t++)for(let n=0;n<e.next.length;n++)if(this.next[t].type==e.next[n].type)return!0;return!1}fillBefore(e,t=!1,n=0){let r=[this];return function o(i,s){let a=i.matchFragment(e,n);if(a&&(!t||a.validEnd))return d.from(s.map((e=>e.createAndFill())));for(let e=0;e<i.next.length;e++){let{type:t,next:n}=i.next[e];if(!t.isText&&!t.hasRequiredAttrs()&&-1==r.indexOf(n)){r.push(n);let e=o(n,s.concat(t));if(e)return e}}return null}(this,[])}findWrapping(e){for(let t=0;t<this.wrapCache.length;t+=2)if(this.wrapCache[t]==e)return this.wrapCache[t+1];let t=this.computeWrapping(e);return this.wrapCache.push(e,t),t}computeWrapping(e){let t=Object.create(null),n=[{match:this,type:null,via:null}];for(;n.length;){let r=n.shift(),o=r.match;if(o.matchType(e)){let e=[];for(let t=r;t.type;t=t.via)e.push(t.type);return e.reverse()}for(let e=0;e<o.next.length;e++){let{type:i,next:s}=o.next[e];i.isLeaf||i.hasRequiredAttrs()||i.name in t||r.type&&!s.validEnd||(n.push({match:i.contentMatch,type:i,via:r}),t[i.name]=!0)}}return null}get edgeCount(){return this.next.length}edge(e){if(e>=this.next.length)throw new RangeError(`There's no ${e}th edge in this content match`);return this.next[e]}toString(){let e=[];return function t(n){e.push(n);for(let r=0;r<n.next.length;r++)-1==e.indexOf(n.next[r].next)&&t(n.next[r].next)}(this),e.map(((t,n)=>{let r=n+(t.validEnd?"*":" ")+" ";for(let n=0;n<t.next.length;n++)r+=(n?", ":"")+t.next[n].type.name+"->"+e.indexOf(t.next[n].next);return r})).join("\n")}}H.empty=new H(!0);class z{constructor(e,t){this.string=e,this.nodeTypes=t,this.inline=null,this.pos=0,this.tokens=e.split(/\s*(?=\b|\W|$)/),""==this.tokens[this.tokens.length-1]&&this.tokens.pop(),""==this.tokens[0]&&this.tokens.shift()}get next(){return this.tokens[this.pos]}eat(e){return this.next==e&&(this.pos++||!0)}err(e){throw new SyntaxError(e+" (in content expression '"+this.string+"')")}}function q(e){let t=[];do{t.push(V(e))}while(e.eat("|"));return 1==t.length?t[0]:{type:"choice",exprs:t}}function V(e){let t=[];do{t.push(j(e))}while(e.next&&")"!=e.next&&"|"!=e.next);return 1==t.length?t[0]:{type:"seq",exprs:t}}function j(e){let t=function(e){if(e.eat("(")){let t=q(e);return e.eat(")")||e.err("Missing closing paren"),t}if(!/\W/.test(e.next)){let t=function(e,t){let n=e.nodeTypes,r=n[t];if(r)return[r];let o=[];for(let e in n){let r=n[e];r.groups.indexOf(t)>-1&&o.push(r)}0==o.length&&e.err("No node type or group '"+t+"' found");return o}(e,e.next).map((t=>(null==e.inline?e.inline=t.isInline:e.inline!=t.isInline&&e.err("Mixing inline and block content"),{type:"name",value:t})));return e.pos++,1==t.length?t[0]:{type:"choice",exprs:t}}e.err("Unexpected token '"+e.next+"'")}(e);for(;;)if(e.eat("+"))t={type:"plus",expr:t};else if(e.eat("*"))t={type:"star",expr:t};else if(e.eat("?"))t={type:"opt",expr:t};else{if(!e.eat("{"))break;t=_(e,t)}return t}function $(e){/\D/.test(e.next)&&e.err("Expected number, got '"+e.next+"'");let t=Number(e.next);return e.pos++,t}function _(e,t){let n=$(e),r=n;return e.eat(",")&&(r="}"!=e.next?$(e):-1),e.eat("}")||e.err("Unclosed braced range"),{type:"range",min:n,max:r,expr:t}}function U(e,t){return t-e}function W(e,t){let n=[];return function t(r){let o=e[r];if(1==o.length&&!o[0].term)return t(o[0].to);n.push(r);for(let e=0;e<o.length;e++){let{term:r,to:i}=o[e];r||-1!=n.indexOf(i)||t(i)}}(t),n.sort(U)}function J(e){let t=Object.create(null);for(let n in e){let r=e[n];if(!r.hasDefault)return null;t[n]=r.default}return t}function G(e,t){let n=Object.create(null);for(let r in e){let o=t&&t[r];if(void 0===o){let t=e[r];if(!t.hasDefault)throw new RangeError("No value supplied for attribute "+r);o=t.default}n[r]=o}return n}function K(e){let t=Object.create(null);if(e)for(let n in e)t[n]=new X(e[n]);return t}class Z{constructor(e,t,n){this.name=e,this.schema=t,this.spec=n,this.markSet=null,this.groups=n.group?n.group.split(" "):[],this.attrs=K(n.attrs),this.defaultAttrs=J(this.attrs),this.contentMatch=null,this.inlineContent=null,this.isBlock=!(n.inline||"text"==e),this.isText="text"==e}get isInline(){return!this.isBlock}get isTextblock(){return this.isBlock&&this.inlineContent}get isLeaf(){return this.contentMatch==H.empty}get isAtom(){return this.isLeaf||!!this.spec.atom}get whitespace(){return this.spec.whitespace||(this.spec.code?"pre":"normal")}hasRequiredAttrs(){for(let e in this.attrs)if(this.attrs[e].isRequired)return!0;return!1}compatibleContent(e){return this==e||this.contentMatch.compatible(e.contentMatch)}computeAttrs(e){return!e&&this.defaultAttrs?this.defaultAttrs:G(this.attrs,e)}create(e=null,t,n){if(this.isText)throw new Error("NodeType.create can't construct text nodes");return new P(this,this.computeAttrs(e),d.from(t),m.setFrom(n))}createChecked(e=null,t,n){if(t=d.from(t),!this.validContent(t))throw new RangeError("Invalid content for node "+this.name);return new P(this,this.computeAttrs(e),t,m.setFrom(n))}createAndFill(e=null,t,n){if(e=this.computeAttrs(e),(t=d.from(t)).size){let e=this.contentMatch.fillBefore(t);if(!e)return null;t=e.append(t)}let r=this.contentMatch.matchFragment(t),o=r&&r.fillBefore(d.empty,!0);return o?new P(this,e,t.append(o),m.setFrom(n)):null}validContent(e){let t=this.contentMatch.matchFragment(e);if(!t||!t.validEnd)return!1;for(let t=0;t<e.childCount;t++)if(!this.allowsMarks(e.child(t).marks))return!1;return!0}allowsMarkType(e){return null==this.markSet||this.markSet.indexOf(e)>-1}allowsMarks(e){if(null==this.markSet)return!0;for(let t=0;t<e.length;t++)if(!this.allowsMarkType(e[t].type))return!1;return!0}allowedMarks(e){if(null==this.markSet)return e;let t;for(let n=0;n<e.length;n++)this.allowsMarkType(e[n].type)?t&&t.push(e[n]):t||(t=e.slice(0,n));return t?t.length?t:m.none:e}static compile(e,t){let n=Object.create(null);e.forEach(((e,r)=>n[e]=new Z(e,t,r)));let r=t.spec.topNode||"doc";if(!n[r])throw new RangeError("Schema is missing its top node type ('"+r+"')");if(!n.text)throw new RangeError("Every schema needs a 'text' type");for(let e in n.text.attrs)throw new RangeError("The text node type should not have attributes");return n}}class X{constructor(e){this.hasDefault=Object.prototype.hasOwnProperty.call(e,"default"),this.default=e.default}get isRequired(){return!this.hasDefault}}class Q{constructor(e,t,n,r){this.name=e,this.rank=t,this.schema=n,this.spec=r,this.attrs=K(r.attrs),this.excluded=null;let o=J(this.attrs);this.instance=o?new m(this,o):null}create(e=null){return!e&&this.instance?this.instance:new m(this,G(this.attrs,e))}static compile(e,t){let n=Object.create(null),r=0;return e.forEach(((e,o)=>n[e]=new Q(e,r++,t,o))),n}removeFromSet(e){for(var t=0;t<e.length;t++)e[t].type==this&&(e=e.slice(0,t).concat(e.slice(t+1)),t--);return e}isInSet(e){for(let t=0;t<e.length;t++)if(e[t].type==this)return e[t]}excludes(e){return this.excluded.indexOf(e)>-1}}class Y{constructor(e){this.cached=Object.create(null),this.spec={nodes:l.from(e.nodes),marks:l.from(e.marks||{}),topNode:e.topNode},this.nodes=Z.compile(this.spec.nodes,this),this.marks=Q.compile(this.spec.marks,this);let t=Object.create(null);for(let e in this.nodes){if(e in this.marks)throw new RangeError(e+" can not be both a node and a mark");let n=this.nodes[e],r=n.spec.content||"",o=n.spec.marks;n.contentMatch=t[r]||(t[r]=H.parse(r,this.nodes)),n.inlineContent=n.contentMatch.inlineContent,n.markSet="_"==o?null:o?ee(this,o.split(" ")):""!=o&&n.inlineContent?null:[]}for(let e in this.marks){let t=this.marks[e],n=t.spec.excludes;t.excluded=null==n?[t]:""==n?[]:ee(this,n.split(" "))}this.nodeFromJSON=this.nodeFromJSON.bind(this),this.markFromJSON=this.markFromJSON.bind(this),this.topNodeType=this.nodes[this.spec.topNode||"doc"],this.cached.wrappings=Object.create(null)}node(e,t=null,n,r){if("string"==typeof e)e=this.nodeType(e);else{if(!(e instanceof Z))throw new RangeError("Invalid node type: "+e);if(e.schema!=this)throw new RangeError("Node type from different schema used ("+e.name+")")}return e.createChecked(t,n,r)}text(e,t){let n=this.nodes.text;return new B(n,n.defaultAttrs,e,m.setFrom(t))}mark(e,t){return"string"==typeof e&&(e=this.marks[e]),e.create(t)}nodeFromJSON(e){return P.fromJSON(this,e)}markFromJSON(e){return m.fromJSON(this,e)}nodeType(e){let t=this.nodes[e];if(!t)throw new RangeError("Unknown node type: "+e);return t}}function ee(e,t){let n=[];for(let r=0;r<t.length;r++){let o=t[r],i=e.marks[o],s=i;if(i)n.push(i);else for(let t in e.marks){let r=e.marks[t];("_"==o||r.spec.group&&r.spec.group.split(" ").indexOf(o)>-1)&&n.push(s=r)}if(!s)throw new SyntaxError("Unknown mark type: '"+t[r]+"'")}return n}class te{constructor(e,t){this.schema=e,this.rules=t,this.tags=[],this.styles=[],t.forEach((e=>{e.tag?this.tags.push(e):e.style&&this.styles.push(e)})),this.normalizeLists=!this.tags.some((t=>{if(!/^(ul|ol)\b/.test(t.tag)||!t.node)return!1;let n=e.nodes[t.node];return n.contentMatch.matchType(n)}))}parse(e,t={}){let n=new ae(this,t,!1);return n.addAll(e,t.from,t.to),n.finish()}parseSlice(e,t={}){let n=new ae(this,t,!0);return n.addAll(e,t.from,t.to),v.maxOpen(n.finish())}matchTag(e,t,n){for(let r=n?this.tags.indexOf(n)+1:0;r<this.tags.length;r++){let n=this.tags[r];if(le(e,n.tag)&&(void 0===n.namespace||e.namespaceURI==n.namespace)&&(!n.context||t.matchesContext(n.context))){if(n.getAttrs){let t=n.getAttrs(e);if(!1===t)continue;n.attrs=t||void 0}return n}}}matchStyle(e,t,n,r){for(let o=r?this.styles.indexOf(r)+1:0;o<this.styles.length;o++){let r=this.styles[o],i=r.style;if(!(0!=i.indexOf(e)||r.context&&!n.matchesContext(r.context)||i.length>e.length&&(61!=i.charCodeAt(e.length)||i.slice(e.length+1)!=t))){if(r.getAttrs){let e=r.getAttrs(t);if(!1===e)continue;r.attrs=e||void 0}return r}}}static schemaRules(e){let t=[];function n(e){let n=null==e.priority?50:e.priority,r=0;for(;r<t.length;r++){let e=t[r];if((null==e.priority?50:e.priority)<n)break}t.splice(r,0,e)}for(let t in e.marks){let r=e.marks[t].spec.parseDOM;r&&r.forEach((e=>{n(e=ce(e)),e.mark=t}))}for(let t in e.nodes){let r=e.nodes[t].spec.parseDOM;r&&r.forEach((e=>{n(e=ce(e)),e.node=t}))}return t}static fromSchema(e){return e.cached.domParser||(e.cached.domParser=new te(e,te.schemaRules(e)))}}const ne={address:!0,article:!0,aside:!0,blockquote:!0,canvas:!0,dd:!0,div:!0,dl:!0,fieldset:!0,figcaption:!0,figure:!0,footer:!0,form:!0,h1:!0,h2:!0,h3:!0,h4:!0,h5:!0,h6:!0,header:!0,hgroup:!0,hr:!0,li:!0,noscript:!0,ol:!0,output:!0,p:!0,pre:!0,section:!0,table:!0,tfoot:!0,ul:!0},re={head:!0,noscript:!0,object:!0,script:!0,style:!0,title:!0},oe={ol:!0,ul:!0};function ie(e,t,n){return null!=t?(t?1:0)|("full"===t?2:0):e&&"pre"==e.whitespace?3:-5&n}class se{constructor(e,t,n,r,o,i,s){this.type=e,this.attrs=t,this.marks=n,this.pendingMarks=r,this.solid=o,this.options=s,this.content=[],this.activeMarks=m.none,this.stashMarks=[],this.match=i||(4&s?null:e.contentMatch)}findWrapping(e){if(!this.match){if(!this.type)return[];let t=this.type.contentMatch.fillBefore(d.from(e));if(!t){let t,n=this.type.contentMatch;return(t=n.findWrapping(e.type))?(this.match=n,t):null}this.match=this.type.contentMatch.matchFragment(t)}return this.match.findWrapping(e.type)}finish(e){if(!(1&this.options)){let e,t=this.content[this.content.length-1];if(t&&t.isText&&(e=/[ \t\r\n\u000c]+$/.exec(t.text))){let n=t;t.text.length==e[0].length?this.content.pop():this.content[this.content.length-1]=n.withText(n.text.slice(0,n.text.length-e[0].length))}}let t=d.from(this.content);return!e&&this.match&&(t=t.append(this.match.fillBefore(d.empty,!0))),this.type?this.type.create(this.attrs,t,this.marks):t}popFromStashMark(e){for(let t=this.stashMarks.length-1;t>=0;t--)if(e.eq(this.stashMarks[t]))return this.stashMarks.splice(t,1)[0]}applyPending(e){for(let t=0,n=this.pendingMarks;t<n.length;t++){let r=n[t];(this.type?this.type.allowsMarkType(r.type):ue(r.type,e))&&!r.isInSet(this.activeMarks)&&(this.activeMarks=r.addToSet(this.activeMarks),this.pendingMarks=r.removeFromSet(this.pendingMarks))}}inlineContext(e){return this.type?this.type.inlineContent:this.content.length?this.content[0].isInline:e.parentNode&&!ne.hasOwnProperty(e.parentNode.nodeName.toLowerCase())}}class ae{constructor(e,t,n){this.parser=e,this.options=t,this.isOpen=n,this.open=0;let r,o=t.topNode,i=ie(null,t.preserveWhitespace,0)|(n?4:0);r=o?new se(o.type,o.attrs,m.none,m.none,!0,t.topMatch||o.type.contentMatch,i):new se(n?null:e.schema.topNodeType,null,m.none,m.none,!0,null,i),this.nodes=[r],this.find=t.findPositions,this.needsBlock=!1}get top(){return this.nodes[this.open]}addDOM(e){if(3==e.nodeType)this.addTextNode(e);else if(1==e.nodeType){let t=e.getAttribute("style"),n=t?this.readStyles(function(e){let t,n=/\s*([\w-]+)\s*:\s*([^;]+)/g,r=[];for(;t=n.exec(e);)r.push(t[1],t[2].trim());return r}(t)):null,r=this.top;if(null!=n)for(let e=0;e<n.length;e++)this.addPendingMark(n[e]);if(this.addElement(e),null!=n)for(let e=0;e<n.length;e++)this.removePendingMark(n[e],r)}}addTextNode(e){let t=e.nodeValue,n=this.top;if(2&n.options||n.inlineContext(e)||/[^ \t\r\n\u000c]/.test(t)){if(1&n.options)t=2&n.options?t.replace(/\r\n?/g,"\n"):t.replace(/\r?\n|\r/g," ");else if(t=t.replace(/[ \t\r\n\u000c]+/g," "),/^[ \t\r\n\u000c]/.test(t)&&this.open==this.nodes.length-1){let r=n.content[n.content.length-1],o=e.previousSibling;(!r||o&&"BR"==o.nodeName||r.isText&&/[ \t\r\n\u000c]$/.test(r.text))&&(t=t.slice(1))}t&&this.insertNode(this.parser.schema.text(t)),this.findInText(e)}else this.findInside(e)}addElement(e,t){let n,r=e.nodeName.toLowerCase();oe.hasOwnProperty(r)&&this.parser.normalizeLists&&function(e){for(let t=e.firstChild,n=null;t;t=t.nextSibling){let e=1==t.nodeType?t.nodeName.toLowerCase():null;e&&oe.hasOwnProperty(e)&&n?(n.appendChild(t),t=n):"li"==e?n=t:e&&(n=null)}}(e);let o=this.options.ruleFromNode&&this.options.ruleFromNode(e)||(n=this.parser.matchTag(e,this,t));if(o?o.ignore:re.hasOwnProperty(r))this.findInside(e),this.ignoreFallback(e);else if(!o||o.skip||o.closeParent){o&&o.closeParent?this.open=Math.max(0,this.open-1):o&&o.skip.nodeType&&(e=o.skip);let t,n=this.top,i=this.needsBlock;if(ne.hasOwnProperty(r))t=!0,n.type||(this.needsBlock=!0);else if(!e.firstChild)return void this.leafFallback(e);this.addAll(e),t&&this.sync(n),this.needsBlock=i}else this.addElementByRule(e,o,!1===o.consuming?n:void 0)}leafFallback(e){"BR"==e.nodeName&&this.top.type&&this.top.type.inlineContent&&this.addTextNode(e.ownerDocument.createTextNode("\n"))}ignoreFallback(e){"BR"!=e.nodeName||this.top.type&&this.top.type.inlineContent||this.findPlace(this.parser.schema.text("-"))}readStyles(e){let t=m.none;e:for(let n=0;n<e.length;n+=2)for(let r;;){let o=this.parser.matchStyle(e[n],e[n+1],this,r);if(!o)continue e;if(o.ignore)return null;if(t=this.parser.schema.marks[o.mark].create(o.attrs).addToSet(t),!1!==o.consuming)break;r=o}return t}addElementByRule(e,t,n){let r,o,i;if(t.node)o=this.parser.schema.nodes[t.node],o.isLeaf?this.insertNode(o.create(t.attrs))||this.leafFallback(e):r=this.enter(o,t.attrs||null,t.preserveWhitespace);else{i=this.parser.schema.marks[t.mark].create(t.attrs),this.addPendingMark(i)}let s=this.top;if(o&&o.isLeaf)this.findInside(e);else if(n)this.addElement(e,n);else if(t.getContent)this.findInside(e),t.getContent(e,this.parser.schema).forEach((e=>this.insertNode(e)));else{let n=e;"string"==typeof t.contentElement?n=e.querySelector(t.contentElement):"function"==typeof t.contentElement?n=t.contentElement(e):t.contentElement&&(n=t.contentElement),this.findAround(e,n,!0),this.addAll(n)}r&&this.sync(s)&&this.open--,i&&this.removePendingMark(i,s)}addAll(e,t,n){let r=t||0;for(let o=t?e.childNodes[t]:e.firstChild,i=null==n?null:e.childNodes[n];o!=i;o=o.nextSibling,++r)this.findAtPoint(e,r),this.addDOM(o);this.findAtPoint(e,r)}findPlace(e){let t,n;for(let r=this.open;r>=0;r--){let o=this.nodes[r],i=o.findWrapping(e);if(i&&(!t||t.length>i.length)&&(t=i,n=o,!i.length))break;if(o.solid)break}if(!t)return!1;this.sync(n);for(let e=0;e<t.length;e++)this.enterInner(t[e],null,!1);return!0}insertNode(e){if(e.isInline&&this.needsBlock&&!this.top.type){let e=this.textblockFromContext();e&&this.enterInner(e)}if(this.findPlace(e)){this.closeExtra();let t=this.top;t.applyPending(e.type),t.match&&(t.match=t.match.matchType(e.type));let n=t.activeMarks;for(let r=0;r<e.marks.length;r++)t.type&&!t.type.allowsMarkType(e.marks[r].type)||(n=e.marks[r].addToSet(n));return t.content.push(e.mark(n)),!0}return!1}enter(e,t,n){let r=this.findPlace(e.create(t));return r&&this.enterInner(e,t,!0,n),r}enterInner(e,t=null,n=!1,r){this.closeExtra();let o=this.top;o.applyPending(e),o.match=o.match&&o.match.matchType(e);let i=ie(e,r,o.options);4&o.options&&0==o.content.length&&(i|=4),this.nodes.push(new se(e,t,o.activeMarks,o.pendingMarks,n,null,i)),this.open++}closeExtra(e=!1){let t=this.nodes.length-1;if(t>this.open){for(;t>this.open;t--)this.nodes[t-1].content.push(this.nodes[t].finish(e));this.nodes.length=this.open+1}}finish(){return this.open=0,this.closeExtra(this.isOpen),this.nodes[0].finish(this.isOpen||this.options.topOpen)}sync(e){for(let t=this.open;t>=0;t--)if(this.nodes[t]==e)return this.open=t,!0;return!1}get currentPos(){this.closeExtra();let e=0;for(let t=this.open;t>=0;t--){let n=this.nodes[t].content;for(let t=n.length-1;t>=0;t--)e+=n[t].nodeSize;t&&e++}return e}findAtPoint(e,t){if(this.find)for(let n=0;n<this.find.length;n++)this.find[n].node==e&&this.find[n].offset==t&&(this.find[n].pos=this.currentPos)}findInside(e){if(this.find)for(let t=0;t<this.find.length;t++)null==this.find[t].pos&&1==e.nodeType&&e.contains(this.find[t].node)&&(this.find[t].pos=this.currentPos)}findAround(e,t,n){if(e!=t&&this.find)for(let r=0;r<this.find.length;r++)if(null==this.find[r].pos&&1==e.nodeType&&e.contains(this.find[r].node)){t.compareDocumentPosition(this.find[r].node)&(n?2:4)&&(this.find[r].pos=this.currentPos)}}findInText(e){if(this.find)for(let t=0;t<this.find.length;t++)this.find[t].node==e&&(this.find[t].pos=this.currentPos-(e.nodeValue.length-this.find[t].offset))}matchesContext(e){if(e.indexOf("|")>-1)return e.split(/\s*\|\s*/).some(this.matchesContext,this);let t=e.split("/"),n=this.options.context,r=!(this.isOpen||n&&n.parent.type!=this.nodes[0].type),o=-(n?n.depth+1:0)+(r?0:1),i=(e,s)=>{for(;e>=0;e--){let a=t[e];if(""==a){if(e==t.length-1||0==e)continue;for(;s>=o;s--)if(i(e-1,s))return!0;return!1}{let e=s>0||0==s&&r?this.nodes[s].type:n&&s>=o?n.node(s-o).type:null;if(!e||e.name!=a&&-1==e.groups.indexOf(a))return!1;s--}}return!0};return i(t.length-1,this.open)}textblockFromContext(){let e=this.options.context;if(e)for(let t=e.depth;t>=0;t--){let n=e.node(t).contentMatchAt(e.indexAfter(t)).defaultType;if(n&&n.isTextblock&&n.defaultAttrs)return n}for(let e in this.parser.schema.nodes){let t=this.parser.schema.nodes[e];if(t.isTextblock&&t.defaultAttrs)return t}}addPendingMark(e){let t=function(e,t){for(let n=0;n<t.length;n++)if(e.eq(t[n]))return t[n]}(e,this.top.pendingMarks);t&&this.top.stashMarks.push(t),this.top.pendingMarks=e.addToSet(this.top.pendingMarks)}removePendingMark(e,t){for(let n=this.open;n>=0;n--){let r=this.nodes[n];if(r.pendingMarks.lastIndexOf(e)>-1)r.pendingMarks=e.removeFromSet(r.pendingMarks);else{r.activeMarks=e.removeFromSet(r.activeMarks);let t=r.popFromStashMark(e);t&&r.type&&r.type.allowsMarkType(t.type)&&(r.activeMarks=t.addToSet(r.activeMarks))}if(r==t)break}}}function le(e,t){return(e.matches||e.msMatchesSelector||e.webkitMatchesSelector||e.mozMatchesSelector).call(e,t)}function ce(e){let t={};for(let n in e)t[n]=e[n];return t}function ue(e,t){let n=t.schema.nodes;for(let r in n){let o=n[r];if(!o.allowsMarkType(e))continue;let i=[],s=e=>{i.push(e);for(let n=0;n<e.edgeCount;n++){let{type:r,next:o}=e.edge(n);if(r==t)return!0;if(i.indexOf(o)<0&&s(o))return!0}};if(s(o.contentMatch))return!0}}class de{constructor(e,t){this.nodes=e,this.marks=t}serializeFragment(e,t={},n){n||(n=he(t).createDocumentFragment());let r=n,o=[];return e.forEach((e=>{if(o.length||e.marks.length){let n=0,i=0;for(;n<o.length&&i<e.marks.length;){let t=e.marks[i];if(this.marks[t.type.name]){if(!t.eq(o[n][0])||!1===t.type.spec.spanning)break;n++,i++}else i++}for(;n<o.length;)r=o.pop()[1];for(;i<e.marks.length;){let n=e.marks[i++],s=this.serializeMark(n,e.isInline,t);s&&(o.push([n,r]),r.appendChild(s.dom),r=s.contentDOM||s.dom)}}r.appendChild(this.serializeNodeInner(e,t))})),n}serializeNodeInner(e,t){let{dom:n,contentDOM:r}=de.renderSpec(he(t),this.nodes[e.type.name](e));if(r){if(e.isLeaf)throw new RangeError("Content hole not allowed in a leaf node spec");this.serializeFragment(e.content,t,r)}return n}serializeNode(e,t={}){let n=this.serializeNodeInner(e,t);for(let r=e.marks.length-1;r>=0;r--){let o=this.serializeMark(e.marks[r],e.isInline,t);o&&((o.contentDOM||o.dom).appendChild(n),n=o.dom)}return n}serializeMark(e,t,n={}){let r=this.marks[e.type.name];return r&&de.renderSpec(he(n),r(e,t))}static renderSpec(e,t,n=null){if("string"==typeof t)return{dom:e.createTextNode(t)};if(null!=t.nodeType)return{dom:t};if(t.dom&&null!=t.dom.nodeType)return t;let r,o=t[0],i=o.indexOf(" ");i>0&&(n=o.slice(0,i),o=o.slice(i+1));let s=n?e.createElementNS(n,o):e.createElement(o),a=t[1],l=1;if(a&&"object"==typeof a&&null==a.nodeType&&!Array.isArray(a)){l=2;for(let e in a)if(null!=a[e]){let t=e.indexOf(" ");t>0?s.setAttributeNS(e.slice(0,t),e.slice(t+1),a[e]):s.setAttribute(e,a[e])}}for(let o=l;o<t.length;o++){let i=t[o];if(0===i){if(o<t.length-1||o>l)throw new RangeError("Content hole must be the only child of its parent node");return{dom:s,contentDOM:s}}{let{dom:t,contentDOM:o}=de.renderSpec(e,i,n);if(s.appendChild(t),o){if(r)throw new RangeError("Multiple content holes");r=o}}}return{dom:s,contentDOM:r}}static fromSchema(e){return e.cached.domSerializer||(e.cached.domSerializer=new de(this.nodesFromSchema(e),this.marksFromSchema(e)))}static nodesFromSchema(e){let t=pe(e.nodes);return t.text||(t.text=e=>e.text),t}static marksFromSchema(e){return pe(e.marks)}}function pe(e){let t={};for(let n in e){let r=e[n].spec.toDOM;r&&(t[n]=r)}return t}function he(e){return e.document||window.document}var fe=n(956),me=n.n(fe),ge=n(969),ve=n.n(ge),ye=n(522),be=n.n(ye),we=n(204),ke=n.n(we),xe=n(462),Ce=n.n(xe),Te=n(758),Me=n.n(Te),Se=n(321),Ee=n.n(Se),Ne=n(929),Oe=n.n(Ne),De=n(934),Ae=n.n(De),Le=n(391),Ie=n.n(Le),Re=(/Mac/.test(navigator.platform),/[\u0020]+/g),Pe=/[>(){}[\]+-.!#|]/g,Be=/<([a-zA-Z_][a-zA-Z0-9\-._]*)(\s|[^\\>])*\/?>|<(\/)([a-zA-Z_][a-zA-Z0-9\-._]*)\s*\/?>|<!--[^-]+-->|<([a-zA-Z_][a-zA-Z0-9\-.:/]*)>/g,Fe=/\\[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~\\]/g,He=/[*_~`]/g,ze=/!\[.*\]\(.*\)/g,qe=/[[\]]/g,Ve=/(?:^|[^\\])\\(?!\\)/g,je=new RegExp('[&<>"]',"g");function $e(e){switch(e){case"&":return"&amp;";case"<":return"&lt;";case">":return"&gt;";case'"':return"&quot;";default:return e}}function _e(e){return je.test(e)?e.replace(je,$e):e}function Ue(e,t){return-1!==e.indexOf(t)}var We=["rel","target","hreflang","type"],Je={codeblock:/(^ {4}[^\n]+\n*)+/,thematicBreak:/^ *((\* *){3,}|(- *){3,} *|(_ *){3,}) */,atxHeading:/^(#{1,6}) +[\s\S]+/,seTextheading:/^([^\n]+)\n *(=|-){2,} */,blockquote:/^( *>[^\n]+.*)+/,list:/^ *(\*+|-+|\d+\.) [\s\S]+/,def:/^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? */,link:/!?\[.*\]\(.*\)/,reflink:/!?\[.*\]\s*\[([^\]]*)\]/,verticalBar:/\u007C/,fencedCodeblock:/^((`|~){3,})/};function Ge(e){if(!e)return null;var t={};return We.forEach((function(n){Oe()(e[n])||(t[n]=e[n])})),t}function Ke(e,t){for(var n="",r=0;r<t;r+=1)n+=e;return n}function Ze(e){for(var t=[],n=ze.exec(e);n;)t.push([n.index,n.index+n[0].length]),n=ze.exec(e);return e.replace(qe,(function(e,n){var r=t.some((function(e){return n>e[0]&&n<e[1]}));return r?e:"\\"+e}))}function Xe(e){var t=function(e){return"\\"+e},n=e.replace(Re," ");return Fe.test(n)&&(n=n.replace(Fe,t)),Ve.test(n)&&(n=n.replace(Ve,(function(e){return e+"\\"}))),n=n.replace(He,t),Be.test(n)&&(n=n.replace(Be,t)),function(e){var t=!1;return me()(Je,(function(n){return n.test(e)&&(t=!0),!t})),t}(n)&&(n=n.replace(Pe,t)),n}function Qe(e){return Ae()(e)||Oe()(e)}function Ye(e,t){if(null===e&&e===t)return!0;if("object"!=typeof e||"object"!=typeof t||Qe(e)||Qe(t))return e===t;for(var n in e)if(e[n]!==t[n])return!1;for(var n in t)if(!(n in e))return!1;return!0}function et(e){return e[e.length-1]}function tt(e){return"object"==typeof e&&null!==e}function nt(e,t){var n=o({},e);return e&&t&&Object.keys(t).forEach((function(e){tt(n[e])?Array.isArray(t[e])?n[e]=rt(t[e]):n.hasOwnProperty(e)?n[e]=nt(n[e],t[e]):n[e]=ot(t[e]):n[e]=t[e]})),n}function rt(e){return e.map((function(e){return tt(e)?Array.isArray(e)?rt(e):ot(e):e}))}function ot(e){var t=Object.keys(e);return t.length?t.reduce((function(t,n){return tt(e[n])?t[n]=Array.isArray(e[n])?rt(e[n]):ot(e[n]):t[n]=e[n],t}),{}):e}function it(e,t){return void 0===t&&(t={}),Object.keys(t).forEach((function(n){e.hasOwnProperty(n)&&"object"==typeof e[n]?Array.isArray(t[n])?e[n]=t[n]:it(e[n],t[n]):e[n]=t[n]})),e}function st(e,t){return e>t?[t,e]:[e,t]}const at=Math.pow(2,16);function lt(e,t){return e+t*at}function ct(e){return 65535&e}class ut{constructor(e,t,n){this.pos=e,this.delInfo=t,this.recover=n}get deleted(){return(8&this.delInfo)>0}get deletedBefore(){return(5&this.delInfo)>0}get deletedAfter(){return(6&this.delInfo)>0}get deletedAcross(){return(4&this.delInfo)>0}}class dt{constructor(e,t=!1){if(this.ranges=e,this.inverted=t,!e.length&&dt.empty)return dt.empty}recover(e){let t=0,n=ct(e);if(!this.inverted)for(let e=0;e<n;e++)t+=this.ranges[3*e+2]-this.ranges[3*e+1];return this.ranges[3*n]+t+function(e){return(e-(65535&e))/at}(e)}mapResult(e,t=1){return this._map(e,t,!1)}map(e,t=1){return this._map(e,t,!0)}_map(e,t,n){let r=0,o=this.inverted?2:1,i=this.inverted?1:2;for(let s=0;s<this.ranges.length;s+=3){let a=this.ranges[s]-(this.inverted?r:0);if(a>e)break;let l=this.ranges[s+o],c=this.ranges[s+i],u=a+l;if(e<=u){let o=a+r+((l?e==a?-1:e==u?1:t:t)<0?0:c);if(n)return o;let i=e==(t<0?a:u)?null:lt(s/3,e-a),d=e==a?2:e==u?1:4;return(t<0?e!=a:e!=u)&&(d|=8),new ut(o,d,i)}r+=c-l}return n?e+r:new ut(e+r,0,null)}touches(e,t){let n=0,r=ct(t),o=this.inverted?2:1,i=this.inverted?1:2;for(let t=0;t<this.ranges.length;t+=3){let s=this.ranges[t]-(this.inverted?n:0);if(s>e)break;let a=this.ranges[t+o];if(e<=s+a&&t==3*r)return!0;n+=this.ranges[t+i]-a}return!1}forEach(e){let t=this.inverted?2:1,n=this.inverted?1:2;for(let r=0,o=0;r<this.ranges.length;r+=3){let i=this.ranges[r],s=i-(this.inverted?o:0),a=i+(this.inverted?0:o),l=this.ranges[r+t],c=this.ranges[r+n];e(s,s+l,a,a+c),o+=c-l}}invert(){return new dt(this.ranges,!this.inverted)}toString(){return(this.inverted?"-":"")+JSON.stringify(this.ranges)}static offset(e){return 0==e?dt.empty:new dt(e<0?[0,-e,0]:[0,0,e])}}dt.empty=new dt([]);class pt{constructor(e=[],t,n=0,r=e.length){this.maps=e,this.mirror=t,this.from=n,this.to=r}slice(e=0,t=this.maps.length){return new pt(this.maps,this.mirror,e,t)}copy(){return new pt(this.maps.slice(),this.mirror&&this.mirror.slice(),this.from,this.to)}appendMap(e,t){this.to=this.maps.push(e),null!=t&&this.setMirror(this.maps.length-1,t)}appendMapping(e){for(let t=0,n=this.maps.length;t<e.maps.length;t++){let r=e.getMirror(t);this.appendMap(e.maps[t],null!=r&&r<t?n+r:void 0)}}getMirror(e){if(this.mirror)for(let t=0;t<this.mirror.length;t++)if(this.mirror[t]==e)return this.mirror[t+(t%2?-1:1)]}setMirror(e,t){this.mirror||(this.mirror=[]),this.mirror.push(e,t)}appendMappingInverted(e){for(let t=e.maps.length-1,n=this.maps.length+e.maps.length;t>=0;t--){let r=e.getMirror(t);this.appendMap(e.maps[t].invert(),null!=r&&r>t?n-r-1:void 0)}}invert(){let e=new pt;return e.appendMappingInverted(this),e}map(e,t=1){if(this.mirror)return this._map(e,t,!0);for(let n=this.from;n<this.to;n++)e=this.maps[n].map(e,t);return e}mapResult(e,t=1){return this._map(e,t,!1)}_map(e,t,n){let r=0;for(let n=this.from;n<this.to;n++){let o=this.maps[n].mapResult(e,t);if(null!=o.recover){let t=this.getMirror(n);if(null!=t&&t>n&&t<this.to){n=t,e=this.maps[t].recover(o.recover);continue}}r|=o.delInfo,e=o.pos}return n?e:new ut(e,r,null)}}const ht=Object.create(null);class ft{getMap(){return dt.empty}merge(e){return null}static fromJSON(e,t){if(!t||!t.stepType)throw new RangeError("Invalid input for Step.fromJSON");let n=ht[t.stepType];if(!n)throw new RangeError(`No step type ${t.stepType} defined`);return n.fromJSON(e,t)}static jsonID(e,t){if(e in ht)throw new RangeError("Duplicate use of step JSON ID "+e);return ht[e]=t,t.prototype.jsonID=e,t}}class mt{constructor(e,t){this.doc=e,this.failed=t}static ok(e){return new mt(e,null)}static fail(e){return new mt(null,e)}static fromReplace(e,t,n,r){try{return mt.ok(e.replace(t,n,r))}catch(e){if(e instanceof g)return mt.fail(e.message);throw e}}}function gt(e,t,n){let r=[];for(let o=0;o<e.childCount;o++){let i=e.child(o);i.content.size&&(i=i.copy(gt(i.content,t,i))),i.isInline&&(i=t(i,n,o)),r.push(i)}return d.fromArray(r)}class vt extends ft{constructor(e,t,n){super(),this.from=e,this.to=t,this.mark=n}apply(e){let t=e.slice(this.from,this.to),n=e.resolve(this.from),r=n.node(n.sharedDepth(this.to)),o=new v(gt(t.content,((e,t)=>e.isAtom&&t.type.allowsMarkType(this.mark.type)?e.mark(this.mark.addToSet(e.marks)):e),r),t.openStart,t.openEnd);return mt.fromReplace(e,this.from,this.to,o)}invert(){return new yt(this.from,this.to,this.mark)}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1);return t.deleted&&n.deleted||t.pos>=n.pos?null:new vt(t.pos,n.pos,this.mark)}merge(e){return e instanceof vt&&e.mark.eq(this.mark)&&this.from<=e.to&&this.to>=e.from?new vt(Math.min(this.from,e.from),Math.max(this.to,e.to),this.mark):null}toJSON(){return{stepType:"addMark",mark:this.mark.toJSON(),from:this.from,to:this.to}}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to)throw new RangeError("Invalid input for AddMarkStep.fromJSON");return new vt(t.from,t.to,e.markFromJSON(t.mark))}}ft.jsonID("addMark",vt);class yt extends ft{constructor(e,t,n){super(),this.from=e,this.to=t,this.mark=n}apply(e){let t=e.slice(this.from,this.to),n=new v(gt(t.content,(e=>e.mark(this.mark.removeFromSet(e.marks))),e),t.openStart,t.openEnd);return mt.fromReplace(e,this.from,this.to,n)}invert(){return new vt(this.from,this.to,this.mark)}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1);return t.deleted&&n.deleted||t.pos>=n.pos?null:new yt(t.pos,n.pos,this.mark)}merge(e){return e instanceof yt&&e.mark.eq(this.mark)&&this.from<=e.to&&this.to>=e.from?new yt(Math.min(this.from,e.from),Math.max(this.to,e.to),this.mark):null}toJSON(){return{stepType:"removeMark",mark:this.mark.toJSON(),from:this.from,to:this.to}}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to)throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");return new yt(t.from,t.to,e.markFromJSON(t.mark))}}ft.jsonID("removeMark",yt);class bt extends ft{constructor(e,t,n,r=!1){super(),this.from=e,this.to=t,this.slice=n,this.structure=r}apply(e){return this.structure&&kt(e,this.from,this.to)?mt.fail("Structure replace would overwrite content"):mt.fromReplace(e,this.from,this.to,this.slice)}getMap(){return new dt([this.from,this.to-this.from,this.slice.size])}invert(e){return new bt(this.from,this.from+this.slice.size,e.slice(this.from,this.to))}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1);return t.deletedAcross&&n.deletedAcross?null:new bt(t.pos,Math.max(t.pos,n.pos),this.slice)}merge(e){if(!(e instanceof bt)||e.structure||this.structure)return null;if(this.from+this.slice.size!=e.from||this.slice.openEnd||e.slice.openStart){if(e.to!=this.from||this.slice.openStart||e.slice.openEnd)return null;{let t=this.slice.size+e.slice.size==0?v.empty:new v(e.slice.content.append(this.slice.content),e.slice.openStart,this.slice.openEnd);return new bt(e.from,this.to,t,this.structure)}}{let t=this.slice.size+e.slice.size==0?v.empty:new v(this.slice.content.append(e.slice.content),this.slice.openStart,e.slice.openEnd);return new bt(this.from,this.to+(e.to-e.from),t,this.structure)}}toJSON(){let e={stepType:"replace",from:this.from,to:this.to};return this.slice.size&&(e.slice=this.slice.toJSON()),this.structure&&(e.structure=!0),e}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to)throw new RangeError("Invalid input for ReplaceStep.fromJSON");return new bt(t.from,t.to,v.fromJSON(e,t.slice),!!t.structure)}}ft.jsonID("replace",bt);class wt extends ft{constructor(e,t,n,r,o,i,s=!1){super(),this.from=e,this.to=t,this.gapFrom=n,this.gapTo=r,this.slice=o,this.insert=i,this.structure=s}apply(e){if(this.structure&&(kt(e,this.from,this.gapFrom)||kt(e,this.gapTo,this.to)))return mt.fail("Structure gap-replace would overwrite content");let t=e.slice(this.gapFrom,this.gapTo);if(t.openStart||t.openEnd)return mt.fail("Gap is not a flat range");let n=this.slice.insertAt(this.insert,t.content);return n?mt.fromReplace(e,this.from,this.to,n):mt.fail("Content does not fit in gap")}getMap(){return new dt([this.from,this.gapFrom-this.from,this.insert,this.gapTo,this.to-this.gapTo,this.slice.size-this.insert])}invert(e){let t=this.gapTo-this.gapFrom;return new wt(this.from,this.from+this.slice.size+t,this.from+this.insert,this.from+this.insert+t,e.slice(this.from,this.to).removeBetween(this.gapFrom-this.from,this.gapTo-this.from),this.gapFrom-this.from,this.structure)}map(e){let t=e.mapResult(this.from,1),n=e.mapResult(this.to,-1),r=e.map(this.gapFrom,-1),o=e.map(this.gapTo,1);return t.deletedAcross&&n.deletedAcross||r<t.pos||o>n.pos?null:new wt(t.pos,n.pos,r,o,this.slice,this.insert,this.structure)}toJSON(){let e={stepType:"replaceAround",from:this.from,to:this.to,gapFrom:this.gapFrom,gapTo:this.gapTo,insert:this.insert};return this.slice.size&&(e.slice=this.slice.toJSON()),this.structure&&(e.structure=!0),e}static fromJSON(e,t){if("number"!=typeof t.from||"number"!=typeof t.to||"number"!=typeof t.gapFrom||"number"!=typeof t.gapTo||"number"!=typeof t.insert)throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");return new wt(t.from,t.to,t.gapFrom,t.gapTo,v.fromJSON(e,t.slice),t.insert,!!t.structure)}}function kt(e,t,n){let r=e.resolve(t),o=n-t,i=r.depth;for(;o>0&&i>0&&r.indexAfter(i)==r.node(i).childCount;)i--,o--;if(o>0){let e=r.node(i).maybeChild(r.indexAfter(i));for(;o>0;){if(!e||e.isLeaf)return!0;e=e.firstChild,o--}}return!1}function xt(e,t,n){return(0==t||e.canReplace(t,e.childCount))&&(n==e.childCount||e.canReplace(0,n))}function Ct(e){let t=e.parent.content.cutByIndex(e.startIndex,e.endIndex);for(let n=e.depth;;--n){let r=e.$from.node(n),o=e.$from.index(n),i=e.$to.indexAfter(n);if(n<e.depth&&r.canReplace(o,i,t))return n;if(0==n||r.type.spec.isolating||!xt(r,o,i))break}return null}function Tt(e){return{type:e,attrs:null}}function Mt(e,t,n=1,r){let o=e.resolve(t),i=o.depth-n,s=r&&r[r.length-1]||o.parent;if(i<0||o.parent.type.spec.isolating||!o.parent.canReplace(o.index(),o.parent.childCount)||!s.type.validContent(o.parent.content.cutByIndex(o.index(),o.parent.childCount)))return!1;for(let e=o.depth-1,t=n-2;e>i;e--,t--){let n=o.node(e),i=o.index(e);if(n.type.spec.isolating)return!1;let s=n.content.cutByIndex(i,n.childCount),a=r&&r[t]||n;if(a!=n&&(s=s.replaceChild(0,a.type.create(a.attrs))),!n.canReplace(i+1,n.childCount)||!a.type.validContent(s))return!1}let a=o.indexAfter(i),l=r&&r[0];return o.node(i).canReplaceWith(a,a,l?l.type:o.node(i+1).type)}function St(e,t){let n=e.resolve(t),r=n.index();return Et(n.nodeBefore,n.nodeAfter)&&n.parent.canReplace(r,r+1)}function Et(e,t){return!(!e||!t||e.isLeaf||!e.canAppend(t))}function Nt(e,t,n=t,r=v.empty){if(t==n&&!r.size)return null;let o=e.resolve(t),i=e.resolve(n);return Ot(o,i,r)?new bt(t,n,r):new Dt(o,i,r).fit()}function Ot(e,t,n){return!n.openStart&&!n.openEnd&&e.start()==t.start()&&e.parent.canReplace(e.index(),t.index(),n.content)}ft.jsonID("replaceAround",wt);class Dt{constructor(e,t,n){this.$from=e,this.$to=t,this.unplaced=n,this.frontier=[],this.placed=d.empty;for(let t=0;t<=e.depth;t++){let n=e.node(t);this.frontier.push({type:n.type,match:n.contentMatchAt(e.indexAfter(t))})}for(let t=e.depth;t>0;t--)this.placed=d.from(e.node(t).copy(this.placed))}get depth(){return this.frontier.length-1}fit(){for(;this.unplaced.size;){let e=this.findFittable();e?this.placeNodes(e):this.openMore()||this.dropNode()}let e=this.mustMoveInline(),t=this.placed.size-this.depth-this.$from.depth,n=this.$from,r=this.close(e<0?this.$to:n.doc.resolve(e));if(!r)return null;let o=this.placed,i=n.depth,s=r.depth;for(;i&&s&&1==o.childCount;)o=o.firstChild.content,i--,s--;let a=new v(o,i,s);return e>-1?new wt(n.pos,e,this.$to.pos,this.$to.end(),a,t):a.size||n.pos!=this.$to.pos?new bt(n.pos,r.pos,a):null}findFittable(){for(let e=1;e<=2;e++)for(let t=this.unplaced.openStart;t>=0;t--){let n,r=null;t?(r=It(this.unplaced.content,t-1).firstChild,n=r.content):n=this.unplaced.content;let o=n.firstChild;for(let n=this.depth;n>=0;n--){let i,{type:s,match:a}=this.frontier[n],l=null;if(1==e&&(o?a.matchType(o.type)||(l=a.fillBefore(d.from(o),!1)):r&&s.compatibleContent(r.type)))return{sliceDepth:t,frontierDepth:n,parent:r,inject:l};if(2==e&&o&&(i=a.findWrapping(o.type)))return{sliceDepth:t,frontierDepth:n,parent:r,wrap:i};if(r&&a.matchType(r.type))break}}}openMore(){let{content:e,openStart:t,openEnd:n}=this.unplaced,r=It(e,t);return!(!r.childCount||r.firstChild.isLeaf)&&(this.unplaced=new v(e,t+1,Math.max(n,r.size+t>=e.size-n?t+1:0)),!0)}dropNode(){let{content:e,openStart:t,openEnd:n}=this.unplaced,r=It(e,t);if(r.childCount<=1&&t>0){let o=e.size-t<=t+r.size;this.unplaced=new v(At(e,t-1,1),t-1,o?t-1:n)}else this.unplaced=new v(At(e,t,1),t,n)}placeNodes({sliceDepth:e,frontierDepth:t,parent:n,inject:r,wrap:o}){for(;this.depth>t;)this.closeFrontierNode();if(o)for(let e=0;e<o.length;e++)this.openFrontierNode(o[e]);let i=this.unplaced,s=n?n.content:i.content,a=i.openStart-e,l=0,c=[],{match:u,type:p}=this.frontier[t];if(r){for(let e=0;e<r.childCount;e++)c.push(r.child(e));u=u.matchFragment(r)}let h=s.size+e-(i.content.size-i.openEnd);for(;l<s.childCount;){let e=s.child(l),t=u.matchType(e.type);if(!t)break;l++,(l>1||0==a||e.content.size)&&(u=t,c.push(Rt(e.mark(p.allowedMarks(e.marks)),1==l?a:0,l==s.childCount?h:-1)))}let f=l==s.childCount;f||(h=-1),this.placed=Lt(this.placed,t,d.from(c)),this.frontier[t].match=u,f&&h<0&&n&&n.type==this.frontier[this.depth].type&&this.frontier.length>1&&this.closeFrontierNode();for(let e=0,t=s;e<h;e++){let e=t.lastChild;this.frontier.push({type:e.type,match:e.contentMatchAt(e.childCount)}),t=e.content}this.unplaced=f?0==e?v.empty:new v(At(i.content,e-1,1),e-1,h<0?i.openEnd:e-1):new v(At(i.content,e,l),i.openStart,i.openEnd)}mustMoveInline(){if(!this.$to.parent.isTextblock)return-1;let e,t=this.frontier[this.depth];if(!t.type.isTextblock||!Pt(this.$to,this.$to.depth,t.type,t.match,!1)||this.$to.depth==this.depth&&(e=this.findCloseLevel(this.$to))&&e.depth==this.depth)return-1;let{depth:n}=this.$to,r=this.$to.after(n);for(;n>1&&r==this.$to.end(--n);)++r;return r}findCloseLevel(e){e:for(let t=Math.min(this.depth,e.depth);t>=0;t--){let{match:n,type:r}=this.frontier[t],o=t<e.depth&&e.end(t+1)==e.pos+(e.depth-(t+1)),i=Pt(e,t,r,n,o);if(i){for(let n=t-1;n>=0;n--){let{match:t,type:r}=this.frontier[n],o=Pt(e,n,r,t,!0);if(!o||o.childCount)continue e}return{depth:t,fit:i,move:o?e.doc.resolve(e.after(t+1)):e}}}}close(e){let t=this.findCloseLevel(e);if(!t)return null;for(;this.depth>t.depth;)this.closeFrontierNode();t.fit.childCount&&(this.placed=Lt(this.placed,t.depth,t.fit)),e=t.move;for(let n=t.depth+1;n<=e.depth;n++){let t=e.node(n),r=t.type.contentMatch.fillBefore(t.content,!0,e.index(n));this.openFrontierNode(t.type,t.attrs,r)}return e}openFrontierNode(e,t=null,n){let r=this.frontier[this.depth];r.match=r.match.matchType(e),this.placed=Lt(this.placed,this.depth,d.from(e.create(t,n))),this.frontier.push({type:e,match:e.contentMatch})}closeFrontierNode(){let e=this.frontier.pop().match.fillBefore(d.empty,!0);e.childCount&&(this.placed=Lt(this.placed,this.frontier.length,e))}}function At(e,t,n){return 0==t?e.cutByIndex(n,e.childCount):e.replaceChild(0,e.firstChild.copy(At(e.firstChild.content,t-1,n)))}function Lt(e,t,n){return 0==t?e.append(n):e.replaceChild(e.childCount-1,e.lastChild.copy(Lt(e.lastChild.content,t-1,n)))}function It(e,t){for(let n=0;n<t;n++)e=e.firstChild.content;return e}function Rt(e,t,n){if(t<=0)return e;let r=e.content;return t>1&&(r=r.replaceChild(0,Rt(r.firstChild,t-1,1==r.childCount?n-1:0))),t>0&&(r=e.type.contentMatch.fillBefore(r).append(r),n<=0&&(r=r.append(e.type.contentMatch.matchFragment(r).fillBefore(d.empty,!0)))),e.copy(r)}function Pt(e,t,n,r,o){let i=e.node(t),s=o?e.indexAfter(t):e.index(t);if(s==i.childCount&&!n.compatibleContent(i.type))return null;let a=r.fillBefore(i.content,!0,s);return a&&!function(e,t,n){for(let r=n;r<t.childCount;r++)if(!e.allowsMarks(t.child(r).marks))return!0;return!1}(n,i.content,s)?a:null}function Bt(e){return e.spec.defining||e.spec.definingForContent}function Ft(e,t,n,r,o){if(t<n){let o=e.firstChild;e=e.replaceChild(0,o.copy(Ft(o.content,t+1,n,r,o)))}if(t>r){let t=o.contentMatchAt(0),n=t.fillBefore(e).append(e);e=n.append(t.matchFragment(n).fillBefore(d.empty,!0))}return e}function Ht(e,t){let n=[];for(let r=Math.min(e.depth,t.depth);r>=0;r--){let o=e.start(r);if(o<e.pos-(e.depth-r)||t.end(r)>t.pos+(t.depth-r)||e.node(r).type.spec.isolating||t.node(r).type.spec.isolating)break;(o==t.start(r)||r==e.depth&&r==t.depth&&e.parent.inlineContent&&t.parent.inlineContent&&r&&t.start(r-1)==o-1)&&n.push(r)}return n}let zt=class extends Error{};zt=function e(t){let n=Error.call(this,t);return n.__proto__=e.prototype,n},(zt.prototype=Object.create(Error.prototype)).constructor=zt,zt.prototype.name="TransformError";const qt=Object.create(null);class Vt{constructor(e,t,n){this.$anchor=e,this.$head=t,this.ranges=n||[new jt(e.min(t),e.max(t))]}get anchor(){return this.$anchor.pos}get head(){return this.$head.pos}get from(){return this.$from.pos}get to(){return this.$to.pos}get $from(){return this.ranges[0].$from}get $to(){return this.ranges[0].$to}get empty(){let e=this.ranges;for(let t=0;t<e.length;t++)if(e[t].$from.pos!=e[t].$to.pos)return!1;return!0}content(){return this.$from.doc.slice(this.from,this.to,!0)}replace(e,t=v.empty){let n=t.content.lastChild,r=null;for(let e=0;e<t.openEnd;e++)r=n,n=n.lastChild;let o=e.steps.length,i=this.ranges;for(let s=0;s<i.length;s++){let{$from:a,$to:l}=i[s],c=e.mapping.slice(o);e.replaceRange(c.map(a.pos),c.map(l.pos),s?v.empty:t),0==s&&Qt(e,o,(n?n.isInline:r&&r.isTextblock)?-1:1)}}replaceWith(e,t){let n=e.steps.length,r=this.ranges;for(let o=0;o<r.length;o++){let{$from:i,$to:s}=r[o],a=e.mapping.slice(n),l=a.map(i.pos),c=a.map(s.pos);o?e.deleteRange(l,c):(e.replaceRangeWith(l,c,t),Qt(e,n,t.isInline?-1:1))}}static findFrom(e,t,n=!1){let r=e.parent.inlineContent?new Ut(e):Xt(e.node(0),e.parent,e.pos,e.index(),t,n);if(r)return r;for(let r=e.depth-1;r>=0;r--){let o=t<0?Xt(e.node(0),e.node(r),e.before(r+1),e.index(r),t,n):Xt(e.node(0),e.node(r),e.after(r+1),e.index(r)+1,t,n);if(o)return o}return null}static near(e,t=1){return this.findFrom(e,t)||this.findFrom(e,-t)||new Kt(e.node(0))}static atStart(e){return Xt(e,e,0,0,1)||new Kt(e)}static atEnd(e){return Xt(e,e,e.content.size,e.childCount,-1)||new Kt(e)}static fromJSON(e,t){if(!t||!t.type)throw new RangeError("Invalid input for Selection.fromJSON");let n=qt[t.type];if(!n)throw new RangeError(`No selection type ${t.type} defined`);return n.fromJSON(e,t)}static jsonID(e,t){if(e in qt)throw new RangeError("Duplicate use of selection JSON ID "+e);return qt[e]=t,t.prototype.jsonID=e,t}getBookmark(){return Ut.between(this.$anchor,this.$head).getBookmark()}}Vt.prototype.visible=!0;class jt{constructor(e,t){this.$from=e,this.$to=t}}let $t=!1;function _t(e){$t||e.parent.inlineContent||($t=!0,console.warn("TextSelection endpoint not pointing into a node with inline content ("+e.parent.type.name+")"))}class Ut extends Vt{constructor(e,t=e){_t(e),_t(t),super(e,t)}get $cursor(){return this.$anchor.pos==this.$head.pos?this.$head:null}map(e,t){let n=e.resolve(t.map(this.head));if(!n.parent.inlineContent)return Vt.near(n);let r=e.resolve(t.map(this.anchor));return new Ut(r.parent.inlineContent?r:n,n)}replace(e,t=v.empty){if(super.replace(e,t),t==v.empty){let t=this.$from.marksAcross(this.$to);t&&e.ensureMarks(t)}}eq(e){return e instanceof Ut&&e.anchor==this.anchor&&e.head==this.head}getBookmark(){return new Wt(this.anchor,this.head)}toJSON(){return{type:"text",anchor:this.anchor,head:this.head}}static fromJSON(e,t){if("number"!=typeof t.anchor||"number"!=typeof t.head)throw new RangeError("Invalid input for TextSelection.fromJSON");return new Ut(e.resolve(t.anchor),e.resolve(t.head))}static create(e,t,n=t){let r=e.resolve(t);return new this(r,n==t?r:e.resolve(n))}static between(e,t,n){let r=e.pos-t.pos;if(n&&!r||(n=r>=0?1:-1),!t.parent.inlineContent){let e=Vt.findFrom(t,n,!0)||Vt.findFrom(t,-n,!0);if(!e)return Vt.near(t,n);t=e.$head}return e.parent.inlineContent||(0==r||(e=(Vt.findFrom(e,-n,!0)||Vt.findFrom(e,n,!0)).$anchor).pos<t.pos!=r<0)&&(e=t),new Ut(e,t)}}Vt.jsonID("text",Ut);class Wt{constructor(e,t){this.anchor=e,this.head=t}map(e){return new Wt(e.map(this.anchor),e.map(this.head))}resolve(e){return Ut.between(e.resolve(this.anchor),e.resolve(this.head))}}class Jt extends Vt{constructor(e){let t=e.nodeAfter,n=e.node(0).resolve(e.pos+t.nodeSize);super(e,n),this.node=t}map(e,t){let{deleted:n,pos:r}=t.mapResult(this.anchor),o=e.resolve(r);return n?Vt.near(o):new Jt(o)}content(){return new v(d.from(this.node),0,0)}eq(e){return e instanceof Jt&&e.anchor==this.anchor}toJSON(){return{type:"node",anchor:this.anchor}}getBookmark(){return new Gt(this.anchor)}static fromJSON(e,t){if("number"!=typeof t.anchor)throw new RangeError("Invalid input for NodeSelection.fromJSON");return new Jt(e.resolve(t.anchor))}static create(e,t){return new Jt(e.resolve(t))}static isSelectable(e){return!e.isText&&!1!==e.type.spec.selectable}}Jt.prototype.visible=!1,Vt.jsonID("node",Jt);class Gt{constructor(e){this.anchor=e}map(e){let{deleted:t,pos:n}=e.mapResult(this.anchor);return t?new Wt(n,n):new Gt(n)}resolve(e){let t=e.resolve(this.anchor),n=t.nodeAfter;return n&&Jt.isSelectable(n)?new Jt(t):Vt.near(t)}}class Kt extends Vt{constructor(e){super(e.resolve(0),e.resolve(e.content.size))}replace(e,t=v.empty){if(t==v.empty){e.delete(0,e.doc.content.size);let t=Vt.atStart(e.doc);t.eq(e.selection)||e.setSelection(t)}else super.replace(e,t)}toJSON(){return{type:"all"}}static fromJSON(e){return new Kt(e)}map(e){return new Kt(e)}eq(e){return e instanceof Kt}getBookmark(){return Zt}}Vt.jsonID("all",Kt);const Zt={map(){return this},resolve:e=>new Kt(e)};function Xt(e,t,n,r,o,i=!1){if(t.inlineContent)return Ut.create(e,n);for(let s=r-(o>0?0:1);o>0?s<t.childCount:s>=0;s+=o){let r=t.child(s);if(r.isAtom){if(!i&&Jt.isSelectable(r))return Jt.create(e,n-(o<0?r.nodeSize:0))}else{let t=Xt(e,r,n+o,o<0?r.childCount:0,o,i);if(t)return t}n+=r.nodeSize*o}return null}function Qt(e,t,n){let r=e.steps.length-1;if(r<t)return;let o,i=e.steps[r];(i instanceof bt||i instanceof wt)&&(e.mapping.maps[r].forEach(((e,t,n,r)=>{null==o&&(o=r)})),e.setSelection(Vt.near(e.doc.resolve(o),n)))}class Yt extends class{constructor(e){this.doc=e,this.steps=[],this.docs=[],this.mapping=new pt}get before(){return this.docs.length?this.docs[0]:this.doc}step(e){let t=this.maybeStep(e);if(t.failed)throw new zt(t.failed);return this}maybeStep(e){let t=e.apply(this.doc);return t.failed||this.addStep(e,t.doc),t}get docChanged(){return this.steps.length>0}addStep(e,t){this.docs.push(this.doc),this.steps.push(e),this.mapping.appendMap(e.getMap()),this.doc=t}replace(e,t=e,n=v.empty){let r=Nt(this.doc,e,t,n);return r&&this.step(r),this}replaceWith(e,t,n){return this.replace(e,t,new v(d.from(n),0,0))}delete(e,t){return this.replace(e,t,v.empty)}insert(e,t){return this.replaceWith(e,e,t)}replaceRange(e,t,n){return function(e,t,n,r){if(!r.size)return e.deleteRange(t,n);let o=e.doc.resolve(t),i=e.doc.resolve(n);if(Ot(o,i,r))return e.step(new bt(t,n,r));let s=Ht(o,e.doc.resolve(n));0==s[s.length-1]&&s.pop();let a=-(o.depth+1);s.unshift(a);for(let e=o.depth,t=o.pos-1;e>0;e--,t--){let n=o.node(e).type.spec;if(n.defining||n.definingAsContext||n.isolating)break;s.indexOf(e)>-1?a=e:o.before(e)==t&&s.splice(1,0,-e)}let l=s.indexOf(a),c=[],u=r.openStart;for(let e=r.content,t=0;;t++){let n=e.firstChild;if(c.push(n),t==r.openStart)break;e=n.content}for(let e=u-1;e>=0;e--){let t=c[e].type,n=Bt(t);if(n&&o.node(l).type!=t)u=e;else if(n||!t.isTextblock)break}for(let t=r.openStart;t>=0;t--){let a=(t+u+1)%(r.openStart+1),d=c[a];if(d)for(let t=0;t<s.length;t++){let c=s[(t+l)%s.length],u=!0;c<0&&(u=!1,c=-c);let p=o.node(c-1),h=o.index(c-1);if(p.canReplaceWith(h,h,d.type,d.marks))return e.replace(o.before(c),u?i.after(c):n,new v(Ft(r.content,0,r.openStart,a),a,r.openEnd))}}let d=e.steps.length;for(let a=s.length-1;a>=0&&(e.replace(t,n,r),!(e.steps.length>d));a--){let e=s[a];e<0||(t=o.before(e),n=i.after(e))}}(this,e,t,n),this}replaceRangeWith(e,t,n){return function(e,t,n,r){if(!r.isInline&&t==n&&e.doc.resolve(t).parent.content.size){let o=function(e,t,n){let r=e.resolve(t);if(r.parent.canReplaceWith(r.index(),r.index(),n))return t;if(0==r.parentOffset)for(let e=r.depth-1;e>=0;e--){let t=r.index(e);if(r.node(e).canReplaceWith(t,t,n))return r.before(e+1);if(t>0)return null}if(r.parentOffset==r.parent.content.size)for(let e=r.depth-1;e>=0;e--){let t=r.indexAfter(e);if(r.node(e).canReplaceWith(t,t,n))return r.after(e+1);if(t<r.node(e).childCount)return null}return null}(e.doc,t,r.type);null!=o&&(t=n=o)}e.replaceRange(t,n,new v(d.from(r),0,0))}(this,e,t,n),this}deleteRange(e,t){return function(e,t,n){let r=e.doc.resolve(t),o=e.doc.resolve(n),i=Ht(r,o);for(let t=0;t<i.length;t++){let n=i[t],s=t==i.length-1;if(s&&0==n||r.node(n).type.contentMatch.validEnd)return e.delete(r.start(n),o.end(n));if(n>0&&(s||r.node(n-1).canReplace(r.index(n-1),o.indexAfter(n-1))))return e.delete(r.before(n),o.after(n))}for(let i=1;i<=r.depth&&i<=o.depth;i++)if(t-r.start(i)==r.depth-i&&n>r.end(i)&&o.end(i)-n!=o.depth-i)return e.delete(r.before(i),n);e.delete(t,n)}(this,e,t),this}lift(e,t){return function(e,t,n){let{$from:r,$to:o,depth:i}=t,s=r.before(i+1),a=o.after(i+1),l=s,c=a,u=d.empty,p=0;for(let e=i,t=!1;e>n;e--)t||r.index(e)>0?(t=!0,u=d.from(r.node(e).copy(u)),p++):l--;let h=d.empty,f=0;for(let e=i,t=!1;e>n;e--)t||o.after(e+1)<o.end(e)?(t=!0,h=d.from(o.node(e).copy(h)),f++):c++;e.step(new wt(l,c,s,a,new v(u.append(h),p,f),u.size-p,!0))}(this,e,t),this}join(e,t=1){return function(e,t,n){let r=new bt(t-n,t+n,v.empty,!0);e.step(r)}(this,e,t),this}wrap(e,t){return function(e,t,n){let r=d.empty;for(let e=n.length-1;e>=0;e--){if(r.size){let t=n[e].type.contentMatch.matchFragment(r);if(!t||!t.validEnd)throw new RangeError("Wrapper type given to Transform.wrap does not form valid content of its parent wrapper")}r=d.from(n[e].type.create(n[e].attrs,r))}let o=t.start,i=t.end;e.step(new wt(o,i,o,i,new v(r,0,0),n.length,!0))}(this,e,t),this}setBlockType(e,t=e,n,r=null){return function(e,t,n,r,o){if(!r.isTextblock)throw new RangeError("Type given to setBlockType should be a textblock");let i=e.steps.length;e.doc.nodesBetween(t,n,((t,n)=>{if(t.isTextblock&&!t.hasMarkup(r,o)&&function(e,t,n){let r=e.resolve(t),o=r.index();return r.parent.canReplaceWith(o,o+1,n)}(e.doc,e.mapping.slice(i).map(n),r)){e.clearIncompatible(e.mapping.slice(i).map(n,1),r);let s=e.mapping.slice(i),a=s.map(n,1),l=s.map(n+t.nodeSize,1);return e.step(new wt(a,l,a+1,l-1,new v(d.from(r.create(o,null,t.marks)),0,0),1,!0)),!1}}))}(this,e,t,n,r),this}setNodeMarkup(e,t,n=null,r=[]){return function(e,t,n,r,o){let i=e.doc.nodeAt(t);if(!i)throw new RangeError("No node at given position");n||(n=i.type);let s=n.create(r,null,o||i.marks);if(i.isLeaf)return e.replaceWith(t,t+i.nodeSize,s);if(!n.validContent(i.content))throw new RangeError("Invalid content for node type "+n.name);e.step(new wt(t,t+i.nodeSize,t+1,t+i.nodeSize-1,new v(d.from(s),0,0),1,!0))}(this,e,t,n,r),this}split(e,t=1,n){return function(e,t,n=1,r){let o=e.doc.resolve(t),i=d.empty,s=d.empty;for(let e=o.depth,t=o.depth-n,a=n-1;e>t;e--,a--){i=d.from(o.node(e).copy(i));let t=r&&r[a];s=d.from(t?t.type.create(t.attrs,s):o.node(e).copy(s))}e.step(new bt(t,t,new v(i.append(s),n,n),!0))}(this,e,t,n),this}addMark(e,t,n){return function(e,t,n,r){let o,i,s=[],a=[];e.doc.nodesBetween(t,n,((e,l,c)=>{if(!e.isInline)return;let u=e.marks;if(!r.isInSet(u)&&c.type.allowsMarkType(r.type)){let c=Math.max(l,t),d=Math.min(l+e.nodeSize,n),p=r.addToSet(u);for(let e=0;e<u.length;e++)u[e].isInSet(p)||(o&&o.to==c&&o.mark.eq(u[e])?o.to=d:s.push(o=new yt(c,d,u[e])));i&&i.to==c?i.to=d:a.push(i=new vt(c,d,r))}})),s.forEach((t=>e.step(t))),a.forEach((t=>e.step(t)))}(this,e,t,n),this}removeMark(e,t,n){return function(e,t,n,r){let o=[],i=0;e.doc.nodesBetween(t,n,((e,s)=>{if(!e.isInline)return;i++;let a=null;if(r instanceof Q){let t,n=e.marks;for(;t=r.isInSet(n);)(a||(a=[])).push(t),n=t.removeFromSet(n)}else r?r.isInSet(e.marks)&&(a=[r]):a=e.marks;if(a&&a.length){let r=Math.min(s+e.nodeSize,n);for(let e=0;e<a.length;e++){let n,l=a[e];for(let e=0;e<o.length;e++){let t=o[e];t.step==i-1&&l.eq(o[e].style)&&(n=t)}n?(n.to=r,n.step=i):o.push({style:l,from:Math.max(s,t),to:r,step:i})}}})),o.forEach((t=>e.step(new yt(t.from,t.to,t.style))))}(this,e,t,n),this}clearIncompatible(e,t,n){return function(e,t,n,r=n.contentMatch){let o=e.doc.nodeAt(t),i=[],s=t+1;for(let t=0;t<o.childCount;t++){let a=o.child(t),l=s+a.nodeSize,c=r.matchType(a.type);if(c){r=c;for(let t=0;t<a.marks.length;t++)n.allowsMarkType(a.marks[t].type)||e.step(new yt(s,l,a.marks[t]))}else i.push(new bt(s,l,v.empty));s=l}if(!r.validEnd){let t=r.fillBefore(d.empty,!0);e.replace(s,s,new v(t,0,0))}for(let t=i.length-1;t>=0;t--)e.step(i[t])}(this,e,t,n),this}}{constructor(e){super(e.doc),this.curSelectionFor=0,this.updated=0,this.meta=Object.create(null),this.time=Date.now(),this.curSelection=e.selection,this.storedMarks=e.storedMarks}get selection(){return this.curSelectionFor<this.steps.length&&(this.curSelection=this.curSelection.map(this.doc,this.mapping.slice(this.curSelectionFor)),this.curSelectionFor=this.steps.length),this.curSelection}setSelection(e){if(e.$from.doc!=this.doc)throw new RangeError("Selection passed to setSelection must point at the current document");return this.curSelection=e,this.curSelectionFor=this.steps.length,this.updated=-3&(1|this.updated),this.storedMarks=null,this}get selectionSet(){return(1&this.updated)>0}setStoredMarks(e){return this.storedMarks=e,this.updated|=2,this}ensureMarks(e){return m.sameSet(this.storedMarks||this.selection.$from.marks(),e)||this.setStoredMarks(e),this}addStoredMark(e){return this.ensureMarks(e.addToSet(this.storedMarks||this.selection.$head.marks()))}removeStoredMark(e){return this.ensureMarks(e.removeFromSet(this.storedMarks||this.selection.$head.marks()))}get storedMarksSet(){return(2&this.updated)>0}addStep(e,t){super.addStep(e,t),this.updated=-3&this.updated,this.storedMarks=null}setTime(e){return this.time=e,this}replaceSelection(e){return this.selection.replace(this,e),this}replaceSelectionWith(e,t=!0){let n=this.selection;return t&&(e=e.mark(this.storedMarks||(n.empty?n.$from.marks():n.$from.marksAcross(n.$to)||m.none))),n.replaceWith(this,e),this}deleteSelection(){return this.selection.replace(this),this}insertText(e,t,n){let r=this.doc.type.schema;if(null==t)return e?this.replaceSelectionWith(r.text(e),!0):this.deleteSelection();{if(null==n&&(n=t),n=null==n?t:n,!e)return this.deleteRange(t,n);let o=this.storedMarks;if(!o){let e=this.doc.resolve(t);o=n==t?e.marks():e.marksAcross(this.doc.resolve(n))}return this.replaceRangeWith(t,n,r.text(e,o)),this.selection.empty||this.setSelection(Vt.near(this.selection.$to)),this}}setMeta(e,t){return this.meta["string"==typeof e?e:e.key]=t,this}getMeta(e){return this.meta["string"==typeof e?e:e.key]}get isGeneric(){for(let e in this.meta)return!1;return!0}scrollIntoView(){return this.updated|=4,this}get scrolledIntoView(){return(4&this.updated)>0}}function en(e,t){return t&&e?e.bind(t):e}class tn{constructor(e,t,n){this.name=e,this.init=en(t.init,n),this.apply=en(t.apply,n)}}const nn=[new tn("doc",{init:e=>e.doc||e.schema.topNodeType.createAndFill(),apply:e=>e.doc}),new tn("selection",{init:(e,t)=>e.selection||Vt.atStart(t.doc),apply:e=>e.selection}),new tn("storedMarks",{init:e=>e.storedMarks||null,apply:(e,t,n,r)=>r.selection.$cursor?e.storedMarks:null}),new tn("scrollToSelection",{init:()=>0,apply:(e,t)=>e.scrolledIntoView?t+1:t})];class rn{constructor(e,t){this.schema=e,this.plugins=[],this.pluginsByKey=Object.create(null),this.fields=nn.slice(),t&&t.forEach((e=>{if(this.pluginsByKey[e.key])throw new RangeError("Adding different instances of a keyed plugin ("+e.key+")");this.plugins.push(e),this.pluginsByKey[e.key]=e,e.spec.state&&this.fields.push(new tn(e.key,e.spec.state,e))}))}}class on{constructor(e){this.config=e}get schema(){return this.config.schema}get plugins(){return this.config.plugins}apply(e){return this.applyTransaction(e).state}filterTransaction(e,t=-1){for(let n=0;n<this.config.plugins.length;n++)if(n!=t){let t=this.config.plugins[n];if(t.spec.filterTransaction&&!t.spec.filterTransaction.call(t,e,this))return!1}return!0}applyTransaction(e){if(!this.filterTransaction(e))return{state:this,transactions:[]};let t=[e],n=this.applyInner(e),r=null;for(;;){let o=!1;for(let i=0;i<this.config.plugins.length;i++){let s=this.config.plugins[i];if(s.spec.appendTransaction){let a=r?r[i].n:0,l=r?r[i].state:this,c=a<t.length&&s.spec.appendTransaction.call(s,a?t.slice(a):t,l,n);if(c&&n.filterTransaction(c,i)){if(c.setMeta("appendedTransaction",e),!r){r=[];for(let e=0;e<this.config.plugins.length;e++)r.push(e<i?{state:n,n:t.length}:{state:this,n:0})}t.push(c),n=n.applyInner(c),o=!0}r&&(r[i]={state:n,n:t.length})}}if(!o)return{state:n,transactions:t}}}applyInner(e){if(!e.before.eq(this.doc))throw new RangeError("Applying a mismatched transaction");let t=new on(this.config),n=this.config.fields;for(let r=0;r<n.length;r++){let o=n[r];t[o.name]=o.apply(e,this[o.name],this,t)}return t}get tr(){return new Yt(this)}static create(e){let t=new rn(e.doc?e.doc.type.schema:e.schema,e.plugins),n=new on(t);for(let r=0;r<t.fields.length;r++)n[t.fields[r].name]=t.fields[r].init(e,n);return n}reconfigure(e){let t=new rn(this.schema,e.plugins),n=t.fields,r=new on(t);for(let t=0;t<n.length;t++){let o=n[t].name;r[o]=this.hasOwnProperty(o)?this[o]:n[t].init(e,r)}return r}toJSON(e){let t={doc:this.doc.toJSON(),selection:this.selection.toJSON()};if(this.storedMarks&&(t.storedMarks=this.storedMarks.map((e=>e.toJSON()))),e&&"object"==typeof e)for(let n in e){if("doc"==n||"selection"==n)throw new RangeError("The JSON fields `doc` and `selection` are reserved");let r=e[n],o=r.spec.state;o&&o.toJSON&&(t[n]=o.toJSON.call(r,this[r.key]))}return t}static fromJSON(e,t,n){if(!t)throw new RangeError("Invalid input for EditorState.fromJSON");if(!e.schema)throw new RangeError("Required config field 'schema' missing");let r=new rn(e.schema,e.plugins),o=new on(r);return r.fields.forEach((r=>{if("doc"==r.name)o.doc=P.fromJSON(e.schema,t.doc);else if("selection"==r.name)o.selection=Vt.fromJSON(o.doc,t.selection);else if("storedMarks"==r.name)t.storedMarks&&(o.storedMarks=t.storedMarks.map(e.schema.markFromJSON));else{if(n)for(let i in n){let s=n[i],a=s.spec.state;if(s.key==r.name&&a&&a.fromJSON&&Object.prototype.hasOwnProperty.call(t,i))return void(o[r.name]=a.fromJSON.call(s,e,t[i],o))}o[r.name]=r.init(e,o)}})),o}}function sn(e,t,n){for(let r in e){let o=e[r];o instanceof Function?o=o.bind(t):"handleDOMEvents"==r&&(o=sn(o,t,{})),n[r]=o}return n}class an{constructor(e){this.spec=e,this.props={},e.props&&sn(e.props,this,this.props),this.key=e.key?e.key.key:cn("plugin")}getState(e){return e[this.key]}}const ln=Object.create(null);function cn(e){return e in ln?e+"$"+ ++ln[e]:(ln[e]=0,e+"$")}class un{constructor(e="key"){this.key=cn(e)}get(e){return e.config.pluginsByKey[this.key]}getState(e){return e[this.key]}}const dn="undefined"!=typeof navigator?navigator:null,pn="undefined"!=typeof document?document:null,hn=dn&&dn.userAgent||"",fn=/Edge\/(\d+)/.exec(hn),mn=/MSIE \d/.exec(hn),gn=/Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(hn),vn=!!(mn||gn||fn),yn=mn?document.documentMode:gn?+gn[1]:fn?+fn[1]:0,bn=!vn&&/gecko\/(\d+)/i.test(hn);bn&&(/Firefox\/(\d+)/.exec(hn)||[0,0])[1];const wn=!vn&&/Chrome\/(\d+)/.exec(hn),kn=!!wn,xn=wn?+wn[1]:0,Cn=!vn&&!!dn&&/Apple Computer/.test(dn.vendor),Tn=Cn&&(/Mobile\/\w+/.test(hn)||!!dn&&dn.maxTouchPoints>2),Mn=Tn||!!dn&&/Mac/.test(dn.platform),Sn=/Android \d/.test(hn),En=!!pn&&"webkitFontSmoothing"in pn.documentElement.style,Nn=En?+(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent)||[0,0])[1]:0,On=function(e){for(var t=0;;t++)if(!(e=e.previousSibling))return t},Dn=function(e){let t=e.assignedSlot||e.parentNode;return t&&11==t.nodeType?t.host:t};let An=null;const Ln=function(e,t,n){let r=An||(An=document.createRange());return r.setEnd(e,null==n?e.nodeValue.length:n),r.setStart(e,t||0),r},In=function(e,t,n,r){return n&&(Pn(e,t,n,r,-1)||Pn(e,t,n,r,1))},Rn=/^(img|br|input|textarea|hr)$/i;function Pn(e,t,n,r,o){for(;;){if(e==n&&t==r)return!0;if(t==(o<0?0:Bn(e))){let n=e.parentNode;if(!n||1!=n.nodeType||Fn(e)||Rn.test(e.nodeName)||"false"==e.contentEditable)return!1;t=On(e)+(o<0?0:1),e=n}else{if(1!=e.nodeType)return!1;if("false"==(e=e.childNodes[t+(o<0?-1:0)]).contentEditable)return!1;t=o<0?Bn(e):0}}}function Bn(e){return 3==e.nodeType?e.nodeValue.length:e.childNodes.length}function Fn(e){let t;for(let n=e;n&&!(t=n.pmViewDesc);n=n.parentNode);return t&&t.node&&t.node.isBlock&&(t.dom==e||t.contentDOM==e)}const Hn=function(e){let t=e.isCollapsed;return t&&kn&&e.rangeCount&&!e.getRangeAt(0).collapsed&&(t=!1),t};function zn(e,t){let n=document.createEvent("Event");return n.initEvent("keydown",!0,!0),n.keyCode=e,n.key=n.code=t,n}function qn(e){return{left:0,right:e.documentElement.clientWidth,top:0,bottom:e.documentElement.clientHeight}}function Vn(e,t){return"number"==typeof e?e:e[t]}function jn(e){let t=e.getBoundingClientRect(),n=t.width/e.offsetWidth||1,r=t.height/e.offsetHeight||1;return{left:t.left,right:t.left+e.clientWidth*n,top:t.top,bottom:t.top+e.clientHeight*r}}function $n(e,t,n){let r=e.someProp("scrollThreshold")||0,o=e.someProp("scrollMargin")||5,i=e.dom.ownerDocument;for(let s=n||e.dom;s;s=Dn(s)){if(1!=s.nodeType)continue;let e=s,n=e==i.body,a=n?qn(i):jn(e),l=0,c=0;if(t.top<a.top+Vn(r,"top")?c=-(a.top-t.top+Vn(o,"top")):t.bottom>a.bottom-Vn(r,"bottom")&&(c=t.bottom-a.bottom+Vn(o,"bottom")),t.left<a.left+Vn(r,"left")?l=-(a.left-t.left+Vn(o,"left")):t.right>a.right-Vn(r,"right")&&(l=t.right-a.right+Vn(o,"right")),l||c)if(n)i.defaultView.scrollBy(l,c);else{let n=e.scrollLeft,r=e.scrollTop;c&&(e.scrollTop+=c),l&&(e.scrollLeft+=l);let o=e.scrollLeft-n,i=e.scrollTop-r;t={left:t.left-o,top:t.top-i,right:t.right-o,bottom:t.bottom-i}}if(n)break}}function _n(e){let t=[],n=e.ownerDocument;for(let r=e;r&&(t.push({dom:r,top:r.scrollTop,left:r.scrollLeft}),e!=n);r=Dn(r));return t}function Un(e,t){for(let n=0;n<e.length;n++){let{dom:r,top:o,left:i}=e[n];r.scrollTop!=o+t&&(r.scrollTop=o+t),r.scrollLeft!=i&&(r.scrollLeft=i)}}let Wn=null;function Jn(e,t){let n,r,o=2e8,i=0,s=t.top,a=t.top;for(let l=e.firstChild,c=0;l;l=l.nextSibling,c++){let e;if(1==l.nodeType)e=l.getClientRects();else{if(3!=l.nodeType)continue;e=Ln(l).getClientRects()}for(let u=0;u<e.length;u++){let d=e[u];if(d.top<=s&&d.bottom>=a){s=Math.max(d.bottom,s),a=Math.min(d.top,a);let e=d.left>t.left?d.left-t.left:d.right<t.left?t.left-d.right:0;if(e<o){n=l,o=e,r=e&&3==n.nodeType?{left:d.right<t.left?d.right:d.left,top:t.top}:t,1==l.nodeType&&e&&(i=c+(t.left>=(d.left+d.right)/2?1:0));continue}}!n&&(t.left>=d.right&&t.top>=d.top||t.left>=d.left&&t.top>=d.bottom)&&(i=c+1)}}return n&&3==n.nodeType?function(e,t){let n=e.nodeValue.length,r=document.createRange();for(let o=0;o<n;o++){r.setEnd(e,o+1),r.setStart(e,o);let n=Xn(r,1);if(n.top!=n.bottom&&Gn(t,n))return{node:e,offset:o+(t.left>=(n.left+n.right)/2?1:0)}}return{node:e,offset:0}}(n,r):!n||o&&1==n.nodeType?{node:e,offset:i}:Jn(n,r)}function Gn(e,t){return e.left>=t.left-1&&e.left<=t.right+1&&e.top>=t.top-1&&e.top<=t.bottom+1}function Kn(e,t,n){let r=e.childNodes.length;if(r&&n.top<n.bottom)for(let o=Math.max(0,Math.min(r-1,Math.floor(r*(t.top-n.top)/(n.bottom-n.top))-2)),i=o;;){let n=e.childNodes[i];if(1==n.nodeType){let e=n.getClientRects();for(let r=0;r<e.length;r++){let o=e[r];if(Gn(t,o))return Kn(n,t,o)}}if((i=(i+1)%r)==o)break}return e}function Zn(e,t){let n,r=e.dom.ownerDocument,o=0;if(r.caretPositionFromPoint)try{let e=r.caretPositionFromPoint(t.left,t.top);e&&({offsetNode:n,offset:o}=e)}catch(e){}if(!n&&r.caretRangeFromPoint){let e=r.caretRangeFromPoint(t.left,t.top);e&&({startContainer:n,startOffset:o}=e)}let i,s=(e.root.elementFromPoint?e.root:r).elementFromPoint(t.left,t.top);if(!s||!e.dom.contains(1!=s.nodeType?s.parentNode:s)){let n=e.dom.getBoundingClientRect();if(!Gn(t,n))return null;if(s=Kn(e.dom,t,n),!s)return null}if(Cn)for(let e=s;n&&e;e=Dn(e))e.draggable&&(n=void 0);if(s=function(e,t){let n=e.parentNode;return n&&/^li$/i.test(n.nodeName)&&t.left<e.getBoundingClientRect().left?n:e}(s,t),n){if(bn&&1==n.nodeType&&(o=Math.min(o,n.childNodes.length),o<n.childNodes.length)){let e,r=n.childNodes[o];"IMG"==r.nodeName&&(e=r.getBoundingClientRect()).right<=t.left&&e.bottom>t.top&&o++}n==e.dom&&o==n.childNodes.length-1&&1==n.lastChild.nodeType&&t.top>n.lastChild.getBoundingClientRect().bottom?i=e.state.doc.content.size:0!=o&&1==n.nodeType&&"BR"==n.childNodes[o-1].nodeName||(i=function(e,t,n,r){let o=-1;for(let n=t;n!=e.dom;){let t=e.docView.nearestDesc(n,!0);if(!t)return null;if(t.node.isBlock&&t.parent){let e=t.dom.getBoundingClientRect();if(e.left>r.left||e.top>r.top)o=t.posBefore;else{if(!(e.right<r.left||e.bottom<r.top))break;o=t.posAfter}}n=t.dom.parentNode}return o>-1?o:e.docView.posFromDOM(t,n,1)}(e,n,o,t))}null==i&&(i=function(e,t,n){let{node:r,offset:o}=Jn(t,n),i=-1;if(1==r.nodeType&&!r.firstChild){let e=r.getBoundingClientRect();i=e.left!=e.right&&n.left>(e.left+e.right)/2?1:-1}return e.docView.posFromDOM(r,o,i)}(e,s,t));let a=e.docView.nearestDesc(s,!0);return{pos:i,inside:a?a.posAtStart-a.border:-1}}function Xn(e,t){let n=e.getClientRects();return n.length?n[t<0?0:n.length-1]:e.getBoundingClientRect()}const Qn=/[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;function Yn(e,t,n){let{node:r,offset:o,atom:i}=e.docView.domFromPos(t,n<0?-1:1),s=En||bn;if(3==r.nodeType){if(!s||!Qn.test(r.nodeValue)&&(n<0?o:o!=r.nodeValue.length)){let e=o,t=o,i=n<0?1:-1;return n<0&&!o?(t++,i=-1):n>=0&&o==r.nodeValue.length?(e--,i=1):n<0?e--:t++,er(Xn(Ln(r,e,t),i),i<0)}{let e=Xn(Ln(r,o,o),n);if(bn&&o&&/\s/.test(r.nodeValue[o-1])&&o<r.nodeValue.length){let t=Xn(Ln(r,o-1,o-1),-1);if(t.top==e.top){let n=Xn(Ln(r,o,o+1),-1);if(n.top!=e.top)return er(n,n.left<t.left)}}return e}}if(!e.state.doc.resolve(t-(i||0)).parent.inlineContent){if(null==i&&o&&(n<0||o==Bn(r))){let e=r.childNodes[o-1];if(1==e.nodeType)return tr(e.getBoundingClientRect(),!1)}if(null==i&&o<Bn(r)){let e=r.childNodes[o];if(1==e.nodeType)return tr(e.getBoundingClientRect(),!0)}return tr(r.getBoundingClientRect(),n>=0)}if(null==i&&o&&(n<0||o==Bn(r))){let e=r.childNodes[o-1],t=3==e.nodeType?Ln(e,Bn(e)-(s?0:1)):1!=e.nodeType||"BR"==e.nodeName&&e.nextSibling?null:e;if(t)return er(Xn(t,1),!1)}if(null==i&&o<Bn(r)){let e=r.childNodes[o];for(;e.pmViewDesc&&e.pmViewDesc.ignoreForCoords;)e=e.nextSibling;let t=e?3==e.nodeType?Ln(e,0,s?0:1):1==e.nodeType?e:null:null;if(t)return er(Xn(t,-1),!0)}return er(Xn(3==r.nodeType?Ln(r):r,-n),n>=0)}function er(e,t){if(0==e.width)return e;let n=t?e.left:e.right;return{top:e.top,bottom:e.bottom,left:n,right:n}}function tr(e,t){if(0==e.height)return e;let n=t?e.top:e.bottom;return{top:n,bottom:n,left:e.left,right:e.right}}function nr(e,t,n){let r=e.state,o=e.root.activeElement;r!=t&&e.updateState(t),o!=e.dom&&e.focus();try{return n()}finally{r!=t&&e.updateState(r),o!=e.dom&&o&&o.focus()}}const rr=/[\u0590-\u08ac]/;let or=null,ir=null,sr=!1;function ar(e,t,n){return or==t&&ir==n?sr:(or=t,ir=n,sr="up"==n||"down"==n?function(e,t,n){let r=t.selection,o="up"==n?r.$from:r.$to;return nr(e,t,(()=>{let{node:t}=e.docView.domFromPos(o.pos,"up"==n?-1:1);for(;;){let n=e.docView.nearestDesc(t,!0);if(!n)break;if(n.node.isBlock){t=n.dom;break}t=n.dom.parentNode}let r=Yn(e,o.pos,1);for(let e=t.firstChild;e;e=e.nextSibling){let t;if(1==e.nodeType)t=e.getClientRects();else{if(3!=e.nodeType)continue;t=Ln(e,0,e.nodeValue.length).getClientRects()}for(let e=0;e<t.length;e++){let o=t[e];if(o.bottom>o.top+1&&("up"==n?r.top-o.top>2*(o.bottom-r.top):o.bottom-r.bottom>2*(r.bottom-o.top)))return!1}}return!0}))}(e,t,n):function(e,t,n){let{$head:r}=t.selection;if(!r.parent.isTextblock)return!1;let o=r.parentOffset,i=!o,s=o==r.parent.content.size,a=e.domSelection();return rr.test(r.parent.textContent)&&a.modify?nr(e,t,(()=>{let t=a.getRangeAt(0),o=a.focusNode,i=a.focusOffset,s=a.caretBidiLevel;a.modify("move",n,"character");let l=!(r.depth?e.docView.domAfterPos(r.before()):e.dom).contains(1==a.focusNode.nodeType?a.focusNode:a.focusNode.parentNode)||o==a.focusNode&&i==a.focusOffset;return a.removeAllRanges(),a.addRange(t),null!=s&&(a.caretBidiLevel=s),l})):"left"==n||"backward"==n?i:s}(e,t,n))}class lr{constructor(e,t,n,r){this.parent=e,this.children=t,this.dom=n,this.contentDOM=r,this.dirty=0,n.pmViewDesc=this}matchesWidget(e){return!1}matchesMark(e){return!1}matchesNode(e,t,n){return!1}matchesHack(e){return!1}parseRule(){return null}stopEvent(e){return!1}get size(){let e=0;for(let t=0;t<this.children.length;t++)e+=this.children[t].size;return e}get border(){return 0}destroy(){this.parent=void 0,this.dom.pmViewDesc==this&&(this.dom.pmViewDesc=void 0);for(let e=0;e<this.children.length;e++)this.children[e].destroy()}posBeforeChild(e){for(let t=0,n=this.posAtStart;;t++){let r=this.children[t];if(r==e)return n;n+=r.size}}get posBefore(){return this.parent.posBeforeChild(this)}get posAtStart(){return this.parent?this.parent.posBeforeChild(this)+this.border:0}get posAfter(){return this.posBefore+this.size}get posAtEnd(){return this.posAtStart+this.size-2*this.border}localPosFromDOM(e,t,n){if(this.contentDOM&&this.contentDOM.contains(1==e.nodeType?e:e.parentNode)){if(n<0){let n,r;if(e==this.contentDOM)n=e.childNodes[t-1];else{for(;e.parentNode!=this.contentDOM;)e=e.parentNode;n=e.previousSibling}for(;n&&(!(r=n.pmViewDesc)||r.parent!=this);)n=n.previousSibling;return n?this.posBeforeChild(r)+r.size:this.posAtStart}{let n,r;if(e==this.contentDOM)n=e.childNodes[t];else{for(;e.parentNode!=this.contentDOM;)e=e.parentNode;n=e.nextSibling}for(;n&&(!(r=n.pmViewDesc)||r.parent!=this);)n=n.nextSibling;return n?this.posBeforeChild(r):this.posAtEnd}}let r;if(e==this.dom&&this.contentDOM)r=t>On(this.contentDOM);else if(this.contentDOM&&this.contentDOM!=this.dom&&this.dom.contains(this.contentDOM))r=2&e.compareDocumentPosition(this.contentDOM);else if(this.dom.firstChild){if(0==t)for(let t=e;;t=t.parentNode){if(t==this.dom){r=!1;break}if(t.previousSibling)break}if(null==r&&t==e.childNodes.length)for(let t=e;;t=t.parentNode){if(t==this.dom){r=!0;break}if(t.nextSibling)break}}return(null==r?n>0:r)?this.posAtEnd:this.posAtStart}nearestDesc(e,t=!1){for(let n=!0,r=e;r;r=r.parentNode){let o,i=this.getDesc(r);if(i&&(!t||i.node)){if(!n||!(o=i.nodeDOM)||(1==o.nodeType?o.contains(1==e.nodeType?e:e.parentNode):o==e))return i;n=!1}}}getDesc(e){let t=e.pmViewDesc;for(let e=t;e;e=e.parent)if(e==this)return t}posFromDOM(e,t,n){for(let r=e;r;r=r.parentNode){let o=this.getDesc(r);if(o)return o.localPosFromDOM(e,t,n)}return-1}descAt(e){for(let t=0,n=0;t<this.children.length;t++){let r=this.children[t],o=n+r.size;if(n==e&&o!=n){for(;!r.border&&r.children.length;)r=r.children[0];return r}if(e<o)return r.descAt(e-n-r.border);n=o}}domFromPos(e,t){if(!this.contentDOM)return{node:this.dom,offset:0,atom:e+1};let n,r=0,o=0;for(let t=0;r<this.children.length;r++){let n=this.children[r],i=t+n.size;if(i>e||n instanceof mr){o=e-t;break}t=i}if(o)return this.children[r].domFromPos(o-this.children[r].border,t);for(;r&&!(n=this.children[r-1]).size&&n instanceof cr&&n.side>=0;r--);if(t<=0){let e,n=!0;for(;e=r?this.children[r-1]:null,e&&e.dom.parentNode!=this.contentDOM;r--,n=!1);return e&&t&&n&&!e.border&&!e.domAtom?e.domFromPos(e.size,t):{node:this.contentDOM,offset:e?On(e.dom)+1:0}}{let e,n=!0;for(;e=r<this.children.length?this.children[r]:null,e&&e.dom.parentNode!=this.contentDOM;r++,n=!1);return e&&n&&!e.border&&!e.domAtom?e.domFromPos(0,t):{node:this.contentDOM,offset:e?On(e.dom):this.contentDOM.childNodes.length}}}parseRange(e,t,n=0){if(0==this.children.length)return{node:this.contentDOM,from:e,to:t,fromOffset:0,toOffset:this.contentDOM.childNodes.length};let r=-1,o=-1;for(let i=n,s=0;;s++){let n=this.children[s],a=i+n.size;if(-1==r&&e<=a){let o=i+n.border;if(e>=o&&t<=a-n.border&&n.node&&n.contentDOM&&this.contentDOM.contains(n.contentDOM))return n.parseRange(e,t,o);e=i;for(let t=s;t>0;t--){let n=this.children[t-1];if(n.size&&n.dom.parentNode==this.contentDOM&&!n.emptyChildAt(1)){r=On(n.dom)+1;break}e-=n.size}-1==r&&(r=0)}if(r>-1&&(a>t||s==this.children.length-1)){t=a;for(let e=s+1;e<this.children.length;e++){let n=this.children[e];if(n.size&&n.dom.parentNode==this.contentDOM&&!n.emptyChildAt(-1)){o=On(n.dom);break}t+=n.size}-1==o&&(o=this.contentDOM.childNodes.length);break}i=a}return{node:this.contentDOM,from:e,to:t,fromOffset:r,toOffset:o}}emptyChildAt(e){if(this.border||!this.contentDOM||!this.children.length)return!1;let t=this.children[e<0?0:this.children.length-1];return 0==t.size||t.emptyChildAt(e)}domAfterPos(e){let{node:t,offset:n}=this.domFromPos(e,0);if(1!=t.nodeType||n==t.childNodes.length)throw new RangeError("No node after pos "+e);return t.childNodes[n]}setSelection(e,t,n,r=!1){let o=Math.min(e,t),i=Math.max(e,t);for(let s=0,a=0;s<this.children.length;s++){let l=this.children[s],c=a+l.size;if(o>a&&i<c)return l.setSelection(e-a-l.border,t-a-l.border,n,r);a=c}let s=this.domFromPos(e,e?-1:1),a=t==e?s:this.domFromPos(t,t?-1:1),l=n.getSelection(),c=!1;if((bn||Cn)&&e==t){let{node:e,offset:t}=s;if(3==e.nodeType){if(c=!(!t||"\n"!=e.nodeValue[t-1]),c&&t==e.nodeValue.length)for(let t,n=e;n;n=n.parentNode){if(t=n.nextSibling){"BR"==t.nodeName&&(s=a={node:t.parentNode,offset:On(t)+1});break}let e=n.pmViewDesc;if(e&&e.node&&e.node.isBlock)break}}else{let n=e.childNodes[t-1];c=n&&("BR"==n.nodeName||"false"==n.contentEditable)}}if(bn&&l.focusNode&&l.focusNode!=a.node&&1==l.focusNode.nodeType){let e=l.focusNode.childNodes[l.focusOffset];e&&"false"==e.contentEditable&&(r=!0)}if(!(r||c&&Cn)&&In(s.node,s.offset,l.anchorNode,l.anchorOffset)&&In(a.node,a.offset,l.focusNode,l.focusOffset))return;let u=!1;if((l.extend||e==t)&&!c){l.collapse(s.node,s.offset);try{e!=t&&l.extend(a.node,a.offset),u=!0}catch(e){if(!(e instanceof DOMException))throw e}}if(!u){if(e>t){let e=s;s=a,a=e}let n=document.createRange();n.setEnd(a.node,a.offset),n.setStart(s.node,s.offset),l.removeAllRanges(),l.addRange(n)}}ignoreMutation(e){return!this.contentDOM&&"selection"!=e.type}get contentLost(){return this.contentDOM&&this.contentDOM!=this.dom&&!this.dom.contains(this.contentDOM)}markDirty(e,t){for(let n=0,r=0;r<this.children.length;r++){let o=this.children[r],i=n+o.size;if(n==i?e<=i&&t>=n:e<i&&t>n){let r=n+o.border,s=i-o.border;if(e>=r&&t<=s)return this.dirty=e==n||t==i?2:1,void(e!=r||t!=s||!o.contentLost&&o.dom.parentNode==this.contentDOM?o.markDirty(e-r,t-r):o.dirty=3);o.dirty=o.dom!=o.contentDOM||o.dom.parentNode!=this.contentDOM||o.children.length?3:2}n=i}this.dirty=2}markParentsDirty(){let e=1;for(let t=this.parent;t;t=t.parent,e++){let n=1==e?2:1;t.dirty<n&&(t.dirty=n)}}get domAtom(){return!1}get ignoreForCoords(){return!1}}class cr extends lr{constructor(e,t,n,r){let o,i=t.type.toDOM;if("function"==typeof i&&(i=i(n,(()=>o?o.parent?o.parent.posBeforeChild(o):void 0:r))),!t.type.spec.raw){if(1!=i.nodeType){let e=document.createElement("span");e.appendChild(i),i=e}i.contentEditable="false",i.classList.add("ProseMirror-widget")}super(e,[],i,null),this.widget=t,this.widget=t,o=this}matchesWidget(e){return 0==this.dirty&&e.type.eq(this.widget.type)}parseRule(){return{ignore:!0}}stopEvent(e){let t=this.widget.spec.stopEvent;return!!t&&t(e)}ignoreMutation(e){return"selection"!=e.type||this.widget.spec.ignoreSelection}destroy(){this.widget.type.destroy(this.dom),super.destroy()}get domAtom(){return!0}get side(){return this.widget.type.side}}class ur extends lr{constructor(e,t,n,r){super(e,[],t,null),this.textDOM=n,this.text=r}get size(){return this.text.length}localPosFromDOM(e,t){return e!=this.textDOM?this.posAtStart+(t?this.size:0):this.posAtStart+t}domFromPos(e){return{node:this.textDOM,offset:e}}ignoreMutation(e){return"characterData"===e.type&&e.target.nodeValue==e.oldValue}}class dr extends lr{constructor(e,t,n,r){super(e,[],n,r),this.mark=t}static create(e,t,n,r){let o=r.nodeViews[t.type.name],i=o&&o(t,r,n);return i&&i.dom||(i=de.renderSpec(document,t.type.spec.toDOM(t,n))),new dr(e,t,i.dom,i.contentDOM||i.dom)}parseRule(){return 3&this.dirty||this.mark.type.spec.reparseInView?null:{mark:this.mark.type.name,attrs:this.mark.attrs,contentElement:this.contentDOM||void 0}}matchesMark(e){return 3!=this.dirty&&this.mark.eq(e)}markDirty(e,t){if(super.markDirty(e,t),0!=this.dirty){let e=this.parent;for(;!e.node;)e=e.parent;e.dirty<this.dirty&&(e.dirty=this.dirty),this.dirty=0}}slice(e,t,n){let r=dr.create(this.parent,this.mark,!0,n),o=this.children,i=this.size;t<i&&(o=Nr(o,t,i,n)),e>0&&(o=Nr(o,0,e,n));for(let e=0;e<o.length;e++)o[e].parent=r;return r.children=o,r}}class pr extends lr{constructor(e,t,n,r,o,i,s,a,l){super(e,[],o,i),this.node=t,this.outerDeco=n,this.innerDeco=r,this.nodeDOM=s,i&&this.updateChildren(a,l)}static create(e,t,n,r,o,i){let s,a=o.nodeViews[t.type.name],l=a&&a(t,o,(()=>s?s.parent?s.parent.posBeforeChild(s):void 0:i),n,r),c=l&&l.dom,u=l&&l.contentDOM;if(t.isText)if(c){if(3!=c.nodeType)throw new RangeError("Text must be rendered as a DOM text node")}else c=document.createTextNode(t.text);else c||({dom:c,contentDOM:u}=de.renderSpec(document,t.type.spec.toDOM(t)));u||t.isText||"BR"==c.nodeName||(c.hasAttribute("contenteditable")||(c.contentEditable="false"),t.type.spec.draggable&&(c.draggable=!0));let d=c;return c=Cr(c,n,t),l?s=new gr(e,t,n,r,c,u||null,d,l,o,i+1):t.isText?new fr(e,t,n,r,c,d,o):new pr(e,t,n,r,c,u||null,d,o,i+1)}parseRule(){if(this.node.type.spec.reparseInView)return null;let e={node:this.node.type.name,attrs:this.node.attrs};if("pre"==this.node.type.whitespace&&(e.preserveWhitespace="full"),this.contentDOM)if(this.contentLost){for(let t=this.children.length-1;t>=0;t--){let n=this.children[t];if(this.dom.contains(n.dom.parentNode)){e.contentElement=n.dom.parentNode;break}}e.contentElement||(e.getContent=()=>d.empty)}else e.contentElement=this.contentDOM;else e.getContent=()=>this.node.content;return e}matchesNode(e,t,n){return 0==this.dirty&&e.eq(this.node)&&Tr(t,this.outerDeco)&&n.eq(this.innerDeco)}get size(){return this.node.nodeSize}get border(){return this.node.isLeaf?0:1}updateChildren(e,t){let n=this.node.inlineContent,r=t,o=e.composing?this.localCompositionInfo(e,t):null,i=o&&o.pos>-1?o:null,s=o&&o.pos<0,a=new Sr(this,i&&i.node);!function(e,t,n,r){let o=t.locals(e),i=0;if(0==o.length){for(let n=0;n<e.childCount;n++){let s=e.child(n);r(s,o,t.forChild(i,s),n),i+=s.nodeSize}return}let s=0,a=[],l=null;for(let c=0;;){if(s<o.length&&o[s].to==i){let e,t=o[s++];for(;s<o.length&&o[s].to==i;)(e||(e=[t])).push(o[s++]);if(e){e.sort(Er);for(let t=0;t<e.length;t++)n(e[t],c,!!l)}else n(t,c,!!l)}let u,d;if(l)d=-1,u=l,l=null;else{if(!(c<e.childCount))break;d=c,u=e.child(c++)}for(let e=0;e<a.length;e++)a[e].to<=i&&a.splice(e--,1);for(;s<o.length&&o[s].from<=i&&o[s].to>i;)a.push(o[s++]);let p=i+u.nodeSize;if(u.isText){let e=p;s<o.length&&o[s].from<e&&(e=o[s].from);for(let t=0;t<a.length;t++)a[t].to<e&&(e=a[t].to);e<p&&(l=u.cut(e-i),u=u.cut(0,e-i),p=e,d=-1)}r(u,u.isInline&&!u.isLeaf?a.filter((e=>!e.inline)):a.slice(),t.forChild(i,u),d),i=p}}(this.node,this.innerDeco,((t,o,i)=>{t.spec.marks?a.syncToMarks(t.spec.marks,n,e):t.type.side>=0&&!i&&a.syncToMarks(o==this.node.childCount?m.none:this.node.child(o).marks,n,e),a.placeWidget(t,e,r)}),((t,i,l,c)=>{let u;a.syncToMarks(t.marks,n,e),a.findNodeMatch(t,i,l,c)||s&&e.state.selection.from>r&&e.state.selection.to<r+t.nodeSize&&(u=a.findIndexWithChild(o.node))>-1&&a.updateNodeAt(t,i,l,u,e)||a.updateNextNode(t,i,l,e,c)||a.addNode(t,i,l,e,r),r+=t.nodeSize})),a.syncToMarks([],n,e),this.node.isTextblock&&a.addTextblockHacks(),a.destroyRest(),(a.changed||2==this.dirty)&&(i&&this.protectLocalComposition(e,i),vr(this.contentDOM,this.children,e),Tn&&function(e){if("UL"==e.nodeName||"OL"==e.nodeName){let t=e.style.cssText;e.style.cssText=t+"; list-style: square !important",window.getComputedStyle(e).listStyle,e.style.cssText=t}}(this.dom))}localCompositionInfo(e,t){let{from:n,to:r}=e.state.selection;if(!(e.state.selection instanceof Ut)||n<t||r>t+this.node.content.size)return null;let o=e.domSelection(),i=function(e,t){for(;;){if(3==e.nodeType)return e;if(1==e.nodeType&&t>0){if(e.childNodes.length>t&&3==e.childNodes[t].nodeType)return e.childNodes[t];t=Bn(e=e.childNodes[t-1])}else{if(!(1==e.nodeType&&t<e.childNodes.length))return null;e=e.childNodes[t],t=0}}}(o.focusNode,o.focusOffset);if(!i||!this.dom.contains(i.parentNode))return null;if(this.node.inlineContent){let e=i.nodeValue,o=function(e,t,n,r){for(let o=0,i=0;o<e.childCount&&i<=r;){let s=e.child(o++),a=i;if(i+=s.nodeSize,!s.isText)continue;let l=s.text;for(;o<e.childCount;){let t=e.child(o++);if(i+=t.nodeSize,!t.isText)break;l+=t.text}if(i>=n){let e=a<r?l.lastIndexOf(t,r-a-1):-1;if(e>=0&&e+t.length+a>=n)return a+e;if(n==r&&l.length>=r+t.length-a&&l.slice(r-a,r-a+t.length)==t)return r}}return-1}(this.node.content,e,n-t,r-t);return o<0?null:{node:i,pos:o,text:e}}return{node:i,pos:-1,text:""}}protectLocalComposition(e,{node:t,pos:n,text:r}){if(this.getDesc(t))return;let o=t;for(;o.parentNode!=this.contentDOM;o=o.parentNode){for(;o.previousSibling;)o.parentNode.removeChild(o.previousSibling);for(;o.nextSibling;)o.parentNode.removeChild(o.nextSibling);o.pmViewDesc&&(o.pmViewDesc=void 0)}let i=new ur(this,o,t,r);e.input.compositionNodes.push(i),this.children=Nr(this.children,n,n+r.length,e,i)}update(e,t,n,r){return!(3==this.dirty||!e.sameMarkup(this.node))&&(this.updateInner(e,t,n,r),!0)}updateInner(e,t,n,r){this.updateOuterDeco(t),this.node=e,this.innerDeco=n,this.contentDOM&&this.updateChildren(r,this.posAtStart),this.dirty=0}updateOuterDeco(e){if(Tr(e,this.outerDeco))return;let t=1!=this.nodeDOM.nodeType,n=this.dom;this.dom=kr(this.dom,this.nodeDOM,wr(this.outerDeco,this.node,t),wr(e,this.node,t)),this.dom!=n&&(n.pmViewDesc=void 0,this.dom.pmViewDesc=this),this.outerDeco=e}selectNode(){1==this.nodeDOM.nodeType&&this.nodeDOM.classList.add("ProseMirror-selectednode"),!this.contentDOM&&this.node.type.spec.draggable||(this.dom.draggable=!0)}deselectNode(){1==this.nodeDOM.nodeType&&this.nodeDOM.classList.remove("ProseMirror-selectednode"),!this.contentDOM&&this.node.type.spec.draggable||this.dom.removeAttribute("draggable")}get domAtom(){return this.node.isAtom}}function hr(e,t,n,r,o){return Cr(r,t,e),new pr(void 0,e,t,n,r,r,r,o,0)}class fr extends pr{constructor(e,t,n,r,o,i,s){super(e,t,n,r,o,null,i,s,0)}parseRule(){let e=this.nodeDOM.parentNode;for(;e&&e!=this.dom&&!e.pmIsDeco;)e=e.parentNode;return{skip:e||!0}}update(e,t,n,r){return!(3==this.dirty||0!=this.dirty&&!this.inParent()||!e.sameMarkup(this.node))&&(this.updateOuterDeco(t),0==this.dirty&&e.text==this.node.text||e.text==this.nodeDOM.nodeValue||(this.nodeDOM.nodeValue=e.text,r.trackWrites==this.nodeDOM&&(r.trackWrites=null)),this.node=e,this.dirty=0,!0)}inParent(){let e=this.parent.contentDOM;for(let t=this.nodeDOM;t;t=t.parentNode)if(t==e)return!0;return!1}domFromPos(e){return{node:this.nodeDOM,offset:e}}localPosFromDOM(e,t,n){return e==this.nodeDOM?this.posAtStart+Math.min(t,this.node.text.length):super.localPosFromDOM(e,t,n)}ignoreMutation(e){return"characterData"!=e.type&&"selection"!=e.type}slice(e,t,n){let r=this.node.cut(e,t),o=document.createTextNode(r.text);return new fr(this.parent,r,this.outerDeco,this.innerDeco,o,o,n)}markDirty(e,t){super.markDirty(e,t),this.dom==this.nodeDOM||0!=e&&t!=this.nodeDOM.nodeValue.length||(this.dirty=3)}get domAtom(){return!1}}class mr extends lr{parseRule(){return{ignore:!0}}matchesHack(e){return 0==this.dirty&&this.dom.nodeName==e}get domAtom(){return!0}get ignoreForCoords(){return"IMG"==this.dom.nodeName}}class gr extends pr{constructor(e,t,n,r,o,i,s,a,l,c){super(e,t,n,r,o,i,s,l,c),this.spec=a}update(e,t,n,r){if(3==this.dirty)return!1;if(this.spec.update){let o=this.spec.update(e,t,n);return o&&this.updateInner(e,t,n,r),o}return!(!this.contentDOM&&!e.isLeaf)&&super.update(e,t,n,r)}selectNode(){this.spec.selectNode?this.spec.selectNode():super.selectNode()}deselectNode(){this.spec.deselectNode?this.spec.deselectNode():super.deselectNode()}setSelection(e,t,n,r){this.spec.setSelection?this.spec.setSelection(e,t,n):super.setSelection(e,t,n,r)}destroy(){this.spec.destroy&&this.spec.destroy(),super.destroy()}stopEvent(e){return!!this.spec.stopEvent&&this.spec.stopEvent(e)}ignoreMutation(e){return this.spec.ignoreMutation?this.spec.ignoreMutation(e):super.ignoreMutation(e)}}function vr(e,t,n){let r=e.firstChild,o=!1;for(let i=0;i<t.length;i++){let s=t[i],a=s.dom;if(a.parentNode==e){for(;a!=r;)r=Mr(r),o=!0;r=r.nextSibling}else o=!0,e.insertBefore(a,r);if(s instanceof dr){let t=r?r.previousSibling:e.lastChild;vr(s.contentDOM,s.children,n),r=t?t.nextSibling:e.firstChild}}for(;r;)r=Mr(r),o=!0;o&&n.trackWrites==e&&(n.trackWrites=null)}const yr=function(e){e&&(this.nodeName=e)};yr.prototype=Object.create(null);const br=[new yr];function wr(e,t,n){if(0==e.length)return br;let r=n?br[0]:new yr,o=[r];for(let i=0;i<e.length;i++){let s=e[i].type.attrs;if(s){s.nodeName&&o.push(r=new yr(s.nodeName));for(let e in s){let i=s[e];null!=i&&(n&&1==o.length&&o.push(r=new yr(t.isInline?"span":"div")),"class"==e?r.class=(r.class?r.class+" ":"")+i:"style"==e?r.style=(r.style?r.style+";":"")+i:"nodeName"!=e&&(r[e]=i))}}}return o}function kr(e,t,n,r){if(n==br&&r==br)return t;let o=t;for(let t=0;t<r.length;t++){let i=r[t],s=n[t];if(t){let t;s&&s.nodeName==i.nodeName&&o!=e&&(t=o.parentNode)&&t.nodeName.toLowerCase()==i.nodeName||(t=document.createElement(i.nodeName),t.pmIsDeco=!0,t.appendChild(o),s=br[0]),o=t}xr(o,s||br[0],i)}return o}function xr(e,t,n){for(let r in t)"class"==r||"style"==r||"nodeName"==r||r in n||e.removeAttribute(r);for(let r in n)"class"!=r&&"style"!=r&&"nodeName"!=r&&n[r]!=t[r]&&e.setAttribute(r,n[r]);if(t.class!=n.class){let r=t.class?t.class.split(" ").filter(Boolean):[],o=n.class?n.class.split(" ").filter(Boolean):[];for(let t=0;t<r.length;t++)-1==o.indexOf(r[t])&&e.classList.remove(r[t]);for(let t=0;t<o.length;t++)-1==r.indexOf(o[t])&&e.classList.add(o[t]);0==e.classList.length&&e.removeAttribute("class")}if(t.style!=n.style){if(t.style){let n,r=/\s*([\w\-\xa1-\uffff]+)\s*:(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|\(.*?\)|[^;])*/g;for(;n=r.exec(t.style);)e.style.removeProperty(n[1])}n.style&&(e.style.cssText+=n.style)}}function Cr(e,t,n){return kr(e,e,br,wr(t,n,1!=e.nodeType))}function Tr(e,t){if(e.length!=t.length)return!1;for(let n=0;n<e.length;n++)if(!e[n].type.eq(t[n].type))return!1;return!0}function Mr(e){let t=e.nextSibling;return e.parentNode.removeChild(e),t}class Sr{constructor(e,t){this.lock=t,this.index=0,this.stack=[],this.changed=!1,this.top=e,this.preMatch=function(e,t){let n=t,r=n.children.length,o=e.childCount,i=new Map,s=[];e:for(;o>0;){let a;for(;;)if(r){let e=n.children[r-1];if(!(e instanceof dr)){a=e,r--;break}n=e,r=e.children.length}else{if(n==t)break e;r=n.parent.children.indexOf(n),n=n.parent}let l=a.node;if(l){if(l!=e.child(o-1))break;--o,i.set(a,o),s.push(a)}}return{index:o,matched:i,matches:s.reverse()}}(e.node.content,e)}destroyBetween(e,t){if(e!=t){for(let n=e;n<t;n++)this.top.children[n].destroy();this.top.children.splice(e,t-e),this.changed=!0}}destroyRest(){this.destroyBetween(this.index,this.top.children.length)}syncToMarks(e,t,n){let r=0,o=this.stack.length>>1,i=Math.min(o,e.length);for(;r<i&&(r==o-1?this.top:this.stack[r+1<<1]).matchesMark(e[r])&&!1!==e[r].type.spec.spanning;)r++;for(;r<o;)this.destroyRest(),this.top.dirty=0,this.index=this.stack.pop(),this.top=this.stack.pop(),o--;for(;o<e.length;){this.stack.push(this.top,this.index+1);let r=-1;for(let t=this.index;t<Math.min(this.index+3,this.top.children.length);t++)if(this.top.children[t].matchesMark(e[o])){r=t;break}if(r>-1)r>this.index&&(this.changed=!0,this.destroyBetween(this.index,r)),this.top=this.top.children[this.index];else{let r=dr.create(this.top,e[o],t,n);this.top.children.splice(this.index,0,r),this.top=r,this.changed=!0}this.index=0,o++}}findNodeMatch(e,t,n,r){let o,i=-1;if(r>=this.preMatch.index&&(o=this.preMatch.matches[r-this.preMatch.index]).parent==this.top&&o.matchesNode(e,t,n))i=this.top.children.indexOf(o,this.index);else for(let r=this.index,o=Math.min(this.top.children.length,r+5);r<o;r++){let o=this.top.children[r];if(o.matchesNode(e,t,n)&&!this.preMatch.matched.has(o)){i=r;break}}return!(i<0)&&(this.destroyBetween(this.index,i),this.index++,!0)}updateNodeAt(e,t,n,r,o){let i=this.top.children[r];return 3==i.dirty&&i.dom==i.contentDOM&&(i.dirty=2),!!i.update(e,t,n,o)&&(this.destroyBetween(this.index,r),this.index++,!0)}findIndexWithChild(e){for(;;){let t=e.parentNode;if(!t)return-1;if(t==this.top.contentDOM){let t=e.pmViewDesc;if(t)for(let e=this.index;e<this.top.children.length;e++)if(this.top.children[e]==t)return e;return-1}e=t}}updateNextNode(e,t,n,r,o){for(let i=this.index;i<this.top.children.length;i++){let s=this.top.children[i];if(s instanceof pr){let a=this.preMatch.matched.get(s);if(null!=a&&a!=o)return!1;let l=s.dom;if(!(this.lock&&(l==this.lock||1==l.nodeType&&l.contains(this.lock.parentNode))&&!(e.isText&&s.node&&s.node.isText&&s.nodeDOM.nodeValue==e.text&&3!=s.dirty&&Tr(t,s.outerDeco)))&&s.update(e,t,n,r))return this.destroyBetween(this.index,i),s.dom!=l&&(this.changed=!0),this.index++,!0;break}}return!1}addNode(e,t,n,r,o){this.top.children.splice(this.index++,0,pr.create(this.top,e,t,n,r,o)),this.changed=!0}placeWidget(e,t,n){let r=this.index<this.top.children.length?this.top.children[this.index]:null;if(!r||!r.matchesWidget(e)||e!=r.widget&&r.widget.type.toDOM.parentNode){let r=new cr(this.top,e,t,n);this.top.children.splice(this.index++,0,r),this.changed=!0}else this.index++}addTextblockHacks(){let e=this.top.children[this.index-1],t=this.top;for(;e instanceof dr;)t=e,e=t.children[t.children.length-1];e&&e instanceof fr&&!/\n$/.test(e.node.text)||((Cn||kn)&&e&&"false"==e.dom.contentEditable&&this.addHackNode("IMG",t),this.addHackNode("BR",this.top))}addHackNode(e,t){if(t==this.top&&this.index<t.children.length&&t.children[this.index].matchesHack(e))this.index++;else{let n=document.createElement(e);"IMG"==e&&(n.className="ProseMirror-separator",n.alt=""),"BR"==e&&(n.className="ProseMirror-trailingBreak");let r=new mr(this.top,[],n,null);t!=this.top?t.children.push(r):t.children.splice(this.index++,0,r),this.changed=!0}}}function Er(e,t){return e.type.side-t.type.side}function Nr(e,t,n,r,o){let i=[];for(let s=0,a=0;s<e.length;s++){let l=e[s],c=a,u=a+=l.size;c>=n||u<=t?i.push(l):(c<t&&i.push(l.slice(0,t-c,r)),o&&(i.push(o),o=void 0),u>n&&i.push(l.slice(n-c,l.size,r)))}return i}function Or(e,t=null){let n=e.domSelection(),r=e.state.doc;if(!n.focusNode)return null;let o=e.docView.nearestDesc(n.focusNode),i=o&&0==o.size,s=e.docView.posFromDOM(n.focusNode,n.focusOffset,1);if(s<0)return null;let a,l,c=r.resolve(s);if(Hn(n)){for(a=c;o&&!o.node;)o=o.parent;let e=o.node;if(o&&e.isAtom&&Jt.isSelectable(e)&&o.parent&&(!e.isInline||!function(e,t,n){for(let r=0==t,o=t==Bn(e);r||o;){if(e==n)return!0;let t=On(e);if(!(e=e.parentNode))return!1;r=r&&0==t,o=o&&t==Bn(e)}}(n.focusNode,n.focusOffset,o.dom))){let e=o.posBefore;l=new Jt(s==e?c:r.resolve(e))}}else{let t=e.docView.posFromDOM(n.anchorNode,n.anchorOffset,1);if(t<0)return null;a=r.resolve(t)}if(!l){l=Hr(e,a,c,"pointer"==t||e.state.selection.head<c.pos&&!i?1:-1)}return l}function Dr(e){return e.editable?e.hasFocus():qr(e)&&document.activeElement&&document.activeElement.contains(e.dom)}function Ar(e,t=!1){let n=e.state.selection;if(Br(e,n),Dr(e)){if(!t&&e.input.mouseDown&&e.input.mouseDown.allowDefault&&kn){let t=e.domSelection(),n=e.domObserver.currentSelection;if(t.anchorNode&&n.anchorNode&&In(t.anchorNode,t.anchorOffset,n.anchorNode,n.anchorOffset))return e.input.mouseDown.delayedSelectionSync=!0,void e.domObserver.setCurSelection()}if(e.domObserver.disconnectSelection(),e.cursorWrapper)!function(e){let t=e.domSelection(),n=document.createRange(),r=e.cursorWrapper.dom,o="IMG"==r.nodeName;o?n.setEnd(r.parentNode,On(r)+1):n.setEnd(r,0);n.collapse(!1),t.removeAllRanges(),t.addRange(n),!o&&!e.state.selection.visible&&vn&&yn<=11&&(r.disabled=!0,r.disabled=!1)}(e);else{let r,o,{anchor:i,head:s}=n;!Lr||n instanceof Ut||(n.$from.parent.inlineContent||(r=Ir(e,n.from)),n.empty||n.$from.parent.inlineContent||(o=Ir(e,n.to))),e.docView.setSelection(i,s,e.root,t),Lr&&(r&&Pr(r),o&&Pr(o)),n.visible?e.dom.classList.remove("ProseMirror-hideselection"):(e.dom.classList.add("ProseMirror-hideselection"),"onselectionchange"in document&&function(e){let t=e.dom.ownerDocument;t.removeEventListener("selectionchange",e.input.hideSelectionGuard);let n=e.domSelection(),r=n.anchorNode,o=n.anchorOffset;t.addEventListener("selectionchange",e.input.hideSelectionGuard=()=>{n.anchorNode==r&&n.anchorOffset==o||(t.removeEventListener("selectionchange",e.input.hideSelectionGuard),setTimeout((()=>{Dr(e)&&!e.state.selection.visible||e.dom.classList.remove("ProseMirror-hideselection")}),20))})}(e))}e.domObserver.setCurSelection(),e.domObserver.connectSelection()}}const Lr=Cn||kn&&xn<63;function Ir(e,t){let{node:n,offset:r}=e.docView.domFromPos(t,0),o=r<n.childNodes.length?n.childNodes[r]:null,i=r?n.childNodes[r-1]:null;if(Cn&&o&&"false"==o.contentEditable)return Rr(o);if(!(o&&"false"!=o.contentEditable||i&&"false"!=i.contentEditable)){if(o)return Rr(o);if(i)return Rr(i)}}function Rr(e){return e.contentEditable="true",Cn&&e.draggable&&(e.draggable=!1,e.wasDraggable=!0),e}function Pr(e){e.contentEditable="false",e.wasDraggable&&(e.draggable=!0,e.wasDraggable=null)}function Br(e,t){if(t instanceof Jt){let n=e.docView.descAt(t.from);n!=e.lastSelectedViewDesc&&(Fr(e),n&&n.selectNode(),e.lastSelectedViewDesc=n)}else Fr(e)}function Fr(e){e.lastSelectedViewDesc&&(e.lastSelectedViewDesc.parent&&e.lastSelectedViewDesc.deselectNode(),e.lastSelectedViewDesc=void 0)}function Hr(e,t,n,r){return e.someProp("createSelectionBetween",(r=>r(e,t,n)))||Ut.between(t,n,r)}function zr(e){return(!e.editable||e.root.activeElement==e.dom)&&qr(e)}function qr(e){let t=e.domSelection();if(!t.anchorNode)return!1;try{return e.dom.contains(3==t.anchorNode.nodeType?t.anchorNode.parentNode:t.anchorNode)&&(e.editable||e.dom.contains(3==t.focusNode.nodeType?t.focusNode.parentNode:t.focusNode))}catch(e){return!1}}function Vr(e,t){let{$anchor:n,$head:r}=e.selection,o=t>0?n.max(r):n.min(r),i=o.parent.inlineContent?o.depth?e.doc.resolve(t>0?o.after():o.before()):null:o;return i&&Vt.findFrom(i,t)}function jr(e,t){return e.dispatch(e.state.tr.setSelection(t).scrollIntoView()),!0}function $r(e,t,n){let r=e.state.selection;if(!(r instanceof Ut)){if(r instanceof Jt&&r.node.isInline)return jr(e,new Ut(t>0?r.$to:r.$from));{let n=Vr(e.state,t);return!!n&&jr(e,n)}}if(!r.empty||n.indexOf("s")>-1)return!1;if(e.endOfTextblock(t>0?"right":"left")){let n=Vr(e.state,t);return!!(n&&n instanceof Jt)&&jr(e,n)}if(!(Mn&&n.indexOf("m")>-1)){let n,o=r.$head,i=o.textOffset?null:t<0?o.nodeBefore:o.nodeAfter;if(!i||i.isText)return!1;let s=t<0?o.pos-i.nodeSize:o.pos;return!!(i.isAtom||(n=e.docView.descAt(s))&&!n.contentDOM)&&(Jt.isSelectable(i)?jr(e,new Jt(t<0?e.state.doc.resolve(o.pos-i.nodeSize):o)):!!En&&jr(e,new Ut(e.state.doc.resolve(t<0?s:s+i.nodeSize))))}}function _r(e){return 3==e.nodeType?e.nodeValue.length:e.childNodes.length}function Ur(e){let t=e.pmViewDesc;return t&&0==t.size&&(e.nextSibling||"BR"!=e.nodeName)}function Wr(e){let t=e.domSelection(),n=t.focusNode,r=t.focusOffset;if(!n)return;let o,i,s=!1;for(bn&&1==n.nodeType&&r<_r(n)&&Ur(n.childNodes[r])&&(s=!0);;)if(r>0){if(1!=n.nodeType)break;{let e=n.childNodes[r-1];if(Ur(e))o=n,i=--r;else{if(3!=e.nodeType)break;n=e,r=n.nodeValue.length}}}else{if(Gr(n))break;{let t=n.previousSibling;for(;t&&Ur(t);)o=n.parentNode,i=On(t),t=t.previousSibling;if(t)n=t,r=_r(n);else{if(n=n.parentNode,n==e.dom)break;r=0}}}s?Kr(e,t,n,r):o&&Kr(e,t,o,i)}function Jr(e){let t=e.domSelection(),n=t.focusNode,r=t.focusOffset;if(!n)return;let o,i,s=_r(n);for(;;)if(r<s){if(1!=n.nodeType)break;if(!Ur(n.childNodes[r]))break;o=n,i=++r}else{if(Gr(n))break;{let t=n.nextSibling;for(;t&&Ur(t);)o=t.parentNode,i=On(t)+1,t=t.nextSibling;if(t)n=t,r=0,s=_r(n);else{if(n=n.parentNode,n==e.dom)break;r=s=0}}}o&&Kr(e,t,o,i)}function Gr(e){let t=e.pmViewDesc;return t&&t.node&&t.node.isBlock}function Kr(e,t,n,r){if(Hn(t)){let e=document.createRange();e.setEnd(n,r),e.setStart(n,r),t.removeAllRanges(),t.addRange(e)}else t.extend&&t.extend(n,r);e.domObserver.setCurSelection();let{state:o}=e;setTimeout((()=>{e.state==o&&Ar(e)}),50)}function Zr(e,t,n){let r=e.state.selection;if(r instanceof Ut&&!r.empty||n.indexOf("s")>-1)return!1;if(Mn&&n.indexOf("m")>-1)return!1;let{$from:o,$to:i}=r;if(!o.parent.inlineContent||e.endOfTextblock(t<0?"up":"down")){let n=Vr(e.state,t);if(n&&n instanceof Jt)return jr(e,n)}if(!o.parent.inlineContent){let n=t<0?o:i,s=r instanceof Kt?Vt.near(n,t):Vt.findFrom(n,t);return!!s&&jr(e,s)}return!1}function Xr(e,t){if(!(e.state.selection instanceof Ut))return!0;let{$head:n,$anchor:r,empty:o}=e.state.selection;if(!n.sameParent(r))return!0;if(!o)return!1;if(e.endOfTextblock(t>0?"forward":"backward"))return!0;let i=!n.textOffset&&(t<0?n.nodeBefore:n.nodeAfter);if(i&&!i.isText){let r=e.state.tr;return t<0?r.delete(n.pos-i.nodeSize,n.pos):r.delete(n.pos,n.pos+i.nodeSize),e.dispatch(r),!0}return!1}function Qr(e,t,n){e.domObserver.stop(),t.contentEditable=n,e.domObserver.start()}function Yr(e,t){let n=t.keyCode,r=function(e){let t="";return e.ctrlKey&&(t+="c"),e.metaKey&&(t+="m"),e.altKey&&(t+="a"),e.shiftKey&&(t+="s"),t}(t);return 8==n||Mn&&72==n&&"c"==r?Xr(e,-1)||Wr(e):46==n||Mn&&68==n&&"c"==r?Xr(e,1)||Jr(e):13==n||27==n||(37==n||Mn&&66==n&&"c"==r?$r(e,-1,r)||Wr(e):39==n||Mn&&70==n&&"c"==r?$r(e,1,r)||Jr(e):38==n||Mn&&80==n&&"c"==r?Zr(e,-1,r)||Wr(e):40==n||Mn&&78==n&&"c"==r?function(e){if(!Cn||e.state.selection.$head.parentOffset>0)return!1;let{focusNode:t,focusOffset:n}=e.domSelection();if(t&&1==t.nodeType&&0==n&&t.firstChild&&"false"==t.firstChild.contentEditable){let n=t.firstChild;Qr(e,n,"true"),setTimeout((()=>Qr(e,n,"false")),20)}return!1}(e)||Zr(e,1,r)||Jr(e):r==(Mn?"m":"c")&&(66==n||73==n||89==n||90==n))}function eo(e,t){let n=[],{content:r,openStart:o,openEnd:i}=t;for(;o>1&&i>1&&1==r.childCount&&1==r.firstChild.childCount;){o--,i--;let e=r.firstChild;n.push(e.type.name,e.attrs!=e.type.defaultAttrs?e.attrs:null),r=e.content}let s=e.someProp("clipboardSerializer")||de.fromSchema(e.state.schema),a=uo(),l=a.createElement("div");l.appendChild(s.serializeFragment(r,{document:a}));let c,u=l.firstChild,d=0;for(;u&&1==u.nodeType&&(c=lo[u.nodeName.toLowerCase()]);){for(let e=c.length-1;e>=0;e--){let t=a.createElement(c[e]);for(;l.firstChild;)t.appendChild(l.firstChild);l.appendChild(t),d++}u=l.firstChild}return u&&1==u.nodeType&&u.setAttribute("data-pm-slice",`${o} ${i}${d?` -${d}`:""} ${JSON.stringify(n)}`),{dom:l,text:e.someProp("clipboardTextSerializer",(e=>e(t)))||t.content.textBetween(0,t.content.size,"\n\n")}}function to(e,t,n,r,o){let i,s,a=o.parent.type.spec.code;if(!n&&!t)return null;let l=t&&(r||a||!n);if(l){if(e.someProp("transformPastedText",(e=>{t=e(t,a||r)})),a)return t?new v(d.from(e.state.schema.text(t.replace(/\r\n?/g,"\n"))),0,0):v.empty;let n=e.someProp("clipboardTextParser",(e=>e(t,o,r)));if(n)s=n;else{let n=o.marks(),{schema:r}=e.state,s=de.fromSchema(r);i=document.createElement("div"),t.split(/(?:\r\n?|\n)+/).forEach((e=>{let t=i.appendChild(document.createElement("p"));e&&t.appendChild(s.serializeNode(r.text(e,n)))}))}}else e.someProp("transformPastedHTML",(e=>{n=e(n)})),i=function(e){let t=/^(\s*<meta [^>]*>)*/.exec(e);t&&(e=e.slice(t[0].length));let n,r=uo().createElement("div"),o=/<([a-z][^>\s]+)/i.exec(e);(n=o&&lo[o[1].toLowerCase()])&&(e=n.map((e=>"<"+e+">")).join("")+e+n.map((e=>"</"+e+">")).reverse().join(""));if(r.innerHTML=e,n)for(let e=0;e<n.length;e++)r=r.querySelector(n[e])||r;return r}(n),En&&function(e){let t=e.querySelectorAll(kn?"span:not([class]):not([style])":"span.Apple-converted-space");for(let n=0;n<t.length;n++){let r=t[n];1==r.childNodes.length&&" "==r.textContent&&r.parentNode&&r.parentNode.replaceChild(e.ownerDocument.createTextNode(" "),r)}}(i);let c=i&&i.querySelector("[data-pm-slice]"),u=c&&/^(\d+) (\d+)(?: -(\d+))? (.*)/.exec(c.getAttribute("data-pm-slice")||"");if(u&&u[3])for(let e=+u[3];e>0&&i.firstChild;e--)i=i.firstChild;if(!s){let t=e.someProp("clipboardParser")||e.someProp("domParser")||te.fromSchema(e.state.schema);s=t.parseSlice(i,{preserveWhitespace:!(!l&&!u),context:o,ruleFromNode:e=>"BR"!=e.nodeName||e.nextSibling||!e.parentNode||no.test(e.parentNode.nodeName)?null:{ignore:!0}})}if(u)s=function(e,t){if(!e.size)return e;let n,r=e.content.firstChild.type.schema;try{n=JSON.parse(t)}catch(t){return e}let{content:o,openStart:i,openEnd:s}=e;for(let e=n.length-2;e>=0;e-=2){let t=r.nodes[n[e]];if(!t||t.hasRequiredAttrs())break;o=d.from(t.create(n[e+1],o)),i++,s++}return new v(o,i,s)}(ao(s,+u[1],+u[2]),u[4]);else if(s=v.maxOpen(function(e,t){if(e.childCount<2)return e;for(let n=t.depth;n>=0;n--){let r,o=t.node(n).contentMatchAt(t.index(n)),i=[];if(e.forEach((e=>{if(!i)return;let t,n=o.findWrapping(e.type);if(!n)return i=null;if(t=i.length&&r.length&&oo(n,r,e,i[i.length-1],0))i[i.length-1]=t;else{i.length&&(i[i.length-1]=io(i[i.length-1],r.length));let t=ro(e,n);i.push(t),o=o.matchType(t.type),r=n}})),i)return d.from(i)}return e}(s.content,o),!0),s.openStart||s.openEnd){let e=0,t=0;for(let t=s.content.firstChild;e<s.openStart&&!t.type.spec.isolating;e++,t=t.firstChild);for(let e=s.content.lastChild;t<s.openEnd&&!e.type.spec.isolating;t++,e=e.lastChild);s=ao(s,e,t)}return e.someProp("transformPasted",(e=>{s=e(s)})),s}const no=/^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var)$/i;function ro(e,t,n=0){for(let r=t.length-1;r>=n;r--)e=t[r].create(null,d.from(e));return e}function oo(e,t,n,r,o){if(o<e.length&&o<t.length&&e[o]==t[o]){let i=oo(e,t,n,r.lastChild,o+1);if(i)return r.copy(r.content.replaceChild(r.childCount-1,i));if(r.contentMatchAt(r.childCount).matchType(o==e.length-1?n.type:e[o+1]))return r.copy(r.content.append(d.from(ro(n,e,o+1))))}}function io(e,t){if(0==t)return e;let n=e.content.replaceChild(e.childCount-1,io(e.lastChild,t-1)),r=e.contentMatchAt(e.childCount).fillBefore(d.empty,!0);return e.copy(n.append(r))}function so(e,t,n,r,o,i){let s=t<0?e.firstChild:e.lastChild,a=s.content;return o<r-1&&(a=so(a,t,n,r,o+1,i)),o>=n&&(a=t<0?s.contentMatchAt(0).fillBefore(a,e.childCount>1||i<=o).append(a):a.append(s.contentMatchAt(s.childCount).fillBefore(d.empty,!0))),e.replaceChild(t<0?0:e.childCount-1,s.copy(a))}function ao(e,t,n){return t<e.openStart&&(e=new v(so(e.content,-1,t,e.openStart,0,e.openEnd),t,e.openEnd)),n<e.openEnd&&(e=new v(so(e.content,1,n,e.openEnd,0,0),e.openStart,n)),e}const lo={thead:["table"],tbody:["table"],tfoot:["table"],caption:["table"],colgroup:["table"],col:["table","colgroup"],tr:["table","tbody"],td:["table","tbody","tr"],th:["table","tbody","tr"]};let co=null;function uo(){return co||(co=document.implementation.createHTMLDocument("title"))}const po={};let ho={};class fo{constructor(){this.shiftKey=!1,this.mouseDown=null,this.lastKeyCode=null,this.lastKeyCodeTime=0,this.lastClick={time:0,x:0,y:0,type:""},this.lastSelectionOrigin=null,this.lastSelectionTime=0,this.lastIOSEnter=0,this.lastIOSEnterFallbackTimeout=-1,this.lastAndroidDelete=0,this.composing=!1,this.composingTimeout=-1,this.compositionNodes=[],this.compositionEndedAt=-2e8,this.domChangeCount=0,this.eventHandlers=Object.create(null),this.hideSelectionGuard=null}}function mo(e,t){e.input.lastSelectionOrigin=t,e.input.lastSelectionTime=Date.now()}function go(e){e.someProp("handleDOMEvents",(t=>{for(let n in t)e.input.eventHandlers[n]||e.dom.addEventListener(n,e.input.eventHandlers[n]=t=>vo(e,t))}))}function vo(e,t){return e.someProp("handleDOMEvents",(n=>{let r=n[t.type];return!!r&&(r(e,t)||t.defaultPrevented)}))}function yo(e,t){if(!t.bubbles)return!0;if(t.defaultPrevented)return!1;for(let n=t.target;n!=e.dom;n=n.parentNode)if(!n||11==n.nodeType||n.pmViewDesc&&n.pmViewDesc.stopEvent(t))return!1;return!0}function bo(e){return{left:e.clientX,top:e.clientY}}function wo(e,t,n,r,o){if(-1==r)return!1;let i=e.state.doc.resolve(r);for(let r=i.depth+1;r>0;r--)if(e.someProp(t,(t=>r>i.depth?t(e,n,i.nodeAfter,i.before(r),o,!0):t(e,n,i.node(r),i.before(r),o,!1))))return!0;return!1}function ko(e,t,n){e.focused||e.focus();let r=e.state.tr.setSelection(t);"pointer"==n&&r.setMeta("pointer",!0),e.dispatch(r)}function xo(e,t,n,r,o){return wo(e,"handleClickOn",t,n,r)||e.someProp("handleClick",(n=>n(e,t,r)))||(o?function(e,t){if(-1==t)return!1;let n,r,o=e.state.selection;o instanceof Jt&&(n=o.node);let i=e.state.doc.resolve(t);for(let e=i.depth+1;e>0;e--){let t=e>i.depth?i.nodeAfter:i.node(e);if(Jt.isSelectable(t)){r=n&&o.$from.depth>0&&e>=o.$from.depth&&i.before(o.$from.depth+1)==o.$from.pos?i.before(o.$from.depth):i.before(e);break}}return null!=r&&(ko(e,Jt.create(e.state.doc,r),"pointer"),!0)}(e,n):function(e,t){if(-1==t)return!1;let n=e.state.doc.resolve(t),r=n.nodeAfter;return!!(r&&r.isAtom&&Jt.isSelectable(r))&&(ko(e,new Jt(n),"pointer"),!0)}(e,n))}function Co(e,t,n,r){return wo(e,"handleDoubleClickOn",t,n,r)||e.someProp("handleDoubleClick",(n=>n(e,t,r)))}function To(e,t,n,r){return wo(e,"handleTripleClickOn",t,n,r)||e.someProp("handleTripleClick",(n=>n(e,t,r)))||function(e,t,n){if(0!=n.button)return!1;let r=e.state.doc;if(-1==t)return!!r.inlineContent&&(ko(e,Ut.create(r,0,r.content.size),"pointer"),!0);let o=r.resolve(t);for(let t=o.depth+1;t>0;t--){let n=t>o.depth?o.nodeAfter:o.node(t),i=o.before(t);if(n.inlineContent)ko(e,Ut.create(r,i+1,i+1+n.content.size),"pointer");else{if(!Jt.isSelectable(n))continue;ko(e,Jt.create(r,i),"pointer")}return!0}}(e,n,r)}function Mo(e){return Lo(e)}ho.keydown=(e,t)=>{let n=t;if(e.input.shiftKey=16==n.keyCode||n.shiftKey,!No(e,n)&&(e.input.lastKeyCode=n.keyCode,e.input.lastKeyCodeTime=Date.now(),!Sn||!kn||13!=n.keyCode))if(229!=n.keyCode&&e.domObserver.forceFlush(),!Tn||13!=n.keyCode||n.ctrlKey||n.altKey||n.metaKey)e.someProp("handleKeyDown",(t=>t(e,n)))||Yr(e,n)?n.preventDefault():mo(e,"key");else{let t=Date.now();e.input.lastIOSEnter=t,e.input.lastIOSEnterFallbackTimeout=setTimeout((()=>{e.input.lastIOSEnter==t&&(e.someProp("handleKeyDown",(t=>t(e,zn(13,"Enter")))),e.input.lastIOSEnter=0)}),200)}},ho.keyup=(e,t)=>{16==t.keyCode&&(e.input.shiftKey=!1)},ho.keypress=(e,t)=>{let n=t;if(No(e,n)||!n.charCode||n.ctrlKey&&!n.altKey||Mn&&n.metaKey)return;if(e.someProp("handleKeyPress",(t=>t(e,n))))return void n.preventDefault();let r=e.state.selection;if(!(r instanceof Ut&&r.$from.sameParent(r.$to))){let t=String.fromCharCode(n.charCode);e.someProp("handleTextInput",(n=>n(e,r.$from.pos,r.$to.pos,t)))||e.dispatch(e.state.tr.insertText(t).scrollIntoView()),n.preventDefault()}};const So=Mn?"metaKey":"ctrlKey";po.mousedown=(e,t)=>{let n=t;e.input.shiftKey=n.shiftKey;let r=Mo(e),o=Date.now(),i="singleClick";o-e.input.lastClick.time<500&&function(e,t){let n=t.x-e.clientX,r=t.y-e.clientY;return n*n+r*r<100}(n,e.input.lastClick)&&!n[So]&&("singleClick"==e.input.lastClick.type?i="doubleClick":"doubleClick"==e.input.lastClick.type&&(i="tripleClick")),e.input.lastClick={time:o,x:n.clientX,y:n.clientY,type:i};let s=e.posAtCoords(bo(n));s&&("singleClick"==i?(e.input.mouseDown&&e.input.mouseDown.done(),e.input.mouseDown=new Eo(e,s,n,!!r)):("doubleClick"==i?Co:To)(e,s.pos,s.inside,n)?n.preventDefault():mo(e,"pointer"))};class Eo{constructor(e,t,n,r){let o,i;if(this.view=e,this.pos=t,this.event=n,this.flushed=r,this.delayedSelectionSync=!1,this.mightDrag=null,this.startDoc=e.state.doc,this.selectNode=!!n[So],this.allowDefault=n.shiftKey,t.inside>-1)o=e.state.doc.nodeAt(t.inside),i=t.inside;else{let n=e.state.doc.resolve(t.pos);o=n.parent,i=n.depth?n.before():0}const s=r?null:n.target,a=s?e.docView.nearestDesc(s,!0):null;this.target=a?a.dom:null;let{selection:l}=e.state;(0==n.button&&o.type.spec.draggable&&!1!==o.type.spec.selectable||l instanceof Jt&&l.from<=i&&l.to>i)&&(this.mightDrag={node:o,pos:i,addAttr:!(!this.target||this.target.draggable),setUneditable:!(!this.target||!bn||this.target.hasAttribute("contentEditable"))}),this.target&&this.mightDrag&&(this.mightDrag.addAttr||this.mightDrag.setUneditable)&&(this.view.domObserver.stop(),this.mightDrag.addAttr&&(this.target.draggable=!0),this.mightDrag.setUneditable&&setTimeout((()=>{this.view.input.mouseDown==this&&this.target.setAttribute("contentEditable","false")}),20),this.view.domObserver.start()),e.root.addEventListener("mouseup",this.up=this.up.bind(this)),e.root.addEventListener("mousemove",this.move=this.move.bind(this)),mo(e,"pointer")}done(){this.view.root.removeEventListener("mouseup",this.up),this.view.root.removeEventListener("mousemove",this.move),this.mightDrag&&this.target&&(this.view.domObserver.stop(),this.mightDrag.addAttr&&this.target.removeAttribute("draggable"),this.mightDrag.setUneditable&&this.target.removeAttribute("contentEditable"),this.view.domObserver.start()),this.delayedSelectionSync&&setTimeout((()=>Ar(this.view))),this.view.input.mouseDown=null}up(e){if(this.done(),!this.view.dom.contains(e.target))return;let t=this.pos;this.view.state.doc!=this.startDoc&&(t=this.view.posAtCoords(bo(e))),this.allowDefault||!t?mo(this.view,"pointer"):xo(this.view,t.pos,t.inside,e,this.selectNode)?e.preventDefault():0==e.button&&(this.flushed||Cn&&this.mightDrag&&!this.mightDrag.node.isAtom||kn&&!(this.view.state.selection instanceof Ut)&&Math.min(Math.abs(t.pos-this.view.state.selection.from),Math.abs(t.pos-this.view.state.selection.to))<=2)?(ko(this.view,Vt.near(this.view.state.doc.resolve(t.pos)),"pointer"),e.preventDefault()):mo(this.view,"pointer")}move(e){!this.allowDefault&&(Math.abs(this.event.x-e.clientX)>4||Math.abs(this.event.y-e.clientY)>4)&&(this.allowDefault=!0),mo(this.view,"pointer"),0==e.buttons&&this.done()}}function No(e,t){return!!e.composing||!!(Cn&&Math.abs(t.timeStamp-e.input.compositionEndedAt)<500)&&(e.input.compositionEndedAt=-2e8,!0)}po.touchdown=e=>{Mo(e),mo(e,"pointer")},po.contextmenu=e=>Mo(e);const Oo=Sn?5e3:-1;function Do(e,t){clearTimeout(e.input.composingTimeout),t>-1&&(e.input.composingTimeout=setTimeout((()=>Lo(e)),t))}function Ao(e){for(e.composing&&(e.input.composing=!1,e.input.compositionEndedAt=function(){let e=document.createEvent("Event");return e.initEvent("event",!0,!0),e.timeStamp}());e.input.compositionNodes.length>0;)e.input.compositionNodes.pop().markParentsDirty()}function Lo(e,t=!1){if(!(Sn&&e.domObserver.flushingSoon>=0)){if(e.domObserver.forceFlush(),Ao(e),t||e.docView&&e.docView.dirty){let t=Or(e);return t&&!t.eq(e.state.selection)?e.dispatch(e.state.tr.setSelection(t)):e.updateState(e.state),!0}return!1}}ho.compositionstart=ho.compositionupdate=e=>{if(!e.composing){e.domObserver.flush();let{state:t}=e,n=t.selection.$from;if(t.selection.empty&&(t.storedMarks||!n.textOffset&&n.parentOffset&&n.nodeBefore.marks.some((e=>!1===e.type.spec.inclusive))))e.markCursor=e.state.storedMarks||n.marks(),Lo(e,!0),e.markCursor=null;else if(Lo(e),bn&&t.selection.empty&&n.parentOffset&&!n.textOffset&&n.nodeBefore.marks.length){let t=e.domSelection();for(let e=t.focusNode,n=t.focusOffset;e&&1==e.nodeType&&0!=n;){let r=n<0?e.lastChild:e.childNodes[n-1];if(!r)break;if(3==r.nodeType){t.collapse(r,r.nodeValue.length);break}e=r,n=-1}}e.input.composing=!0}Do(e,Oo)},ho.compositionend=(e,t)=>{e.composing&&(e.input.composing=!1,e.input.compositionEndedAt=t.timeStamp,Do(e,20))};const Io=vn&&yn<15||Tn&&Nn<604;function Ro(e,t,n,r){let o=to(e,t,n,e.input.shiftKey,e.state.selection.$from);if(e.someProp("handlePaste",(t=>t(e,r,o||v.empty))))return!0;if(!o)return!1;let i=function(e){return 0==e.openStart&&0==e.openEnd&&1==e.content.childCount?e.content.firstChild:null}(o),s=i?e.state.tr.replaceSelectionWith(i,e.input.shiftKey):e.state.tr.replaceSelection(o);return e.dispatch(s.scrollIntoView().setMeta("paste",!0).setMeta("uiEvent","paste")),!0}po.copy=ho.cut=(e,t)=>{let n=t,r=e.state.selection,o="cut"==n.type;if(r.empty)return;let i=Io?null:n.clipboardData,s=r.content(),{dom:a,text:l}=eo(e,s);i?(n.preventDefault(),i.clearData(),i.setData("text/html",a.innerHTML),i.setData("text/plain",l)):function(e,t){if(!e.dom.parentNode)return;let n=e.dom.parentNode.appendChild(document.createElement("div"));n.appendChild(t),n.style.cssText="position: fixed; left: -10000px; top: 10px";let r=getSelection(),o=document.createRange();o.selectNodeContents(t),e.dom.blur(),r.removeAllRanges(),r.addRange(o),setTimeout((()=>{n.parentNode&&n.parentNode.removeChild(n),e.focus()}),50)}(e,a),o&&e.dispatch(e.state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent","cut"))},ho.paste=(e,t)=>{let n=t;if(e.composing&&!Sn)return;let r=Io?null:n.clipboardData;r&&Ro(e,r.getData("text/plain"),r.getData("text/html"),n)?n.preventDefault():function(e,t){if(!e.dom.parentNode)return;let n=e.input.shiftKey||e.state.selection.$from.parent.type.spec.code,r=e.dom.parentNode.appendChild(document.createElement(n?"textarea":"div"));n||(r.contentEditable="true"),r.style.cssText="position: fixed; left: -10000px; top: 10px",r.focus(),setTimeout((()=>{e.focus(),r.parentNode&&r.parentNode.removeChild(r),n?Ro(e,r.value,null,t):Ro(e,r.textContent,r.innerHTML,t)}),50)}(e,n)};class Po{constructor(e,t){this.slice=e,this.move=t}}const Bo=Mn?"altKey":"ctrlKey";po.dragstart=(e,t)=>{let n=t,r=e.input.mouseDown;if(r&&r.done(),!n.dataTransfer)return;let o=e.state.selection,i=o.empty?null:e.posAtCoords(bo(n));if(i&&i.pos>=o.from&&i.pos<=(o instanceof Jt?o.to-1:o.to));else if(r&&r.mightDrag)e.dispatch(e.state.tr.setSelection(Jt.create(e.state.doc,r.mightDrag.pos)));else if(n.target&&1==n.target.nodeType){let t=e.docView.nearestDesc(n.target,!0);t&&t.node.type.spec.draggable&&t!=e.docView&&e.dispatch(e.state.tr.setSelection(Jt.create(e.state.doc,t.posBefore)))}let s=e.state.selection.content(),{dom:a,text:l}=eo(e,s);n.dataTransfer.clearData(),n.dataTransfer.setData(Io?"Text":"text/html",a.innerHTML),n.dataTransfer.effectAllowed="copyMove",Io||n.dataTransfer.setData("text/plain",l),e.dragging=new Po(s,!n[Bo])},po.dragend=e=>{let t=e.dragging;window.setTimeout((()=>{e.dragging==t&&(e.dragging=null)}),50)},ho.dragover=ho.dragenter=(e,t)=>t.preventDefault(),ho.drop=(e,t)=>{let n=t,r=e.dragging;if(e.dragging=null,!n.dataTransfer)return;let o=e.posAtCoords(bo(n));if(!o)return;let i=e.state.doc.resolve(o.pos);if(!i)return;let s=r&&r.slice;s?e.someProp("transformPasted",(e=>{s=e(s)})):s=to(e,n.dataTransfer.getData(Io?"Text":"text/plain"),Io?null:n.dataTransfer.getData("text/html"),!1,i);let a=!(!r||n[Bo]);if(e.someProp("handleDrop",(t=>t(e,n,s||v.empty,a))))return void n.preventDefault();if(!s)return;n.preventDefault();let l=s?function(e,t,n){let r=e.resolve(t);if(!n.content.size)return t;let o=n.content;for(let e=0;e<n.openStart;e++)o=o.firstChild.content;for(let e=1;e<=(0==n.openStart&&n.size?2:1);e++)for(let t=r.depth;t>=0;t--){let n=t==r.depth?0:r.pos<=(r.start(t+1)+r.end(t+1))/2?-1:1,i=r.index(t)+(n>0?1:0),s=r.node(t),a=!1;if(1==e)a=s.canReplace(i,i,o);else{let e=s.contentMatchAt(i).findWrapping(o.firstChild.type);a=e&&s.canReplaceWith(i,i,e[0])}if(a)return 0==n?r.pos:n<0?r.before(t+1):r.after(t+1)}return null}(e.state.doc,i.pos,s):i.pos;null==l&&(l=i.pos);let c=e.state.tr;a&&c.deleteSelection();let u=c.mapping.map(l),d=0==s.openStart&&0==s.openEnd&&1==s.content.childCount,p=c.doc;if(d?c.replaceRangeWith(u,u,s.content.firstChild):c.replaceRange(u,u,s),c.doc.eq(p))return;let h=c.doc.resolve(u);if(d&&Jt.isSelectable(s.content.firstChild)&&h.nodeAfter&&h.nodeAfter.sameMarkup(s.content.firstChild))c.setSelection(new Jt(h));else{let t=c.mapping.map(l);c.mapping.maps[c.mapping.maps.length-1].forEach(((e,n,r,o)=>t=o)),c.setSelection(Hr(e,h,c.doc.resolve(t)))}e.focus(),e.dispatch(c.setMeta("uiEvent","drop"))},po.focus=e=>{e.focused||(e.domObserver.stop(),e.dom.classList.add("ProseMirror-focused"),e.domObserver.start(),e.focused=!0,setTimeout((()=>{e.docView&&e.hasFocus()&&!e.domObserver.currentSelection.eq(e.domSelection())&&Ar(e)}),20))},po.blur=(e,t)=>{let n=t;e.focused&&(e.domObserver.stop(),e.dom.classList.remove("ProseMirror-focused"),e.domObserver.start(),n.relatedTarget&&e.dom.contains(n.relatedTarget)&&e.domObserver.currentSelection.clear(),e.focused=!1)},po.beforeinput=(e,t)=>{if(kn&&Sn&&"deleteContentBackward"==t.inputType){e.domObserver.flushSoon();let{domChangeCount:t}=e.input;setTimeout((()=>{if(e.input.domChangeCount!=t)return;if(e.dom.blur(),e.focus(),e.someProp("handleKeyDown",(t=>t(e,zn(8,"Backspace")))))return;let{$cursor:n}=e.state.selection;n&&n.pos>0&&e.dispatch(e.state.tr.delete(n.pos-1,n.pos).scrollIntoView())}),50)}};for(let e in ho)po[e]=ho[e];function Fo(e,t){if(e==t)return!0;for(let n in e)if(e[n]!==t[n])return!1;for(let n in t)if(!(n in e))return!1;return!0}class Ho{constructor(e,t){this.toDOM=e,this.spec=t||$o,this.side=this.spec.side||0}map(e,t,n,r){let{pos:o,deleted:i}=e.mapResult(t.from+r,this.side<0?-1:1);return i?null:new Vo(o-n,o-n,this)}valid(){return!0}eq(e){return this==e||e instanceof Ho&&(this.spec.key&&this.spec.key==e.spec.key||this.toDOM==e.toDOM&&Fo(this.spec,e.spec))}destroy(e){this.spec.destroy&&this.spec.destroy(e)}}class zo{constructor(e,t){this.attrs=e,this.spec=t||$o}map(e,t,n,r){let o=e.map(t.from+r,this.spec.inclusiveStart?-1:1)-n,i=e.map(t.to+r,this.spec.inclusiveEnd?1:-1)-n;return o>=i?null:new Vo(o,i,this)}valid(e,t){return t.from<t.to}eq(e){return this==e||e instanceof zo&&Fo(this.attrs,e.attrs)&&Fo(this.spec,e.spec)}static is(e){return e.type instanceof zo}destroy(){}}class qo{constructor(e,t){this.attrs=e,this.spec=t||$o}map(e,t,n,r){let o=e.mapResult(t.from+r,1);if(o.deleted)return null;let i=e.mapResult(t.to+r,-1);return i.deleted||i.pos<=o.pos?null:new Vo(o.pos-n,i.pos-n,this)}valid(e,t){let n,{index:r,offset:o}=e.content.findIndex(t.from);return o==t.from&&!(n=e.child(r)).isText&&o+n.nodeSize==t.to}eq(e){return this==e||e instanceof qo&&Fo(this.attrs,e.attrs)&&Fo(this.spec,e.spec)}destroy(){}}class Vo{constructor(e,t,n){this.from=e,this.to=t,this.type=n}copy(e,t){return new Vo(e,t,this.type)}eq(e,t=0){return this.type.eq(e.type)&&this.from+t==e.from&&this.to+t==e.to}map(e,t,n){return this.type.map(e,this,t,n)}static widget(e,t,n){return new Vo(e,e,new Ho(t,n))}static inline(e,t,n,r){return new Vo(e,t,new zo(n,r))}static node(e,t,n,r){return new Vo(e,t,new qo(n,r))}get spec(){return this.type.spec}get inline(){return this.type instanceof zo}}const jo=[],$o={};class _o{constructor(e,t){this.local=e.length?e:jo,this.children=t.length?t:jo}static create(e,t){return t.length?Zo(t,e,0,$o):Uo}find(e,t,n){let r=[];return this.findInner(null==e?0:e,null==t?1e9:t,r,0,n),r}findInner(e,t,n,r,o){for(let i=0;i<this.local.length;i++){let s=this.local[i];s.from<=t&&s.to>=e&&(!o||o(s.spec))&&n.push(s.copy(s.from+r,s.to+r))}for(let i=0;i<this.children.length;i+=3)if(this.children[i]<t&&this.children[i+1]>e){let s=this.children[i]+1;this.children[i+2].findInner(e-s,t-s,n,r+s,o)}}map(e,t,n){return this==Uo||0==e.maps.length?this:this.mapInner(e,t,0,0,n||$o)}mapInner(e,t,n,r,o){let i;for(let s=0;s<this.local.length;s++){let a=this.local[s].map(e,n,r);a&&a.type.valid(t,a)?(i||(i=[])).push(a):o.onRemove&&o.onRemove(this.local[s].spec)}return this.children.length?function(e,t,n,r,o,i,s){let a=e.slice(),l=(e,t,n,r)=>{for(let s=0;s<a.length;s+=3){let l,c=a[s+1];if(c<0||e>c+i)continue;let u=a[s]+i;t>=u?a[s+1]=e<=u?-2:-1:n>=o&&(l=r-n-(t-e))&&(a[s]+=l,a[s+1]+=l)}};for(let e=0;e<n.maps.length;e++)n.maps[e].forEach(l);let c=!1;for(let t=0;t<a.length;t+=3)if(a[t+1]<0){if(-2==a[t+1]){c=!0,a[t+1]=-1;continue}let l=n.map(e[t]+i),u=l-o;if(u<0||u>=r.content.size){c=!0;continue}let d=n.map(e[t+1]+i,-1)-o,{index:p,offset:h}=r.content.findIndex(u),f=r.maybeChild(p);if(f&&h==u&&h+f.nodeSize==d){let r=a[t+2].mapInner(n,f,l+1,e[t]+i+1,s);r!=Uo?(a[t]=u,a[t+1]=d,a[t+2]=r):(a[t+1]=-2,c=!0)}else c=!0}if(c){let l=function(e,t,n,r,o,i,s){function a(e,t){for(let i=0;i<e.local.length;i++){let a=e.local[i].map(r,o,t);a?n.push(a):s.onRemove&&s.onRemove(e.local[i].spec)}for(let n=0;n<e.children.length;n+=3)a(e.children[n+2],e.children[n]+t+1)}for(let n=0;n<e.length;n+=3)-1==e[n+1]&&a(e[n+2],t[n]+i+1);return n}(a,e,t,n,o,i,s),c=Zo(l,r,0,s);t=c.local;for(let e=0;e<a.length;e+=3)a[e+1]<0&&(a.splice(e,3),e-=3);for(let e=0,t=0;e<c.children.length;e+=3){let n=c.children[e];for(;t<a.length&&a[t]<n;)t+=3;a.splice(t,0,c.children[e],c.children[e+1],c.children[e+2])}}return new _o(t.sort(Xo),a)}(this.children,i||[],e,t,n,r,o):i?new _o(i.sort(Xo),jo):Uo}add(e,t){return t.length?this==Uo?_o.create(e,t):this.addInner(e,t,0):this}addInner(e,t,n){let r,o=0;e.forEach(((e,i)=>{let s,a=i+n;if(s=Go(t,e,a)){for(r||(r=this.children.slice());o<r.length&&r[o]<i;)o+=3;r[o]==i?r[o+2]=r[o+2].addInner(e,s,a+1):r.splice(o,0,i,i+e.nodeSize,Zo(s,e,a+1,$o)),o+=3}}));let i=Jo(o?Ko(t):t,-n);for(let t=0;t<i.length;t++)i[t].type.valid(e,i[t])||i.splice(t--,1);return new _o(i.length?this.local.concat(i).sort(Xo):this.local,r||this.children)}remove(e){return 0==e.length||this==Uo?this:this.removeInner(e,0)}removeInner(e,t){let n=this.children,r=this.local;for(let r=0;r<n.length;r+=3){let o,i=n[r]+t,s=n[r+1]+t;for(let t,n=0;n<e.length;n++)(t=e[n])&&t.from>i&&t.to<s&&(e[n]=null,(o||(o=[])).push(t));if(!o)continue;n==this.children&&(n=this.children.slice());let a=n[r+2].removeInner(o,i+1);a!=Uo?n[r+2]=a:(n.splice(r,3),r-=3)}if(r.length)for(let n,o=0;o<e.length;o++)if(n=e[o])for(let e=0;e<r.length;e++)r[e].eq(n,t)&&(r==this.local&&(r=this.local.slice()),r.splice(e--,1));return n==this.children&&r==this.local?this:r.length||n.length?new _o(r,n):Uo}forChild(e,t){if(this==Uo)return this;if(t.isLeaf)return _o.empty;let n,r;for(let t=0;t<this.children.length;t+=3)if(this.children[t]>=e){this.children[t]==e&&(n=this.children[t+2]);break}let o=e+1,i=o+t.content.size;for(let e=0;e<this.local.length;e++){let t=this.local[e];if(t.from<i&&t.to>o&&t.type instanceof zo){let e=Math.max(o,t.from)-o,n=Math.min(i,t.to)-o;e<n&&(r||(r=[])).push(t.copy(e,n))}}if(r){let e=new _o(r.sort(Xo),jo);return n?new Wo([e,n]):e}return n||Uo}eq(e){if(this==e)return!0;if(!(e instanceof _o)||this.local.length!=e.local.length||this.children.length!=e.children.length)return!1;for(let t=0;t<this.local.length;t++)if(!this.local[t].eq(e.local[t]))return!1;for(let t=0;t<this.children.length;t+=3)if(this.children[t]!=e.children[t]||this.children[t+1]!=e.children[t+1]||!this.children[t+2].eq(e.children[t+2]))return!1;return!0}locals(e){return Qo(this.localsInner(e))}localsInner(e){if(this==Uo)return jo;if(e.inlineContent||!this.local.some(zo.is))return this.local;let t=[];for(let e=0;e<this.local.length;e++)this.local[e].type instanceof zo||t.push(this.local[e]);return t}}_o.empty=new _o([],[]),_o.removeOverlap=Qo;const Uo=_o.empty;class Wo{constructor(e){this.members=e}map(e,t){const n=this.members.map((n=>n.map(e,t,$o)));return Wo.from(n)}forChild(e,t){if(t.isLeaf)return _o.empty;let n=[];for(let r=0;r<this.members.length;r++){let o=this.members[r].forChild(e,t);o!=Uo&&(o instanceof Wo?n=n.concat(o.members):n.push(o))}return Wo.from(n)}eq(e){if(!(e instanceof Wo)||e.members.length!=this.members.length)return!1;for(let t=0;t<this.members.length;t++)if(!this.members[t].eq(e.members[t]))return!1;return!0}locals(e){let t,n=!0;for(let r=0;r<this.members.length;r++){let o=this.members[r].localsInner(e);if(o.length)if(t){n&&(t=t.slice(),n=!1);for(let e=0;e<o.length;e++)t.push(o[e])}else t=o}return t?Qo(n?t:t.sort(Xo)):jo}static from(e){switch(e.length){case 0:return Uo;case 1:return e[0];default:return new Wo(e)}}}function Jo(e,t){if(!t||!e.length)return e;let n=[];for(let r=0;r<e.length;r++){let o=e[r];n.push(new Vo(o.from+t,o.to+t,o.type))}return n}function Go(e,t,n){if(t.isLeaf)return null;let r=n+t.nodeSize,o=null;for(let t,i=0;i<e.length;i++)(t=e[i])&&t.from>n&&t.to<r&&((o||(o=[])).push(t),e[i]=null);return o}function Ko(e){let t=[];for(let n=0;n<e.length;n++)null!=e[n]&&t.push(e[n]);return t}function Zo(e,t,n,r){let o=[],i=!1;t.forEach(((t,s)=>{let a=Go(e,t,s+n);if(a){i=!0;let e=Zo(a,t,n+s+1,r);e!=Uo&&o.push(s,s+t.nodeSize,e)}}));let s=Jo(i?Ko(e):e,-n).sort(Xo);for(let e=0;e<s.length;e++)s[e].type.valid(t,s[e])||(r.onRemove&&r.onRemove(s[e].spec),s.splice(e--,1));return s.length||o.length?new _o(s,o):Uo}function Xo(e,t){return e.from-t.from||e.to-t.to}function Qo(e){let t=e;for(let n=0;n<t.length-1;n++){let r=t[n];if(r.from!=r.to)for(let o=n+1;o<t.length;o++){let i=t[o];if(i.from!=r.from){i.from<r.to&&(t==e&&(t=e.slice()),t[n]=r.copy(r.from,i.from),Yo(t,o,r.copy(i.from,r.to)));break}i.to!=r.to&&(t==e&&(t=e.slice()),t[o]=i.copy(i.from,r.to),Yo(t,o+1,i.copy(r.to,i.to)))}}return t}function Yo(e,t,n){for(;t<e.length&&Xo(n,e[t])>0;)t++;e.splice(t,0,n)}function ei(e){let t=[];return e.someProp("decorations",(n=>{let r=n(e.state);r&&r!=Uo&&t.push(r)})),e.cursorWrapper&&t.push(_o.create(e.state.doc,[e.cursorWrapper.deco])),Wo.from(t)}const ti={childList:!0,characterData:!0,characterDataOldValue:!0,attributes:!0,attributeOldValue:!0,subtree:!0},ni=vn&&yn<=11;class ri{constructor(){this.anchorNode=null,this.anchorOffset=0,this.focusNode=null,this.focusOffset=0}set(e){this.anchorNode=e.anchorNode,this.anchorOffset=e.anchorOffset,this.focusNode=e.focusNode,this.focusOffset=e.focusOffset}clear(){this.anchorNode=this.focusNode=null}eq(e){return e.anchorNode==this.anchorNode&&e.anchorOffset==this.anchorOffset&&e.focusNode==this.focusNode&&e.focusOffset==this.focusOffset}}class oi{constructor(e,t){this.view=e,this.handleDOMChange=t,this.queue=[],this.flushingSoon=-1,this.observer=null,this.currentSelection=new ri,this.onCharData=null,this.suppressingSelectionUpdates=!1,this.observer=window.MutationObserver&&new window.MutationObserver((e=>{for(let t=0;t<e.length;t++)this.queue.push(e[t]);vn&&yn<=11&&e.some((e=>"childList"==e.type&&e.removedNodes.length||"characterData"==e.type&&e.oldValue.length>e.target.nodeValue.length))?this.flushSoon():this.flush()})),ni&&(this.onCharData=e=>{this.queue.push({target:e.target,type:"characterData",oldValue:e.prevValue}),this.flushSoon()}),this.onSelectionChange=this.onSelectionChange.bind(this)}flushSoon(){this.flushingSoon<0&&(this.flushingSoon=window.setTimeout((()=>{this.flushingSoon=-1,this.flush()}),20))}forceFlush(){this.flushingSoon>-1&&(window.clearTimeout(this.flushingSoon),this.flushingSoon=-1,this.flush())}start(){this.observer&&(this.observer.takeRecords(),this.observer.observe(this.view.dom,ti)),this.onCharData&&this.view.dom.addEventListener("DOMCharacterDataModified",this.onCharData),this.connectSelection()}stop(){if(this.observer){let e=this.observer.takeRecords();if(e.length){for(let t=0;t<e.length;t++)this.queue.push(e[t]);window.setTimeout((()=>this.flush()),20)}this.observer.disconnect()}this.onCharData&&this.view.dom.removeEventListener("DOMCharacterDataModified",this.onCharData),this.disconnectSelection()}connectSelection(){this.view.dom.ownerDocument.addEventListener("selectionchange",this.onSelectionChange)}disconnectSelection(){this.view.dom.ownerDocument.removeEventListener("selectionchange",this.onSelectionChange)}suppressSelectionUpdates(){this.suppressingSelectionUpdates=!0,setTimeout((()=>this.suppressingSelectionUpdates=!1),50)}onSelectionChange(){if(zr(this.view)){if(this.suppressingSelectionUpdates)return Ar(this.view);if(vn&&yn<=11&&!this.view.state.selection.empty){let e=this.view.domSelection();if(e.focusNode&&In(e.focusNode,e.focusOffset,e.anchorNode,e.anchorOffset))return this.flushSoon()}this.flush()}}setCurSelection(){this.currentSelection.set(this.view.domSelection())}ignoreSelectionChange(e){if(0==e.rangeCount)return!0;let t=e.getRangeAt(0).commonAncestorContainer,n=this.view.docView.nearestDesc(t);return n&&n.ignoreMutation({type:"selection",target:3==t.nodeType?t.parentNode:t})?(this.setCurSelection(),!0):void 0}flush(){if(!this.view.docView||this.flushingSoon>-1)return;let e=this.observer?this.observer.takeRecords():[];this.queue.length&&(e=this.queue.concat(e),this.queue.length=0);let t=this.view.domSelection(),n=!this.suppressingSelectionUpdates&&!this.currentSelection.eq(t)&&zr(this.view)&&!this.ignoreSelectionChange(t),r=-1,o=-1,i=!1,s=[];if(this.view.editable)for(let t=0;t<e.length;t++){let n=this.registerMutation(e[t],s);n&&(r=r<0?n.from:Math.min(n.from,r),o=o<0?n.to:Math.max(n.to,o),n.typeOver&&(i=!0))}if(bn&&s.length>1){let e=s.filter((e=>"BR"==e.nodeName));if(2==e.length){let t=e[0],n=e[1];t.parentNode&&t.parentNode.parentNode==n.parentNode?n.remove():t.remove()}}(r>-1||n)&&(r>-1&&(this.view.docView.markDirty(r,o),function(e){if(ii)return;ii=!0,"normal"==getComputedStyle(e.dom).whiteSpace&&console.warn("ProseMirror expects the CSS white-space property to be set, preferably to 'pre-wrap'. It is recommended to load style/prosemirror.css from the prosemirror-view package.")}(this.view)),this.handleDOMChange(r,o,i,s),this.view.docView&&this.view.docView.dirty?this.view.updateState(this.view.state):this.currentSelection.eq(t)||Ar(this.view),this.currentSelection.set(t))}registerMutation(e,t){if(t.indexOf(e.target)>-1)return null;let n=this.view.docView.nearestDesc(e.target);if("attributes"==e.type&&(n==this.view.docView||"contenteditable"==e.attributeName||"style"==e.attributeName&&!e.oldValue&&!e.target.getAttribute("style")))return null;if(!n||n.ignoreMutation(e))return null;if("childList"==e.type){for(let n=0;n<e.addedNodes.length;n++)t.push(e.addedNodes[n]);if(n.contentDOM&&n.contentDOM!=n.dom&&!n.contentDOM.contains(e.target))return{from:n.posBefore,to:n.posAfter};let r=e.previousSibling,o=e.nextSibling;if(vn&&yn<=11&&e.addedNodes.length)for(let t=0;t<e.addedNodes.length;t++){let{previousSibling:n,nextSibling:i}=e.addedNodes[t];(!n||Array.prototype.indexOf.call(e.addedNodes,n)<0)&&(r=n),(!i||Array.prototype.indexOf.call(e.addedNodes,i)<0)&&(o=i)}let i=r&&r.parentNode==e.target?On(r)+1:0,s=n.localPosFromDOM(e.target,i,-1),a=o&&o.parentNode==e.target?On(o):e.target.childNodes.length;return{from:s,to:n.localPosFromDOM(e.target,a,1)}}return"attributes"==e.type?{from:n.posAtStart-n.border,to:n.posAtEnd+n.border}:{from:n.posAtStart,to:n.posAtEnd,typeOver:e.target.nodeValue==e.oldValue}}}let ii=!1;function si(e){let t=e.pmViewDesc;if(t)return t.parseRule();if("BR"==e.nodeName&&e.parentNode){if(Cn&&/^(ul|ol)$/i.test(e.parentNode.nodeName)){let e=document.createElement("div");return e.appendChild(document.createElement("li")),{skip:e}}if(e.parentNode.lastChild==e||Cn&&/^(tr|table)$/i.test(e.parentNode.nodeName))return{ignore:!0}}else if("IMG"==e.nodeName&&e.getAttribute("mark-placeholder"))return{ignore:!0};return null}function ai(e,t,n,r,o){if(t<0){let t=e.input.lastSelectionTime>Date.now()-50?e.input.lastSelectionOrigin:null,n=Or(e,t);if(n&&!e.state.selection.eq(n)){let r=e.state.tr.setSelection(n);"pointer"==t?r.setMeta("pointer",!0):"key"==t&&r.scrollIntoView(),e.dispatch(r)}return}let i=e.state.doc.resolve(t),s=i.sharedDepth(n);t=i.before(s+1),n=e.state.doc.resolve(n).after(s+1);let a=e.state.selection,l=function(e,t,n){let r,{node:o,fromOffset:i,toOffset:s,from:a,to:l}=e.docView.parseRange(t,n),c=e.domSelection(),u=c.anchorNode;if(u&&e.dom.contains(1==u.nodeType?u:u.parentNode)&&(r=[{node:u,offset:c.anchorOffset}],Hn(c)||r.push({node:c.focusNode,offset:c.focusOffset})),kn&&8===e.input.lastKeyCode)for(let e=s;e>i;e--){let t=o.childNodes[e-1],n=t.pmViewDesc;if("BR"==t.nodeName&&!n){s=e;break}if(!n||n.size)break}let d=e.state.doc,p=e.someProp("domParser")||te.fromSchema(e.state.schema),h=d.resolve(a),f=null,m=p.parse(o,{topNode:h.parent,topMatch:h.parent.contentMatchAt(h.index()),topOpen:!0,from:i,to:s,preserveWhitespace:"pre"!=h.parent.type.whitespace||"full",findPositions:r,ruleFromNode:si,context:h});if(r&&null!=r[0].pos){let e=r[0].pos,t=r[1]&&r[1].pos;null==t&&(t=e),f={anchor:e+a,head:t+a}}return{doc:m,sel:f,from:a,to:l}}(e,t,n);if(kn&&e.cursorWrapper&&l.sel&&l.sel.anchor==e.cursorWrapper.deco.from&&l.sel.head==l.sel.anchor){let t=e.cursorWrapper.deco.type.toDOM.nextSibling,n=t&&t.nodeValue?t.nodeValue.length:1;l.sel={anchor:l.sel.anchor+n,head:l.sel.anchor+n}}let c,u,p=e.state.doc,h=p.slice(l.from,l.to);8===e.input.lastKeyCode&&Date.now()-100<e.input.lastKeyCodeTime?(c=e.state.selection.to,u="end"):(c=e.state.selection.from,u="start"),e.input.lastKeyCode=null;let f=function(e,t,n,r,o){let i=e.findDiffStart(t,n);if(null==i)return null;let{a:s,b:a}=e.findDiffEnd(t,n+e.size,n+t.size);if("end"==o){r-=s+Math.max(0,i-Math.min(s,a))-i}if(s<i&&e.size<t.size){i-=r<=i&&r>=s?i-r:0,a=i+(a-s),s=i}else if(a<i){i-=r<=i&&r>=a?i-r:0,s=i+(s-a),a=i}return{start:i,endA:s,endB:a}}(h.content,l.doc.content,l.from,c,u);if((Tn&&e.input.lastIOSEnter>Date.now()-225||Sn)&&o.some((e=>"DIV"==e.nodeName||"P"==e.nodeName))&&(!f||f.endA>=f.endB)&&e.someProp("handleKeyDown",(t=>t(e,zn(13,"Enter")))))return void(e.input.lastIOSEnter=0);if(!f){if(!(r&&a instanceof Ut&&!a.empty&&a.$head.sameParent(a.$anchor))||e.composing||l.sel&&l.sel.anchor!=l.sel.head){if(l.sel){let t=li(e,e.state.doc,l.sel);t&&!t.eq(e.state.selection)&&e.dispatch(e.state.tr.setSelection(t))}return}f={start:a.from,endA:a.to,endB:a.to}}e.input.domChangeCount++,e.state.selection.from<e.state.selection.to&&f.start==f.endB&&e.state.selection instanceof Ut&&(f.start>e.state.selection.from&&f.start<=e.state.selection.from+2&&e.state.selection.from>=l.from?f.start=e.state.selection.from:f.endA<e.state.selection.to&&f.endA>=e.state.selection.to-2&&e.state.selection.to<=l.to&&(f.endB+=e.state.selection.to-f.endA,f.endA=e.state.selection.to)),vn&&yn<=11&&f.endB==f.start+1&&f.endA==f.start&&f.start>l.from&&"  "==l.doc.textBetween(f.start-l.from-1,f.start-l.from+1)&&(f.start--,f.endA--,f.endB--);let m,g=l.doc.resolveNoCache(f.start-l.from),v=l.doc.resolveNoCache(f.endB-l.from),y=p.resolve(f.start),b=g.sameParent(v)&&g.parent.inlineContent&&y.end()>=f.endA;if((Tn&&e.input.lastIOSEnter>Date.now()-225&&(!b||o.some((e=>"DIV"==e.nodeName||"P"==e.nodeName)))||!b&&g.pos<l.doc.content.size&&(m=Vt.findFrom(l.doc.resolve(g.pos+1),1,!0))&&m.head==v.pos)&&e.someProp("handleKeyDown",(t=>t(e,zn(13,"Enter")))))return void(e.input.lastIOSEnter=0);if(e.state.selection.anchor>f.start&&function(e,t,n,r,o){if(!r.parent.isTextblock||n-t<=o.pos-r.pos||ci(r,!0,!1)<o.pos)return!1;let i=e.resolve(t);if(i.parentOffset<i.parent.content.size||!i.parent.isTextblock)return!1;let s=e.resolve(ci(i,!0,!0));return!(!s.parent.isTextblock||s.pos>n||ci(s,!0,!1)<n)&&r.parent.content.cut(r.parentOffset).eq(s.parent.content)}(p,f.start,f.endA,g,v)&&e.someProp("handleKeyDown",(t=>t(e,zn(8,"Backspace")))))return void(Sn&&kn&&e.domObserver.suppressSelectionUpdates());kn&&Sn&&f.endB==f.start&&(e.input.lastAndroidDelete=Date.now()),Sn&&!b&&g.start()!=v.start()&&0==v.parentOffset&&g.depth==v.depth&&l.sel&&l.sel.anchor==l.sel.head&&l.sel.head==f.endA&&(f.endB-=2,v=l.doc.resolveNoCache(f.endB-l.from),setTimeout((()=>{e.someProp("handleKeyDown",(function(t){return t(e,zn(13,"Enter"))}))}),20));let w,k,x,C=f.start,T=f.endA;if(b)if(g.pos==v.pos)vn&&yn<=11&&0==g.parentOffset&&(e.domObserver.suppressSelectionUpdates(),setTimeout((()=>Ar(e)),20)),w=e.state.tr.delete(C,T),k=p.resolve(f.start).marksAcross(p.resolve(f.endA));else if(f.endA==f.endB&&(x=function(e,t){let n,r,o,i=e.firstChild.marks,s=t.firstChild.marks,a=i,l=s;for(let e=0;e<s.length;e++)a=s[e].removeFromSet(a);for(let e=0;e<i.length;e++)l=i[e].removeFromSet(l);if(1==a.length&&0==l.length)r=a[0],n="add",o=e=>e.mark(r.addToSet(e.marks));else{if(0!=a.length||1!=l.length)return null;r=l[0],n="remove",o=e=>e.mark(r.removeFromSet(e.marks))}let c=[];for(let e=0;e<t.childCount;e++)c.push(o(t.child(e)));if(d.from(c).eq(e))return{mark:r,type:n}}(g.parent.content.cut(g.parentOffset,v.parentOffset),y.parent.content.cut(y.parentOffset,f.endA-y.start()))))w=e.state.tr,"add"==x.type?w.addMark(C,T,x.mark):w.removeMark(C,T,x.mark);else if(g.parent.child(g.index()).isText&&g.index()==v.index()-(v.textOffset?0:1)){let t=g.parent.textBetween(g.parentOffset,v.parentOffset);if(e.someProp("handleTextInput",(n=>n(e,C,T,t))))return;w=e.state.tr.insertText(t,C,T)}if(w||(w=e.state.tr.replace(C,T,l.doc.slice(f.start-l.from,f.endB-l.from))),l.sel){let t=li(e,w.doc,l.sel);t&&!(kn&&Sn&&e.composing&&t.empty&&(f.start!=f.endB||e.input.lastAndroidDelete<Date.now()-100)&&(t.head==C||t.head==w.mapping.map(T)-1)||vn&&t.empty&&t.head==C)&&w.setSelection(t)}k&&w.ensureMarks(k),e.dispatch(w.scrollIntoView())}function li(e,t,n){return Math.max(n.anchor,n.head)>t.content.size?null:Hr(e,t.resolve(n.anchor),t.resolve(n.head))}function ci(e,t,n){let r=e.depth,o=t?e.end():e.pos;for(;r>0&&(t||e.indexAfter(r)==e.node(r).childCount);)r--,o++,t=!1;if(n){let t=e.node(r).maybeChild(e.indexAfter(r));for(;t&&!t.isLeaf;)t=t.firstChild,o++}return o}class ui{constructor(e,t){this._root=null,this.focused=!1,this.trackWrites=null,this.mounted=!1,this.markCursor=null,this.cursorWrapper=null,this.lastSelectedViewDesc=void 0,this.input=new fo,this.prevDirectPlugins=[],this.pluginViews=[],this.dragging=null,this._props=t,this.state=t.state,this.directPlugins=t.plugins||[],this.directPlugins.forEach(mi),this.dispatch=this.dispatch.bind(this),this.dom=e&&e.mount||document.createElement("div"),e&&(e.appendChild?e.appendChild(this.dom):"function"==typeof e?e(this.dom):e.mount&&(this.mounted=!0)),this.editable=hi(this),pi(this),this.nodeViews=fi(this),this.docView=hr(this.state.doc,di(this),ei(this),this.dom,this),this.domObserver=new oi(this,((e,t,n,r)=>ai(this,e,t,n,r))),this.domObserver.start(),function(e){for(let t in po){let n=po[t];e.dom.addEventListener(t,e.input.eventHandlers[t]=t=>{!yo(e,t)||vo(e,t)||!e.editable&&t.type in ho||n(e,t)})}Cn&&e.dom.addEventListener("input",(()=>null)),go(e)}(this),this.updatePluginViews()}get composing(){return this.input.composing}get props(){if(this._props.state!=this.state){let e=this._props;this._props={};for(let t in e)this._props[t]=e[t];this._props.state=this.state}return this._props}update(e){e.handleDOMEvents!=this._props.handleDOMEvents&&go(this),this._props=e,e.plugins&&(e.plugins.forEach(mi),this.directPlugins=e.plugins),this.updateStateInner(e.state,!0)}setProps(e){let t={};for(let e in this._props)t[e]=this._props[e];t.state=this.state;for(let n in e)t[n]=e[n];this.update(t)}updateState(e){this.updateStateInner(e,this.state.plugins!=e.plugins)}updateStateInner(e,t){let n=this.state,r=!1,o=!1;if(e.storedMarks&&this.composing&&(Ao(this),o=!0),this.state=e,t){let e=fi(this);(function(e,t){let n=0,r=0;for(let r in e){if(e[r]!=t[r])return!0;n++}for(let e in t)r++;return n!=r})(e,this.nodeViews)&&(this.nodeViews=e,r=!0),go(this)}this.editable=hi(this),pi(this);let i=ei(this),s=di(this),a=t?"reset":e.scrollToSelection>n.scrollToSelection?"to selection":"preserve",l=r||!this.docView.matchesNode(e.doc,s,i);!l&&e.selection.eq(n.selection)||(o=!0);let c="preserve"==a&&o&&null==this.dom.style.overflowAnchor&&function(e){let t,n,r=e.dom.getBoundingClientRect(),o=Math.max(0,r.top);for(let i=(r.left+r.right)/2,s=o+1;s<Math.min(innerHeight,r.bottom);s+=5){let r=e.root.elementFromPoint(i,s);if(!r||r==e.dom||!e.dom.contains(r))continue;let a=r.getBoundingClientRect();if(a.top>=o-20){t=r,n=a.top;break}}return{refDOM:t,refTop:n,stack:_n(e.dom)}}(this);if(o){this.domObserver.stop();let t=l&&(vn||kn)&&!this.composing&&!n.selection.empty&&!e.selection.empty&&function(e,t){let n=Math.min(e.$anchor.sharedDepth(e.head),t.$anchor.sharedDepth(t.head));return e.$anchor.start(n)!=t.$anchor.start(n)}(n.selection,e.selection);if(l){let n=kn?this.trackWrites=this.domSelection().focusNode:null;!r&&this.docView.update(e.doc,s,i,this)||(this.docView.updateOuterDeco([]),this.docView.destroy(),this.docView=hr(e.doc,s,i,this.dom,this)),n&&!this.trackWrites&&(t=!0)}t||!(this.input.mouseDown&&this.domObserver.currentSelection.eq(this.domSelection())&&function(e){let t=e.docView.domFromPos(e.state.selection.anchor,0),n=e.domSelection();return In(t.node,t.offset,n.anchorNode,n.anchorOffset)}(this))?Ar(this,t):(Br(this,e.selection),this.domObserver.setCurSelection()),this.domObserver.start()}if(this.updatePluginViews(n),"reset"==a)this.dom.scrollTop=0;else if("to selection"==a){let t=this.domSelection().focusNode;if(this.someProp("handleScrollToSelection",(e=>e(this))));else if(e.selection instanceof Jt){let n=this.docView.domAfterPos(e.selection.from);1==n.nodeType&&$n(this,n.getBoundingClientRect(),t)}else $n(this,this.coordsAtPos(e.selection.head,1),t)}else c&&function({refDOM:e,refTop:t,stack:n}){let r=e?e.getBoundingClientRect().top:0;Un(n,0==r?0:r-t)}(c)}destroyPluginViews(){let e;for(;e=this.pluginViews.pop();)e.destroy&&e.destroy()}updatePluginViews(e){if(e&&e.plugins==this.state.plugins&&this.directPlugins==this.prevDirectPlugins)for(let t=0;t<this.pluginViews.length;t++){let n=this.pluginViews[t];n.update&&n.update(this,e)}else{this.prevDirectPlugins=this.directPlugins,this.destroyPluginViews();for(let e=0;e<this.directPlugins.length;e++){let t=this.directPlugins[e];t.spec.view&&this.pluginViews.push(t.spec.view(this))}for(let e=0;e<this.state.plugins.length;e++){let t=this.state.plugins[e];t.spec.view&&this.pluginViews.push(t.spec.view(this))}}}someProp(e,t){let n,r=this._props&&this._props[e];if(null!=r&&(n=t?t(r):r))return n;for(let r=0;r<this.directPlugins.length;r++){let o=this.directPlugins[r].props[e];if(null!=o&&(n=t?t(o):o))return n}let o=this.state.plugins;if(o)for(let r=0;r<o.length;r++){let i=o[r].props[e];if(null!=i&&(n=t?t(i):i))return n}}hasFocus(){return this.root.activeElement==this.dom}focus(){this.domObserver.stop(),this.editable&&function(e){if(e.setActive)return e.setActive();if(Wn)return e.focus(Wn);let t=_n(e);e.focus(null==Wn?{get preventScroll(){return Wn={preventScroll:!0},!0}}:void 0),Wn||(Wn=!1,Un(t,0))}(this.dom),Ar(this),this.domObserver.start()}get root(){let e=this._root;if(null==e)for(let e=this.dom.parentNode;e;e=e.parentNode)if(9==e.nodeType||11==e.nodeType&&e.host)return e.getSelection||(Object.getPrototypeOf(e).getSelection=()=>e.ownerDocument.getSelection()),this._root=e;return e||document}posAtCoords(e){return Zn(this,e)}coordsAtPos(e,t=1){return Yn(this,e,t)}domAtPos(e,t=0){return this.docView.domFromPos(e,t)}nodeDOM(e){let t=this.docView.descAt(e);return t?t.nodeDOM:null}posAtDOM(e,t,n=-1){let r=this.docView.posFromDOM(e,t,n);if(null==r)throw new RangeError("DOM position not inside the editor");return r}endOfTextblock(e,t){return ar(this,t||this.state,e)}destroy(){this.docView&&(!function(e){e.domObserver.stop();for(let t in e.input.eventHandlers)e.dom.removeEventListener(t,e.input.eventHandlers[t]);clearTimeout(e.input.composingTimeout),clearTimeout(e.input.lastIOSEnterFallbackTimeout)}(this),this.destroyPluginViews(),this.mounted?(this.docView.update(this.state.doc,[],ei(this),this),this.dom.textContent=""):this.dom.parentNode&&this.dom.parentNode.removeChild(this.dom),this.docView.destroy(),this.docView=null)}get isDestroyed(){return null==this.docView}dispatchEvent(e){return function(e,t){vo(e,t)||!po[t.type]||!e.editable&&t.type in ho||po[t.type](e,t)}(this,e)}dispatch(e){let t=this._props.dispatchTransaction;t?t.call(this,e):this.updateState(this.state.apply(e))}domSelection(){return this.root.getSelection()}}function di(e){let t=Object.create(null);return t.class="ProseMirror",t.contenteditable=String(e.editable),t.translate="no",e.someProp("attributes",(n=>{if("function"==typeof n&&(n=n(e.state)),n)for(let e in n)"class"==e&&(t.class+=" "+n[e]),"style"==e?t.style=(t.style?t.style+";":"")+n[e]:t[e]||"contenteditable"==e||"nodeName"==e||(t[e]=String(n[e]))})),[Vo.node(0,e.state.doc.content.size,t)]}function pi(e){if(e.markCursor){let t=document.createElement("img");t.className="ProseMirror-separator",t.setAttribute("mark-placeholder","true"),t.setAttribute("alt",""),e.cursorWrapper={dom:t,deco:Vo.widget(e.state.selection.head,t,{raw:!0,marks:e.markCursor})}}else e.cursorWrapper=null}function hi(e){return!e.someProp("editable",(t=>!1===t(e.state)))}function fi(e){let t=Object.create(null);function n(e){for(let n in e)Object.prototype.hasOwnProperty.call(t,n)||(t[n]=e[n])}return e.someProp("nodeViews",n),e.someProp("markViews",n),t}function mi(e){if(e.spec.state||e.spec.filterTransaction||e.spec.appendTransaction)throw new RangeError("Plugins passed directly to the view must not have a state component")}for(var gi=n(354),vi=n.n(gi),yi={8:"Backspace",9:"Tab",10:"Enter",12:"NumLock",13:"Enter",16:"Shift",17:"Control",18:"Alt",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",44:"PrintScreen",45:"Insert",46:"Delete",59:";",61:"=",91:"Meta",92:"Meta",106:"*",107:"+",108:",",109:"-",110:".",111:"/",144:"NumLock",145:"ScrollLock",160:"Shift",161:"Shift",162:"Control",163:"Control",164:"Alt",165:"Alt",173:"-",186:";",187:"=",188:",",189:"-",190:".",191:"/",192:"`",219:"[",220:"\\",221:"]",222:"'",229:"q"},bi={48:")",49:"!",50:"@",51:"#",52:"$",53:"%",54:"^",55:"&",56:"*",57:"(",59:":",61:"+",173:"_",186:":",187:"+",188:"<",189:"_",190:">",191:"?",192:"~",219:"{",220:"|",221:"}",222:'"',229:"Q"},wi="undefined"!=typeof navigator&&/Chrome\/(\d+)/.exec(navigator.userAgent),ki="undefined"!=typeof navigator&&/Apple Computer/.test(navigator.vendor),xi="undefined"!=typeof navigator&&/Gecko\/\d+/.test(navigator.userAgent),Ci="undefined"!=typeof navigator&&/Mac/.test(navigator.platform),Ti="undefined"!=typeof navigator&&/MSIE \d|Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent),Mi=wi&&(Ci||+wi[1]<57)||xi&&Ci,Si=0;Si<10;Si++)yi[48+Si]=yi[96+Si]=String(Si);for(Si=1;Si<=24;Si++)yi[Si+111]="F"+Si;for(Si=65;Si<=90;Si++)yi[Si]=String.fromCharCode(Si+32),bi[Si]=String.fromCharCode(Si);for(var Ei in yi)bi.hasOwnProperty(Ei)||(bi[Ei]=yi[Ei]);const Ni="undefined"!=typeof navigator&&/Mac|iP(hone|[oa]d)/.test(navigator.platform);function Oi(e){let t,n,r,o,i=e.split(/-(?!$)/),s=i[i.length-1];"Space"==s&&(s=" ");for(let e=0;e<i.length-1;e++){let s=i[e];if(/^(cmd|meta|m)$/i.test(s))o=!0;else if(/^a(lt)?$/i.test(s))t=!0;else if(/^(c|ctrl|control)$/i.test(s))n=!0;else if(/^s(hift)?$/i.test(s))r=!0;else{if(!/^mod$/i.test(s))throw new Error("Unrecognized modifier name: "+s);Ni?o=!0:n=!0}}return t&&(s="Alt-"+s),n&&(s="Ctrl-"+s),o&&(s="Meta-"+s),r&&(s="Shift-"+s),s}function Di(e,t,n){return t.altKey&&(e="Alt-"+e),t.ctrlKey&&(e="Ctrl-"+e),t.metaKey&&(e="Meta-"+e),!1!==n&&t.shiftKey&&(e="Shift-"+e),e}function Ai(e){return new an({props:{handleKeyDown:Li(e)}})}function Li(e){let t=function(e){let t=Object.create(null);for(let n in e)t[Oi(n)]=e[n];return t}(e);return function(e,n){let r,o=function(e){var t=!(Mi&&(e.ctrlKey||e.altKey||e.metaKey)||(ki||Ti)&&e.shiftKey&&e.key&&1==e.key.length)&&e.key||(e.shiftKey?bi:yi)[e.keyCode]||e.key||"Unidentified";return"Esc"==t&&(t="Escape"),"Del"==t&&(t="Delete"),"Left"==t&&(t="ArrowLeft"),"Up"==t&&(t="ArrowUp"),"Right"==t&&(t="ArrowRight"),"Down"==t&&(t="ArrowDown"),t}(n),i=1==o.length&&" "!=o,s=t[Di(o,n,!i)];if(s&&s(e.state,e.dispatch,e))return!0;if(i&&(n.shiftKey||n.altKey||n.metaKey||o.charCodeAt(0)>127)&&(r=yi[n.keyCode])&&r!=o){let o=t[Di(r,n,!0)];if(o&&o(e.state,e.dispatch,e))return!0}else if(i&&n.shiftKey){let r=t[Di(o,n,!0)];if(r&&r(e.state,e.dispatch,e))return!0}return!1}}const Ii=(e,t)=>!e.selection.empty&&(t&&t(e.tr.deleteSelection().scrollIntoView()),!0);function Ri(e,t,n=!1){for(let r=e;r;r="start"==t?r.firstChild:r.lastChild){if(r.isTextblock)return!0;if(n&&1!=r.childCount)return!1}return!1}function Pi(e){if(!e.parent.type.spec.isolating)for(let t=e.depth-1;t>=0;t--){if(e.index(t)>0)return e.doc.resolve(e.before(t+1));if(e.node(t).type.spec.isolating)break}return null}const Bi=(e,t,n)=>{let{$cursor:r}=e.selection;if(!r||(n?!n.endOfTextblock("forward",e):r.parentOffset<r.parent.content.size))return!1;let o=Fi(r);if(!o)return!1;let i=o.nodeAfter;if($i(e,o,t))return!0;if(0==r.parent.content.size&&(Ri(i,"start")||Jt.isSelectable(i))){let n=Nt(e.doc,r.before(),r.after(),v.empty);if(n&&n.slice.size<n.to-n.from){if(t){let r=e.tr.step(n);r.setSelection(Ri(i,"start")?Vt.findFrom(r.doc.resolve(r.mapping.map(o.pos)),1):Jt.create(r.doc,r.mapping.map(o.pos))),t(r.scrollIntoView())}return!0}}return!(!i.isAtom||o.depth!=r.depth-1)&&(t&&t(e.tr.delete(o.pos,o.pos+i.nodeSize).scrollIntoView()),!0)};function Fi(e){if(!e.parent.type.spec.isolating)for(let t=e.depth-1;t>=0;t--){let n=e.node(t);if(e.index(t)+1<n.childCount)return e.doc.resolve(e.after(t+1));if(n.type.spec.isolating)break}return null}const Hi=(e,t)=>{let{$head:n,$anchor:r}=e.selection;return!(!n.parent.type.spec.code||!n.sameParent(r))&&(t&&t(e.tr.insertText("\n").scrollIntoView()),!0)};function zi(e){for(let t=0;t<e.edgeCount;t++){let{type:n}=e.edge(t);if(n.isTextblock&&!n.hasRequiredAttrs())return n}return null}const qi=(e,t)=>{let{$head:n,$anchor:r}=e.selection;if(!n.parent.type.spec.code||!n.sameParent(r))return!1;let o=n.node(-1),i=n.indexAfter(-1),s=zi(o.contentMatchAt(i));if(!s||!o.canReplaceWith(i,i,s))return!1;if(t){let r=n.after(),o=e.tr.replaceWith(r,r,s.createAndFill());o.setSelection(Vt.near(o.doc.resolve(r),1)),t(o.scrollIntoView())}return!0},Vi=(e,t)=>{let{$from:n,$to:r}=e.selection;if(e.selection instanceof Jt&&e.selection.node.isBlock)return!(!n.parentOffset||!Mt(e.doc,n.pos))&&(t&&t(e.tr.split(n.pos).scrollIntoView()),!0);if(!n.parent.isBlock)return!1;if(t){let o=r.parentOffset==r.parent.content.size,i=e.tr;(e.selection instanceof Ut||e.selection instanceof Kt)&&i.deleteSelection();let s=0==n.depth?null:zi(n.node(-1).contentMatchAt(n.indexAfter(-1))),a=o&&s?[{type:s}]:void 0,l=Mt(i.doc,i.mapping.map(n.pos),1,a);if(a||l||!Mt(i.doc,i.mapping.map(n.pos),1,s?[{type:s}]:void 0)||(s&&(a=[{type:s}]),l=!0),l&&(i.split(i.mapping.map(n.pos),1,a),!o&&!n.parentOffset&&n.parent.type!=s)){let e=i.mapping.map(n.before()),t=i.doc.resolve(e);s&&n.node(-1).canReplaceWith(t.index(),t.index()+1,s)&&i.setNodeMarkup(i.mapping.map(n.before()),s)}t(i.scrollIntoView())}return!0},ji=(e,t)=>(t&&t(e.tr.setSelection(new Kt(e.doc))),!0);function $i(e,t,n){let r,o,i=t.nodeBefore,s=t.nodeAfter;if(i.type.spec.isolating||s.type.spec.isolating)return!1;if(function(e,t,n){let r=t.nodeBefore,o=t.nodeAfter,i=t.index();return!(!(r&&o&&r.type.compatibleContent(o.type))||(!r.content.size&&t.parent.canReplace(i-1,i)?(n&&n(e.tr.delete(t.pos-r.nodeSize,t.pos).scrollIntoView()),0):!t.parent.canReplace(i,i+1)||!o.isTextblock&&!St(e.doc,t.pos)||(n&&n(e.tr.clearIncompatible(t.pos,r.type,r.contentMatchAt(r.childCount)).join(t.pos).scrollIntoView()),0)))}(e,t,n))return!0;let a=t.parent.canReplace(t.index(),t.index()+1);if(a&&(r=(o=i.contentMatchAt(i.childCount)).findWrapping(s.type))&&o.matchType(r[0]||s.type).validEnd){if(n){let o=t.pos+s.nodeSize,a=d.empty;for(let e=r.length-1;e>=0;e--)a=d.from(r[e].create(null,a));a=d.from(i.copy(a));let l=e.tr.step(new wt(t.pos-1,o,t.pos,o,new v(a,1,0),r.length,!0)),c=o+2*r.length;St(l.doc,c)&&l.join(c),n(l.scrollIntoView())}return!0}let l=Vt.findFrom(t,1),c=l&&l.$from.blockRange(l.$to),u=c&&Ct(c);if(null!=u&&u>=t.depth)return n&&n(e.tr.lift(c,u).scrollIntoView()),!0;if(a&&Ri(s,"start",!0)&&Ri(i,"end")){let r=i,o=[];for(;o.push(r),!r.isTextblock;)r=r.lastChild;let a=s,l=1;for(;!a.isTextblock;a=a.firstChild)l++;if(r.canReplace(r.childCount,r.childCount,a.content)){if(n){let r=d.empty;for(let e=o.length-1;e>=0;e--)r=d.from(o[e].copy(r));n(e.tr.step(new wt(t.pos-o.length,t.pos+s.nodeSize,t.pos+l,t.pos+s.nodeSize-l,new v(r,o.length,0),0,!0)).scrollIntoView())}return!0}}return!1}function _i(e){return function(t,n){let r=t.selection,o=e<0?r.$from:r.$to,i=o.depth;for(;o.node(i).isInline;){if(!i)return!1;i--}return!!o.node(i).isTextblock&&(n&&n(t.tr.setSelection(Ut.create(t.doc,e<0?o.start(i):o.end(i)))),!0)}}const Ui=_i(-1),Wi=_i(1);function Ji(e,t=null){return function(n,r){let{$from:o,$to:i}=n.selection,s=o.blockRange(i),a=s&&function(e,t,n=null,r=e){let o=function(e,t){let{parent:n,startIndex:r,endIndex:o}=e,i=n.contentMatchAt(r).findWrapping(t);if(!i)return null;let s=i.length?i[0]:t;return n.canReplaceWith(r,o,s)?i:null}(e,t),i=o&&function(e,t){let{parent:n,startIndex:r,endIndex:o}=e,i=n.child(r),s=t.contentMatch.findWrapping(i.type);if(!s)return null;let a=(s.length?s[s.length-1]:t).contentMatch;for(let e=r;a&&e<o;e++)a=a.matchType(n.child(e).type);return a&&a.validEnd?s:null}(r,t);return i?o.map(Tt).concat({type:t,attrs:n}).concat(i.map(Tt)):null}(s,e,t);return!!a&&(r&&r(n.tr.wrap(s,a).scrollIntoView()),!0)}}function Gi(e,t=null){return function(n,r){let{from:o,to:i}=n.selection,s=!1;return n.doc.nodesBetween(o,i,((r,o)=>{if(s)return!1;if(r.isTextblock&&!r.hasMarkup(e,t))if(r.type==e)s=!0;else{let t=n.doc.resolve(o),r=t.index();s=t.parent.canReplaceWith(r,r+1,e)}})),!!s&&(r&&r(n.tr.setBlockType(o,i,e,t).scrollIntoView()),!0)}}function Ki(e,t=null){return function(n,r){let{empty:o,$cursor:i,ranges:s}=n.selection;if(o&&!i||!function(e,t,n){for(let r=0;r<t.length;r++){let{$from:o,$to:i}=t[r],s=0==o.depth&&e.type.allowsMarkType(n);if(e.nodesBetween(o.pos,i.pos,(e=>{if(s)return!1;s=e.inlineContent&&e.type.allowsMarkType(n)})),s)return!0}return!1}(n.doc,s,e))return!1;if(r)if(i)e.isInSet(n.storedMarks||i.marks())?r(n.tr.removeStoredMark(e)):r(n.tr.addStoredMark(e.create(t)));else{let o=!1,i=n.tr;for(let t=0;!o&&t<s.length;t++){let{$from:r,$to:i}=s[t];o=n.doc.rangeHasMark(r.pos,i.pos,e)}for(let n=0;n<s.length;n++){let{$from:r,$to:a}=s[n];if(o)i.removeMark(r.pos,a.pos,e);else{let n=r.pos,o=a.pos,s=r.nodeAfter,l=a.nodeBefore,c=s&&s.isText?/^\s*/.exec(s.text)[0].length:0,u=l&&l.isText?/\s*$/.exec(l.text)[0].length:0;n+c<o&&(n+=c,o-=u),i.addMark(n,o,e.create(t))}}r(i.scrollIntoView())}return!0}}function Zi(...e){return function(t,n,r){for(let o=0;o<e.length;o++)if(e[o](t,n,r))return!0;return!1}}let Xi=Zi(Ii,((e,t,n)=>{let{$cursor:r}=e.selection;if(!r||(n?!n.endOfTextblock("backward",e):r.parentOffset>0))return!1;let o=Pi(r);if(!o){let n=r.blockRange(),o=n&&Ct(n);return null!=o&&(t&&t(e.tr.lift(n,o).scrollIntoView()),!0)}let i=o.nodeBefore;if(!i.type.spec.isolating&&$i(e,o,t))return!0;if(0==r.parent.content.size&&(Ri(i,"end")||Jt.isSelectable(i))){let n=Nt(e.doc,r.before(),r.after(),v.empty);if(n&&n.slice.size<n.to-n.from){if(t){let r=e.tr.step(n);r.setSelection(Ri(i,"end")?Vt.findFrom(r.doc.resolve(r.mapping.map(o.pos,-1)),-1):Jt.create(r.doc,o.pos-i.nodeSize)),t(r.scrollIntoView())}return!0}}return!(!i.isAtom||o.depth!=r.depth-1)&&(t&&t(e.tr.delete(o.pos-i.nodeSize,o.pos).scrollIntoView()),!0)}),((e,t,n)=>{let{$head:r,empty:o}=e.selection,i=r;if(!o)return!1;if(r.parent.isTextblock){if(n?!n.endOfTextblock("backward",e):r.parentOffset>0)return!1;i=Pi(r)}let s=i&&i.nodeBefore;return!(!s||!Jt.isSelectable(s))&&(t&&t(e.tr.setSelection(Jt.create(e.doc,i.pos-s.nodeSize)).scrollIntoView()),!0)})),Qi=Zi(Ii,Bi,((e,t,n)=>{let{$head:r,empty:o}=e.selection,i=r;if(!o)return!1;if(r.parent.isTextblock){if(n?!n.endOfTextblock("forward",e):r.parentOffset<r.parent.content.size)return!1;i=Fi(r)}let s=i&&i.nodeAfter;return!(!s||!Jt.isSelectable(s))&&(t&&t(e.tr.setSelection(Jt.create(e.doc,i.pos)).scrollIntoView()),!0)}));const Yi={Enter:Zi(Hi,((e,t)=>{let n=e.selection,{$from:r,$to:o}=n;if(n instanceof Kt||r.parent.inlineContent||o.parent.inlineContent)return!1;let i=zi(o.parent.contentMatchAt(o.indexAfter()));if(!i||!i.isTextblock)return!1;if(t){let n=(!r.parentOffset&&o.index()<o.parent.childCount?r:o).pos,s=e.tr.insert(n,i.createAndFill());s.setSelection(Ut.create(s.doc,n+1)),t(s.scrollIntoView())}return!0}),((e,t)=>{let{$cursor:n}=e.selection;if(!n||n.parent.content.size)return!1;if(n.depth>1&&n.after()!=n.end(-1)){let r=n.before();if(Mt(e.doc,r))return t&&t(e.tr.split(r).scrollIntoView()),!0}let r=n.blockRange(),o=r&&Ct(r);return null!=o&&(t&&t(e.tr.lift(r,o).scrollIntoView()),!0)}),Vi),"Mod-Enter":qi,Backspace:Xi,"Mod-Backspace":Xi,"Shift-Backspace":Xi,Delete:Qi,"Mod-Delete":Qi,"Mod-a":ji},es={"Ctrl-h":Yi.Backspace,"Alt-Backspace":Yi["Mod-Backspace"],"Ctrl-d":Yi.Delete,"Ctrl-Alt-Backspace":Yi["Mod-Delete"],"Alt-Delete":Yi["Mod-Delete"],"Alt-d":Yi["Mod-Delete"],"Ctrl-a":Ui,"Ctrl-e":Wi};for(let e in Yi)es[e]=Yi[e];const ts=("undefined"!=typeof navigator?/Mac|iP(hone|[oa]d)/.test(navigator.platform):!("undefined"==typeof os||!os.platform)&&"darwin"==os.platform())?es:Yi;class ns{constructor(e,t){var n;this.match=e,this.match=e,this.handler="string"==typeof t?(n=t,function(e,t,r,o){let i=n;if(t[1]){let e=t[0].lastIndexOf(t[1]);i+=t[0].slice(e+t[1].length);let n=(r+=e)-o;n>0&&(i=t[0].slice(e-n,e)+i,r=o)}return e.tr.insertText(i,r,o)}):t}}function rs({rules:e}){let t=new an({state:{init:()=>null,apply(e,t){let n=e.getMeta(this);return n||(e.selectionSet||e.docChanged?null:t)}},props:{handleTextInput:(n,r,o,i)=>is(n,r,o,i,e,t),handleDOMEvents:{compositionend:n=>{setTimeout((()=>{let{$cursor:r}=n.state.selection;r&&is(n,r.pos,r.pos,"",e,t)}))}}},isInputRules:!0});return t}function is(e,t,n,r,o,i){if(e.composing)return!1;let s=e.state,a=s.doc.resolve(t);if(a.parent.type.spec.code)return!1;let l=a.parent.textBetween(Math.max(0,a.parentOffset-500),a.parentOffset,null,"")+r;for(let a=0;a<o.length;a++){let c=o[a].match.exec(l),u=c&&o[a].handler(s,c,t-(c[0].length-r.length),n);if(u)return e.dispatch(u.setMeta(i,{transform:u,from:t,to:n,text:r})),!0}return!1}const ss=(e,t)=>{let n=e.plugins;for(let r=0;r<n.length;r++){let o,i=n[r];if(i.spec.isInputRules&&(o=i.getState(e))){if(t){let n=e.tr,r=o.transform;for(let e=r.steps.length-1;e>=0;e--)n.step(r.steps[e].invert(r.docs[e]));if(o.text){let t=n.doc.resolve(o.from).marks();n.replaceWith(o.from,o.to,e.schema.text(o.text,t))}else n.delete(o.from,o.to);t(n)}return!0}}return!1};new ns(/--$/,"—"),new ns(/\.\.\.$/,"…"),new ns(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(")$/,"“"),new ns(/"$/,"”"),new ns(/(?:^|[\s\{\[\(\<'"\u2018\u201C])(')$/,"‘"),new ns(/'$/,"’");var as=200,ls=function(){};ls.prototype.append=function(e){return e.length?(e=ls.from(e),!this.length&&e||e.length<as&&this.leafAppend(e)||this.length<as&&e.leafPrepend(this)||this.appendInner(e)):this},ls.prototype.prepend=function(e){return e.length?ls.from(e).append(this):this},ls.prototype.appendInner=function(e){return new us(this,e)},ls.prototype.slice=function(e,t){return void 0===e&&(e=0),void 0===t&&(t=this.length),e>=t?ls.empty:this.sliceInner(Math.max(0,e),Math.min(this.length,t))},ls.prototype.get=function(e){if(!(e<0||e>=this.length))return this.getInner(e)},ls.prototype.forEach=function(e,t,n){void 0===t&&(t=0),void 0===n&&(n=this.length),t<=n?this.forEachInner(e,t,n,0):this.forEachInvertedInner(e,t,n,0)},ls.prototype.map=function(e,t,n){void 0===t&&(t=0),void 0===n&&(n=this.length);var r=[];return this.forEach((function(t,n){return r.push(e(t,n))}),t,n),r},ls.from=function(e){return e instanceof ls?e:e&&e.length?new cs(e):ls.empty};var cs=function(e){function t(t){e.call(this),this.values=t}e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t;var n={length:{configurable:!0},depth:{configurable:!0}};return t.prototype.flatten=function(){return this.values},t.prototype.sliceInner=function(e,n){return 0==e&&n==this.length?this:new t(this.values.slice(e,n))},t.prototype.getInner=function(e){return this.values[e]},t.prototype.forEachInner=function(e,t,n,r){for(var o=t;o<n;o++)if(!1===e(this.values[o],r+o))return!1},t.prototype.forEachInvertedInner=function(e,t,n,r){for(var o=t-1;o>=n;o--)if(!1===e(this.values[o],r+o))return!1},t.prototype.leafAppend=function(e){if(this.length+e.length<=as)return new t(this.values.concat(e.flatten()))},t.prototype.leafPrepend=function(e){if(this.length+e.length<=as)return new t(e.flatten().concat(this.values))},n.length.get=function(){return this.values.length},n.depth.get=function(){return 0},Object.defineProperties(t.prototype,n),t}(ls);ls.empty=new cs([]);var us=function(e){function t(t,n){e.call(this),this.left=t,this.right=n,this.length=t.length+n.length,this.depth=Math.max(t.depth,n.depth)+1}return e&&(t.__proto__=e),t.prototype=Object.create(e&&e.prototype),t.prototype.constructor=t,t.prototype.flatten=function(){return this.left.flatten().concat(this.right.flatten())},t.prototype.getInner=function(e){return e<this.left.length?this.left.get(e):this.right.get(e-this.left.length)},t.prototype.forEachInner=function(e,t,n,r){var o=this.left.length;return!(t<o&&!1===this.left.forEachInner(e,t,Math.min(n,o),r))&&(!(n>o&&!1===this.right.forEachInner(e,Math.max(t-o,0),Math.min(this.length,n)-o,r+o))&&void 0)},t.prototype.forEachInvertedInner=function(e,t,n,r){var o=this.left.length;return!(t>o&&!1===this.right.forEachInvertedInner(e,t-o,Math.max(n,o)-o,r+o))&&(!(n<o&&!1===this.left.forEachInvertedInner(e,Math.min(t,o),n,r))&&void 0)},t.prototype.sliceInner=function(e,t){if(0==e&&t==this.length)return this;var n=this.left.length;return t<=n?this.left.slice(e,t):e>=n?this.right.slice(e-n,t-n):this.left.slice(e,n).append(this.right.slice(0,t-n))},t.prototype.leafAppend=function(e){var n=this.right.leafAppend(e);if(n)return new t(this.left,n)},t.prototype.leafPrepend=function(e){var n=this.left.leafPrepend(e);if(n)return new t(n,this.right)},t.prototype.appendInner=function(e){return this.left.depth>=Math.max(this.right.depth,e.depth)+1?new t(this.left,new t(this.right,e)):new t(this,e)},t}(ls),ds=ls;class ps{constructor(e,t){this.items=e,this.eventCount=t}popEvent(e,t){if(0==this.eventCount)return null;let n,r,o=this.items.length;for(;;o--){if(this.items.get(o-1).selection){--o;break}}t&&(n=this.remapping(o,this.items.length),r=n.maps.length);let i,s,a=e.tr,l=[],c=[];return this.items.forEach(((e,t)=>{if(!e.step)return n||(n=this.remapping(o,t+1),r=n.maps.length),r--,void c.push(e);if(n){c.push(new hs(e.map));let t,o=e.step.map(n.slice(r));o&&a.maybeStep(o).doc&&(t=a.mapping.maps[a.mapping.maps.length-1],l.push(new hs(t,void 0,void 0,l.length+c.length))),r--,t&&n.appendMap(t,r)}else a.maybeStep(e.step);return e.selection?(i=n?e.selection.map(n.slice(r)):e.selection,s=new ps(this.items.slice(0,o).append(c.reverse().concat(l)),this.eventCount-1),!1):void 0}),this.items.length,0),{remaining:s,transform:a,selection:i}}addTransform(e,t,n,r){let o=[],i=this.eventCount,s=this.items,a=!r&&s.length?s.get(s.length-1):null;for(let n=0;n<e.steps.length;n++){let l,c=e.steps[n].invert(e.docs[n]),u=new hs(e.mapping.maps[n],c,t);(l=a&&a.merge(u))&&(u=l,n?o.pop():s=s.slice(0,s.length-1)),o.push(u),t&&(i++,t=void 0),r||(a=u)}let l=i-n.depth;return l>ms&&(s=function(e,t){let n;return e.forEach(((e,r)=>{if(e.selection&&0==t--)return n=r,!1})),e.slice(n)}(s,l),i-=l),new ps(s.append(o),i)}remapping(e,t){let n=new pt;return this.items.forEach(((t,r)=>{let o=null!=t.mirrorOffset&&r-t.mirrorOffset>=e?n.maps.length-t.mirrorOffset:void 0;n.appendMap(t.map,o)}),e,t),n}addMaps(e){return 0==this.eventCount?this:new ps(this.items.append(e.map((e=>new hs(e)))),this.eventCount)}rebased(e,t){if(!this.eventCount)return this;let n=[],r=Math.max(0,this.items.length-t),o=e.mapping,i=e.steps.length,s=this.eventCount;this.items.forEach((e=>{e.selection&&s--}),r);let a=t;this.items.forEach((t=>{let r=o.getMirror(--a);if(null==r)return;i=Math.min(i,r);let l=o.maps[r];if(t.step){let i=e.steps[r].invert(e.docs[r]),c=t.selection&&t.selection.map(o.slice(a+1,r));c&&s++,n.push(new hs(l,i,c))}else n.push(new hs(l))}),r);let l=[];for(let e=t;e<i;e++)l.push(new hs(o.maps[e]));let c=this.items.slice(0,r).append(l).append(n),u=new ps(c,s);return u.emptyItemCount()>500&&(u=u.compress(this.items.length-n.length)),u}emptyItemCount(){let e=0;return this.items.forEach((t=>{t.step||e++})),e}compress(e=this.items.length){let t=this.remapping(0,e),n=t.maps.length,r=[],o=0;return this.items.forEach(((i,s)=>{if(s>=e)r.push(i),i.selection&&o++;else if(i.step){let e=i.step.map(t.slice(n)),s=e&&e.getMap();if(n--,s&&t.appendMap(s,n),e){let a=i.selection&&i.selection.map(t.slice(n));a&&o++;let l,c=new hs(s.invert(),e,a),u=r.length-1;(l=r.length&&r[u].merge(c))?r[u]=l:r.push(c)}}else i.map&&n--}),this.items.length,0),new ps(ds.from(r.reverse()),o)}}ps.empty=new ps(ds.empty,0);class hs{constructor(e,t,n,r){this.map=e,this.step=t,this.selection=n,this.mirrorOffset=r}merge(e){if(this.step&&e.step&&!e.selection){let t=e.step.merge(this.step);if(t)return new hs(t.getMap().invert(),t,this.selection)}}}class fs{constructor(e,t,n,r){this.done=e,this.undone=t,this.prevRanges=n,this.prevTime=r}}const ms=20;function gs(e){let t=[];return e.forEach(((e,n,r,o)=>t.push(r,o))),t}function vs(e,t){if(!e)return null;let n=[];for(let r=0;r<e.length;r+=2){let o=t.map(e[r],1),i=t.map(e[r+1],-1);o<=i&&n.push(o,i)}return n}function ys(e,t,n,r){let o=ks(t),i=xs.get(t).spec.config,s=(r?e.undone:e.done).popEvent(t,o);if(!s)return;let a=s.selection.resolve(s.transform.doc),l=(r?e.done:e.undone).addTransform(s.transform,t.selection.getBookmark(),i,o),c=new fs(r?l:s.remaining,r?s.remaining:l,null,0);n(s.transform.setSelection(a).setMeta(xs,{redo:r,historyState:c}).scrollIntoView())}let bs=!1,ws=null;function ks(e){let t=e.plugins;if(ws!=t){bs=!1,ws=t;for(let e=0;e<t.length;e++)if(t[e].spec.historyPreserveItems){bs=!0;break}}return bs}const xs=new un("history"),Cs=new un("closeHistory");function Ts(e={}){return e={depth:e.depth||100,newGroupDelay:e.newGroupDelay||500},new an({key:xs,state:{init:()=>new fs(ps.empty,ps.empty,null,0),apply:(t,n,r)=>function(e,t,n,r){let o,i=n.getMeta(xs);if(i)return i.historyState;n.getMeta(Cs)&&(e=new fs(e.done,e.undone,null,0));let s=n.getMeta("appendedTransaction");if(0==n.steps.length)return e;if(s&&s.getMeta(xs))return s.getMeta(xs).redo?new fs(e.done.addTransform(n,void 0,r,ks(t)),e.undone,gs(n.mapping.maps[n.steps.length-1]),e.prevTime):new fs(e.done,e.undone.addTransform(n,void 0,r,ks(t)),null,e.prevTime);if(!1===n.getMeta("addToHistory")||s&&!1===s.getMeta("addToHistory"))return(o=n.getMeta("rebased"))?new fs(e.done.rebased(n,o),e.undone.rebased(n,o),vs(e.prevRanges,n.mapping),e.prevTime):new fs(e.done.addMaps(n.mapping.maps),e.undone.addMaps(n.mapping.maps),vs(e.prevRanges,n.mapping),e.prevTime);{let o=0==e.prevTime||!s&&(e.prevTime<(n.time||0)-r.newGroupDelay||!function(e,t){if(!t)return!1;if(!e.docChanged)return!0;let n=!1;return e.mapping.maps[0].forEach(((e,r)=>{for(let o=0;o<t.length;o+=2)e<=t[o+1]&&r>=t[o]&&(n=!0)})),n}(n,e.prevRanges)),i=s?vs(e.prevRanges,n.mapping):gs(n.mapping.maps[n.steps.length-1]);return new fs(e.done.addTransform(n,o?t.selection.getBookmark():void 0,r,ks(t)),ps.empty,i,n.time)}}(n,r,t,e)},config:e,props:{handleDOMEvents:{beforeinput(e,t){let n=t.inputType,r="historyUndo"==n?Ms:"historyRedo"==n?Ss:null;return!!r&&(t.preventDefault(),r(e.state,e.dispatch))}}}})}const Ms=(e,t)=>{let n=xs.getState(e);return!(!n||0==n.done.eventCount)&&(t&&ys(n,e,t,!1),!0)},Ss=(e,t)=>{let n=xs.getState(e);return!(!n||0==n.undone.eventCount)&&(t&&ys(n,e,t,!0),!0)};function Es(e,t){var n=e.nodes.paragraph;return t?n.create(null,Me()(t)?e.text(t):t):n.createAndFill()}function Ns(e,t,n){return e.text(t,n)}function Os(e,t,n){void 0===n&&(n=t);var r=e.doc.content.size,o=r>0?r-1:1;return Ut.create(e.doc,Math.min(t,o),Math.min(n,o))}function Ds(e,t,n){var r=t.pos;return e.replaceWith(r,r,Es(n)),e.setSelection(Os(e,r+1))}function As(e){for(var t=e.state,n=e.from,r=e.startIndex,o=e.endIndex,i=e.createText,s=t.tr,a=t.doc,l=t.schema,c=r;c<=o;c+=1){var u=a.child(c),p=u.nodeSize,h=u.textContent,f=u.content,m=i(h),g=m?Ns(l,m):d.empty,v=s.mapping.map(n),y=v+f.size;s.replaceWith(v,y,g),n+=p}return s}function Ls(e,t,n,r){var o=n.length;e.split(t).delete(t-o,t).insert(e.mapping.map(t),r).setSelection(Os(e,e.mapping.map(t)-o))}function Is(e){return e.sourcepos[0][0]}function Rs(e){return e.sourcepos[1][0]}function Ps(e){return e.sourcepos[0][1]}function Bs(e){return e.sourcepos[1][1]}function Fs(e){var t=e.type;return"strike"===t||"strong"===t||"emph"===t||"code"===t||"link"===t||"image"===t}function Hs(e){return e&&("item"===e.type||"list"===e.type)}function zs(e){return Hs(e)&&"ordered"===e.listData.type}function qs(e){return Hs(e)&&"ordered"!==e.listData.type}function Vs(e){return e&&("tableCell"===e.type||"tableDelimCell"===e.type)}function js(e,t,n){for(void 0===n&&(n=!0),e=n?e:e.parent;e&&"document"!==e.type;){if(t(e))return e;e=e.parent}return null}function $s(e,t){return[e[0],e[1]+t]}function _s(e,t){return[e[0],t]}function Us(e){var t=e.firstChild.literal;switch(e.type){case"emph":return"*"+t+"*";case"strong":return"**"+t+"**";case"strike":return"~~"+t+"~~";case"code":return"`"+t+"`";case"link":case"image":var n=e,r=n.destination,o=n.title;return("link"===e.type?"":"!")+"["+t+"]("+r+(o?' "'+o+'"':"")+")";default:return null}}function Ws(e){switch(e.type){case"document":case"blockQuote":case"list":case"item":case"paragraph":case"heading":case"emph":case"strong":case"strike":case"link":case"image":case"table":case"tableHead":case"tableBody":case"tableRow":case"tableCell":case"tableDelimRow":case"customInline":return!0;default:return!1}}function Js(e){for(var t=[],n=e.walker(),r=null;r=n.next();){var o=r.node;"text"===o.type&&t.push(o.literal)}return t.join("")}var Gs=[],Ks={},Zs=/\$\$widget\d+\s/;function Xs(e){var t=e.search(Zs);if(-1!==t){var n=e.substring(t).replace(Zs,"").replace("$$","");e=e.substring(0,t),e+=Xs(n)}return e}function Qs(e,t){return"$$"+e+" "+t+"$$"}function Ys(e,t){var n=Ks[e],r=n.rule,o=n.toDOM,i=Xs(t).match(r);return i&&(t=i[0]),o(t)}function ea(){return Gs}function ta(e){(Gs=e).forEach((function(e,t){Ks["widget"+t]=e}))}function na(e,t,n,r){return e.concat(ra(t,n,r))}function ra(e,t,n){void 0===n&&(n=0);var r=[],o=(Gs[n]||{}).rule,i=n+1;if(e=Xs(e),o&&o.test(e)){for(var s=void 0;-1!==(s=e.search(o));){var a=e.substring(0,s);a&&(r=na(r,a,t,i));var l=(e=e.substring(s)).match(o)[0],c="widget"+n;r.push(t.nodes.widget.create({info:c},t.text(Qs(c,l)))),e=e.substring(l.length)}e&&(r=na(r,e,t,i))}else e&&(r=n<Gs.length-1?na(r,e,t,i):[t.text(e)]);return r}function oa(e){for(var t,n="",r=e.walker();t=r.next();){var o=t.node;t.entering&&(o!==e&&"text"!==o.type?(n+=Us(o),r.resumeAt(e,!1),r.next()):"text"===o.type&&(n+=o.literal))}return n}function ia(){return{deleteSelection:function(){return Ii},selectAll:function(){return ji},undo:function(){return Ms},redo:function(){return Ss}}}var sa=n(322),aa=n.n(sa),la=n(714),ca=n.n(la),ua=n(471),da=n.n(ua),pa="[A-Za-z][A-Za-z0-9-]*",ha="(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)",fa="<("+pa+")("+ha+")*\\s*/?>",ma="(?:"+fa+"|</([A-Za-z][A-Za-z0-9-]*)\\s*[>])",ga=new RegExp("^"+ma,"i"),va=/<br\s*\/*>/i,ya=/<! ---->|<!--(?:-?[^>-])(?:-?[^-])*-->/,ba="</p><p>";function wa(e,t,n){var r=parseInt(e.left,10),o=parseInt(e.top,10),i=parseInt(e.width,10)+parseInt(e.paddingLeft,10)+parseInt(e.paddingRight,10),s=parseInt(e.height,10)+parseInt(e.paddingTop,10)+parseInt(e.paddingBottom,10);return t>=r&&t<=r+i&&n>=o&&n<=o+s}var ka="toastui-editor-";function xa(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];for(var n=[],r=0,o=e;r<o.length;r++){var i=o[r],s=void 0;(s=Array.isArray(i)?i[0]?i[1]:null:i)&&n.push(""+ka+s)}return n.join(" ")}function Ca(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];return e.map((function(e){return ka+"md-"+e})).join(" ")}function Ta(e){return e&&e.nodeType===Node.ELEMENT_NODE}function Ma(e){e.parentNode&&e.parentNode.removeChild(e)}function Sa(e,t,n){Oe()(n)&&(n=!ca()(e,t)),(n?ke():Ce())(e,t)}function Ea(e,t){var n=document.createElement("div");Me()(e)?n.innerHTML=e:n.appendChild(e);var r=n.firstChild;return t&&t.appendChild(r),r}function Na(e){var t=window.getComputedStyle(e);return["margin-left","margin-right"].reduce((function(e,n){return e+parseInt(t.getPropertyValue(n),10)}),0)+e.offsetWidth}function Oa(e,t){var n;for(n=Me()(t)?function(e){return da()(e,t)}:function(e){return e===t};e&&e!==document;){if(Ta(e)&&n(e))return e;e=e.parentNode}return null}function Da(e,t){for(var n=0,r=0;e&&e!==t;){if(n+=e.offsetTop,r+=e.offsetLeft,e.offsetParent===t.offsetParent)break;e=e.offsetParent}return{offsetTop:n,offsetLeft:r}}function Aa(e,t){Object.keys(e).forEach((function(n){Qe(e[n])?t.removeAttribute(n):t.setAttribute(n,e[n])}))}function La(e){var t=e;return t=(t=t.replace(/<img class="ProseMirror-separator" alt="">/g,"")).replace(/ class="ProseMirror-trailingBreak"/g,"")}var Ia=new un("widget"),Ra=function(){function e(e,t){var n=this;this.popup=null,this.removeWidget=function(){n.popup&&(n.rootEl.removeChild(n.popup),n.popup=null)},this.rootEl=e.dom.parentElement,this.eventEmitter=t,this.eventEmitter.listen("blur",this.removeWidget),this.eventEmitter.listen("loadUI",(function(){n.rootEl=Oa(e.dom.parentElement,"."+xa("defaultUI"))})),this.eventEmitter.listen("removePopupWidget",this.removeWidget)}return e.prototype.update=function(e){var t=Ia.getState(e.state);if(this.removeWidget(),t){var n=t.node,r=t.style,o=e.coordsAtPos(t.pos),i=o.top,s=o.left,a=o.bottom-i,l=this.rootEl.getBoundingClientRect(),c=i-l.top;be()(n,{opacity:"0"}),this.rootEl.appendChild(n),be()(n,{position:"absolute",left:s-l.left+5+"px",top:("bottom"===r?c+a-5:c-a)+"px",opacity:"1"}),this.popup=n,e.focus()}},e.prototype.destroy=function(){this.eventEmitter.removeEventHandler("blur",this.removeWidget)},e}();function Pa(e){return new an({key:Ia,state:{init:function(){return null},apply:function(e){return e.getMeta("widget")}},view:function(t){return new Ra(t,e)}})}var Ba=n(893),Fa=n.n(Ba);function Ha(e,t,n){e.emit("addImageBlobHook",t,(function(n,r){e.emit("command","addImage",{imageUrl:n,altText:r||t.name||"image"})}),n)}function za(e){var t=vi()(e).filter((function(e){return-1!==e.type.indexOf("image")}));if(1===t.length){var n=t[0];if(n)return n.getAsFile()}return null}function qa(e){var t=e.eventEmitter;return new an({props:{handleDOMEvents:{drop:function(e,n){var r,o=null===(r=n.dataTransfer)||void 0===r?void 0:r.files;return o&&Fa()(o,(function(e){return-1===e.type.indexOf("image")||(n.preventDefault(),n.stopPropagation(),Ha(t,e,n.type),!1)})),!0}}}})}var Va=function(){function e(){}return Object.defineProperty(e.prototype,"type",{get:function(){return"node"},enumerable:!1,configurable:!0}),e.prototype.setContext=function(e){this.context=e},e}();function ja(e){var t=document.createElement("span"),n=Ys(e.attrs.info,e.textContent);return t.className="tui-widget",t.appendChild(n),{dom:t}}function $a(e){return"widget"===e.type.name}var _a=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"widget"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{info:{default:null}},group:"inline",inline:!0,content:"text*",selectable:!1,atom:!0,toDOM:function(){return["span",{class:"tui-widget"},0]},parseDOM:[{tag:"span.tui-widget",getAttrs:function(e){return{info:e.textContent.match(/\$\$(widget\d+)/)[1]}}}]}},enumerable:!1,configurable:!0}),n}(Va),Ua=function(){function e(e){this.timer=null,this.el=document.createElement("div"),this.el.className="toastui-editor",this.eventEmitter=e,this.placeholder={text:""}}return e.prototype.createState=function(){return on.create({schema:this.schema,plugins:this.createPlugins()})},e.prototype.initEvent=function(){var e=this,t=e.eventEmitter,n=e.view,r=e.editorType;n.dom.addEventListener("focus",(function(){return t.emit("focus",r)})),n.dom.addEventListener("blur",(function(){return t.emit("blur",r)}))},e.prototype.emitChangeEvent=function(e){this.eventEmitter.emit("caretChange",this.editorType),e.docChanged&&this.eventEmitter.emit("change",this.editorType)},Object.defineProperty(e.prototype,"defaultPlugins",{get:function(){var e,t=this.createInputRules(),n=i(i([],this.keymaps),[Ai(o({"Shift-Enter":ts.Enter},ts)),Ts(),(e=this.placeholder,new an({props:{decorations:function(t){var n=t.doc;if(e.text&&1===n.childCount&&n.firstChild.isTextblock&&0===n.firstChild.content.size){var r=document.createElement("span");return ke()(r,"placeholder"),e.className&&ke()(r,e.className),r.textContent=e.text,_o.create(n,[Vo.widget(1,r)])}return null}}})),Pa(this.eventEmitter),qa(this.context)]);return t?n.concat(t):n},enumerable:!1,configurable:!0}),e.prototype.createInputRules=function(){var e=ea().map((function(e){var t=e.rule;return new ns(t,(function(e,n,r,o){var i=e.schema,s=e.tr,a=e.doc,l=n.input.match(new RegExp(t,"g")),c=a.resolve(r),u=c.parent,d=0;if($a(u)&&(u=c.node(c.depth-1)),u.forEach((function(e){return $a(e)&&(d+=1)})),l.length>d){var p=et(l),h=ra(p,i);return s.replaceWith(o-p.length+1,o,h)}return null}))}));return e.length?rs({rules:e}):null},e.prototype.clearTimer=function(){this.timer&&(clearTimeout(this.timer),this.timer=null)},e.prototype.createSchema=function(){return new Y({nodes:this.specs.nodes,marks:this.specs.marks})},e.prototype.createKeymaps=function(e){var t=ia(),n=t.undo,r=t.redo,o=this.specs.keymaps(e),i={"Mod-z":n(),"Shift-Mod-z":r()};return e?o.concat(Ai(i)):o},e.prototype.createCommands=function(){return this.specs.commands(this.view)},e.prototype.createPluginProps=function(){var e=this;return this.extraPlugins.map((function(t){return t(e.eventEmitter)}))},e.prototype.focus=function(){var e=this;this.clearTimer(),this.timer=setTimeout((function(){e.view.focus(),e.view.dispatch(e.view.state.tr.scrollIntoView())}))},e.prototype.blur=function(){this.view.dom.blur()},e.prototype.destroy=function(){var e=this;this.clearTimer(),this.view.destroy(),Object.keys(this).forEach((function(t){delete e[t]}))},e.prototype.moveCursorToStart=function(e){var t=this.view.state.tr;this.view.dispatch(t.setSelection(Os(t,1)).scrollIntoView()),e&&this.focus()},e.prototype.moveCursorToEnd=function(e){var t=this.view.state.tr;this.view.dispatch(t.setSelection(Os(t,t.doc.content.size-1)).scrollIntoView()),e&&this.focus()},e.prototype.setScrollTop=function(e){this.view.dom.scrollTop=e},e.prototype.getScrollTop=function(){return this.view.dom.scrollTop},e.prototype.setPlaceholder=function(e){this.placeholder.text=e,this.view.dispatch(this.view.state.tr.scrollIntoView())},e.prototype.setHeight=function(e){be()(this.el,{height:e+"px"})},e.prototype.setMinHeight=function(e){be()(this.el,{minHeight:e+"px"})},e.prototype.getElement=function(){return this.el},e}(),Wa=Ua,Ja=n(294),Ga=n.n(Ja),Ka=["Enter","Shift-Enter","Mod-Enter","Tab","Shift-Tab","Delete","Backspace","Mod-Delete","Mod-Backspace","ArrowUp","ArrowDown","ArrowLeft","ArrowRight","Mod-d","Mod-D","Alt-ArrowUp","Alt-ArrowDown"];function Za(e,t,n){return e.focus(),t(n)(e.state,e.dispatch,e)}var Xa=function(){function e(e){this.specs=e}return Object.defineProperty(e.prototype,"nodes",{get:function(){return this.specs.filter((function(e){return"node"===e.type})).reduce((function(e,t){var n,r=t.name,i=t.schema;return o(o({},e),((n={})[r]=i,n))}),{})},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"marks",{get:function(){return this.specs.filter((function(e){return"mark"===e.type})).reduce((function(e,t){var n,r=t.name,i=t.schema;return o(o({},e),((n={})[r]=i,n))}),{})},enumerable:!1,configurable:!0}),e.prototype.commands=function(e,t){var n=this.specs.filter((function(e){return e.commands})).reduce((function(t,n){var r={},i=n.commands();return Ga()(i)?r[n.name]=function(t){return Za(e,i,t)}:Object.keys(i).forEach((function(t){r[t]=function(n){return Za(e,i[t],n)}})),o(o({},t),r)}),{}),r=ia();return Object.keys(r).forEach((function(t){n[t]=function(n){return Za(e,r[t],n)}})),t&&Object.keys(t).forEach((function(r){n[r]=function(n){return Za(e,t[r],n)}})),n},e.prototype.keymaps=function(e){return this.specs.filter((function(e){return e.keymaps})).map((function(e){return e.keymaps()})).map((function(t){return e||Object.keys(t).forEach((function(e){Ue(Ka,e)||delete t[e]})),Ai(t)}))},e.prototype.setContext=function(e){this.specs.forEach((function(t){t.setContext(e)}))},e}(),Qa=Xa;function Ya(e){var t=e.from,n=e.to;return e instanceof Kt?[t+1,n-1]:[t,n]}function el(e){return e.index(0)+1}function tl(e,t,n){void 0===n&&(n=1);var r=0;return e.forEach((function(e,o){$a(e)&&o+2<t&&(r+=2*n)})),r}function nl(e,t,n){void 0===n&&(n=t);var r=t===n,o=e.resolve(t),i=el(o),s=i,a=o.start(1),l=a;if(!r){var c=e.resolve(n===e.content.size?n-1:n);l=c.start(1),s=el(c),c.pos===e.content.size&&(n=e.content.size-2)}var u=Math.max(t-a+1,1),d=Math.max(n-l+1,1);return[[i,u+tl(e.child(i-1),u,-1)],[s,d+tl(e.child(s-1),d,-1)]]}function rl(e,t){for(var n=[],r=0,o=0;r<t;r+=1){var i=e.child(r);n[r]=o,o+=i.nodeSize}return n}function ol(e,t,n){var r=rl(e,n[0]),o=t[0]-1,i=n[0]-1,s=e.child(o),a=e.child(i),l=r[o],c=r[i];return l+=t[1]+tl(s,t[1]-1),c+=n[1]+tl(a,n[1]-1),[l,Math.min(c,e.content.size)]}function il(e){var t=e.$from,n=e.$to,r=e.from,o=e.to,i=t.doc;return e instanceof Kt&&(t=i.resolve(r+1),n=i.resolve(o-1)),0===t.depth&&(n=t=i.resolve(r-1)),{startFromOffset:t.start(1),endFromOffset:n.start(1),startToOffset:t.end(1),endToOffset:n.end(1),startIndex:t.index(0),endIndex:n.index(0),from:t.pos,to:n.pos}}function sl(e,t){for(var n=1,r=1,o=0,i=0;o<e.childCount;o+=1){var s=e.child(o).nodeSize;if(n=i+1,r=i+s-1,o===t)break;i+=s}return{startOffset:n,endOffset:r}}var al="heading",ll="link",cl="code",ul="meta",dl="delimiter",pl="markedText",hl={strong:2,emph:1,strike:2};function fl(e,t,n,r){return{start:e,end:t,spec:{type:n,attrs:r}}}function ml(e,t,n){var r=e.type,o=$s(t,hl[r]),i=$s(n,-hl[r]);return[fl(o,i,r),fl(t,o,dl),fl(i,n,dl)]}function gl(e,t,n,r){return[fl(e,t,ll),fl(_s(e,n[1]+1),_s(t,r),ll,{desc:!0}),fl(_s(t,r+2),$s(t,-1),ll,{url:!0})]}function vl(e,t,n,r){var i={start:t,end:n,spec:{attrs:{className:r+"-line-background",codeStart:t[0],codeEnd:n[0]}},lineBackground:!0};return"item"!==e.type&&"blockQuote"!==e.type?[o(o({},i),{end:t,spec:{attrs:{className:r+"-line-background start"}}}),o(o({},i),{start:[Math.min(t[0]+1,n[0]),t[1]]})]:null}function yl(e,t){for(var n=[];e;){var r=e.type;"paragraph"!==r&&"codeBlock"!==r||n.push(fl([Is(e),Ps(e)-1],[Rs(e),Bs(e)+1],t)),e=e.next}return n}var bl={heading:function(e,t,n){var r=e.level,o=e.headingType,i=[fl(t,n,al,{level:r})];return"atx"===o?i.push(fl(t,$s(t,r),dl)):i.push(fl(_s(n,0),n,al,{seText:!0})),i},strong:ml,emph:ml,strike:ml,link:function(e,t,n){var r=e.lastChild,o=e.extendedAutolink,i=r?Bs(r)+1:2;return o?[fl(t,n,ll,{desc:!0})]:gl(t,n,t,i)},image:function(e,t,n){var r=e.lastChild,o=r?Bs(r)+1:3,s=$s(t,1);return i([fl(t,s,ul)],gl(t,n,s,o))},code:function(e,t,n){var r=e.tickCount,o=$s(t,r),i=$s(n,-r);return[fl(t,n,cl),fl(t,o,cl,{start:!0}),fl(o,i,cl,{marked:!0}),fl(i,n,cl,{end:!0})]},codeBlock:function(e,t,n,r){var o=e.fenceOffset,i=e.fenceLength,s=e.fenceChar,a=e.info,l=e.infoPadding,c=e.parent,u=o+i,d=[fl(_s(t,1),n,"codeBlock")];s&&d.push(fl(t,$s(t,u),dl)),a&&d.push(fl($s(t,i),$s(t,i+l+a.length),ul)),new RegExp("^(\\s{0,4})("+s+"{"+i+",})").test(r)&&d.push(fl(_s(n,1),n,dl));var p=vl(c,t,n,"code-block");return p?d.concat(p):d},blockQuote:function(e,t,n){var r=e.parent&&"blockQuote"!==e.parent.type?[fl(t,n,"blockQuote")]:[];if(e.firstChild){var o=[];"paragraph"===e.firstChild.type?o=function(e){for(var t=[];e;)t.push(fl([Is(e),Ps(e)],[Rs(e),Bs(e)+1],pl)),e=e.next;return t}(e.firstChild.firstChild):"list"===e.firstChild.type&&(o=yl(e.firstChild,pl)),r=i(i([],r),o)}return r},item:function(e,t){var n=e.listData,r=n.padding,s=n.task,a=function(e){for(var t=0;e.parent.parent&&"item"===e.parent.parent.type;)e=e.parent.parent,t+=1;return["listItem",o(o({},[{odd:!0},{even:!0}][t%2]),{listStyle:!0})]}(e),l=[fl.apply(void 0,i([t,$s(t,r)],a))];return s&&(l.push(fl($s(t,r),$s(t,r+3),"taskDelimiter")),l.push(fl($s(t,r+1),$s(t,r+2),ul))),l.concat(yl(e.firstChild,pl))},customBlock:function(e,t,n){var r=e,o=r.offset,i=r.syntaxLength,s=r.info,a=r.parent,l=o+i,c=[fl(_s(t,1),n,"customBlock")];c.push(fl(t,$s(t,l),dl)),s&&c.push(fl($s(t,l),$s(t,i+s.length),ul)),c.push(fl(_s(n,1),n,dl));var u=vl(a,t,n,"custom-block");return u?c.concat(u):c}},wl={thematicBreak:"thematicBreak",table:"table",tableCell:"tableCell",htmlInline:"html"};function kl(e,t,n,r){var o=e.type;return Ga()(bl[o])?bl[o](e,t,n,r):wl[o]?[fl(t,n,wl[o])]:null}var xl={};function Cl(e){var t=e.schema,n=e.toastMark;return new an({appendTransaction:function(e,r,o){var i=e[0],s=o.tr;if(i.docChanged){var a=[];i.getMeta("editResult").forEach((function(e){var t=e.nodes,r=e.removedNodeRange;if(t.length){a=a.concat(function(e,t){var n=e.doc,r=t[0].sourcepos[0],o=et(t).sourcepos[1],i=[r[0],r[1]],s=[o[0],o[1]+1],a=[];return function(e,t,n){var r=[];xl={};for(var o=t[0]-1;o<n[0];o+=1){var i=e.child(o),s=i.attrs.codeEnd,a=i.attrs.codeStart;if(a&&s&&!Ue(r,a)){r.push(a),s=Math.min(s,e.childCount);for(var l=a-1,c=n[0],u=l;u<c;u+=1)xl[u]=!0}}}(n,r,o),a.push({start:i,end:s}),a}(s,t));for(var o=0,i=t;o<i.length;o++)for(var l=i[o].walker(),c=l.next();c;){var u=c.node;c.entering&&(a=a.concat(Ml(u,n))),c=l.next()}}else if(r)for(var d=s.doc.childCount-1,p=r.line,h=p[0],f=p[1],m=Math.min(h,d),g=Math.min(f,d),v=m;v<=g;v+=1)xl[v]=!0})),function(e,t,n){var r=e.doc,o=t.nodes.paragraph,i=rl(r,r.childCount);n.forEach((function(n){var s=n.start,a=n.end,l=n.spec,c=n.lineBackground,u=Math.min(s[0],r.childCount)-1,d=Math.min(a[0],r.childCount)-1,p=r.child(u),h=r.child(d),f=i[u],m=i[d];(f+=s[1]+tl(p,s[1]-1),m+=a[1]+tl(h,a[1]-1),l)?c?function(e,t,n,r,o){void 0===o&&(o={});for(var i=r.startIndex,s=r.endIndex,a=r.from,l=r.to,c=!1,u=i;u<=s;u+=1)delete xl[u],c=Tl(t,u,o);c&&e.setBlockType(a,l,n,o)}(e,r,o,{from:f,to:m,startIndex:u,endIndex:d},l.attrs):e.addMark(f,m,t.mark(l.type,l.attrs)):e.removeMark(f,m)})),function(e,t,n){Object.keys(xl).forEach((function(r){var o=Number(r),i=Math.min(Number(r)+1,e.doc.childCount-1),s=t[o],a=t[i]-1;o===i&&(a+=2),e.setBlockType(s,a,n)}))}(e,i,o)}(s,t,a)}return s.setMeta("widget",i.getMeta("widget"))}})}function Tl(e,t,n){return Object.keys(n).some((function(r){return n[r]!==e.child(t).attrs[r]}))}function Ml(e,t){var n=t.getLineTexts(),r=[Is(e),Ps(e)],o=[Rs(e),Bs(e)+1],i=kl(e,r,o,n[o[0]-1]);return null!=i?i:[]}var Sl=["taskList","orderedList","bulletList","table","strong","emph","strike","heading","thematicBreak","blockQuote","code","codeBlock","indent","outdent"];function El(e){var t={indent:{active:!1,disabled:!0},outdent:{active:!1,disabled:!0}},n=!0;return function(e,t,n){for(void 0===n&&(n=!0),e=n?e:e.parent;e&&"document"!==e.type;)t(e),e=e.parent}(e,(function(e){var r=function(e){var t=e.type;return Hs(e)?e.listData.task?"taskList":"ordered"===e.listData.type?"orderedList":"bulletList":-1!==t.indexOf("table")?"table":Ue(Sl,t)?t:null}(e);r&&("bulletList"===r||"orderedList"===r?n&&(t[r]={active:!0},t.indent.disabled=!1,t.outdent.disabled=!1,n=!1):t[r]={active:!0})})),t}function Nl(e){var t=e.toastMark,n=e.eventEmitter;return new an({view:function(){return{update:function(e,r){var o=e.state,i=o.doc,s=o.selection;if(!(r&&r.doc.eq(i)&&r.selection.eq(s))){var a=s.from,l=o.doc.resolve(a).start(),c=a-l;a===l&&(c+=1);var u=[o.doc.content.findIndex(a).index+1,c],d=t.findNodeAtPosition(u),p=El(d);n.emit("changeToolbarState",{cursorPos:u,mdNode:d,toolbarState:p}),n.emit("setFocusedNode",d)}}}}})}var Ol=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"doc"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"block+"}},enumerable:!1,configurable:!0}),n}(Va),Dl=function(){function e(){}return Object.defineProperty(e.prototype,"type",{get:function(){return"mark"},enumerable:!1,configurable:!0}),e.prototype.setContext=function(e){this.context=e},e}(),Al=Dl;function Ll(e,t){return Il(e,t-1)}function Il(e,t){return e.child(t).textContent}var Rl=/^\s*> ?/,Pl=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"blockQuote"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("block-quote")},0]}}},enumerable:!1,configurable:!0}),n.prototype.createBlockQuoteText=function(e,t){return t?e.replace(Rl,"").trim():"> "+e.trim()},n.prototype.extendBlockQuote=function(){var e=this;return function(t,n){var r=t.selection,o=t.doc,i=t.tr,s=t.schema,a=il(r),l=a.endFromOffset,c=a.endToOffset,u=a.endIndex,d=a.to,p=Il(o,u);if(Rl.test(p)&&d>l&&r.empty){if(!p.replace(Rl,"").trim())i.deleteRange(l,c).split(i.mapping.map(c));else{var h=p.slice(d-l).trim();Ls(i,c,h,Ns(s,e.createBlockQuoteText(h)))}return n(i),!0}return!1}},n.prototype.commands=function(){var e=this;return function(){return function(t,n){var r=t.selection,o=t.doc,i=il(r),s=i.startFromOffset,a=i.endToOffset,l=i.startIndex,c=i.endIndex,u=Rl.test(Il(o,l)),d=As({state:t,startIndex:l,endIndex:c,from:s,createText:function(t){return e.createBlockQuoteText(t,u)}});return n(d.setSelection(Os(d,d.mapping.map(a)))),!0}}},n.prototype.keymaps=function(){var e=this.commands()();return{"alt-q":e,"alt-Q":e,Enter:this.extendBlockQuote()}},n}(Al),Bl=/(^\s*)([-*+] |[\d]+\. )/,Fl=/(^\s*)([\d])+\.( \[[ xX]])? /,Hl=/^(\s*)((\d+)([.)]\s(?:\[(?:x|\s)\]\s)?))(.*)/,zl=/(^\s*)([-*+]|[\d]+\.)( \[[ xX]])? /,ql=/^(\s*)([-*+]+(\s(?:\[(?:x|\s)\]\s)?))(.*)/,Vl=/(^\s*)([-*+] |[\d]+\. )(\[[ xX]] )/,jl=/(^\s*)([-*+])( \[[ xX]]) /;function $l(e){return Fl.test(e)?"ordered":"bullet"}function _l(e){for(var t=0;e&&"document"!==e.type;)"list"===e.type&&(t+=1),e=e.parent;return t}function Ul(e,t,n,r){for(var o=e.getLineTexts().length,i=[],s=t;r?s<o:s>1;){s=r?s+1:s-1;var a=e.findFirstNodeAtLine(s),l=_l(a);if(l===n)i.push({line:s,depth:n,mdNode:a});else if(l<n)break}return i}function Wl(e,t,n,r){void 0===r&&(r=0);var o=Number.MAX_VALUE,i=0,s=t.map((function(t,s){var a=t.line;o=Math.min(a-1,o),i=Math.max(a-1,i);var l=Ll(e,a);return l="bullet"===n?function(e){if(!Bl.test(e))return"* "+e;var t=$l(e);return"bullet"===t&&zl.test(e)?e=e.replace(jl,"$1$2 "):"ordered"===t&&(e=e.replace(Fl,"$1* ")),e}(l):function(e,t){if(!Bl.test(e))return t+". "+e;var n=$l(e);if("bullet"===n||"ordered"===n&&zl.test(e))e=e.replace(zl,"$1"+t+". ");else if("ordered"===n){var r=Hl.exec(e)[3];Number(r)!==t&&(e=e.replace(Fl,"$1"+t+". "))}return e}(l,s+1+r),{text:l,line:a}}));return{changedResults:s,firstIndex:o,lastIndex:i}}function Jl(e,t){var n,r,o,i,s,a,l,c=(r=(n=t).toastMark,o=n.mdNode,i=n.line,s=_l(o),a=Ul(r,i,s,!1).reverse(),l=Ul(r,i,s,!0),a.concat([{line:i,depth:s,mdNode:o}]).concat(l));return Wl(t.doc,c,e)}var Gl={bullet:function(e){return Jl("bullet",e)},ordered:function(e){return Jl("ordered",e)},task:function(e){var t=e.mdNode,n=e.doc,r=e.line,o=Ll(n,r);return t.listData.task?o=o.replace(Vl,"$1$2"):Hs(t)&&(o=o.replace(Bl,"$1$2[ ] ")),{changedResults:[{text:o,line:r}]}}},Kl={bullet:function(e){var t=e.doc,n=e.line;return{changedResults:[{text:"* "+Ll(t,n),line:n}]}},ordered:function(e){for(var t=e.toastMark,n=e.doc,r=e.line,o=e.startLine,i=Ll(n,r),s=1,a=o,l=0,c=o-1;c>0;c-=1){var u=t.findFirstNodeAtLine(c),d=Ll(n,c)&&!!js(u,(function(e){return Hs(e)})),p=Hl.exec(Ll(n,c));if(!p&&!d)break;if(p||!d){var h=p,f=h[1],m=h[3];if(!f){s=Number(m),a=c;break}}else l+=1}return{changedResults:[{text:s+r-a-l+". "+i,line:r}]}},task:function(e){var t=e.doc,n=e.line;return{changedResults:[{text:"* [ ] "+Ll(t,n),line:n}]}}},Zl={bullet:function(e){var t=e.line,n=Ll(e.doc,t),r=ql.exec(n);return{listSyntax:""+r[1]+r[2]}},ordered:function(e){var t=e.toastMark,n=e.line,r=e.mdNode,i=e.doc,s=_l(r),a=Ll(i,n),l=Hl.exec(a),c=l[1],u=l[3],d=l[4],p=Number(u)+1,h=""+c+p+d,f=Ul(t,n,s,!0).filter((function(e){var t=Hl.exec(Ll(i,e.line));return t&&t[1].length===c.length&&!!js(e.mdNode,(function(e){return zs(e)}))}));return o({listSyntax:h},Wl(i,f,"ordered",p))}};function Xl(e,t,n,r,o){for(var i=[],s=Ll(e,n),a=Hl.exec(s);a;){var l=a[1],c=a[4],u=a[5],d=l.length;if(d===o)i.push(Ns(t,""+l+r+c+u)),r+=1,n+=1;else if(d>o){var p=Xl(e,t,n,1,d);n=p.line,i=i.concat(p.nodes)}if(d<o||n>e.childCount)break;s=Ll(e,n),a=Hl.exec(s)}return{nodes:i,line:n}}var Ql=/(^\s{1,4})(.*)/;function Yl(e,t,n){return e<t||Bl.test(n)||Rl.test(n)}function ec(e,t,n){var r=n.$from;0===r.depth&&(r=e.resolve(r.pos-1));var o=r.node(1),i=r.start(1),s=o.content.size;return o.rangeHasMark(0,s,t.marks.table)&&r.pos-i!==s&&r.pos!==i}function tc(e,t){var n=t.from,r=t.to;if("indent"===t.type){n+=4,r+=4*(t.lineLen+1)}else{var o=t.spaceLenList;n-=o[0];for(var i=0;i<o.length;i+=1)r-=o[i]}return Os(e,n,r)}var nc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"paragraph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"inline*",attrs:{className:{default:null},codeStart:{default:null},codeEnd:{default:null}},selectable:!1,group:"block",parseDOM:[{tag:"div"}],toDOM:function(e){var t=e.attrs;return t.className?["div",{class:Ca(t.className)},0]:["div",0]}}},enumerable:!1,configurable:!0}),n.prototype.reorderList=function(e,t){for(var n=this.context,r=n.view,o=n.toastMark,i=n.schema,s=r.state,a=s.tr,l=s.selection,c=s.doc,u=o.findFirstNodeAtLine(e),d=u;u&&!qs(u)&&"document"!==u.parent.type;)if(zs(u=u.parent)){d=u;break}d&&(e=d.sourcepos[0][0]);var p=Hl.exec(Ll(c,e)),h=p[1],f=p[3],m=h.length,g=Xl(c,i,e,Number(f),m),v=g.line,y=g.nodes;t=Math.max(t,v-1);for(var b=sl(c,e-1).startOffset,w=e-1;w<=t-1;w+=1){var k=c.child(w),x=k.nodeSize,C=k.content,T=a.mapping.map(b),M=T+C.size;a.replaceWith(T,M,y[w-e+1]),b+=x}var S=Os(a,l.from,l.to);r.dispatch(a.setSelection(S))},n.prototype.indent=function(e){var t=this;return void 0===e&&(e=!1),function(){return function(n,r){var o=n.schema,i=n.selection,s=n.doc,a=il(i),l=a.from,c=a.to,u=a.startFromOffset,d=a.startIndex,p=a.endIndex;if(e&&ec(s,o,i))return!1;var h=Il(s,d);if(e&&Yl(l,c,h)||!e&&Bl.test(h)){var f=As({state:n,from:u,startIndex:d,endIndex:p,createText:function(e){return"    "+e}}),m={type:"indent",from:l,to:c,lineLen:p-d};r(f.setSelection(tc(f,m))),Hl.test(h)&&t.reorderList(d+1,p+1)}else e&&r(n.tr.insert(c,Ns(o,"    ")));return!0}}},n.prototype.outdent=function(e){var t=this;return void 0===e&&(e=!1),function(){return function(n,r){var o=n.selection,i=n.doc,s=n.schema,a=il(o),l=a.from,c=a.to,u=a.startFromOffset,d=a.startIndex,p=a.endIndex;if(e&&ec(i,s,o))return!1;var h=Il(i,d);if(e&&Yl(l,c,h)||!e&&Bl.test(h)){var f=[],m=As({state:n,from:u,startIndex:d,endIndex:p,createText:function(e){var t=Ql.exec(e);return f.push(t?t[1].length:0),e.replace(Ql,"$2")}}),g={type:"outdent",from:l,to:c,spaceLenList:f};r(m.setSelection(tc(m,g))),Hl.test(h)&&t.reorderList(d+1,p+1)}else if(e){var v=h.slice(0,c-u),y=v.replace(/\s{1,4}$/,""),b=c-(v.length-y.length);r(n.tr.delete(b,c))}return!0}}},n.prototype.deleteLines=function(){var e=this;return function(t,n){var r=e.context.view,o=il(t.selection),i=o.startFromOffset,s=o.endToOffset;return Zi((function(){return n(t.tr.deleteRange(i,s)),!0}),Bi)(t,n,r)}},n.prototype.moveDown=function(){return function(e,t){var n=e.doc,r=e.tr,o=e.selection,i=e.schema,s=il(o),a=s.startFromOffset,l=s.endToOffset,c=s.endIndex;if(c<n.content.childCount-1){var u=n.child(c+1),d=u.nodeSize,p=u.textContent;return r.delete(l,l+d).split(a).insert(r.mapping.map(a)-2,Ns(i,p)),t(r),!0}return!1}},n.prototype.moveUp=function(){return function(e,t){var n=e.tr,r=e.doc,o=e.selection,i=e.schema,s=il(o),a=s.startFromOffset,l=s.endToOffset,c=s.startIndex;if(c>0){var u=r.child(c-1),d=u.nodeSize,p=u.textContent;return n.delete(a-d,a).split(n.mapping.map(l)).insert(n.mapping.map(l),Ns(i,p)),t(n),!0}return!1}},n.prototype.commands=function(){return{indent:this.indent(),outdent:this.outdent()}},n.prototype.keymaps=function(){return{Tab:this.indent(!0)(),"Shift-Tab":this.outdent(!0)(),"Mod-d":this.deleteLines(),"Mod-D":this.deleteLines(),"Alt-ArrowUp":this.moveUp(),"Alt-ArrowDown":this.moveDown()}},n}(Va),rc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"text"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{group:"inline"}},enumerable:!1,configurable:!0}),n}(Va),oc=/^#{1,6}\s/,ic=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"heading"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{level:{default:1},seText:{default:!1}},toDOM:function(e){var t=e.attrs,n="heading|heading"+t.level;return t.seText&&(n+="|delimiter|setext"),["span",{class:Ca.apply(void 0,n.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.createHeadingText=function(e,t,n){for(var r=t.replace(n,"").trim(),o="";e>0;)o+="#",e-=1;return o+" "+r},n.prototype.commands=function(){var e=this;return function(t){return function(n,r){var o=t.level,i=il(n.selection),s=i.startFromOffset,a=i.endToOffset,l=As({state:n,from:s,startIndex:i.startIndex,endIndex:i.endIndex,createText:function(t){var n=t.match(oc),r=n?n[0]:"";return e.createHeadingText(o,t,r)}});return r(l.setSelection(Os(l,l.mapping.map(a)))),!0}}},n}(Al),sc="```",ac=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"codeBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("code-block")},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){var n=e.selection,r=e.schema,o=e.tr,i=il(n),s=i.startFromOffset,a=i.endToOffset,l=Ns(r,sc);return o.insert(s,l).split(s+sc.length),o.split(o.mapping.map(a)).insert(o.mapping.map(a),l),t(o.setSelection(Os(o,o.mapping.map(a)-(sc.length+2)))),!0}}},n.prototype.keepIndentation=function(){var e=this;return function(t,n){var r=t.selection,o=t.tr,i=t.doc,s=t.schema,a=e.context.toastMark,l=il(r),c=l.startFromOffset,u=l.endToOffset,d=l.endIndex,p=l.from,h=l.to,f=Il(i,d);if(p===h&&f.trim()){var m=f.match(/^\s+/);if(function(e){return e&&"codeBlock"===e.type}(a.findFirstNodeAtLine(d+1))&&m){var g=m[0],v=f.slice(h-c);return Ls(o,u,v,Ns(s,g+v)),n(o),!0}}return!1}},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-p":e,"Shift-Mod-P":e,Enter:this.keepIndentation()}},n}(Al),lc=/\||\s/g;function cc(e,t){for(var n="|",r=0;r<e;r+=1)n+=t?" --- |":"  |";return n}var uc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"table"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("table")},0]}}},enumerable:!1,configurable:!0}),n.prototype.extendTable=function(){var e=this;return function(t,n){var r=t.selection,o=t.doc,i=t.tr,s=t.schema;if(!r.empty)return!1;var a=il(r),l=a.endFromOffset,c=a.endToOffset,u=a.endIndex,d=a.to,p=Il(o,u),h=[u+1,d-l+1],f=js(e.context.toastMark.findNodeAtPosition(h),(function(e){return Vs(e)&&("tableDelimRow"===e.parent.type||"tableBody"===e.parent.parent.type)}));if(f){var m=!p.replace(lc,"").trim(),g=cc(f.parent.parent.parent.columns.length);return m?i.deleteRange(l,c).split(i.mapping.map(c)):i.split(c).insert(i.mapping.map(c),Ns(s,g)).setSelection(Os(i,i.mapping.map(c)-2)),n(i),!0}return!1}},n.prototype.moveTableCell=function(e){var t=this;return function(n,r){var o=n.selection,i=n.tr,s=il(o),a=s.endFromOffset,l=[s.endIndex+1,s.to-a],c=js(t.context.toastMark.findNodeAtPosition(l),(function(e){return Vs(e)}));if(c){var u=c.parent,d=function(e){return e?{type:"next",parentType:"tableHead",childType:"firstChild"}:{type:"prev",parentType:"tableBody",childType:"lastChild"}}(e),p=d.type,h=d.parentType,f=d.childType,m=Bs(c);if(c[p])m=Bs(c[p])-1;else{var g=u[p]||u.parent.type!==h?u[p]:u.parent[p][f];if("next"===p)m+=(g?Bs(g[f]):0)+2;else"prev"===p&&(m=g?-4:0)}return r(i.setSelection(Os(i,a+m))),!0}return!1}},n.prototype.addTable=function(){return function(e){return function(t,n){var r=t.selection,o=t.tr,s=t.schema,a=e,l=a.columnCount,c=a.rowCount,u=il(r).endToOffset,d=function(e){return[cc(e),cc(e,!0)]}(l),p=function(e,t){for(var n=[],r=0;r<t;r+=1)n.push(cc(e));return n}(l,c-1);return i(i([],d),p).forEach((function(e){o.split(o.mapping.map(u)).insert(o.mapping.map(u),Ns(s,e))})),n(o.setSelection(Os(o,u+4))),!0}}},n.prototype.commands=function(){return{addTable:this.addTable()}},n.prototype.keymaps=function(){return{Enter:this.extendTable(),Tab:this.moveTableCell(!0),"Shift-Tab":this.moveTableCell(!1)}},n}(Al),dc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"thematicBreak"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("thematic-break")},0]}}},enumerable:!1,configurable:!0}),n.prototype.hr=function(){return function(){return function(e,t){var n=e.selection,r=e.schema,o=e.tr,i=il(n),s=i.from,a=i.to,l=i.endToOffset,c=Ns(r,"***");return o.split(s).replaceWith(o.mapping.map(s),o.mapping.map(a),c).split(o.mapping.map(a)).setSelection(Os(o,o.mapping.map(l))),t(o),!0}}},n.prototype.commands=function(){return{hr:this.hr()}},n.prototype.keymaps=function(){var e=this.hr()();return{"Mod-l":e,"Mod-L":e}},n}(Al);function pc(e,t){var n=e.type;return t<=e.sourcepos[0][0]&&("codeBlock"===n||"heading"===n||n.match("table"))}var hc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"listItem"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{odd:{default:!1},even:{default:!1},listStyle:{default:!1}},toDOM:function(e){var t=e.attrs,n=t.odd,r=t.even,o="list-item";return t.listStyle&&(o+="|list-item-style"),n&&(o+="|list-item-odd"),r&&(o+="|list-item-even"),["span",{class:Ca.apply(void 0,o.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.extendList=function(){var e=this;return function(t,n){var r=t.selection,o=t.doc,i=t.schema,s=t.tr,a=e.context.toastMark,l=il(r),c=l.to,u=l.startFromOffset,d=l.endFromOffset,p=l.endIndex,h=l.endToOffset,f=Il(o,p);if(!Bl.test(f)||r.from===u||!r.empty)return!1;if(!f.replace(zl,"").trim())s.deleteRange(d,h).split(s.mapping.map(h));else{var m=$l(f),g=a.findFirstNodeAtLine(p+1),v=f.slice(c-d),y={toastMark:a,mdNode:g,doc:o,line:p+1},b=Zl[m](y),w=b.listSyntax,k=b.changedResults;if(null==k?void 0:k.length){s.split(c),k.unshift({text:w+v,line:p+1}),e.changeToListPerLine(s,k,{from:c,startLine:k[0].line,endLine:et(k).line});var x=s.mapping.map(h)-v.length;s.setSelection(Os(s,x))}else{Ls(s,h,v,Ns(i,w+v))}}return n(s),!0}},n.prototype.toList=function(e){var t=this;return function(){return function(n,r){for(var o=n.doc,i=n.tr,s=n.selection,a=t.context.toastMark,l=il(s),c=l.startIndex+1,u=l.endIndex+1,d=l.endToOffset,p=[],h=c;h<=u;h+=1){var f=a.findFirstNodeAtLine(h);if(f&&pc(f,h))break;if(-1===p.indexOf(h)){var m={toastMark:a,mdNode:f,doc:o,line:h,startLine:c},g=(Hs(f)?Gl[e](m):Kl[e](m)).changedResults,v=t.changeToListPerLine(i,g,{from:sl(o,g[0].line-1).startOffset,startLine:g[0].line,endLine:et(g).line,indexDiff:1});d=Math.max(v,d),g&&(p=p.concat(g.map((function(e){return e.line}))))}}return r(i.setSelection(Os(i,i.mapping.map(d)))),!0}}},n.prototype.changeToListPerLine=function(e,t,n){for(var r=n.from,o=n.startLine,i=n.endLine,s=n.indexDiff,a=void 0===s?0:s,l=0,c=function(n){var o=e.doc.child(n),i=o.nodeSize,s=o.content,c=e.mapping.map(r),d=c+s.size,p=t.filter((function(e){return e.line-a===n}))[0];p&&(e.replaceWith(c,d,Ns(u.context.schema,p.text)),l=Math.max(l,r+s.size)),r+=i},u=this,d=o-a;d<=i-a;d+=1)c(d);return l},n.prototype.toggleTask=function(){var e=this;return function(t,n){for(var r=t.selection,o=t.tr,i=t.doc,s=t.schema,a=e.context.toastMark,l=il(r),c=l.startIndex,u=l.endIndex,d=null,p=c;p<=u;p+=1){var h=a.findFirstNodeAtLine(p+1);if(Hs(h)&&h.listData.task){var f=h.listData,m=f.checked,g=f.padding,v=m?" ":"x",y=h.sourcepos[0],b=sl(i,y[0]-1).startOffset;b+=y[1]+g,d=o.replaceWith(b,b+1,s.text(v))}}return!!d&&(n(d),!0)}},n.prototype.commands=function(){return{bulletList:this.toList("bullet"),orderedList:this.toList("ordered"),taskList:this.toList("task")}},n.prototype.keymaps=function(){var e=this.toList("bullet")(),t=this.toList("ordered")(),n=this.toList("task")(),r=this.toggleTask();return{"Mod-u":e,"Mod-U":e,"Mod-o":t,"Mod-O":t,"alt-t":n,"alt-T":n,"Shift-Ctrl-x":r,"Shift-Ctrl-X":r,Enter:this.extendList()}},n}(Al);function fc(e,t){return function(){return function(n,r){var o=n.tr,i=n.selection,s=Ga()(e)?e:function(t){return e.test(t)},a=t.length,l=o.doc,c=Ya(i),u=c[0],d=c[1],p=Math.max(u-a,1),h=Math.min(d+a,l.content.size-1),f=i.content(),m=f.content.textBetween(0,f.content.size,"\n"),g=l.textBetween(p,u,"\n"),v=l.textBetween(d,h,"\n");if(m=""+g+m+v,g&&v&&s(m))o.delete(h-a,h).delete(p,p+a);else{o.insertText(t,d).insertText(t,u);var y=i.empty?Os(o,u+a):Os(o,u+a,d+a);o.setSelection(y)}return r(o),!0}}}var mc=/^(\*{2}|_{2}).*([\s\S]*)\1$/m,gc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strong"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("strong")},0]}}},enumerable:!1,configurable:!0}),n.prototype.bold=function(){return fc(mc,"**")},n.prototype.commands=function(){return{bold:this.bold()}},n.prototype.keymaps=function(){var e=this.bold()();return{"Mod-b":e,"Mod-B":e}},n}(Al),vc=/^(~{2}).*([\s\S]*)\1$/m,yc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strike"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("strike")},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return fc(vc,"~~")},n.prototype.keymaps=function(){var e=this.commands()();return{"Mod-s":e,"Mod-S":e}},n}(Al),bc=/^(\*|_).*([\s\S]*)\1$/m,wc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"emph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("emph")},0]}}},enumerable:!1,configurable:!0}),n.prototype.italic=function(){return fc(bc,"*")},n.prototype.commands=function(){return{italic:this.italic()}},n.prototype.keymaps=function(){var e=this.italic()();return{"Mod-i":e,"Mod-I":e}},n}(Al),kc=/^(`).*([\s\S]*)\1$/m,xc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"code"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{start:{default:!1},end:{default:!1},marked:{default:!1}},toDOM:function(e){var t=e.attrs,n="code";return t.start&&(n+="|delimiter|start"),t.end&&(n+="|delimiter|end"),t.marked&&(n+="|marked-text"),["span",{class:Ca.apply(void 0,n.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return fc(kc,"`")},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-c":e,"Shift-Mod-C":e}},n}(Al),Cc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"link"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:{url:{default:!1},desc:{default:!1}},toDOM:function(e){var t=e.attrs,n="link";return t.url&&(n+="|link-url|marked-text"),t.desc&&(n+="|link-desc|marked-text"),["span",{class:Ca.apply(void 0,n.split("|"))},0]}}},enumerable:!1,configurable:!0}),n.prototype.addLinkOrImage=function(e){return function(t){return function(n,r){var o=n.selection,i=n.tr,s=n.schema,a=Ya(o),l=a[0],c=a[1],u=t,d=u.linkText,p=u.altText,h=u.linkUrl,f=u.imageUrl,m=d,g=h,v="";return"image"===e&&(m=p,g=f,v="!"),v+="["+(m=Ze(m))+"]("+g+")",r(i.replaceWith(l,c,Ns(s,v))),!0}}},n.prototype.commands=function(){return{addImage:this.addLinkOrImage("image"),addLink:this.addLinkOrImage("link")}},n}(Al),Tc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"taskDelimiter"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("delimiter","list-item")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Mc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"delimiter"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("delimiter")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Sc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"meta"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("meta")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Ec=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"markedText"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("marked-text")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Nc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableCell"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("table-cell")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Oc=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"html"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("html")},0]}}},enumerable:!1,configurable:!0}),n}(Al),Dc="$$",Ac=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"customBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{toDOM:function(){return["span",{class:Ca("custom-block")},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(e){return function(t,n){var r=t.selection,o=t.schema,i=t.tr,s=il(r),a=s.startFromOffset,l=s.endToOffset;if(!(null==e?void 0:e.info))return!1;var c="$$"+e.info,u=Ns(o,c),d=Ns(o,Dc);return i.insert(a,u).split(a+c.length),i.split(i.mapping.map(l)).insert(i.mapping.map(l),d),n(i.setSelection(Os(i,i.mapping.map(l)-(Dc.length+2)))),!0}}},n}(Al),Lc=/x|backspace/i,Ic=/^\[(\s*)(x?)(\s*)\](?:\s+)/i;var Rc="cut",Pc=/\r\n|\n|\r/,Bc=function(e){function n(t,n){var r=e.call(this,t)||this,i=n.toastMark,s=n.useCommandShortcut,a=void 0===s||s,l=n.mdPlugins,c=void 0===l?[]:l;return r.editorType="markdown",r.el.classList.add("md-mode"),r.toastMark=i,r.extraPlugins=c,r.specs=r.createSpecs(),r.schema=r.createSchema(),r.context=r.createContext(),r.keymaps=r.createKeymaps(a),r.view=r.createView(),r.commands=r.createCommands(),r.specs.setContext(o(o({},r.context),{view:r.view})),r.createClipboard(),r.eventEmitter.listen("changePreviewTabWrite",(function(e){return r.toggleActive(!0,e)})),r.eventEmitter.listen("changePreviewTabPreview",(function(){return r.toggleActive(!1)})),r.initEvent(),r}return t(n,e),n.prototype.toggleActive=function(e,t){Sa(this.el,"active",e),e?t||this.focus():this.blur()},n.prototype.createClipboard=function(){var e=this;this.clipboard=document.createElement("textarea"),this.clipboard.className=xa("pseudo-clipboard"),this.clipboard.addEventListener("paste",(function(t){var n=t.clipboardData||window.clipboardData,r=n&&n.items;if(r){var o=vi()(r).some((function(e){return"string"===e.kind&&"text/rtf"===e.type}));if(!o){var i=za(r);i&&(t.preventDefault(),Ha(e.eventEmitter,i,t.type))}}})),this.clipboard.addEventListener("input",(function(t){var n=t.target.value;e.replaceSelection(n),t.preventDefault(),t.target.value=""})),this.el.insertBefore(this.clipboard,this.view.dom)},n.prototype.createContext=function(){return{toastMark:this.toastMark,schema:this.schema,eventEmitter:this.eventEmitter}},n.prototype.createSpecs=function(){return new Qa([new Ol,new nc,new _a,new rc,new ic,new Pl,new ac,new Ac,new uc,new Nc,new dc,new hc,new gc,new yc,new wc,new xc,new Cc,new Mc,new Tc,new Ec,new Sc,new Oc])},n.prototype.createPlugins=function(){return i([Cl(this.context),Nl(this.context),(e=this.context,t=e.schema,n=e.toastMark,new an({props:{handleDOMEvents:{keyup:function(e,r){var o,i=e.state,s=i.doc,a=i.tr,l=i.selection;if(l.empty&&Lc.test(r.key)){var c=il(l),u=c.startIndex,d=c.startFromOffset,p=[u+1,c.from-d+1],h=js(n.findNodeAtPosition(p),(function(e){var t;return"paragraph"===e.type&&"item"===(null===(t=e.parent)||void 0===t?void 0:t.type)}));if(null===(o=null==h?void 0:h.firstChild)||void 0===o?void 0:o.literal){var f=h.firstChild,m=f.literal.match(Ic);if(m){var g=f.sourcepos[0],v=m[1],y=m[2],b=m[3],w=v.length+b.length,k=sl(s,g[0]-1).startOffset,x=g[1]+k;if(y){var C=w?w+1:0;a.replaceWith(x,C+x,t.text(y)),e.dispatch(a)}else w||(a.insertText(" ",x),e.dispatch(a))}}}return!1}}}}))],this.createPluginProps()).concat(this.defaultPlugins);var e,t,n},n.prototype.createView=function(){var e=this;return new ui(this.el,{state:this.createState(),dispatchTransaction:function(t){e.updateMarkdown(t);var n=e.view.state.applyTransaction(t).state;e.view.updateState(n),e.emitChangeEvent(t)},handleKeyDown:function(t,n){return(n.metaKey||n.ctrlKey)&&"V"===n.key.toUpperCase()&&e.clipboard.focus(),e.eventEmitter.emit("keydown",e.editorType,n),!1},handleDOMEvents:{copy:function(t,n){return e.captureCopy(n)},cut:function(t,n){return e.captureCopy(n,Rc)},scroll:function(){return e.eventEmitter.emit("scroll","editor"),!0},keyup:function(t,n){return e.eventEmitter.emit("keyup",e.editorType,n),!1}},nodeViews:{widget:ja}})},n.prototype.createCommands=function(){return this.specs.commands(this.view)},n.prototype.captureCopy=function(e,t){e.preventDefault();var n=this.view.state,r=n.selection,o=n.tr;if(r.empty)return!0;var i=this.getChanged(r.content());return e.clipboardData?e.clipboardData.setData("text/plain",i):window.clipboardData.setData("Text",i),t===Rc&&this.view.dispatch(o.deleteSelection().scrollIntoView().setMeta("uiEvent",Rc)),!0},n.prototype.updateMarkdown=function(e){var t=this;e.docChanged&&e.steps.forEach((function(n,r){if(n.slice&&!(n instanceof wt)){var o=e.docs[r],i=[n.from,n.to],s=nl(o,i[0],i[1]),a=s[0],l=s[1],c=t.getChanged(n.slice);a[0]===l[0]&&a[1]===l[1]&&""===c&&(c="\n");var u=t.toastMark.editMarkdown(a,l,c);t.eventEmitter.emit("updatePreview",u),e.setMeta("editResult",u).scrollIntoView()}}))},n.prototype.getChanged=function(e){var t="",n=e.content.size;return e.content.nodesBetween(0,n,(function(e,r){e.isText?t+=e.text.slice(Math.max(0,r)-r,n-r):e.isBlock&&r>0&&(t+="\n")})),t},n.prototype.setSelection=function(e,t){void 0===t&&(t=e);var n=this.view.state.tr,r=ol(n.doc,e,t),o=r[0],i=r[1];this.view.dispatch(n.setSelection(Os(n,o,i)).scrollIntoView())},n.prototype.replaceSelection=function(e,t,n){var r,o=this.view.state,i=o.tr,s=o.schema,a=o.doc,l=e.split(Pc).map((function(e){return Es(s,ra(e,s))})),c=new v(d.from(l),1,1);if(this.focus(),t&&n){var u=ol(a,t,n),p=u[0],h=u[1];r=i.replaceRange(p,h,c)}else r=i.replaceSelection(c);this.view.dispatch(r.scrollIntoView())},n.prototype.deleteSelection=function(e,t){var n,r=this.view.state,o=r.tr,i=r.doc;if(e&&t){var s=ol(i,e,t),a=s[0],l=s[1];n=o.deleteRange(a,l)}else n=o.deleteSelection();this.view.dispatch(n.scrollIntoView())},n.prototype.getSelectedText=function(e,t){var n=this.view.state,r=n.doc,o=n.selection,i=o.from,s=o.to;if(e&&t){var a=ol(r,e,t);i=a[0],s=a[1]}return r.textBetween(i,s,"\n")},n.prototype.getSelection=function(){var e=this.view.state.selection,t=e.from,n=e.to;return nl(this.view.state.tr.doc,t,n)},n.prototype.setMarkdown=function(e,t){void 0===t&&(t=!0);var n=e.split(Pc),r=this.view.state,o=r.tr,i=r.doc,s=r.schema,a=n.map((function(e){return Es(s,ra(e,s))}));this.view.dispatch(o.replaceWith(0,i.content.size,a)),t&&this.moveCursorToEnd(!0)},n.prototype.addWidget=function(e,t,n){var r=this.view.state,o=r.tr,i=r.doc,s=r.selection,a=n?ol(i,n,n)[0]:s.to;this.view.dispatch(o.setMeta("widget",{pos:a,node:e,style:t}))},n.prototype.replaceWithWidget=function(e,t,n){var r=this.view.state,o=r.tr,i=r.schema,s=ol(r.doc,e,t),a=ra(n,i);this.view.dispatch(o.replaceWith(s[0],s[1],a))},n.prototype.getRangeInfoOfNode=function(e){var t=this.view.state,n=t.doc,r=t.selection,o=e||nl(n,r.from)[0],i=this.toastMark.findNodeAtPosition(o);return"text"===i.type&&"paragraph"!==i.parent.type&&(i=i.parent),i.sourcepos[1][1]+=1,{range:i.sourcepos,type:i.type}},n.prototype.getMarkdown=function(){return this.toastMark.getLineTexts().map((function(e){return Xs(e)})).join("\n")},n.prototype.getToastMark=function(){return this.toastMark},n}(Wa),Fc=Bc,Hc=n(349),zc=n.n(Hc),qc=n(348),Vc=n.n(qc),jc=function(e,t){return jc=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n])},jc(e,t)};function $c(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Class extends value "+String(t)+" is not a constructor or null");function n(){this.constructor=e}jc(e,t),e.prototype=null===t?Object.create(t):(n.prototype=t.prototype,new n)}var _c=function(){return _c=Object.assign||function(e){for(var t,n=1,r=arguments.length;n<r;n++)for(var o in t=arguments[n])Object.prototype.hasOwnProperty.call(t,o)&&(e[o]=t[o]);return e},_c.apply(this,arguments)};function Uc(e,t,n){if(n||2===arguments.length)for(var r,o=0,i=t.length;o<i;o++)!r&&o in t||(r||(r=Array.prototype.slice.call(t,0,o)),r[o]=t[o]);return e.concat(r||Array.prototype.slice.call(t))}var Wc="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:void 0!==n.g?n.g:"undefined"!=typeof self?self:{},Jc={};function Gc(e,t,n){var r,o,i,s,a,l="";for("string"!=typeof t&&(n=t,t=Gc.defaultChars),void 0===n&&(n=!0),a=function(e){var t,n,r=Jc[e];if(r)return r;for(r=Jc[e]=[],t=0;t<128;t++)n=String.fromCharCode(t),/^[0-9a-z]$/i.test(n)?r.push(n):r.push("%"+("0"+t.toString(16).toUpperCase()).slice(-2));for(t=0;t<e.length;t++)r[e.charCodeAt(t)]=e[t];return r}(t),r=0,o=e.length;r<o;r++)if(i=e.charCodeAt(r),n&&37===i&&r+2<o&&/^[0-9a-f]{2}$/i.test(e.slice(r+1,r+3)))l+=e.slice(r,r+3),r+=2;else if(i<128)l+=a[i];else if(i>=55296&&i<=57343){if(i>=55296&&i<=56319&&r+1<o&&(s=e.charCodeAt(r+1))>=56320&&s<=57343){l+=encodeURIComponent(e[r]+e[r+1]),r++;continue}l+="%EF%BF%BD"}else l+=encodeURIComponent(e[r]);return l}Gc.defaultChars=";/?:@&=+$,-_.!~*'()#",Gc.componentChars="-_.!~*'()";var Kc=Gc,Zc={},Xc={},Qc={Aacute:"Á",aacute:"á",Abreve:"Ă",abreve:"ă",ac:"∾",acd:"∿",acE:"∾̳",Acirc:"Â",acirc:"â",acute:"´",Acy:"А",acy:"а",AElig:"Æ",aelig:"æ",af:"⁡",Afr:"𝔄",afr:"𝔞",Agrave:"À",agrave:"à",alefsym:"ℵ",aleph:"ℵ",Alpha:"Α",alpha:"α",Amacr:"Ā",amacr:"ā",amalg:"⨿",amp:"&",AMP:"&",andand:"⩕",And:"⩓",and:"∧",andd:"⩜",andslope:"⩘",andv:"⩚",ang:"∠",ange:"⦤",angle:"∠",angmsdaa:"⦨",angmsdab:"⦩",angmsdac:"⦪",angmsdad:"⦫",angmsdae:"⦬",angmsdaf:"⦭",angmsdag:"⦮",angmsdah:"⦯",angmsd:"∡",angrt:"∟",angrtvb:"⊾",angrtvbd:"⦝",angsph:"∢",angst:"Å",angzarr:"⍼",Aogon:"Ą",aogon:"ą",Aopf:"𝔸",aopf:"𝕒",apacir:"⩯",ap:"≈",apE:"⩰",ape:"≊",apid:"≋",apos:"'",ApplyFunction:"⁡",approx:"≈",approxeq:"≊",Aring:"Å",aring:"å",Ascr:"𝒜",ascr:"𝒶",Assign:"≔",ast:"*",asymp:"≈",asympeq:"≍",Atilde:"Ã",atilde:"ã",Auml:"Ä",auml:"ä",awconint:"∳",awint:"⨑",backcong:"≌",backepsilon:"϶",backprime:"‵",backsim:"∽",backsimeq:"⋍",Backslash:"∖",Barv:"⫧",barvee:"⊽",barwed:"⌅",Barwed:"⌆",barwedge:"⌅",bbrk:"⎵",bbrktbrk:"⎶",bcong:"≌",Bcy:"Б",bcy:"б",bdquo:"„",becaus:"∵",because:"∵",Because:"∵",bemptyv:"⦰",bepsi:"϶",bernou:"ℬ",Bernoullis:"ℬ",Beta:"Β",beta:"β",beth:"ℶ",between:"≬",Bfr:"𝔅",bfr:"𝔟",bigcap:"⋂",bigcirc:"◯",bigcup:"⋃",bigodot:"⨀",bigoplus:"⨁",bigotimes:"⨂",bigsqcup:"⨆",bigstar:"★",bigtriangledown:"▽",bigtriangleup:"△",biguplus:"⨄",bigvee:"⋁",bigwedge:"⋀",bkarow:"⤍",blacklozenge:"⧫",blacksquare:"▪",blacktriangle:"▴",blacktriangledown:"▾",blacktriangleleft:"◂",blacktriangleright:"▸",blank:"␣",blk12:"▒",blk14:"░",blk34:"▓",block:"█",bne:"=⃥",bnequiv:"≡⃥",bNot:"⫭",bnot:"⌐",Bopf:"𝔹",bopf:"𝕓",bot:"⊥",bottom:"⊥",bowtie:"⋈",boxbox:"⧉",boxdl:"┐",boxdL:"╕",boxDl:"╖",boxDL:"╗",boxdr:"┌",boxdR:"╒",boxDr:"╓",boxDR:"╔",boxh:"─",boxH:"═",boxhd:"┬",boxHd:"╤",boxhD:"╥",boxHD:"╦",boxhu:"┴",boxHu:"╧",boxhU:"╨",boxHU:"╩",boxminus:"⊟",boxplus:"⊞",boxtimes:"⊠",boxul:"┘",boxuL:"╛",boxUl:"╜",boxUL:"╝",boxur:"└",boxuR:"╘",boxUr:"╙",boxUR:"╚",boxv:"│",boxV:"║",boxvh:"┼",boxvH:"╪",boxVh:"╫",boxVH:"╬",boxvl:"┤",boxvL:"╡",boxVl:"╢",boxVL:"╣",boxvr:"├",boxvR:"╞",boxVr:"╟",boxVR:"╠",bprime:"‵",breve:"˘",Breve:"˘",brvbar:"¦",bscr:"𝒷",Bscr:"ℬ",bsemi:"⁏",bsim:"∽",bsime:"⋍",bsolb:"⧅",bsol:"\\",bsolhsub:"⟈",bull:"•",bullet:"•",bump:"≎",bumpE:"⪮",bumpe:"≏",Bumpeq:"≎",bumpeq:"≏",Cacute:"Ć",cacute:"ć",capand:"⩄",capbrcup:"⩉",capcap:"⩋",cap:"∩",Cap:"⋒",capcup:"⩇",capdot:"⩀",CapitalDifferentialD:"ⅅ",caps:"∩︀",caret:"⁁",caron:"ˇ",Cayleys:"ℭ",ccaps:"⩍",Ccaron:"Č",ccaron:"č",Ccedil:"Ç",ccedil:"ç",Ccirc:"Ĉ",ccirc:"ĉ",Cconint:"∰",ccups:"⩌",ccupssm:"⩐",Cdot:"Ċ",cdot:"ċ",cedil:"¸",Cedilla:"¸",cemptyv:"⦲",cent:"¢",centerdot:"·",CenterDot:"·",cfr:"𝔠",Cfr:"ℭ",CHcy:"Ч",chcy:"ч",check:"✓",checkmark:"✓",Chi:"Χ",chi:"χ",circ:"ˆ",circeq:"≗",circlearrowleft:"↺",circlearrowright:"↻",circledast:"⊛",circledcirc:"⊚",circleddash:"⊝",CircleDot:"⊙",circledR:"®",circledS:"Ⓢ",CircleMinus:"⊖",CirclePlus:"⊕",CircleTimes:"⊗",cir:"○",cirE:"⧃",cire:"≗",cirfnint:"⨐",cirmid:"⫯",cirscir:"⧂",ClockwiseContourIntegral:"∲",CloseCurlyDoubleQuote:"”",CloseCurlyQuote:"’",clubs:"♣",clubsuit:"♣",colon:":",Colon:"∷",Colone:"⩴",colone:"≔",coloneq:"≔",comma:",",commat:"@",comp:"∁",compfn:"∘",complement:"∁",complexes:"ℂ",cong:"≅",congdot:"⩭",Congruent:"≡",conint:"∮",Conint:"∯",ContourIntegral:"∮",copf:"𝕔",Copf:"ℂ",coprod:"∐",Coproduct:"∐",copy:"©",COPY:"©",copysr:"℗",CounterClockwiseContourIntegral:"∳",crarr:"↵",cross:"✗",Cross:"⨯",Cscr:"𝒞",cscr:"𝒸",csub:"⫏",csube:"⫑",csup:"⫐",csupe:"⫒",ctdot:"⋯",cudarrl:"⤸",cudarrr:"⤵",cuepr:"⋞",cuesc:"⋟",cularr:"↶",cularrp:"⤽",cupbrcap:"⩈",cupcap:"⩆",CupCap:"≍",cup:"∪",Cup:"⋓",cupcup:"⩊",cupdot:"⊍",cupor:"⩅",cups:"∪︀",curarr:"↷",curarrm:"⤼",curlyeqprec:"⋞",curlyeqsucc:"⋟",curlyvee:"⋎",curlywedge:"⋏",curren:"¤",curvearrowleft:"↶",curvearrowright:"↷",cuvee:"⋎",cuwed:"⋏",cwconint:"∲",cwint:"∱",cylcty:"⌭",dagger:"†",Dagger:"‡",daleth:"ℸ",darr:"↓",Darr:"↡",dArr:"⇓",dash:"‐",Dashv:"⫤",dashv:"⊣",dbkarow:"⤏",dblac:"˝",Dcaron:"Ď",dcaron:"ď",Dcy:"Д",dcy:"д",ddagger:"‡",ddarr:"⇊",DD:"ⅅ",dd:"ⅆ",DDotrahd:"⤑",ddotseq:"⩷",deg:"°",Del:"∇",Delta:"Δ",delta:"δ",demptyv:"⦱",dfisht:"⥿",Dfr:"𝔇",dfr:"𝔡",dHar:"⥥",dharl:"⇃",dharr:"⇂",DiacriticalAcute:"´",DiacriticalDot:"˙",DiacriticalDoubleAcute:"˝",DiacriticalGrave:"`",DiacriticalTilde:"˜",diam:"⋄",diamond:"⋄",Diamond:"⋄",diamondsuit:"♦",diams:"♦",die:"¨",DifferentialD:"ⅆ",digamma:"ϝ",disin:"⋲",div:"÷",divide:"÷",divideontimes:"⋇",divonx:"⋇",DJcy:"Ђ",djcy:"ђ",dlcorn:"⌞",dlcrop:"⌍",dollar:"$",Dopf:"𝔻",dopf:"𝕕",Dot:"¨",dot:"˙",DotDot:"⃜",doteq:"≐",doteqdot:"≑",DotEqual:"≐",dotminus:"∸",dotplus:"∔",dotsquare:"⊡",doublebarwedge:"⌆",DoubleContourIntegral:"∯",DoubleDot:"¨",DoubleDownArrow:"⇓",DoubleLeftArrow:"⇐",DoubleLeftRightArrow:"⇔",DoubleLeftTee:"⫤",DoubleLongLeftArrow:"⟸",DoubleLongLeftRightArrow:"⟺",DoubleLongRightArrow:"⟹",DoubleRightArrow:"⇒",DoubleRightTee:"⊨",DoubleUpArrow:"⇑",DoubleUpDownArrow:"⇕",DoubleVerticalBar:"∥",DownArrowBar:"⤓",downarrow:"↓",DownArrow:"↓",Downarrow:"⇓",DownArrowUpArrow:"⇵",DownBreve:"̑",downdownarrows:"⇊",downharpoonleft:"⇃",downharpoonright:"⇂",DownLeftRightVector:"⥐",DownLeftTeeVector:"⥞",DownLeftVectorBar:"⥖",DownLeftVector:"↽",DownRightTeeVector:"⥟",DownRightVectorBar:"⥗",DownRightVector:"⇁",DownTeeArrow:"↧",DownTee:"⊤",drbkarow:"⤐",drcorn:"⌟",drcrop:"⌌",Dscr:"𝒟",dscr:"𝒹",DScy:"Ѕ",dscy:"ѕ",dsol:"⧶",Dstrok:"Đ",dstrok:"đ",dtdot:"⋱",dtri:"▿",dtrif:"▾",duarr:"⇵",duhar:"⥯",dwangle:"⦦",DZcy:"Џ",dzcy:"џ",dzigrarr:"⟿",Eacute:"É",eacute:"é",easter:"⩮",Ecaron:"Ě",ecaron:"ě",Ecirc:"Ê",ecirc:"ê",ecir:"≖",ecolon:"≕",Ecy:"Э",ecy:"э",eDDot:"⩷",Edot:"Ė",edot:"ė",eDot:"≑",ee:"ⅇ",efDot:"≒",Efr:"𝔈",efr:"𝔢",eg:"⪚",Egrave:"È",egrave:"è",egs:"⪖",egsdot:"⪘",el:"⪙",Element:"∈",elinters:"⏧",ell:"ℓ",els:"⪕",elsdot:"⪗",Emacr:"Ē",emacr:"ē",empty:"∅",emptyset:"∅",EmptySmallSquare:"◻",emptyv:"∅",EmptyVerySmallSquare:"▫",emsp13:" ",emsp14:" ",emsp:" ",ENG:"Ŋ",eng:"ŋ",ensp:" ",Eogon:"Ę",eogon:"ę",Eopf:"𝔼",eopf:"𝕖",epar:"⋕",eparsl:"⧣",eplus:"⩱",epsi:"ε",Epsilon:"Ε",epsilon:"ε",epsiv:"ϵ",eqcirc:"≖",eqcolon:"≕",eqsim:"≂",eqslantgtr:"⪖",eqslantless:"⪕",Equal:"⩵",equals:"=",EqualTilde:"≂",equest:"≟",Equilibrium:"⇌",equiv:"≡",equivDD:"⩸",eqvparsl:"⧥",erarr:"⥱",erDot:"≓",escr:"ℯ",Escr:"ℰ",esdot:"≐",Esim:"⩳",esim:"≂",Eta:"Η",eta:"η",ETH:"Ð",eth:"ð",Euml:"Ë",euml:"ë",euro:"€",excl:"!",exist:"∃",Exists:"∃",expectation:"ℰ",exponentiale:"ⅇ",ExponentialE:"ⅇ",fallingdotseq:"≒",Fcy:"Ф",fcy:"ф",female:"♀",ffilig:"ffi",fflig:"ff",ffllig:"ffl",Ffr:"𝔉",ffr:"𝔣",filig:"fi",FilledSmallSquare:"◼",FilledVerySmallSquare:"▪",fjlig:"fj",flat:"♭",fllig:"fl",fltns:"▱",fnof:"ƒ",Fopf:"𝔽",fopf:"𝕗",forall:"∀",ForAll:"∀",fork:"⋔",forkv:"⫙",Fouriertrf:"ℱ",fpartint:"⨍",frac12:"½",frac13:"⅓",frac14:"¼",frac15:"⅕",frac16:"⅙",frac18:"⅛",frac23:"⅔",frac25:"⅖",frac34:"¾",frac35:"⅗",frac38:"⅜",frac45:"⅘",frac56:"⅚",frac58:"⅝",frac78:"⅞",frasl:"⁄",frown:"⌢",fscr:"𝒻",Fscr:"ℱ",gacute:"ǵ",Gamma:"Γ",gamma:"γ",Gammad:"Ϝ",gammad:"ϝ",gap:"⪆",Gbreve:"Ğ",gbreve:"ğ",Gcedil:"Ģ",Gcirc:"Ĝ",gcirc:"ĝ",Gcy:"Г",gcy:"г",Gdot:"Ġ",gdot:"ġ",ge:"≥",gE:"≧",gEl:"⪌",gel:"⋛",geq:"≥",geqq:"≧",geqslant:"⩾",gescc:"⪩",ges:"⩾",gesdot:"⪀",gesdoto:"⪂",gesdotol:"⪄",gesl:"⋛︀",gesles:"⪔",Gfr:"𝔊",gfr:"𝔤",gg:"≫",Gg:"⋙",ggg:"⋙",gimel:"ℷ",GJcy:"Ѓ",gjcy:"ѓ",gla:"⪥",gl:"≷",glE:"⪒",glj:"⪤",gnap:"⪊",gnapprox:"⪊",gne:"⪈",gnE:"≩",gneq:"⪈",gneqq:"≩",gnsim:"⋧",Gopf:"𝔾",gopf:"𝕘",grave:"`",GreaterEqual:"≥",GreaterEqualLess:"⋛",GreaterFullEqual:"≧",GreaterGreater:"⪢",GreaterLess:"≷",GreaterSlantEqual:"⩾",GreaterTilde:"≳",Gscr:"𝒢",gscr:"ℊ",gsim:"≳",gsime:"⪎",gsiml:"⪐",gtcc:"⪧",gtcir:"⩺",gt:">",GT:">",Gt:"≫",gtdot:"⋗",gtlPar:"⦕",gtquest:"⩼",gtrapprox:"⪆",gtrarr:"⥸",gtrdot:"⋗",gtreqless:"⋛",gtreqqless:"⪌",gtrless:"≷",gtrsim:"≳",gvertneqq:"≩︀",gvnE:"≩︀",Hacek:"ˇ",hairsp:" ",half:"½",hamilt:"ℋ",HARDcy:"Ъ",hardcy:"ъ",harrcir:"⥈",harr:"↔",hArr:"⇔",harrw:"↭",Hat:"^",hbar:"ℏ",Hcirc:"Ĥ",hcirc:"ĥ",hearts:"♥",heartsuit:"♥",hellip:"…",hercon:"⊹",hfr:"𝔥",Hfr:"ℌ",HilbertSpace:"ℋ",hksearow:"⤥",hkswarow:"⤦",hoarr:"⇿",homtht:"∻",hookleftarrow:"↩",hookrightarrow:"↪",hopf:"𝕙",Hopf:"ℍ",horbar:"―",HorizontalLine:"─",hscr:"𝒽",Hscr:"ℋ",hslash:"ℏ",Hstrok:"Ħ",hstrok:"ħ",HumpDownHump:"≎",HumpEqual:"≏",hybull:"⁃",hyphen:"‐",Iacute:"Í",iacute:"í",ic:"⁣",Icirc:"Î",icirc:"î",Icy:"И",icy:"и",Idot:"İ",IEcy:"Е",iecy:"е",iexcl:"¡",iff:"⇔",ifr:"𝔦",Ifr:"ℑ",Igrave:"Ì",igrave:"ì",ii:"ⅈ",iiiint:"⨌",iiint:"∭",iinfin:"⧜",iiota:"℩",IJlig:"IJ",ijlig:"ij",Imacr:"Ī",imacr:"ī",image:"ℑ",ImaginaryI:"ⅈ",imagline:"ℐ",imagpart:"ℑ",imath:"ı",Im:"ℑ",imof:"⊷",imped:"Ƶ",Implies:"⇒",incare:"℅",in:"∈",infin:"∞",infintie:"⧝",inodot:"ı",intcal:"⊺",int:"∫",Int:"∬",integers:"ℤ",Integral:"∫",intercal:"⊺",Intersection:"⋂",intlarhk:"⨗",intprod:"⨼",InvisibleComma:"⁣",InvisibleTimes:"⁢",IOcy:"Ё",iocy:"ё",Iogon:"Į",iogon:"į",Iopf:"𝕀",iopf:"𝕚",Iota:"Ι",iota:"ι",iprod:"⨼",iquest:"¿",iscr:"𝒾",Iscr:"ℐ",isin:"∈",isindot:"⋵",isinE:"⋹",isins:"⋴",isinsv:"⋳",isinv:"∈",it:"⁢",Itilde:"Ĩ",itilde:"ĩ",Iukcy:"І",iukcy:"і",Iuml:"Ï",iuml:"ï",Jcirc:"Ĵ",jcirc:"ĵ",Jcy:"Й",jcy:"й",Jfr:"𝔍",jfr:"𝔧",jmath:"ȷ",Jopf:"𝕁",jopf:"𝕛",Jscr:"𝒥",jscr:"𝒿",Jsercy:"Ј",jsercy:"ј",Jukcy:"Є",jukcy:"є",Kappa:"Κ",kappa:"κ",kappav:"ϰ",Kcedil:"Ķ",kcedil:"ķ",Kcy:"К",kcy:"к",Kfr:"𝔎",kfr:"𝔨",kgreen:"ĸ",KHcy:"Х",khcy:"х",KJcy:"Ќ",kjcy:"ќ",Kopf:"𝕂",kopf:"𝕜",Kscr:"𝒦",kscr:"𝓀",lAarr:"⇚",Lacute:"Ĺ",lacute:"ĺ",laemptyv:"⦴",lagran:"ℒ",Lambda:"Λ",lambda:"λ",lang:"⟨",Lang:"⟪",langd:"⦑",langle:"⟨",lap:"⪅",Laplacetrf:"ℒ",laquo:"«",larrb:"⇤",larrbfs:"⤟",larr:"←",Larr:"↞",lArr:"⇐",larrfs:"⤝",larrhk:"↩",larrlp:"↫",larrpl:"⤹",larrsim:"⥳",larrtl:"↢",latail:"⤙",lAtail:"⤛",lat:"⪫",late:"⪭",lates:"⪭︀",lbarr:"⤌",lBarr:"⤎",lbbrk:"❲",lbrace:"{",lbrack:"[",lbrke:"⦋",lbrksld:"⦏",lbrkslu:"⦍",Lcaron:"Ľ",lcaron:"ľ",Lcedil:"Ļ",lcedil:"ļ",lceil:"⌈",lcub:"{",Lcy:"Л",lcy:"л",ldca:"⤶",ldquo:"“",ldquor:"„",ldrdhar:"⥧",ldrushar:"⥋",ldsh:"↲",le:"≤",lE:"≦",LeftAngleBracket:"⟨",LeftArrowBar:"⇤",leftarrow:"←",LeftArrow:"←",Leftarrow:"⇐",LeftArrowRightArrow:"⇆",leftarrowtail:"↢",LeftCeiling:"⌈",LeftDoubleBracket:"⟦",LeftDownTeeVector:"⥡",LeftDownVectorBar:"⥙",LeftDownVector:"⇃",LeftFloor:"⌊",leftharpoondown:"↽",leftharpoonup:"↼",leftleftarrows:"⇇",leftrightarrow:"↔",LeftRightArrow:"↔",Leftrightarrow:"⇔",leftrightarrows:"⇆",leftrightharpoons:"⇋",leftrightsquigarrow:"↭",LeftRightVector:"⥎",LeftTeeArrow:"↤",LeftTee:"⊣",LeftTeeVector:"⥚",leftthreetimes:"⋋",LeftTriangleBar:"⧏",LeftTriangle:"⊲",LeftTriangleEqual:"⊴",LeftUpDownVector:"⥑",LeftUpTeeVector:"⥠",LeftUpVectorBar:"⥘",LeftUpVector:"↿",LeftVectorBar:"⥒",LeftVector:"↼",lEg:"⪋",leg:"⋚",leq:"≤",leqq:"≦",leqslant:"⩽",lescc:"⪨",les:"⩽",lesdot:"⩿",lesdoto:"⪁",lesdotor:"⪃",lesg:"⋚︀",lesges:"⪓",lessapprox:"⪅",lessdot:"⋖",lesseqgtr:"⋚",lesseqqgtr:"⪋",LessEqualGreater:"⋚",LessFullEqual:"≦",LessGreater:"≶",lessgtr:"≶",LessLess:"⪡",lesssim:"≲",LessSlantEqual:"⩽",LessTilde:"≲",lfisht:"⥼",lfloor:"⌊",Lfr:"𝔏",lfr:"𝔩",lg:"≶",lgE:"⪑",lHar:"⥢",lhard:"↽",lharu:"↼",lharul:"⥪",lhblk:"▄",LJcy:"Љ",ljcy:"љ",llarr:"⇇",ll:"≪",Ll:"⋘",llcorner:"⌞",Lleftarrow:"⇚",llhard:"⥫",lltri:"◺",Lmidot:"Ŀ",lmidot:"ŀ",lmoustache:"⎰",lmoust:"⎰",lnap:"⪉",lnapprox:"⪉",lne:"⪇",lnE:"≨",lneq:"⪇",lneqq:"≨",lnsim:"⋦",loang:"⟬",loarr:"⇽",lobrk:"⟦",longleftarrow:"⟵",LongLeftArrow:"⟵",Longleftarrow:"⟸",longleftrightarrow:"⟷",LongLeftRightArrow:"⟷",Longleftrightarrow:"⟺",longmapsto:"⟼",longrightarrow:"⟶",LongRightArrow:"⟶",Longrightarrow:"⟹",looparrowleft:"↫",looparrowright:"↬",lopar:"⦅",Lopf:"𝕃",lopf:"𝕝",loplus:"⨭",lotimes:"⨴",lowast:"∗",lowbar:"_",LowerLeftArrow:"↙",LowerRightArrow:"↘",loz:"◊",lozenge:"◊",lozf:"⧫",lpar:"(",lparlt:"⦓",lrarr:"⇆",lrcorner:"⌟",lrhar:"⇋",lrhard:"⥭",lrm:"‎",lrtri:"⊿",lsaquo:"‹",lscr:"𝓁",Lscr:"ℒ",lsh:"↰",Lsh:"↰",lsim:"≲",lsime:"⪍",lsimg:"⪏",lsqb:"[",lsquo:"‘",lsquor:"‚",Lstrok:"Ł",lstrok:"ł",ltcc:"⪦",ltcir:"⩹",lt:"<",LT:"<",Lt:"≪",ltdot:"⋖",lthree:"⋋",ltimes:"⋉",ltlarr:"⥶",ltquest:"⩻",ltri:"◃",ltrie:"⊴",ltrif:"◂",ltrPar:"⦖",lurdshar:"⥊",luruhar:"⥦",lvertneqq:"≨︀",lvnE:"≨︀",macr:"¯",male:"♂",malt:"✠",maltese:"✠",Map:"⤅",map:"↦",mapsto:"↦",mapstodown:"↧",mapstoleft:"↤",mapstoup:"↥",marker:"▮",mcomma:"⨩",Mcy:"М",mcy:"м",mdash:"—",mDDot:"∺",measuredangle:"∡",MediumSpace:" ",Mellintrf:"ℳ",Mfr:"𝔐",mfr:"𝔪",mho:"℧",micro:"µ",midast:"*",midcir:"⫰",mid:"∣",middot:"·",minusb:"⊟",minus:"−",minusd:"∸",minusdu:"⨪",MinusPlus:"∓",mlcp:"⫛",mldr:"…",mnplus:"∓",models:"⊧",Mopf:"𝕄",mopf:"𝕞",mp:"∓",mscr:"𝓂",Mscr:"ℳ",mstpos:"∾",Mu:"Μ",mu:"μ",multimap:"⊸",mumap:"⊸",nabla:"∇",Nacute:"Ń",nacute:"ń",nang:"∠⃒",nap:"≉",napE:"⩰̸",napid:"≋̸",napos:"ʼn",napprox:"≉",natural:"♮",naturals:"ℕ",natur:"♮",nbsp:" ",nbump:"≎̸",nbumpe:"≏̸",ncap:"⩃",Ncaron:"Ň",ncaron:"ň",Ncedil:"Ņ",ncedil:"ņ",ncong:"≇",ncongdot:"⩭̸",ncup:"⩂",Ncy:"Н",ncy:"н",ndash:"–",nearhk:"⤤",nearr:"↗",neArr:"⇗",nearrow:"↗",ne:"≠",nedot:"≐̸",NegativeMediumSpace:"​",NegativeThickSpace:"​",NegativeThinSpace:"​",NegativeVeryThinSpace:"​",nequiv:"≢",nesear:"⤨",nesim:"≂̸",NestedGreaterGreater:"≫",NestedLessLess:"≪",NewLine:"\n",nexist:"∄",nexists:"∄",Nfr:"𝔑",nfr:"𝔫",ngE:"≧̸",nge:"≱",ngeq:"≱",ngeqq:"≧̸",ngeqslant:"⩾̸",nges:"⩾̸",nGg:"⋙̸",ngsim:"≵",nGt:"≫⃒",ngt:"≯",ngtr:"≯",nGtv:"≫̸",nharr:"↮",nhArr:"⇎",nhpar:"⫲",ni:"∋",nis:"⋼",nisd:"⋺",niv:"∋",NJcy:"Њ",njcy:"њ",nlarr:"↚",nlArr:"⇍",nldr:"‥",nlE:"≦̸",nle:"≰",nleftarrow:"↚",nLeftarrow:"⇍",nleftrightarrow:"↮",nLeftrightarrow:"⇎",nleq:"≰",nleqq:"≦̸",nleqslant:"⩽̸",nles:"⩽̸",nless:"≮",nLl:"⋘̸",nlsim:"≴",nLt:"≪⃒",nlt:"≮",nltri:"⋪",nltrie:"⋬",nLtv:"≪̸",nmid:"∤",NoBreak:"⁠",NonBreakingSpace:" ",nopf:"𝕟",Nopf:"ℕ",Not:"⫬",not:"¬",NotCongruent:"≢",NotCupCap:"≭",NotDoubleVerticalBar:"∦",NotElement:"∉",NotEqual:"≠",NotEqualTilde:"≂̸",NotExists:"∄",NotGreater:"≯",NotGreaterEqual:"≱",NotGreaterFullEqual:"≧̸",NotGreaterGreater:"≫̸",NotGreaterLess:"≹",NotGreaterSlantEqual:"⩾̸",NotGreaterTilde:"≵",NotHumpDownHump:"≎̸",NotHumpEqual:"≏̸",notin:"∉",notindot:"⋵̸",notinE:"⋹̸",notinva:"∉",notinvb:"⋷",notinvc:"⋶",NotLeftTriangleBar:"⧏̸",NotLeftTriangle:"⋪",NotLeftTriangleEqual:"⋬",NotLess:"≮",NotLessEqual:"≰",NotLessGreater:"≸",NotLessLess:"≪̸",NotLessSlantEqual:"⩽̸",NotLessTilde:"≴",NotNestedGreaterGreater:"⪢̸",NotNestedLessLess:"⪡̸",notni:"∌",notniva:"∌",notnivb:"⋾",notnivc:"⋽",NotPrecedes:"⊀",NotPrecedesEqual:"⪯̸",NotPrecedesSlantEqual:"⋠",NotReverseElement:"∌",NotRightTriangleBar:"⧐̸",NotRightTriangle:"⋫",NotRightTriangleEqual:"⋭",NotSquareSubset:"⊏̸",NotSquareSubsetEqual:"⋢",NotSquareSuperset:"⊐̸",NotSquareSupersetEqual:"⋣",NotSubset:"⊂⃒",NotSubsetEqual:"⊈",NotSucceeds:"⊁",NotSucceedsEqual:"⪰̸",NotSucceedsSlantEqual:"⋡",NotSucceedsTilde:"≿̸",NotSuperset:"⊃⃒",NotSupersetEqual:"⊉",NotTilde:"≁",NotTildeEqual:"≄",NotTildeFullEqual:"≇",NotTildeTilde:"≉",NotVerticalBar:"∤",nparallel:"∦",npar:"∦",nparsl:"⫽⃥",npart:"∂̸",npolint:"⨔",npr:"⊀",nprcue:"⋠",nprec:"⊀",npreceq:"⪯̸",npre:"⪯̸",nrarrc:"⤳̸",nrarr:"↛",nrArr:"⇏",nrarrw:"↝̸",nrightarrow:"↛",nRightarrow:"⇏",nrtri:"⋫",nrtrie:"⋭",nsc:"⊁",nsccue:"⋡",nsce:"⪰̸",Nscr:"𝒩",nscr:"𝓃",nshortmid:"∤",nshortparallel:"∦",nsim:"≁",nsime:"≄",nsimeq:"≄",nsmid:"∤",nspar:"∦",nsqsube:"⋢",nsqsupe:"⋣",nsub:"⊄",nsubE:"⫅̸",nsube:"⊈",nsubset:"⊂⃒",nsubseteq:"⊈",nsubseteqq:"⫅̸",nsucc:"⊁",nsucceq:"⪰̸",nsup:"⊅",nsupE:"⫆̸",nsupe:"⊉",nsupset:"⊃⃒",nsupseteq:"⊉",nsupseteqq:"⫆̸",ntgl:"≹",Ntilde:"Ñ",ntilde:"ñ",ntlg:"≸",ntriangleleft:"⋪",ntrianglelefteq:"⋬",ntriangleright:"⋫",ntrianglerighteq:"⋭",Nu:"Ν",nu:"ν",num:"#",numero:"№",numsp:" ",nvap:"≍⃒",nvdash:"⊬",nvDash:"⊭",nVdash:"⊮",nVDash:"⊯",nvge:"≥⃒",nvgt:">⃒",nvHarr:"⤄",nvinfin:"⧞",nvlArr:"⤂",nvle:"≤⃒",nvlt:"<⃒",nvltrie:"⊴⃒",nvrArr:"⤃",nvrtrie:"⊵⃒",nvsim:"∼⃒",nwarhk:"⤣",nwarr:"↖",nwArr:"⇖",nwarrow:"↖",nwnear:"⤧",Oacute:"Ó",oacute:"ó",oast:"⊛",Ocirc:"Ô",ocirc:"ô",ocir:"⊚",Ocy:"О",ocy:"о",odash:"⊝",Odblac:"Ő",odblac:"ő",odiv:"⨸",odot:"⊙",odsold:"⦼",OElig:"Œ",oelig:"œ",ofcir:"⦿",Ofr:"𝔒",ofr:"𝔬",ogon:"˛",Ograve:"Ò",ograve:"ò",ogt:"⧁",ohbar:"⦵",ohm:"Ω",oint:"∮",olarr:"↺",olcir:"⦾",olcross:"⦻",oline:"‾",olt:"⧀",Omacr:"Ō",omacr:"ō",Omega:"Ω",omega:"ω",Omicron:"Ο",omicron:"ο",omid:"⦶",ominus:"⊖",Oopf:"𝕆",oopf:"𝕠",opar:"⦷",OpenCurlyDoubleQuote:"“",OpenCurlyQuote:"‘",operp:"⦹",oplus:"⊕",orarr:"↻",Or:"⩔",or:"∨",ord:"⩝",order:"ℴ",orderof:"ℴ",ordf:"ª",ordm:"º",origof:"⊶",oror:"⩖",orslope:"⩗",orv:"⩛",oS:"Ⓢ",Oscr:"𝒪",oscr:"ℴ",Oslash:"Ø",oslash:"ø",osol:"⊘",Otilde:"Õ",otilde:"õ",otimesas:"⨶",Otimes:"⨷",otimes:"⊗",Ouml:"Ö",ouml:"ö",ovbar:"⌽",OverBar:"‾",OverBrace:"⏞",OverBracket:"⎴",OverParenthesis:"⏜",para:"¶",parallel:"∥",par:"∥",parsim:"⫳",parsl:"⫽",part:"∂",PartialD:"∂",Pcy:"П",pcy:"п",percnt:"%",period:".",permil:"‰",perp:"⊥",pertenk:"‱",Pfr:"𝔓",pfr:"𝔭",Phi:"Φ",phi:"φ",phiv:"ϕ",phmmat:"ℳ",phone:"☎",Pi:"Π",pi:"π",pitchfork:"⋔",piv:"ϖ",planck:"ℏ",planckh:"ℎ",plankv:"ℏ",plusacir:"⨣",plusb:"⊞",pluscir:"⨢",plus:"+",plusdo:"∔",plusdu:"⨥",pluse:"⩲",PlusMinus:"±",plusmn:"±",plussim:"⨦",plustwo:"⨧",pm:"±",Poincareplane:"ℌ",pointint:"⨕",popf:"𝕡",Popf:"ℙ",pound:"£",prap:"⪷",Pr:"⪻",pr:"≺",prcue:"≼",precapprox:"⪷",prec:"≺",preccurlyeq:"≼",Precedes:"≺",PrecedesEqual:"⪯",PrecedesSlantEqual:"≼",PrecedesTilde:"≾",preceq:"⪯",precnapprox:"⪹",precneqq:"⪵",precnsim:"⋨",pre:"⪯",prE:"⪳",precsim:"≾",prime:"′",Prime:"″",primes:"ℙ",prnap:"⪹",prnE:"⪵",prnsim:"⋨",prod:"∏",Product:"∏",profalar:"⌮",profline:"⌒",profsurf:"⌓",prop:"∝",Proportional:"∝",Proportion:"∷",propto:"∝",prsim:"≾",prurel:"⊰",Pscr:"𝒫",pscr:"𝓅",Psi:"Ψ",psi:"ψ",puncsp:" ",Qfr:"𝔔",qfr:"𝔮",qint:"⨌",qopf:"𝕢",Qopf:"ℚ",qprime:"⁗",Qscr:"𝒬",qscr:"𝓆",quaternions:"ℍ",quatint:"⨖",quest:"?",questeq:"≟",quot:'"',QUOT:'"',rAarr:"⇛",race:"∽̱",Racute:"Ŕ",racute:"ŕ",radic:"√",raemptyv:"⦳",rang:"⟩",Rang:"⟫",rangd:"⦒",range:"⦥",rangle:"⟩",raquo:"»",rarrap:"⥵",rarrb:"⇥",rarrbfs:"⤠",rarrc:"⤳",rarr:"→",Rarr:"↠",rArr:"⇒",rarrfs:"⤞",rarrhk:"↪",rarrlp:"↬",rarrpl:"⥅",rarrsim:"⥴",Rarrtl:"⤖",rarrtl:"↣",rarrw:"↝",ratail:"⤚",rAtail:"⤜",ratio:"∶",rationals:"ℚ",rbarr:"⤍",rBarr:"⤏",RBarr:"⤐",rbbrk:"❳",rbrace:"}",rbrack:"]",rbrke:"⦌",rbrksld:"⦎",rbrkslu:"⦐",Rcaron:"Ř",rcaron:"ř",Rcedil:"Ŗ",rcedil:"ŗ",rceil:"⌉",rcub:"}",Rcy:"Р",rcy:"р",rdca:"⤷",rdldhar:"⥩",rdquo:"”",rdquor:"”",rdsh:"↳",real:"ℜ",realine:"ℛ",realpart:"ℜ",reals:"ℝ",Re:"ℜ",rect:"▭",reg:"®",REG:"®",ReverseElement:"∋",ReverseEquilibrium:"⇋",ReverseUpEquilibrium:"⥯",rfisht:"⥽",rfloor:"⌋",rfr:"𝔯",Rfr:"ℜ",rHar:"⥤",rhard:"⇁",rharu:"⇀",rharul:"⥬",Rho:"Ρ",rho:"ρ",rhov:"ϱ",RightAngleBracket:"⟩",RightArrowBar:"⇥",rightarrow:"→",RightArrow:"→",Rightarrow:"⇒",RightArrowLeftArrow:"⇄",rightarrowtail:"↣",RightCeiling:"⌉",RightDoubleBracket:"⟧",RightDownTeeVector:"⥝",RightDownVectorBar:"⥕",RightDownVector:"⇂",RightFloor:"⌋",rightharpoondown:"⇁",rightharpoonup:"⇀",rightleftarrows:"⇄",rightleftharpoons:"⇌",rightrightarrows:"⇉",rightsquigarrow:"↝",RightTeeArrow:"↦",RightTee:"⊢",RightTeeVector:"⥛",rightthreetimes:"⋌",RightTriangleBar:"⧐",RightTriangle:"⊳",RightTriangleEqual:"⊵",RightUpDownVector:"⥏",RightUpTeeVector:"⥜",RightUpVectorBar:"⥔",RightUpVector:"↾",RightVectorBar:"⥓",RightVector:"⇀",ring:"˚",risingdotseq:"≓",rlarr:"⇄",rlhar:"⇌",rlm:"‏",rmoustache:"⎱",rmoust:"⎱",rnmid:"⫮",roang:"⟭",roarr:"⇾",robrk:"⟧",ropar:"⦆",ropf:"𝕣",Ropf:"ℝ",roplus:"⨮",rotimes:"⨵",RoundImplies:"⥰",rpar:")",rpargt:"⦔",rppolint:"⨒",rrarr:"⇉",Rrightarrow:"⇛",rsaquo:"›",rscr:"𝓇",Rscr:"ℛ",rsh:"↱",Rsh:"↱",rsqb:"]",rsquo:"’",rsquor:"’",rthree:"⋌",rtimes:"⋊",rtri:"▹",rtrie:"⊵",rtrif:"▸",rtriltri:"⧎",RuleDelayed:"⧴",ruluhar:"⥨",rx:"℞",Sacute:"Ś",sacute:"ś",sbquo:"‚",scap:"⪸",Scaron:"Š",scaron:"š",Sc:"⪼",sc:"≻",sccue:"≽",sce:"⪰",scE:"⪴",Scedil:"Ş",scedil:"ş",Scirc:"Ŝ",scirc:"ŝ",scnap:"⪺",scnE:"⪶",scnsim:"⋩",scpolint:"⨓",scsim:"≿",Scy:"С",scy:"с",sdotb:"⊡",sdot:"⋅",sdote:"⩦",searhk:"⤥",searr:"↘",seArr:"⇘",searrow:"↘",sect:"§",semi:";",seswar:"⤩",setminus:"∖",setmn:"∖",sext:"✶",Sfr:"𝔖",sfr:"𝔰",sfrown:"⌢",sharp:"♯",SHCHcy:"Щ",shchcy:"щ",SHcy:"Ш",shcy:"ш",ShortDownArrow:"↓",ShortLeftArrow:"←",shortmid:"∣",shortparallel:"∥",ShortRightArrow:"→",ShortUpArrow:"↑",shy:"­",Sigma:"Σ",sigma:"σ",sigmaf:"ς",sigmav:"ς",sim:"∼",simdot:"⩪",sime:"≃",simeq:"≃",simg:"⪞",simgE:"⪠",siml:"⪝",simlE:"⪟",simne:"≆",simplus:"⨤",simrarr:"⥲",slarr:"←",SmallCircle:"∘",smallsetminus:"∖",smashp:"⨳",smeparsl:"⧤",smid:"∣",smile:"⌣",smt:"⪪",smte:"⪬",smtes:"⪬︀",SOFTcy:"Ь",softcy:"ь",solbar:"⌿",solb:"⧄",sol:"/",Sopf:"𝕊",sopf:"𝕤",spades:"♠",spadesuit:"♠",spar:"∥",sqcap:"⊓",sqcaps:"⊓︀",sqcup:"⊔",sqcups:"⊔︀",Sqrt:"√",sqsub:"⊏",sqsube:"⊑",sqsubset:"⊏",sqsubseteq:"⊑",sqsup:"⊐",sqsupe:"⊒",sqsupset:"⊐",sqsupseteq:"⊒",square:"□",Square:"□",SquareIntersection:"⊓",SquareSubset:"⊏",SquareSubsetEqual:"⊑",SquareSuperset:"⊐",SquareSupersetEqual:"⊒",SquareUnion:"⊔",squarf:"▪",squ:"□",squf:"▪",srarr:"→",Sscr:"𝒮",sscr:"𝓈",ssetmn:"∖",ssmile:"⌣",sstarf:"⋆",Star:"⋆",star:"☆",starf:"★",straightepsilon:"ϵ",straightphi:"ϕ",strns:"¯",sub:"⊂",Sub:"⋐",subdot:"⪽",subE:"⫅",sube:"⊆",subedot:"⫃",submult:"⫁",subnE:"⫋",subne:"⊊",subplus:"⪿",subrarr:"⥹",subset:"⊂",Subset:"⋐",subseteq:"⊆",subseteqq:"⫅",SubsetEqual:"⊆",subsetneq:"⊊",subsetneqq:"⫋",subsim:"⫇",subsub:"⫕",subsup:"⫓",succapprox:"⪸",succ:"≻",succcurlyeq:"≽",Succeeds:"≻",SucceedsEqual:"⪰",SucceedsSlantEqual:"≽",SucceedsTilde:"≿",succeq:"⪰",succnapprox:"⪺",succneqq:"⪶",succnsim:"⋩",succsim:"≿",SuchThat:"∋",sum:"∑",Sum:"∑",sung:"♪",sup1:"¹",sup2:"²",sup3:"³",sup:"⊃",Sup:"⋑",supdot:"⪾",supdsub:"⫘",supE:"⫆",supe:"⊇",supedot:"⫄",Superset:"⊃",SupersetEqual:"⊇",suphsol:"⟉",suphsub:"⫗",suplarr:"⥻",supmult:"⫂",supnE:"⫌",supne:"⊋",supplus:"⫀",supset:"⊃",Supset:"⋑",supseteq:"⊇",supseteqq:"⫆",supsetneq:"⊋",supsetneqq:"⫌",supsim:"⫈",supsub:"⫔",supsup:"⫖",swarhk:"⤦",swarr:"↙",swArr:"⇙",swarrow:"↙",swnwar:"⤪",szlig:"ß",Tab:"\t",target:"⌖",Tau:"Τ",tau:"τ",tbrk:"⎴",Tcaron:"Ť",tcaron:"ť",Tcedil:"Ţ",tcedil:"ţ",Tcy:"Т",tcy:"т",tdot:"⃛",telrec:"⌕",Tfr:"𝔗",tfr:"𝔱",there4:"∴",therefore:"∴",Therefore:"∴",Theta:"Θ",theta:"θ",thetasym:"ϑ",thetav:"ϑ",thickapprox:"≈",thicksim:"∼",ThickSpace:"  ",ThinSpace:" ",thinsp:" ",thkap:"≈",thksim:"∼",THORN:"Þ",thorn:"þ",tilde:"˜",Tilde:"∼",TildeEqual:"≃",TildeFullEqual:"≅",TildeTilde:"≈",timesbar:"⨱",timesb:"⊠",times:"×",timesd:"⨰",tint:"∭",toea:"⤨",topbot:"⌶",topcir:"⫱",top:"⊤",Topf:"𝕋",topf:"𝕥",topfork:"⫚",tosa:"⤩",tprime:"‴",trade:"™",TRADE:"™",triangle:"▵",triangledown:"▿",triangleleft:"◃",trianglelefteq:"⊴",triangleq:"≜",triangleright:"▹",trianglerighteq:"⊵",tridot:"◬",trie:"≜",triminus:"⨺",TripleDot:"⃛",triplus:"⨹",trisb:"⧍",tritime:"⨻",trpezium:"⏢",Tscr:"𝒯",tscr:"𝓉",TScy:"Ц",tscy:"ц",TSHcy:"Ћ",tshcy:"ћ",Tstrok:"Ŧ",tstrok:"ŧ",twixt:"≬",twoheadleftarrow:"↞",twoheadrightarrow:"↠",Uacute:"Ú",uacute:"ú",uarr:"↑",Uarr:"↟",uArr:"⇑",Uarrocir:"⥉",Ubrcy:"Ў",ubrcy:"ў",Ubreve:"Ŭ",ubreve:"ŭ",Ucirc:"Û",ucirc:"û",Ucy:"У",ucy:"у",udarr:"⇅",Udblac:"Ű",udblac:"ű",udhar:"⥮",ufisht:"⥾",Ufr:"𝔘",ufr:"𝔲",Ugrave:"Ù",ugrave:"ù",uHar:"⥣",uharl:"↿",uharr:"↾",uhblk:"▀",ulcorn:"⌜",ulcorner:"⌜",ulcrop:"⌏",ultri:"◸",Umacr:"Ū",umacr:"ū",uml:"¨",UnderBar:"_",UnderBrace:"⏟",UnderBracket:"⎵",UnderParenthesis:"⏝",Union:"⋃",UnionPlus:"⊎",Uogon:"Ų",uogon:"ų",Uopf:"𝕌",uopf:"𝕦",UpArrowBar:"⤒",uparrow:"↑",UpArrow:"↑",Uparrow:"⇑",UpArrowDownArrow:"⇅",updownarrow:"↕",UpDownArrow:"↕",Updownarrow:"⇕",UpEquilibrium:"⥮",upharpoonleft:"↿",upharpoonright:"↾",uplus:"⊎",UpperLeftArrow:"↖",UpperRightArrow:"↗",upsi:"υ",Upsi:"ϒ",upsih:"ϒ",Upsilon:"Υ",upsilon:"υ",UpTeeArrow:"↥",UpTee:"⊥",upuparrows:"⇈",urcorn:"⌝",urcorner:"⌝",urcrop:"⌎",Uring:"Ů",uring:"ů",urtri:"◹",Uscr:"𝒰",uscr:"𝓊",utdot:"⋰",Utilde:"Ũ",utilde:"ũ",utri:"▵",utrif:"▴",uuarr:"⇈",Uuml:"Ü",uuml:"ü",uwangle:"⦧",vangrt:"⦜",varepsilon:"ϵ",varkappa:"ϰ",varnothing:"∅",varphi:"ϕ",varpi:"ϖ",varpropto:"∝",varr:"↕",vArr:"⇕",varrho:"ϱ",varsigma:"ς",varsubsetneq:"⊊︀",varsubsetneqq:"⫋︀",varsupsetneq:"⊋︀",varsupsetneqq:"⫌︀",vartheta:"ϑ",vartriangleleft:"⊲",vartriangleright:"⊳",vBar:"⫨",Vbar:"⫫",vBarv:"⫩",Vcy:"В",vcy:"в",vdash:"⊢",vDash:"⊨",Vdash:"⊩",VDash:"⊫",Vdashl:"⫦",veebar:"⊻",vee:"∨",Vee:"⋁",veeeq:"≚",vellip:"⋮",verbar:"|",Verbar:"‖",vert:"|",Vert:"‖",VerticalBar:"∣",VerticalLine:"|",VerticalSeparator:"❘",VerticalTilde:"≀",VeryThinSpace:" ",Vfr:"𝔙",vfr:"𝔳",vltri:"⊲",vnsub:"⊂⃒",vnsup:"⊃⃒",Vopf:"𝕍",vopf:"𝕧",vprop:"∝",vrtri:"⊳",Vscr:"𝒱",vscr:"𝓋",vsubnE:"⫋︀",vsubne:"⊊︀",vsupnE:"⫌︀",vsupne:"⊋︀",Vvdash:"⊪",vzigzag:"⦚",Wcirc:"Ŵ",wcirc:"ŵ",wedbar:"⩟",wedge:"∧",Wedge:"⋀",wedgeq:"≙",weierp:"℘",Wfr:"𝔚",wfr:"𝔴",Wopf:"𝕎",wopf:"𝕨",wp:"℘",wr:"≀",wreath:"≀",Wscr:"𝒲",wscr:"𝓌",xcap:"⋂",xcirc:"◯",xcup:"⋃",xdtri:"▽",Xfr:"𝔛",xfr:"𝔵",xharr:"⟷",xhArr:"⟺",Xi:"Ξ",xi:"ξ",xlarr:"⟵",xlArr:"⟸",xmap:"⟼",xnis:"⋻",xodot:"⨀",Xopf:"𝕏",xopf:"𝕩",xoplus:"⨁",xotime:"⨂",xrarr:"⟶",xrArr:"⟹",Xscr:"𝒳",xscr:"𝓍",xsqcup:"⨆",xuplus:"⨄",xutri:"△",xvee:"⋁",xwedge:"⋀",Yacute:"Ý",yacute:"ý",YAcy:"Я",yacy:"я",Ycirc:"Ŷ",ycirc:"ŷ",Ycy:"Ы",ycy:"ы",yen:"¥",Yfr:"𝔜",yfr:"𝔶",YIcy:"Ї",yicy:"ї",Yopf:"𝕐",yopf:"𝕪",Yscr:"𝒴",yscr:"𝓎",YUcy:"Ю",yucy:"ю",yuml:"ÿ",Yuml:"Ÿ",Zacute:"Ź",zacute:"ź",Zcaron:"Ž",zcaron:"ž",Zcy:"З",zcy:"з",Zdot:"Ż",zdot:"ż",zeetrf:"ℨ",ZeroWidthSpace:"​",Zeta:"Ζ",zeta:"ζ",zfr:"𝔷",Zfr:"ℨ",ZHcy:"Ж",zhcy:"ж",zigrarr:"⇝",zopf:"𝕫",Zopf:"ℤ",Zscr:"𝒵",zscr:"𝓏",zwj:"‍",zwnj:"‌"},Yc={Aacute:"Á",aacute:"á",Acirc:"Â",acirc:"â",acute:"´",AElig:"Æ",aelig:"æ",Agrave:"À",agrave:"à",amp:"&",AMP:"&",Aring:"Å",aring:"å",Atilde:"Ã",atilde:"ã",Auml:"Ä",auml:"ä",brvbar:"¦",Ccedil:"Ç",ccedil:"ç",cedil:"¸",cent:"¢",copy:"©",COPY:"©",curren:"¤",deg:"°",divide:"÷",Eacute:"É",eacute:"é",Ecirc:"Ê",ecirc:"ê",Egrave:"È",egrave:"è",ETH:"Ð",eth:"ð",Euml:"Ë",euml:"ë",frac12:"½",frac14:"¼",frac34:"¾",gt:">",GT:">",Iacute:"Í",iacute:"í",Icirc:"Î",icirc:"î",iexcl:"¡",Igrave:"Ì",igrave:"ì",iquest:"¿",Iuml:"Ï",iuml:"ï",laquo:"«",lt:"<",LT:"<",macr:"¯",micro:"µ",middot:"·",nbsp:" ",not:"¬",Ntilde:"Ñ",ntilde:"ñ",Oacute:"Ó",oacute:"ó",Ocirc:"Ô",ocirc:"ô",Ograve:"Ò",ograve:"ò",ordf:"ª",ordm:"º",Oslash:"Ø",oslash:"ø",Otilde:"Õ",otilde:"õ",Ouml:"Ö",ouml:"ö",para:"¶",plusmn:"±",pound:"£",quot:'"',QUOT:'"',raquo:"»",reg:"®",REG:"®",sect:"§",shy:"­",sup1:"¹",sup2:"²",sup3:"³",szlig:"ß",THORN:"Þ",thorn:"þ",times:"×",Uacute:"Ú",uacute:"ú",Ucirc:"Û",ucirc:"û",Ugrave:"Ù",ugrave:"ù",uml:"¨",Uuml:"Ü",uuml:"ü",Yacute:"Ý",yacute:"ý",yen:"¥",yuml:"ÿ"},eu={amp:"&",apos:"'",gt:">",lt:"<",quot:'"'},tu={},nu=Wc&&Wc.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(tu,"__esModule",{value:!0});var ru=nu({0:65533,128:8364,130:8218,131:402,132:8222,133:8230,134:8224,135:8225,136:710,137:8240,138:352,139:8249,140:338,142:381,145:8216,146:8217,147:8220,148:8221,149:8226,150:8211,151:8212,152:732,153:8482,154:353,155:8250,156:339,158:382,159:376}),ou=String.fromCodePoint||function(e){var t="";return e>65535&&(e-=65536,t+=String.fromCharCode(e>>>10&1023|55296),e=56320|1023&e),t+=String.fromCharCode(e)};tu.default=function(e){return e>=55296&&e<=57343||e>1114111?"�":(e in ru.default&&(e=ru.default[e]),ou(e))};var iu=Wc&&Wc.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(Xc,"__esModule",{value:!0}),Xc.decodeHTML=Xc.decodeHTMLStrict=Xc.decodeXML=void 0;var su=iu(Qc),au=iu(Yc),lu=iu(eu),cu=iu(tu),uu=/&(?:[a-zA-Z0-9]+|#[xX][\da-fA-F]+|#\d+);/g;function du(e){var t=hu(e);return function(e){return String(e).replace(uu,t)}}Xc.decodeXML=du(lu.default),Xc.decodeHTMLStrict=du(su.default);var pu=function(e,t){return e<t?1:-1};function hu(e){return function(t){if("#"===t.charAt(1)){var n=t.charAt(2);return"X"===n||"x"===n?cu.default(parseInt(t.substr(3),16)):cu.default(parseInt(t.substr(2),10))}return e[t.slice(1,-1)]||t}}Xc.decodeHTML=function(){for(var e=Object.keys(au.default).sort(pu),t=Object.keys(su.default).sort(pu),n=0,r=0;n<t.length;n++)e[r]===t[n]?(t[n]+=";?",r++):t[n]+=";";var o=new RegExp("&(?:"+t.join("|")+"|#[xX][\\da-fA-F]+;?|#\\d+;?)","g"),i=hu(su.default);function s(e){return";"!==e.substr(-1)&&(e+=";"),i(e)}return function(e){return String(e).replace(o,s)}}();var fu={},mu=Wc&&Wc.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(fu,"__esModule",{value:!0}),fu.escapeUTF8=fu.escape=fu.encodeNonAsciiHTML=fu.encodeHTML=fu.encodeXML=void 0;var gu=xu(mu(eu).default),vu=Cu(gu);fu.encodeXML=Nu(gu);var yu,bu,wu=xu(mu(Qc).default),ku=Cu(wu);function xu(e){return Object.keys(e).sort().reduce((function(t,n){return t[e[n]]="&"+n+";",t}),{})}function Cu(e){for(var t=[],n=[],r=0,o=Object.keys(e);r<o.length;r++){var i=o[r];1===i.length?t.push("\\"+i):n.push(i)}t.sort();for(var s=0;s<t.length-1;s++){for(var a=s;a<t.length-1&&t[a].charCodeAt(1)+1===t[a+1].charCodeAt(1);)a+=1;var l=1+a-s;l<3||t.splice(s,l,t[s]+"-"+t[a])}return n.unshift("["+t.join("")+"]"),new RegExp(n.join("|"),"g")}fu.encodeHTML=(yu=wu,bu=ku,function(e){return e.replace(bu,(function(e){return yu[e]})).replace(Tu,Su)}),fu.encodeNonAsciiHTML=Nu(wu);var Tu=/(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g,Mu=null!=String.prototype.codePointAt?function(e){return e.codePointAt(0)}:function(e){return 1024*(e.charCodeAt(0)-55296)+e.charCodeAt(1)-56320+65536};function Su(e){return"&#x"+(e.length>1?Mu(e):e.charCodeAt(0)).toString(16).toUpperCase()+";"}var Eu=new RegExp(vu.source+"|"+Tu.source,"g");function Nu(e){return function(t){return t.replace(Eu,(function(t){return e[t]||Su(t)}))}}fu.escape=function(e){return e.replace(Eu,Su)},fu.escapeUTF8=function(e){return e.replace(vu,Su)},function(e){Object.defineProperty(e,"__esModule",{value:!0}),e.decodeXMLStrict=e.decodeHTML5Strict=e.decodeHTML4Strict=e.decodeHTML5=e.decodeHTML4=e.decodeHTMLStrict=e.decodeHTML=e.decodeXML=e.encodeHTML5=e.encodeHTML4=e.escapeUTF8=e.escape=e.encodeNonAsciiHTML=e.encodeHTML=e.encodeXML=e.encode=e.decodeStrict=e.decode=void 0;var t=Xc,n=fu;e.decode=function(e,n){return(!n||n<=0?t.decodeXML:t.decodeHTML)(e)},e.decodeStrict=function(e,n){return(!n||n<=0?t.decodeXML:t.decodeHTMLStrict)(e)},e.encode=function(e,t){return(!t||t<=0?n.encodeXML:n.encodeHTML)(e)};var r=fu;Object.defineProperty(e,"encodeXML",{enumerable:!0,get:function(){return r.encodeXML}}),Object.defineProperty(e,"encodeHTML",{enumerable:!0,get:function(){return r.encodeHTML}}),Object.defineProperty(e,"encodeNonAsciiHTML",{enumerable:!0,get:function(){return r.encodeNonAsciiHTML}}),Object.defineProperty(e,"escape",{enumerable:!0,get:function(){return r.escape}}),Object.defineProperty(e,"escapeUTF8",{enumerable:!0,get:function(){return r.escapeUTF8}}),Object.defineProperty(e,"encodeHTML4",{enumerable:!0,get:function(){return r.encodeHTML}}),Object.defineProperty(e,"encodeHTML5",{enumerable:!0,get:function(){return r.encodeHTML}});var o=Xc;Object.defineProperty(e,"decodeXML",{enumerable:!0,get:function(){return o.decodeXML}}),Object.defineProperty(e,"decodeHTML",{enumerable:!0,get:function(){return o.decodeHTML}}),Object.defineProperty(e,"decodeHTMLStrict",{enumerable:!0,get:function(){return o.decodeHTMLStrict}}),Object.defineProperty(e,"decodeHTML4",{enumerable:!0,get:function(){return o.decodeHTML}}),Object.defineProperty(e,"decodeHTML5",{enumerable:!0,get:function(){return o.decodeHTML}}),Object.defineProperty(e,"decodeHTML4Strict",{enumerable:!0,get:function(){return o.decodeHTMLStrict}}),Object.defineProperty(e,"decodeHTML5Strict",{enumerable:!0,get:function(){return o.decodeHTMLStrict}}),Object.defineProperty(e,"decodeXMLStrict",{enumerable:!0,get:function(){return o.decodeXML}})}(Zc);var Ou="&(?:#x[a-f0-9]{1,6}|#[0-9]{1,7}|[a-z][a-z0-9]{1,31});",Du=/[\\&]/,Au="[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]",Lu=new RegExp("\\\\"+Au+"|"+Ou,"gi"),Iu=new RegExp('[&<>"]',"g"),Ru=function(e){return 92===e.charCodeAt(0)?e.charAt(1):Zc.decodeHTML(e)};function Pu(e){return Du.test(e)?e.replace(Lu,Ru):e}function Bu(e){try{return Kc(e)}catch(t){return e}}function Fu(e){switch(e){case"&":return"&amp;";case"<":return"&lt;";case">":return"&gt;";case'"':return"&quot;";default:return e}}function Hu(e){return Iu.test(e)?e.replace(Iu,Fu):e}function zu(e,t){for(var n=[],r=0;r<t;r++)n.push(e);return n.join("")}function qu(e){return!e||!/[^ \t]+/.test(e)}var Vu=function(){function e(e){this.current=e,this.root=e,this.entering=!0}return e.prototype.next=function(){var e=this.current,t=this.entering;if(null===e)return null;var n=ju(e);return t&&n?e.firstChild?(this.current=e.firstChild,this.entering=!0):this.entering=!1:e===this.root?this.current=null:null===e.next?(this.current=e.parent,this.entering=!1):(this.current=e.next,this.entering=!0),{entering:t,node:e}},e.prototype.resumeAt=function(e,t){this.current=e,this.entering=!0===t},e}();function ju(e){switch(e.type){case"document":case"blockQuote":case"list":case"item":case"paragraph":case"heading":case"emph":case"strong":case"strike":case"link":case"image":case"table":case"tableHead":case"tableBody":case"tableRow":case"tableCell":case"tableDelimRow":case"customInline":return!0;default:return!1}}var $u=1,_u={};function Uu(e){delete _u[e]}var Wu=function(){function e(e,t){this.parent=null,this.prev=null,this.next=null,this.firstChild=null,this.lastChild=null,this.literal=null,this.id="document"===e?-1:$u++,this.type=e,this.sourcepos=t,_u[this.id]=this}return e.prototype.isContainer=function(){return ju(this)},e.prototype.unlink=function(){this.prev?this.prev.next=this.next:this.parent&&(this.parent.firstChild=this.next),this.next?this.next.prev=this.prev:this.parent&&(this.parent.lastChild=this.prev),this.parent=null,this.next=null,this.prev=null},e.prototype.replaceWith=function(e){this.insertBefore(e),this.unlink()},e.prototype.insertAfter=function(e){e.unlink(),e.next=this.next,e.next&&(e.next.prev=e),e.prev=this,this.next=e,this.parent&&(e.parent=this.parent,e.next||(e.parent.lastChild=e))},e.prototype.insertBefore=function(e){e.unlink(),e.prev=this.prev,e.prev&&(e.prev.next=e),e.next=this,this.prev=e,e.parent=this.parent,e.prev||(e.parent.firstChild=e)},e.prototype.appendChild=function(e){e.unlink(),e.parent=this,this.lastChild?(this.lastChild.next=e,e.prev=this.lastChild,this.lastChild=e):(this.firstChild=e,this.lastChild=e)},e.prototype.prependChild=function(e){e.unlink(),e.parent=this,this.firstChild?(this.firstChild.prev=e,e.next=this.firstChild,this.firstChild=e):(this.firstChild=e,this.lastChild=e)},e.prototype.walker=function(){return new Vu(this)},e}(),Ju=function(e){function t(t,n){var r=e.call(this,t,n)||this;return r.open=!0,r.lineOffsets=null,r.stringContent=null,r.lastLineBlank=!1,r.lastLineChecked=!1,r.type=t,r}return $c(t,e),t}(Wu),Gu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.listData=null,t}return $c(t,e),t}(Ju),Ku=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.level=0,t.headingType="atx",t}return $c(t,e),t}(Ju),Zu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.isFenced=!1,t.fenceChar=null,t.fenceLength=0,t.fenceOffset=-1,t.info=null,t.infoPadding=0,t}return $c(t,e),t}(Ju),Xu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.columns=[],t}return $c(t,e),t}(Ju),Qu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.startIdx=0,t.endIdx=0,t.paddingLeft=0,t.paddingRight=0,t.ignored=!1,t}return $c(t,e),t}(Ju),Yu=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.title="",t.dest="",t.label="",t}return $c(t,e),t}(Ju),ed=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.syntaxLength=0,t.offset=-1,t.info="",t}return $c(t,e),t}(Ju),td=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.htmlBlockType=-1,t}return $c(t,e),t}(Ju),nd=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.destination=null,t.title=null,t.extendedAutolink=!1,t}return $c(t,e),t}(Wu),rd=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.tickCount=0,t}return $c(t,e),t}(Wu),od=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.info="",t}return $c(t,e),t}(Wu);function id(e,t){switch(e){case"heading":return new Ku(e,t);case"list":case"item":return new Gu(e,t);case"link":case"image":return new nd(e,t);case"codeBlock":return new Zu(e,t);case"htmlBlock":return new td(e,t);case"table":return new Xu(e,t);case"tableCell":return new Qu(e,t);case"document":case"paragraph":case"blockQuote":case"thematicBreak":case"tableRow":case"tableBody":case"tableHead":case"frontMatter":return new Ju(e,t);case"code":return new rd(e,t);case"refDef":return new Yu(e,t);case"customBlock":return new ed(e,t);case"customInline":return new od(e,t);default:return new Wu(e,t)}}function sd(e){return"codeBlock"===e.type}function ad(e){return"list"===e.type}function ld(e){return"refDef"===e.type}function cd(e){return"customBlock"===e.type}function ud(e,t){var n=id("text",t);return n.literal=e,n}var dd,pd="[A-Za-z][A-Za-z0-9-]*",hd="<"+pd+"(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>",fd="</"+pd+"\\s*[>]",md=new RegExp("^(?:<[A-Za-z][A-Za-z0-9-]*(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^\"'=<>`\\x00-\\x20]+|'[^']*'|\"[^\"]*\"))?)*\\s*/?>|</[A-Za-z][A-Za-z0-9-]*\\s*[>]|\x3c!----\x3e|\x3c!--(?:-?[^>-])(?:-?[^-])*--\x3e|[<][?].*?[?][>]|<![A-Z]+\\s+[^>]*>|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>)","i");if(String.fromCodePoint)dd=function(e){try{return String.fromCodePoint(e)}catch(e){if(e instanceof RangeError)return String.fromCharCode(65533);throw e}};else{var gd=String.fromCharCode,vd=Math.floor;dd=function(){for(var e=[],t=0;t<arguments.length;t++)e[t]=arguments[t];var n,r,o=16384,i=[],s=-1,a=e.length;if(!a)return"";for(var l="";++s<a;){var c=Number(e[s]);if(!isFinite(c)||c<0||c>1114111||vd(c)!==c)return String.fromCharCode(65533);c<=65535?i.push(c):(n=55296+((c-=65536)>>10),r=c%1024+56320,i.push(n,r)),(s+1===a||i.length>o)&&(l+=gd.apply(void 0,i),i.length=0)}return l}}var yd=dd;function bd(e){var t=/\)+$/.exec(e);if(t){for(var n=0,r=0,o=e;r<o.length;r++){var i=o[r];"("===i?n<0?n=1:n+=1:")"===i&&(n-=1)}if(n<0){var s=Math.min(-n,t[0].length);return e.substring(0,e.length-s)}}return e}function wd(e){return e.replace(/&[A-Za-z0-9]+;$/,"")}function kd(e){return Uc(Uc([],function(e){for(var t,n=new RegExp("(www|https?://).(?:[w-]+.)*[A-Za-z0-9-]+.[A-Za-z0-9-]+[^<\\s]*[^<?!.,:*_?~\\s]","g"),r=[];t=n.exec(e);){var o=wd(bd(t[0])),i="www"===t[1]?"http://":"";r.push({text:o,range:[t.index,t.index+o.length-1],url:""+i+o})}return r}(e)),function(e){for(var t,n=new RegExp("[\\w.+-]+@(?:[\\w-]+\\.)+[\\w-]+","g"),r=[];t=n.exec(e);){var o=t[0];/[_-]+$/.test(o)||r.push({text:o,range:[t.index,t.index+o.length-1],url:"mailto:"+o})}return r}(e)).sort((function(e,t){return e.range[0]-t.range[0]}))}function xd(e){return e[e.length-1]}function Cd(e){return e.slice(1,e.length-1).trim().replace(/[ \t\r\n]+/," ").toLowerCase().toUpperCase()}function Td(e,t){Object.keys(e).forEach((function(n){t(n,e[n])}))}function Md(e){return!Object.keys(e).length}var Sd=126,Ed=39,Nd=34,Od=36,Dd="\\\\"+Au,Ad=new RegExp(/[!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u0AF0\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E42\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC9\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDF3C-\uDF3E]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]/),Ld=new RegExp('^(?:"('+Dd+'|[^"\\x00])*"|\'('+Dd+"|[^'\\x00])*'|\\(("+Dd+"|[^()\\x00])*\\))"),Id=/^(?:<(?:[^<>\n\\\x00]|\\.)*>)/,Rd=new RegExp("^"+Au),Pd=new RegExp("^"+Ou,"i"),Bd=/`+/,Fd=/^`+/,Hd=/\.\.\./g,zd=/--+/g,qd=/^<([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/,Vd=/^<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*>/i,jd=/^ *(?:\n *)?/,$d=/^[ \t\n\x0b\x0c\x0d]/,_d=/^\s/,Ud=/ *$/,Wd=/^ */,Jd=/^ *(?:\n|$)/,Gd=/^\[(?:[^\\\[\]]|\\.){0,1000}\]/,Kd=/^[^\n`\[\]\\!<&*_'"~$]+/m,Zd=function(){function e(e){this.subject="",this.delimiters=null,this.brackets=null,this.pos=0,this.lineStartNum=0,this.lineIdx=0,this.lineOffsets=[0],this.linePosOffset=0,this.refMap={},this.refLinkCandidateMap={},this.refDefCandidateMap={},this.options=e}return e.prototype.sourcepos=function(e,t){var n=this.linePosOffset+this.lineOffsets[this.lineIdx],r=this.lineStartNum+this.lineIdx,o=[r,e+n];return"number"==typeof t?[o,[r,t+n]]:o},e.prototype.nextLine=function(){this.lineIdx+=1,this.linePosOffset=-this.pos},e.prototype.match=function(e){var t=e.exec(this.subject.slice(this.pos));return null===t?null:(this.pos+=t.index+t[0].length,t[0])},e.prototype.peek=function(){return this.pos<this.subject.length?this.subject.charCodeAt(this.pos):-1},e.prototype.spnl=function(){return this.match(jd),!0},e.prototype.parseBackticks=function(e){var t=this.pos+1,n=this.match(Fd);if(null===n)return!1;for(var r,o=this.pos;null!==(r=this.match(Bd));)if(r===n){var i=this.subject.slice(o,this.pos-n.length),s=this.sourcepos(t,this.pos),a=i.split("\n");if(a.length>1){var l=xd(a);this.lineIdx+=a.length-1,this.linePosOffset=-(this.pos-l.length-n.length),s[1]=this.sourcepos(this.pos),i=a.join(" ")}var c=id("code",s);return i.length>0&&null!==i.match(/[^ ]/)&&" "==i[0]&&" "==i[i.length-1]?c.literal=i.slice(1,i.length-1):c.literal=i,c.tickCount=n.length,e.appendChild(c),!0}return this.pos=o,e.appendChild(ud(n,this.sourcepos(t,this.pos-1))),!0},e.prototype.parseBackslash=function(e){var t,n=this.subject;this.pos+=1;var r=this.pos;return 10===this.peek()?(this.pos+=1,t=id("linebreak",this.sourcepos(this.pos-1,this.pos)),e.appendChild(t),this.nextLine()):Rd.test(n.charAt(this.pos))?(e.appendChild(ud(n.charAt(this.pos),this.sourcepos(r,this.pos))),this.pos+=1):e.appendChild(ud("\\",this.sourcepos(r,r))),!0},e.prototype.parseAutolink=function(e){var t,n,r,o=this.pos+1;return(t=this.match(qd))?(n=t.slice(1,t.length-1),(r=id("link",this.sourcepos(o,this.pos))).destination=Bu("mailto:"+n),r.title="",r.appendChild(ud(n,this.sourcepos(o+1,this.pos-1))),e.appendChild(r),!0):!!(t=this.match(Vd))&&(n=t.slice(1,t.length-1),(r=id("link",this.sourcepos(o,this.pos))).destination=Bu(n),r.title="",r.appendChild(ud(n,this.sourcepos(o+1,this.pos-1))),e.appendChild(r),!0)},e.prototype.parseHtmlTag=function(e){var t=this.pos+1,n=this.match(md);if(null===n)return!1;var r=id("htmlInline",this.sourcepos(t,this.pos));return r.literal=n,e.appendChild(r),!0},e.prototype.scanDelims=function(e){var t=0,n=this.pos;if(e===Ed||e===Nd)t++,this.pos++;else for(;this.peek()===e;)t++,this.pos++;if(0===t||t<2&&(e===Sd||e===Od))return this.pos=n,null;var r,o=0===n?"\n":this.subject.charAt(n-1),i=this.peek();r=-1===i?"\n":yd(i);var s,a,l=_d.test(r),c=Ad.test(r),u=_d.test(o),d=Ad.test(o),p=!l&&(!c||u||d),h=!u&&(!d||l||c);return 95===e?(s=p&&(!h||d),a=h&&(!p||c)):e===Ed||e===Nd?(s=p&&!h,a=h):e===Od?(s=!l,a=!u):(s=p,a=h),this.pos=n,{numdelims:t,canOpen:s,canClose:a}},e.prototype.handleDelim=function(e,t){var n=this.scanDelims(e);if(!n)return!1;var r=n.numdelims,o=this.pos+1;this.pos+=r;var i=ud(e===Ed?"’":e===Nd?"“":this.subject.slice(o-1,this.pos),this.sourcepos(o,this.pos));return t.appendChild(i),(n.canOpen||n.canClose)&&(this.options.smart||e!==Ed&&e!==Nd)&&(this.delimiters={cc:e,numdelims:r,origdelims:r,node:i,previous:this.delimiters,next:null,canOpen:n.canOpen,canClose:n.canClose},this.delimiters.previous&&(this.delimiters.previous.next=this.delimiters)),!0},e.prototype.removeDelimiter=function(e){null!==e.previous&&(e.previous.next=e.next),null===e.next?this.delimiters=e.previous:e.next.previous=e.previous},e.prototype.removeDelimitersBetween=function(e,t){e.next!==t&&(e.next=t,t.previous=e)},e.prototype.processEmphasis=function(e){var t,n,r,o,i,s,a,l=!1,c=((t={})[95]=[e,e,e],t[42]=[e,e,e],t[39]=[e],t[34]=[e],t[126]=[e],t[36]=[e],t);for(r=this.delimiters;null!==r&&r.previous!==e;)r=r.previous;for(;null!==r;){var u=r.cc,d=95===u||42===u;if(r.canClose){for(n=r.previous,a=!1;null!==n&&n!==e&&n!==c[u][d?r.origdelims%3:0];){if(l=d&&(r.canOpen||n.canClose)&&r.origdelims%3!=0&&(n.origdelims+r.origdelims)%3==0,n.cc===r.cc&&n.canOpen&&!l){a=!0;break}n=n.previous}if(o=r,d||u===Sd||u===Od)if(a){if(n){var p=r.numdelims>=2&&n.numdelims>=2?2:1,h=d?0:1;i=n.node,s=r.node;var f=d?1===p?"emph":"strong":"strike";u===Od&&(f="customInline");var m=id(f),g=i.sourcepos[1],v=s.sourcepos[0];m.sourcepos=[[g[0],g[1]-p+1],[v[0],v[1]+p-1]],i.sourcepos[1][1]-=p,s.sourcepos[0][1]+=p,i.literal=i.literal.slice(p),s.literal=s.literal.slice(p),n.numdelims-=p,r.numdelims-=p;for(var y=i.next,b=void 0;y&&y!==s;)b=y.next,y.unlink(),m.appendChild(y),y=b;if(u===Od){var w=m.firstChild,k=w.literal||"",x=k.split(/\s/)[0];m.info=x,k.length<=x.length?w.unlink():(w.sourcepos[0][1]+=x.length,w.literal=k.replace(x+" ",""))}if(i.insertAfter(m),this.removeDelimitersBetween(n,r),n.numdelims<=h&&(0===n.numdelims&&i.unlink(),this.removeDelimiter(n)),r.numdelims<=h){0===r.numdelims&&s.unlink();var C=r.next;this.removeDelimiter(r),r=C}}}else r=r.next;else u===Ed?(r.node.literal="’",a&&(n.node.literal="‘"),r=r.next):u===Nd&&(r.node.literal="”",a&&(n.node.literal="“"),r=r.next);a||(c[u][d?o.origdelims%3:0]=o.previous,o.canOpen||this.removeDelimiter(o))}else r=r.next}for(;null!==this.delimiters&&this.delimiters!==e;)this.removeDelimiter(this.delimiters)},e.prototype.parseLinkTitle=function(){var e=this.match(Ld);return null===e?null:Pu(e.substr(1,e.length-2))},e.prototype.parseLinkDestination=function(){var e=this.match(Id);if(null===e){if(60===this.peek())return null;for(var t=this.pos,n=0,r=void 0;-1!==(r=this.peek());)if(92===r&&Rd.test(this.subject.charAt(this.pos+1)))this.pos+=1,-1!==this.peek()&&(this.pos+=1);else if(40===r)this.pos+=1,n+=1;else if(41===r){if(n<1)break;this.pos+=1,n-=1}else{if(null!==$d.exec(yd(r)))break;this.pos+=1}return this.pos===t&&41!==r||0!==n?null:Bu(Pu(e=this.subject.substr(t,this.pos-t)))}return Bu(Pu(e.substr(1,e.length-2)))},e.prototype.parseLinkLabel=function(){var e=this.match(Gd);return null===e||e.length>1001?0:e.length},e.prototype.parseOpenBracket=function(e){var t=this.pos;this.pos+=1;var n=ud("[",this.sourcepos(this.pos,this.pos));return e.appendChild(n),this.addBracket(n,t,!1),!0},e.prototype.parseBang=function(e){var t=this.pos;if(this.pos+=1,91===this.peek()){this.pos+=1;var n=ud("![",this.sourcepos(this.pos-1,this.pos));e.appendChild(n),this.addBracket(n,t+1,!0)}else{n=ud("!",this.sourcepos(this.pos,this.pos));e.appendChild(n)}return!0},e.prototype.parseCloseBracket=function(e){var t=null,n=null,r=!1;this.pos+=1;var o=this.pos,i=this.brackets;if(null===i)return e.appendChild(ud("]",this.sourcepos(o,o))),!0;if(!i.active)return e.appendChild(ud("]",this.sourcepos(o,o))),this.removeBracket(),!0;var s=i.image,a=this.pos;40===this.peek()&&(this.pos++,this.spnl()&&null!==(t=this.parseLinkDestination())&&this.spnl()&&($d.test(this.subject.charAt(this.pos-1))&&(n=this.parseLinkTitle()),1)&&this.spnl()&&41===this.peek()?(this.pos+=1,r=!0):this.pos=a);var l="";if(!r){var c=this.pos,u=this.parseLinkLabel();if(u>2?l=this.subject.slice(c,c+u):i.bracketAfter||(l=this.subject.slice(i.index,o)),0===u&&(this.pos=a),l){l=Cd(l);var d=this.refMap[l];d&&(t=d.destination,n=d.title,r=!0)}}if(r){var p=id(s?"image":"link");p.destination=t,p.title=n||"",p.sourcepos=[i.startpos,this.sourcepos(this.pos)];for(var h=i.node.next,f=void 0;h;)f=h.next,h.unlink(),p.appendChild(h),h=f;if(e.appendChild(p),this.processEmphasis(i.previousDelimiter),this.removeBracket(),i.node.unlink(),!s)for(i=this.brackets;null!==i;)i.image||(i.active=!1),i=i.previous;return this.options.referenceDefinition&&(this.refLinkCandidateMap[e.id]={node:e,refLabel:l}),!0}return this.removeBracket(),this.pos=o,e.appendChild(ud("]",this.sourcepos(o,o))),this.options.referenceDefinition&&(this.refLinkCandidateMap[e.id]={node:e,refLabel:l}),!0},e.prototype.addBracket=function(e,t,n){null!==this.brackets&&(this.brackets.bracketAfter=!0),this.brackets={node:e,startpos:this.sourcepos(t+(n?0:1)),previous:this.brackets,previousDelimiter:this.delimiters,index:t,image:n,active:!0}},e.prototype.removeBracket=function(){this.brackets&&(this.brackets=this.brackets.previous)},e.prototype.parseEntity=function(e){var t,n=this.pos+1;return!!(t=this.match(Pd))&&(e.appendChild(ud(Zc.decodeHTML(t),this.sourcepos(n,this.pos))),!0)},e.prototype.parseString=function(e){var t,n=this.pos+1;if(t=this.match(Kd)){if(this.options.smart){var r=t.replace(Hd,"…").replace(zd,(function(e){var t=0,n=0;return e.length%3==0?n=e.length/3:e.length%2==0?t=e.length/2:e.length%3==2?(t=1,n=(e.length-2)/3):(t=2,n=(e.length-4)/3),zu("—",n)+zu("–",t)}));e.appendChild(ud(r,this.sourcepos(n,this.pos)))}else{var o=ud(t,this.sourcepos(n,this.pos));e.appendChild(o)}return!0}return!1},e.prototype.parseNewline=function(e){this.pos+=1;var t=e.lastChild;if(t&&"text"===t.type&&" "===t.literal[t.literal.length-1]){var n=" "===t.literal[t.literal.length-2],r=t.literal.length;t.literal=t.literal.replace(Ud,"");var o=r-t.literal.length;t.sourcepos[1][1]-=o,e.appendChild(id(n?"linebreak":"softbreak",this.sourcepos(this.pos-o,this.pos)))}else e.appendChild(id("softbreak",this.sourcepos(this.pos,this.pos)));return this.nextLine(),this.match(Wd),!0},e.prototype.parseReference=function(e,t){if(!this.options.referenceDefinition)return 0;this.subject=e.stringContent,this.pos=0;var n=null,r=this.pos,o=this.parseLinkLabel();if(0===o)return 0;var i=this.subject.substr(0,o);if(58!==this.peek())return this.pos=r,0;this.pos++,this.spnl();var s=this.parseLinkDestination();if(null===s)return this.pos=r,0;var a=this.pos;this.spnl(),this.pos!==a&&(n=this.parseLinkTitle()),null===n&&(n="",this.pos=a);var l=!0;if(null===this.match(Jd)&&(""===n?l=!1:(n="",this.pos=a,l=null!==this.match(Jd))),!l)return this.pos=r,0;var c=Cd(i);if(""===c)return this.pos=r,0;var u=this.getReferenceDefSourcepos(e);e.sourcepos[0][0]=u[1][0]+1;var d=id("refDef",u);return d.title=n,d.dest=s,d.label=c,e.insertBefore(d),t[c]?this.refDefCandidateMap[d.id]=d:t[c]=$p(d),this.pos-r},e.prototype.mergeTextNodes=function(e){for(var t,n=[];t=e.next();){var r=t.entering,o=t.node;if(r&&"text"===o.type)n.push(o);else if(1===n.length)n=[];else if(n.length>1){var i=n[0],s=n[n.length-1];i.sourcepos&&s.sourcepos&&(i.sourcepos[1]=s.sourcepos[1]),i.next=s.next,i.next&&(i.next.prev=i);for(var a=1;a<n.length;a+=1)i.literal+=n[a].literal,n[a].unlink();n=[]}}},e.prototype.getReferenceDefSourcepos=function(e){for(var t=e.stringContent.split(/\n|\r\n/),n=!1,r=0,o={line:0,ch:0},i=0;i<t.length;i+=1){var s=t[i];if($d.test(s))break;if(/\:/.test(s)&&0===r){if(n)break;var a=s.indexOf(":")===s.length-1?i+1:i;o={line:a,ch:t[a].length},n=!0}var l=s.match(/'|"/g);if(l&&(r+=l.length),2===r){o={line:i,ch:s.length};break}}return[[e.sourcepos[0][0],e.sourcepos[0][1]],[e.sourcepos[0][0]+o.line,o.ch]]},e.prototype.parseInline=function(e){var t,n=!1,r=this.peek();if(-1===r)return!1;switch(r){case 10:n=this.parseNewline(e);break;case 92:n=this.parseBackslash(e);break;case 96:n=this.parseBackticks(e);break;case 42:case 95:case Sd:case Od:n=this.handleDelim(r,e);break;case Ed:case Nd:n=!!(null===(t=this.options)||void 0===t?void 0:t.smart)&&this.handleDelim(r,e);break;case 91:n=this.parseOpenBracket(e);break;case 33:n=this.parseBang(e);break;case 93:n=this.parseCloseBracket(e);break;case 60:n=this.parseAutolink(e)||this.parseHtmlTag(e);break;case 38:e.disabledEntityParse||(n=this.parseEntity(e));break;default:n=this.parseString(e)}return n||(this.pos+=1,e.appendChild(ud(yd(r),this.sourcepos(this.pos,this.pos+1)))),!0},e.prototype.parse=function(e){for(this.subject=e.stringContent.trim(),this.pos=0,this.delimiters=null,this.brackets=null,this.lineOffsets=e.lineOffsets||[0],this.lineIdx=0,this.linePosOffset=0,this.lineStartNum=e.sourcepos[0][0],function(e){return"heading"===e.type}(e)&&(this.lineOffsets[0]+=e.level+1);this.parseInline(e););e.stringContent=null,this.processEmphasis(null),this.mergeTextNodes(e.walker());var t=this.options,n=t.extendedAutolinks,r=t.customParser;if(n&&function(e,t){var n;"boolean"==typeof t&&(t=kd);for(var r=function(){var e=n.entering,r=n.node;if(e&&"text"===r.type&&"link"!==r.parent.type){var o=r.literal,i=t(o);if(!i||!i.length)return"continue";for(var s=0,a=r.sourcepos[0],l=a[0],c=a[1],u=function(e,t){return[[l,c+e],[l,c+t]]},d=[],p=0,h=i;p<h.length;p++){var f=h[p],m=f.range,g=f.url,v=f.text;m[0]>s&&d.push(ud(o.substring(s,m[0]),u(s,m[0]-1)));var y=id("link",u.apply(void 0,m));y.appendChild(ud(v,u.apply(void 0,m))),y.destination=g,y.extendedAutolink=!0,d.push(y),s=m[1]+1}s<o.length&&d.push(ud(o.substring(s),u(s,o.length-1)));for(var b=0,w=d;b<w.length;b++){var k=w[b];r.insertBefore(k)}r.unlink()}};n=e.next();)r()}(e.walker(),n),r&&e.firstChild)for(var o,i=e.firstChild.walker();o=i.next();){var s=o.node,a=o.entering;r[s.type]&&r[s.type](s,{entering:a,options:this.options})}},e}(),Xd=/^\[([ \txX])\][ \t]+/;var Qd=/[^ \t\f\v\r\n]/,Yd=/^(?:`{3,}|~{3,})(?= *$)/;function ep(e){for(var t=e;t;){if(t.lastLineBlank)return!0;var n=t.type;if(t.lastLineChecked||"list"!==n&&"item"!==n){t.lastLineChecked=!0;break}t.lastLineChecked=!0,t=t.lastChild}return!1}function tp(e,t){return t<e.length?e.charCodeAt(t):-1}function np(e){return!Qd.test(e)}function rp(e){return 32===e||9===e}var op=/^\$\$$/,ip={continue:function(e,t){var n=e.currentLine,r=n.match(op);if(r)return e.lastLineLength=r[0].length,e.finalize(t,e.lineNumber),2;for(var o=t.offset;o>0&&rp(tp(n,e.offset));)e.advanceOffset(1,!0),o--;return 0},finalize:function(e,t){if(null!==t.stringContent){var n=t.stringContent,r=n.indexOf("\n"),o=n.slice(0,r),i=n.slice(r+1),s=o.match(/^(\s*)(.*)/);t.info=Pu(s[2].trim()),t.literal=i,t.stringContent=null}},canContain:function(){return!1},acceptsLines:!0},sp={continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!0},ap={continue:function(){return 0},finalize:function(e,t){for(var n=t.firstChild;n;){if(ep(n)&&n.next){t.listData.tight=!1;break}for(var r=n.firstChild;r;){if(ep(r)&&(n.next||r.next)){t.listData.tight=!1;break}r=r.next}n=n.next}},canContain:function(e){return"item"===e},acceptsLines:!1},lp={continue:function(e,t){if(e.blank){if(null===t.firstChild)return 1;e.advanceNextNonspace()}else{if(!(e.indent>=t.listData.markerOffset+t.listData.padding))return 1;e.advanceOffset(t.listData.markerOffset+t.listData.padding,!0)}return 0},finalize:function(e,t){if(t.firstChild&&"paragraph"===t.firstChild.type){var n=t.firstChild,r=n.stringContent.match(Xd);if(r){var o=r[0].length;n.stringContent=n.stringContent.substring(o-1),n.sourcepos[0][1]+=o,n.lineOffsets[0]+=o,t.listData.task=!0,t.listData.checked=/[xX]/.test(r[1])}}},canContain:function(e){return"item"!==e},acceptsLines:!1},cp={continue:function(e,t){var n=e.currentLine,r=e.indent;if(t.isFenced){var o=r<=3&&n.charAt(e.nextNonspace)===t.fenceChar&&n.slice(e.nextNonspace).match(Yd);if(o&&o[0].length>=t.fenceLength)return e.lastLineLength=e.offset+r+o[0].length,e.finalize(t,e.lineNumber),2;for(var i=t.fenceOffset;i>0&&rp(tp(n,e.offset));)e.advanceOffset(1,!0),i--}else if(r>=4)e.advanceOffset(4,!0);else{if(!e.blank)return 1;e.advanceNextNonspace()}return 0},finalize:function(e,t){var n;if(null!==t.stringContent){if(t.isFenced){var r=t.stringContent,o=r.indexOf("\n"),i=r.slice(0,o),s=r.slice(o+1),a=i.match(/^(\s*)(.*)/);t.infoPadding=a[1].length,t.info=Pu(a[2].trim()),t.literal=s}else t.literal=null===(n=t.stringContent)||void 0===n?void 0:n.replace(/(\n *)+$/,"\n");t.stringContent=null}},canContain:function(){return!1},acceptsLines:!0},up={continue:function(e){return e.blank?1:0},finalize:function(e,t){if(null!==t.stringContent){for(var n,r=!1;91===tp(t.stringContent,0)&&(n=e.inlineParser.parseReference(t,e.refMap));)t.stringContent=t.stringContent.slice(n),r=!0;r&&np(t.stringContent)&&t.unlink()}},canContain:function(){return!1},acceptsLines:!0},dp={document:{continue:function(){return 0},finalize:function(){},canContain:function(e){return"item"!==e},acceptsLines:!1},list:ap,blockQuote:{continue:function(e){var t=e.currentLine;return e.indented||62!==tp(t,e.nextNonspace)?1:(e.advanceNextNonspace(),e.advanceOffset(1,!1),rp(tp(t,e.offset))&&e.advanceOffset(1,!0),0)},finalize:function(){},canContain:function(e){return"item"!==e},acceptsLines:!1},item:lp,heading:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},thematicBreak:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},codeBlock:cp,htmlBlock:{continue:function(e,t){return!e.blank||6!==t.htmlBlockType&&7!==t.htmlBlockType?0:1},finalize:function(e,t){var n;t.literal=(null===(n=t.stringContent)||void 0===n?void 0:n.replace(/(\n *)+$/,""))||null,t.stringContent=null},canContain:function(){return!1},acceptsLines:!0},paragraph:up,table:{continue:function(){return 0},finalize:function(){},canContain:function(e){return"tableHead"===e||"tableBody"===e},acceptsLines:!1},tableBody:{continue:function(){return 0},finalize:function(){},canContain:function(e){return"tableRow"===e},acceptsLines:!1},tableHead:{continue:function(){return 1},finalize:function(){},canContain:function(e){return"tableRow"===e||"tableDelimRow"===e},acceptsLines:!1},tableRow:{continue:function(){return 1},finalize:function(){},canContain:function(e){return"tableCell"===e},acceptsLines:!1},tableCell:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},tableDelimRow:{continue:function(){return 1},finalize:function(){},canContain:function(e){return"tableDelimCell"===e},acceptsLines:!1},tableDelimCell:{continue:function(){return 1},finalize:function(){},canContain:function(){return!1},acceptsLines:!1},refDef:sp,customBlock:ip,frontMatter:sp};function pp(e){for(var t=0,n=0,r=[],o=0;o<e.length;o+=1)if("|"===e[o]&&"\\"!==e[o-1]){var i=e.substring(t,o);0===t&&qu(i)?n=o+1:r.push(i),t=o+1}t<e.length&&(qu(i=e.substring(t,e.length))||r.push(i));return[n,r]}function hp(e,t,n,r){for(var o=[],i=0,s=t;i<s.length;i++){var a=s[i],l=a.match(/^[ \t]+/),c=l?l[0].length:0,u=void 0,d=void 0;if(c===a.length)c=0,u=0,d="";else{var p=a.match(/[ \t]+$/);u=p?p[0].length:0,d=a.slice(c,a.length-u)}var h=r+c,f=id(e,[[n,r],[n,r+a.length-1]]);f.stringContent=d.replace(/\\\|/g,"|"),f.startIdx=o.length,f.endIdx=o.length,f.lineOffsets=[h-1],f.paddingLeft=c,f.paddingRight=u,o.push(f),r+=a.length+1}return o}function fp(e){var t=null,n=e.stringContent,r=n[0];return":"===n[n.length-1]?t=":"===r?"center":"right":":"===r&&(t="left"),{align:t}}var mp=/^(\$\$)(\s*[a-zA-Z])+/,gp=/^(\$\$)(\s*[a-zA-Z])+.*(\$\$)/,vp=/^`{3,}(?!.*`)|^~{3,}/,yp=[/./,/^<(?:script|pre|style)(?:\s|>|$)/i,/^<!--/,/^<[?]/,/^<![A-Z]/,/^<!\[CDATA\[/,/^<[/]?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[123456]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|section|source|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|[/]?[>]|$)/i,new RegExp("^(?:"+hd+"|"+fd+")\\s*$","i")],bp=/^(?:=+|-+)[ \t]*$/,wp=/^#{1,6}(?:[ \t]+|$)/,kp=/^(?:(?:\*[ \t]*){3,}|(?:_[ \t]*){3,}|(?:-[ \t]*){3,})[ \t]*$/,xp=/^[*+-]/,Cp=/^(\d{1,9})([.)])/;function Tp(e,t){return e.options.disallowDeepHeading&&("blockQuote"===t.type||"item"===t.type)}var Mp=[function(e){return e.indented||62!==tp(e.currentLine,e.nextNonspace)?0:(e.advanceNextNonspace(),e.advanceOffset(1,!1),rp(tp(e.currentLine,e.offset))&&e.advanceOffset(1,!0),e.closeUnmatchedBlocks(),e.addChild("blockQuote",e.nextNonspace),1)},function(e,t){var n;if(!e.indented&&!Tp(e,t)&&(n=e.currentLine.slice(e.nextNonspace).match(wp))){e.advanceNextNonspace(),e.advanceOffset(n[0].length,!1),e.closeUnmatchedBlocks();var r=e.addChild("heading",e.nextNonspace);return r.level=n[0].trim().length,r.headingType="atx",r.stringContent=e.currentLine.slice(e.offset).replace(/^[ \t]*#+[ \t]*$/,"").replace(/[ \t]+#+[ \t]*$/,""),e.advanceOffset(e.currentLine.length-e.offset),2}return 0},function(e){var t;if(!e.indented&&(t=e.currentLine.slice(e.nextNonspace).match(vp))){var n=t[0].length;e.closeUnmatchedBlocks();var r=e.addChild("codeBlock",e.nextNonspace);return r.isFenced=!0,r.fenceLength=n,r.fenceChar=t[0][0],r.fenceOffset=e.indent,e.advanceNextNonspace(),e.advanceOffset(n,!1),2}return 0},function(e,t){if(!e.indented&&60===tp(e.currentLine,e.nextNonspace)){var n=e.currentLine.slice(e.nextNonspace),r=e.options.disallowedHtmlBlockTags,o=void 0;for(o=1;o<=7;o++){var i=n.match(yp[o]);if(i){if(7===o){if("paragraph"===t.type)return 0;if(r.length>0)if(new RegExp("</?(?:"+r.join("|")+")","i").test(i[0]))return 0}return e.closeUnmatchedBlocks(),e.addChild("htmlBlock",e.offset).htmlBlockType=o,2}}}return 0},function(e,t){var n;if(null!==t.stringContent&&!e.indented&&"paragraph"===t.type&&!Tp(e,t.parent)&&(n=e.currentLine.slice(e.nextNonspace).match(bp))){e.closeUnmatchedBlocks();for(var r=void 0;91===tp(t.stringContent,0)&&(r=e.inlineParser.parseReference(t,e.refMap));)t.stringContent=t.stringContent.slice(r);if(t.stringContent.length>0){var o=id("heading",t.sourcepos);return o.level="="===n[0][0]?1:2,o.headingType="setext",o.stringContent=t.stringContent,t.insertAfter(o),t.unlink(),e.tip=o,e.advanceOffset(e.currentLine.length-e.offset,!1),2}return 0}return 0},function(e){return!e.indented&&kp.test(e.currentLine.slice(e.nextNonspace))?(e.closeUnmatchedBlocks(),e.addChild("thematicBreak",e.nextNonspace),e.advanceOffset(e.currentLine.length-e.offset,!1),2):0},function(e,t){var n,r,o,i=t;return e.indented&&"list"!==t.type||!(n=function(e,t){var n,r,o=e.currentLine.slice(e.nextNonspace),i={type:"bullet",tight:!0,bulletChar:"",start:0,delimiter:"",padding:0,markerOffset:e.indent,task:!1,checked:!1};if(e.indent>=4)return null;if(n=o.match(xp))i.type="bullet",i.bulletChar=n[0][0];else{if(!(n=o.match(Cp))||"paragraph"===t.type&&"1"!==n[1])return null;i.type="ordered",i.start=parseInt(n[1],10),i.delimiter=n[2]}if(-1!==(r=tp(e.currentLine,e.nextNonspace+n[0].length))&&9!==r&&32!==r)return null;if("paragraph"===t.type&&!e.currentLine.slice(e.nextNonspace+n[0].length).match(Qd))return null;e.advanceNextNonspace(),e.advanceOffset(n[0].length,!0);var s=e.column,a=e.offset;do{e.advanceOffset(1,!0),r=tp(e.currentLine,e.offset)}while(e.column-s<5&&rp(r));var l=-1===tp(e.currentLine,e.offset),c=e.column-s;return c>=5||c<1||l?(i.padding=n[0].length+1,e.column=s,e.offset=a,rp(tp(e.currentLine,e.offset))&&e.advanceOffset(1,!0)):i.padding=n[0].length+c,i}(e,i))?0:(e.closeUnmatchedBlocks(),"list"===e.tip.type&&(r=i.listData,o=n,r.type===o.type&&r.delimiter===o.delimiter&&r.bulletChar===o.bulletChar)||((i=e.addChild("list",e.nextNonspace)).listData=n),(i=e.addChild("item",e.nextNonspace)).listData=n,1)},function(e){return e.indented&&"paragraph"!==e.tip.type&&!e.blank?(e.advanceOffset(4,!0),e.closeUnmatchedBlocks(),e.addChild("codeBlock",e.offset),2):0},function(e,t){var n=t.stringContent;if("paragraph"===t.type&&!e.indented&&!e.blank){var r=n.length-1,o=n.lastIndexOf("\n",r-1)+1,i=n.slice(o,r),s=e.currentLine.slice(e.nextNonspace),a=pp(i),l=a[0],c=a[1],u=pp(s),d=u[0],p=u[1],h=/^[ \t]*:?-+:?[ \t]*$/;if(!c.length||!p.length||p.some((function(e){return!h.test(e)}))||1===p.length&&0!==s.indexOf("|"))return 0;var f=t.lineOffsets,m=e.lineNumber-1,g=xd(f)+1,v=id("table",[[m,g],[e.lineNumber,e.offset]]);if(v.columns=p.map((function(){return{align:null}})),t.insertAfter(v),1===f.length)t.unlink();else{t.stringContent=n.slice(0,o);var y=o-(n.lastIndexOf("\n",o-2)+1)-1;e.lastLineLength=f[f.length-2]+y,e.finalize(t,m-1)}e.advanceOffset(e.currentLine.length-e.offset,!1);var b=id("tableHead",[[m,g],[e.lineNumber,e.offset]]);v.appendChild(b);var w=id("tableRow",[[m,g],[m,g+i.length-1]]),k=id("tableDelimRow",[[e.lineNumber,e.nextNonspace+1],[e.lineNumber,e.offset]]);b.appendChild(w),b.appendChild(k),hp("tableCell",c,m,g+l).forEach((function(e){w.appendChild(e)}));var x=hp("tableDelimCell",p,e.lineNumber,e.nextNonspace+1+d);return x.forEach((function(e){k.appendChild(e)})),v.columns=x.map(fp),e.tip=v,2}return 0},function(e,t){if("table"!==t.type&&"tableBody"!==t.type||!e.blank&&-1===e.currentLine.indexOf("|"))return 0;if(e.advanceOffset(e.currentLine.length-e.offset,!1),e.blank){var n=t;return"tableBody"===t.type&&(n=t.parent,e.finalize(t,e.lineNumber-1)),e.finalize(n,e.lineNumber-1),0}var r=t;"table"===t.type&&((r=e.addChild("tableBody",e.nextNonspace)).stringContent=null);var o=id("tableRow",[[e.lineNumber,e.nextNonspace+1],[e.lineNumber,e.currentLine.length]]);r.appendChild(o);var i=r.parent,s=pp(e.currentLine.slice(e.nextNonspace)),a=s[0];return hp("tableCell",s[1],e.lineNumber,e.nextNonspace+1+a).forEach((function(e,t){t>=i.columns.length&&(e.ignored=!0),o.appendChild(e)})),2},function(e){var t;if(!e.indented&&!gp.test(e.currentLine)&&(t=e.currentLine.match(mp))){var n=t[1].length;e.closeUnmatchedBlocks();var r=e.addChild("customBlock",e.nextNonspace);return r.syntaxLength=n,r.offset=e.indent,e.advanceNextNonspace(),e.advanceOffset(n,!1),2}return 0}],Sp=/^(-{3}|\+{3}|;{3})$/,Ep=function(e,t){var n=e.currentLine,r=e.lineNumber,o=e.indented;return 1===r&&!o&&"document"===t.type&&Sp.test(n)?(e.closeUnmatchedBlocks(),e.addChild("frontMatter",e.nextNonspace).stringContent=n,e.advanceNextNonspace(),e.advanceOffset(n.length,!1),2):0},Np={continue:function(e,t){var n=e.currentLine,r=n.match(Sp);return"frontMatter"===t.type&&r?(t.stringContent+=n,e.lastLineLength=r[0].length,e.finalize(t,e.lineNumber),2):0},finalize:function(e,t){null!==t.stringContent&&(t.literal=t.stringContent,t.stringContent=null)},canContain:function(){return!1},acceptsLines:!0},Op=[/./,/<\/(?:script|pre|style)>/i,/-->/,/\?>/,/>/,/\]\]>/],Dp=/^[#`~*+_=<>0-9-;$]/,Ap=/\r\n|\n|\r/;function Lp(){return id("document",[[1,1],[0,0]])}var Ip={smart:!1,tagFilter:!1,extendedAutolinks:!1,disallowedHtmlBlockTags:[],referenceDefinition:!1,disallowDeepHeading:!1,customParser:null,frontMatter:!1},Rp=function(){function e(e){this.options=_c(_c({},Ip),e),this.doc=Lp(),this.tip=this.doc,this.oldtip=this.doc,this.lineNumber=0,this.offset=0,this.column=0,this.nextNonspace=0,this.nextNonspaceColumn=0,this.indent=0,this.currentLine="",this.indented=!1,this.blank=!1,this.partiallyConsumedTab=!1,this.allClosed=!0,this.lastMatchedContainer=this.doc,this.refMap={},this.refLinkCandidateMap={},this.refDefCandidateMap={},this.lastLineLength=0,this.lines=[],this.options.frontMatter&&(dp.frontMatter=Np,Mp.unshift(Ep)),this.inlineParser=new Zd(this.options)}return e.prototype.advanceOffset=function(e,t){void 0===t&&(t=!1);for(var n,r,o,i=this.currentLine;e>0&&(o=i[this.offset]);)"\t"===o?(n=4-this.column%4,t?(this.partiallyConsumedTab=n>e,r=n>e?e:n,this.column+=r,this.offset+=this.partiallyConsumedTab?0:1,e-=r):(this.partiallyConsumedTab=!1,this.column+=n,this.offset+=1,e-=1)):(this.partiallyConsumedTab=!1,this.offset+=1,this.column+=1,e-=1)},e.prototype.advanceNextNonspace=function(){this.offset=this.nextNonspace,this.column=this.nextNonspaceColumn,this.partiallyConsumedTab=!1},e.prototype.findNextNonspace=function(){for(var e,t=this.currentLine,n=this.offset,r=this.column;""!==(e=t.charAt(n));)if(" "===e)n++,r++;else{if("\t"!==e)break;n++,r+=4-r%4}this.blank="\n"===e||"\r"===e||""===e,this.nextNonspace=n,this.nextNonspaceColumn=r,this.indent=this.nextNonspaceColumn-this.column,this.indented=this.indent>=4},e.prototype.addLine=function(){if(this.partiallyConsumedTab){this.offset+=1;var e=4-this.column%4;this.tip.stringContent+=zu(" ",e)}this.tip.lineOffsets?this.tip.lineOffsets.push(this.offset):this.tip.lineOffsets=[this.offset],this.tip.stringContent+=this.currentLine.slice(this.offset)+"\n"},e.prototype.addChild=function(e,t){for(;!dp[this.tip.type].canContain(e);)this.finalize(this.tip,this.lineNumber-1);var n=t+1,r=id(e,[[this.lineNumber,n],[0,0]]);return r.stringContent="",this.tip.appendChild(r),this.tip=r,r},e.prototype.closeUnmatchedBlocks=function(){if(!this.allClosed){for(;this.oldtip!==this.lastMatchedContainer;){var e=this.oldtip.parent;this.finalize(this.oldtip,this.lineNumber-1),this.oldtip=e}this.allClosed=!0}},e.prototype.finalize=function(e,t){var n=e.parent;e.open=!1,e.sourcepos[1]=[t,this.lastLineLength],dp[e.type].finalize(this,e),this.tip=n},e.prototype.processInlines=function(e){var t,n=this.options.customParser,r=e.walker();for(this.inlineParser.refMap=this.refMap,this.inlineParser.refLinkCandidateMap=this.refLinkCandidateMap,this.inlineParser.refDefCandidateMap=this.refDefCandidateMap,this.inlineParser.options=this.options;t=r.next();){var o=t.node,i=t.entering,s=o.type;n&&n[s]&&n[s](o,{entering:i,options:this.options}),i||"paragraph"!==s&&"heading"!==s&&("tableCell"!==s||o.ignored)||this.inlineParser.parse(o)}},e.prototype.incorporateLine=function(e){var t=this.doc;this.oldtip=this.tip,this.offset=0,this.column=0,this.blank=!1,this.partiallyConsumedTab=!1,this.lineNumber+=1,-1!==e.indexOf("\0")&&(e=e.replace(/\0/g,"�")),this.currentLine=e;for(var n,r=!0;(n=t.lastChild)&&n.open;){switch(t=n,this.findNextNonspace(),dp[t.type].continue(this,t)){case 0:break;case 1:r=!1;break;case 2:return void(this.lastLineLength=e.length);default:throw new Error("continue returned illegal value, must be 0, 1, or 2")}if(!r){t=t.parent;break}}this.allClosed=t===this.oldtip,this.lastMatchedContainer=t;for(var o="paragraph"!==t.type&&dp[t.type].acceptsLines,i=Mp.length;!o;){if(this.findNextNonspace(),"table"!==t.type&&"tableBody"!==t.type&&"paragraph"!==t.type&&!this.indented&&!Dp.test(e.slice(this.nextNonspace))){this.advanceNextNonspace();break}for(var s=0;s<i;){var a=Mp[s](this,t);if(1===a){t=this.tip;break}if(2===a){t=this.tip,o=!0;break}s++}if(s===i){this.advanceNextNonspace();break}}if(this.allClosed||this.blank||"paragraph"!==this.tip.type){this.closeUnmatchedBlocks(),this.blank&&t.lastChild&&(t.lastChild.lastLineBlank=!0);for(var l=t.type,c=this.blank&&!("blockQuote"===l||sd(t)&&t.isFenced||"item"===l&&!t.firstChild&&t.sourcepos[0][0]===this.lineNumber),u=t;u;)u.lastLineBlank=c,u=u.parent;dp[l].acceptsLines?(this.addLine(),function(e){return"htmlBlock"===e.type}(t)&&t.htmlBlockType>=1&&t.htmlBlockType<=5&&Op[t.htmlBlockType].test(this.currentLine.slice(this.offset))&&(this.lastLineLength=e.length,this.finalize(t,this.lineNumber))):this.offset<e.length&&!this.blank&&(t=this.addChild("paragraph",this.offset),this.advanceNextNonspace(),this.addLine())}else this.addLine();this.lastLineLength=e.length},e.prototype.parse=function(e,t){this.doc=Lp(),this.tip=this.doc,this.lineNumber=0,this.lastLineLength=0,this.offset=0,this.column=0,this.lastMatchedContainer=this.doc,this.currentLine="";var n=e.split(Ap),r=n.length;this.lines=t||n,this.options.referenceDefinition&&this.clearRefMaps(),10===e.charCodeAt(e.length-1)&&(r-=1);for(var o=0;o<r;o++)this.incorporateLine(n[o]);for(;this.tip;)this.finalize(this.tip,r);return this.processInlines(this.doc),this.doc},e.prototype.partialParseStart=function(e,t){this.doc=Lp(),this.tip=this.doc,this.lineNumber=e-1,this.lastLineLength=0,this.offset=0,this.column=0,this.lastMatchedContainer=this.doc,this.currentLine="";for(var n=t.length,r=0;r<n;r++)this.incorporateLine(t[r]);return this.doc},e.prototype.partialParseExtends=function(e){for(var t=0;t<e.length;t++)this.incorporateLine(e[t])},e.prototype.partialParseFinish=function(){for(;this.tip;)this.finalize(this.tip,this.lineNumber);this.processInlines(this.doc)},e.prototype.setRefMaps=function(e,t,n){this.refMap=e,this.refLinkCandidateMap=t,this.refDefCandidateMap=n},e.prototype.clearRefMaps=function(){[this.refMap,this.refLinkCandidateMap,this.refDefCandidateMap].forEach((function(e){var t;t=e,Object.keys(t).forEach((function(e){delete t[e]}))}))},e}();function Pp(e,t){return e[0]<t[0]?1:e[0]>t[0]?-1:e[1]<t[1]?1:e[1]>t[1]?-1:0}function Bp(e,t){var n=e[0];return 1===Pp(e[1],t)?1:-1===Pp(n,t)?-1:0}function Fp(e,t){for(var n=0,r=t;n<r.length;n++){var o=r[n];e.insertBefore(o)}}function Hp(e,t){var n=e[0];return e[1][0]<t?1:n[0]>t?-1:0}function zp(e,t){for(var n=e.firstChild;n;){var r=Hp(n.sourcepos,t);if(0===r)return n;if(-1===r)return n.prev||n;n=n.next}return e.lastChild}function qp(e){return function(e){return _u[e]}(e)||null}function Vp(e,t,n){if(void 0===n&&(n=null),t)for(var r=t.walker();t&&t!==n;){e(t);var o=r.next();if(!o)break;t=o.node}}var jp=/\r\n|\n|\r/;function $p(e){return{id:e.id,title:e.title,sourcepos:e.sourcepos,unlinked:!1,destination:e.dest}}var _p=function(){function e(e,t){this.refMap={},this.refLinkCandidateMap={},this.refDefCandidateMap={},this.referenceDefinition=!!(null==t?void 0:t.referenceDefinition),this.parser=new Rp(t),this.parser.setRefMaps(this.refMap,this.refLinkCandidateMap,this.refDefCandidateMap),this.eventHandlerMap={change:[]},e=e||"",this.lineTexts=e.split(jp),this.root=this.parser.parse(e,this.lineTexts)}return e.prototype.updateLineTexts=function(e,t,n){var r,o=e[0],i=e[1],s=t[0],a=t[1],l=n.split(jp),c=l.length,u=this.lineTexts[o-1],d=this.lineTexts[s-1];l[0]=u.slice(0,i-1)+l[0],l[c-1]=l[c-1]+d.slice(a-1);var p=s-o+1;return(r=this.lineTexts).splice.apply(r,Uc([o-1,p],l)),c-p},e.prototype.updateRootNodeState=function(){if(1===this.lineTexts.length&&""===this.lineTexts[0])return this.root.lastLineBlank=!0,void(this.root.sourcepos=[[1,1],[1,0]]);this.root.lastChild&&(this.root.lastLineBlank=this.root.lastChild.lastLineBlank);for(var e=this.lineTexts,t=e.length-1;""===e[t];)t-=1;e.length-2>t&&(t+=1),this.root.sourcepos[1]=[t+1,e[t].length]},e.prototype.replaceRangeNodes=function(e,t,n){e?(Fp(e,n),function(e,t){if(e.parent===t.parent&&e!==t){for(var n=e.next;n&&n!==t;){for(var r=n.next,o=0,i=["parent","prev","next"];o<i.length;o++){var s=i[o];n[s]&&(Uu(n[s].id),n[s]=null)}n=r}e.next=t.next,t.next?t.next.prev=e:e.parent.lastChild=e}}(e,t),[e.id,t.id].forEach((function(e){return Uu(e)})),e.unlink()):t?(Fp(t,n),Uu(t.id),t.unlink()):function(e,t){for(var n=t.length-1;n>=0;n-=1)e.prependChild(t[n])}(this.root,n)},e.prototype.getNodeRange=function(e,t){var n=zp(this.root,e[0]),r=zp(this.root,t[0]);return r&&r.next&&t[0]+1===r.next.sourcepos[0][0]&&(r=r.next),[n,r]},e.prototype.trigger=function(e,t){this.eventHandlerMap[e].forEach((function(e){e(t)}))},e.prototype.extendEndLine=function(e){for(;""===this.lineTexts[e];)e+=1;return e},e.prototype.parseRange=function(e,t,n,r){var o;e&&e.prev&&(ad(e.prev)&&function(e){var t=e.match(/^[ \t]+/);if(t&&(t[0].length>=2||/\t/.test(t[0])))return!0;var n=t?e.slice(t.length):e;return xp.test(n)||Cp.test(n)}(this.lineTexts[n-1])||function(e){return"table"===e.type}(e.prev)&&(!np(o=this.lineTexts[n-1])&&-1!==o.indexOf("|")))&&(n=(e=e.prev).sourcepos[0][0]);for(var i=this.lineTexts.slice(n-1,r),s=this.parser.partialParseStart(n,i),a=t?t.next:this.root.firstChild,l=s.lastChild,c=l&&sd(l)&&l.open,u=l&&cd(l)&&l.open,d=l&&ad(l);(c||u)&&a||d&&a&&("list"===a.type||a.sourcepos[0][1]>=2);){var p=this.extendEndLine(a.sourcepos[1][0]);this.parser.partialParseExtends(this.lineTexts.slice(r,p)),e||(e=t),t=a,r=p,a=a.next}return this.parser.partialParseFinish(),{newNodes:function(e){for(var t=[],n=e.firstChild;n;)t.push(n),n=n.next;return t}(s),extStartNode:e,extEndNode:t}},e.prototype.getRemovedNodeRange=function(e,t){return!e||e&&ld(e)||t&&ld(t)?null:{id:[e.id,t.id],line:[e.sourcepos[0][0]-1,t.sourcepos[1][0]-1]}},e.prototype.markDeletedRefMap=function(e,t){var n=this;if(!Md(this.refMap)){var r=function(e){if(ld(e)){var t=n.refMap[e.label];t&&e.id===t.id&&(t.unlinked=!0)}};e&&Vp(r,e.parent,t),t&&Vp(r,t)}},e.prototype.replaceWithNewRefDefState=function(e){var t=this;if(!Md(this.refMap)){var n=function(e){if(ld(e)){var n=e.label,r=t.refMap[n];r&&!r.unlinked||(t.refMap[n]=$p(e))}};e.forEach((function(e){Vp(n,e)}))}},e.prototype.replaceWithRefDefCandidate=function(){var e=this;Md(this.refDefCandidateMap)||Td(this.refDefCandidateMap,(function(t,n){var r=n.label,o=n.sourcepos,i=e.refMap[r];(!i||i.unlinked||i.sourcepos[0][0]>o[0][0])&&(e.refMap[r]=$p(n))}))},e.prototype.getRangeWithRefDef=function(e,t,n,r,o){if(this.referenceDefinition&&!Md(this.refMap)){var i=zp(this.root,e-1),s=zp(this.root,t+1);i&&ld(i)&&i!==n&&i!==r&&(e=(n=i).sourcepos[0][0]),s&&ld(s)&&s!==n&&s!==r&&(r=s,t=this.extendEndLine(r.sourcepos[1][0]+o))}return[n,r,e,t]},e.prototype.parse=function(e,t,n){void 0===n&&(n=0);var r=this.getNodeRange(e,t),o=r[0],i=r[1],s=o?Math.min(o.sourcepos[0][0],e[0]):e[0],a=this.extendEndLine((i?Math.max(i.sourcepos[1][0],t[0]):t[0])+n),l=this.parseRange.apply(this,this.getRangeWithRefDef(s,a,o,i,n)),c=l.newNodes,u=l.extStartNode,d=l.extEndNode,p=this.getRemovedNodeRange(u,d),h=d?d.next:this.root.firstChild;return this.referenceDefinition?(this.markDeletedRefMap(u,d),this.replaceRangeNodes(u,d,c),this.replaceWithNewRefDefState(c)):this.replaceRangeNodes(u,d,c),{nodes:c,removedNodeRange:p,nextNode:h}},e.prototype.parseRefLink=function(){var e=this,t=[];return Md(this.refMap)||Td(this.refMap,(function(n,r){r.unlinked&&delete e.refMap[n],Td(e.refLinkCandidateMap,(function(r,o){var i=o.node;o.refLabel===n&&t.push(e.parse(i.sourcepos[0],i.sourcepos[1]))}))})),t},e.prototype.removeUnlinkedCandidate=function(){Md(this.refDefCandidateMap)||[this.refLinkCandidateMap,this.refDefCandidateMap].forEach((function(e){Td(e,(function(t){(function(e){var t=qp(e);if(!t)return!0;for(;t&&"document"!==t.type;){if(!t.parent&&!t.prev&&!t.next)return!0;t=t.parent}return!1})(t)&&delete e[t]}))}))},e.prototype.editMarkdown=function(e,t,n){var r=this.updateLineTexts(e,t,n),o=this.parse(e,t,r),i=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=_c({},e);return t.forEach((function(e){delete r[e]})),r}(o,"nextNode");!function(e,t){if(e&&e.parent&&0!==t){var n,r=e.parent.walker();for(r.resumeAt(e,!0);n=r.next();){var o=n.node;n.entering&&(o.sourcepos[0][0]+=t,o.sourcepos[1][0]+=t)}}}(o.nextNode,r),this.updateRootNodeState();var s=[i];return this.referenceDefinition&&(this.removeUnlinkedCandidate(),this.replaceWithRefDefCandidate(),s=s.concat(this.parseRefLink())),this.trigger("change",s),s},e.prototype.getLineTexts=function(){return this.lineTexts},e.prototype.getRootNode=function(){return this.root},e.prototype.findNodeAtPosition=function(e){var t=function(e,t){for(var n=e,r=null;n;){var o=Bp(n.sourcepos,t);if(0===o){if(!n.firstChild)return n;r=n,n=n.firstChild}else{if(-1===o)return r;if(!n.next)return r;n=n.next}}return n}(this.root,e);return t&&t!==this.root?t:null},e.prototype.findFirstNodeAtLine=function(e){return function(e,t){for(var n=e.firstChild,r=null;n;){var o=Hp(n.sourcepos,t);if(0===o){if(n.sourcepos[0][0]===t||!n.firstChild)return n;r=n,n=n.firstChild}else{if(-1===o)break;r=n,n=n.next}}return r?function(e){for(;e.parent&&"document"!==e.parent.type&&e.parent.sourcepos[0][0]===e.sourcepos[0][0];)e=e.parent;return e}(function(e){for(;e.lastChild;)e=e.lastChild;return e}(r)):null}(this.root,e)},e.prototype.on=function(e,t){this.eventHandlerMap[e].push(t)},e.prototype.off=function(e,t){var n=this.eventHandlerMap[e],r=n.indexOf(t);n.splice(r,1)},e.prototype.findNodeById=function(e){return qp(e)},e.prototype.removeAllNode=function(){_u={}},e}(),Up=new RegExp("<(/?(?:"+["title","textarea","style","xmp","iframe","noembed","noframes","script","plaintext"].join("|")+")[^>]*>)","ig");function Wp(e){return Up.test(e)?e.replace(Up,(function(e,t){return"&lt;"+t})):e}var Jp={heading:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"h"+e.level,outerNewLine:!0}},text:function(e){return{type:"text",content:e.literal}},softbreak:function(e,t){return{type:"html",content:t.options.softbreak}},linebreak:function(){return{type:"html",content:"<br />\n"}},emph:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"em"}},strong:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"strong"}},paragraph:function(e,t){var n,r=t.entering,o=null===(n=e.parent)||void 0===n?void 0:n.parent;return o&&"list"===o.type&&o.listData.tight?null:{type:r?"openTag":"closeTag",tagName:"p",outerNewLine:!0}},thematicBreak:function(){return{type:"openTag",tagName:"hr",outerNewLine:!0,selfClose:!0}},blockQuote:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"blockquote",outerNewLine:!0,innerNewLine:!0}},list:function(e,t){var n=t.entering,r=e.listData,o=r.type,i=r.start,s="bullet"===o?"ul":"ol",a={};return"ol"===s&&null!==i&&1!==i&&(a.start=i.toString()),{type:n?"openTag":"closeTag",tagName:s,attributes:a,outerNewLine:!0}},item:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"li",outerNewLine:!0}},htmlInline:function(e,t){return{type:"html",content:t.options.tagFilter?Wp(e.literal):e.literal}},htmlBlock:function(e,t){var n=t.options,r=n.tagFilter?Wp(e.literal):e.literal;return n.nodeId?[{type:"openTag",tagName:"div",outerNewLine:!0},{type:"html",content:r},{type:"closeTag",tagName:"div",outerNewLine:!0}]:{type:"html",content:r,outerNewLine:!0}},code:function(e){return[{type:"openTag",tagName:"code"},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"}]},codeBlock:function(e){var t=e.info,n=t?t.split(/\s+/):[],r=[];return n.length>0&&n[0].length>0&&r.push("language-"+Hu(n[0])),[{type:"openTag",tagName:"pre",outerNewLine:!0},{type:"openTag",tagName:"code",classNames:r},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"},{type:"closeTag",tagName:"pre",outerNewLine:!0}]},link:function(e,t){if(t.entering){var n=e,r=n.title,o=n.destination;return{type:"openTag",tagName:"a",attributes:_c({href:Hu(o)},r&&{title:Hu(r)})}}return{type:"closeTag",tagName:"a"}},image:function(e,t){var n=t.getChildrenText,r=t.skipChildren,o=e,i=o.title,s=o.destination;return r(),{type:"openTag",tagName:"img",selfClose:!0,attributes:_c({src:Hu(s),alt:n(e)},i&&{title:Hu(i)})}},customBlock:function(e,t,n){var r=e.info.trim().toLowerCase(),o=n[r];if(o)try{return o(e,t)}catch(e){console.warn("[@toast-ui/editor] - The error occurred when "+r+" block node was parsed in markdown renderer: "+e)}return[{type:"openTag",tagName:"div",outerNewLine:!0},{type:"text",content:e.literal},{type:"closeTag",tagName:"div",outerNewLine:!0}]},frontMatter:function(e){return[{type:"openTag",tagName:"div",outerNewLine:!0,attributes:{style:"white-space: pre; display: none;"}},{type:"text",content:e.literal},{type:"closeTag",tagName:"div",outerNewLine:!0}]},customInline:function(e,t,n){var r=e,o=r.info,i=r.firstChild,s=o.trim().toLowerCase(),a=n[s],l=t.entering;if(a)try{return a(e,t)}catch(e){console.warn("[@toast-ui/editor] - The error occurred when "+s+" inline node was parsed in markdown renderer: "+e)}return l?[{type:"openTag",tagName:"span"},{type:"text",content:"$$"+o+(i?" ":"")}]:[{type:"text",content:"$$"},{type:"closeTag",tagName:"span"}]}},Gp={strike:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"del"}},item:function(e,t){var n=t.entering,r=e.listData,o=r.checked,i=r.task;if(n){var s={type:"openTag",tagName:"li",outerNewLine:!0};return i?[s,{type:"openTag",tagName:"input",selfClose:!0,attributes:_c(_c({},o&&{checked:""}),{disabled:"",type:"checkbox"})},{type:"text",content:" "}]:s}return{type:"closeTag",tagName:"li",outerNewLine:!0}},table:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"table",outerNewLine:!0}},tableHead:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"thead",outerNewLine:!0}},tableBody:function(e,t){return{type:t.entering?"openTag":"closeTag",tagName:"tbody",outerNewLine:!0}},tableRow:function(e,t){if(t.entering)return{type:"openTag",tagName:"tr",outerNewLine:!0};var n=[];if(e.lastChild)for(var r=e.parent.parent.columns.length,o=e.lastChild.endIdx+1;o<r;o+=1)n.push({type:"openTag",tagName:"td",outerNewLine:!0},{type:"closeTag",tagName:"td",outerNewLine:!0});return n.push({type:"closeTag",tagName:"tr",outerNewLine:!0}),n},tableCell:function(e,t){var n=t.entering;if(e.ignored)return{type:"text",content:""};var r=e.parent.parent,o="tableHead"===r.type?"th":"td",i=r.parent.columns[e.startIdx],s=(null==i?void 0:i.align)?{align:i.align}:null;return n?_c({type:"openTag",tagName:o,outerNewLine:!0},s&&{attributes:s}):{type:"closeTag",tagName:o,outerNewLine:!0}}},Kp={softbreak:"\n",gfm:!1,tagFilter:!1,nodeId:!1};function Zp(e){for(var t=[],n=e.walker(),r=null;r=n.next();){var o=r.node;"text"===o.type&&t.push(o.literal)}return t.join("")}var Xp=function(){function e(e){this.buffer=[],this.options=_c(_c({},Kp),e),this.convertors=this.createConvertors(),delete this.options.convertors}return e.prototype.createConvertors=function(){var e=_c({},Jp);if(this.options.gfm&&(e=_c(_c({},e),Gp)),this.options.convertors){var t=this.options.convertors,n=Object.keys(t),r=_c(_c({},Jp),Gp);n.forEach((function(n){var o=e[n],i=t[n],s=-1===Object.keys(r).indexOf(n)?n.toLowerCase():n;e[s]=o?function(e,t,n){return t.origin=function(){return o(e,t,n)},i(e,t)}:i}))}return e},e.prototype.getConvertors=function(){return this.convertors},e.prototype.getOptions=function(){return this.options},e.prototype.render=function(e){var t=this;this.buffer=[];for(var n=e.walker(),r=null,o=function(){var e=r.node,o=r.entering,s=i.convertors[e.type];if(!s)return"continue";var a=!1,l={entering:o,leaf:!ju(e),options:i.options,getChildrenText:Zp,skipChildren:function(){a=!0}},c=cd(e)||function(e){return"customInline"===e.type}(e)?s(e,l,i.convertors):s(e,l);c&&((Array.isArray(c)?c:[c]).forEach((function(n,r){"openTag"===n.type&&t.options.nodeId&&0===r&&(n.attributes||(n.attributes={}),n.attributes["data-nodeid"]=String(e.id)),t.renderHTMLNode(n)})),a&&(n.resumeAt(e,!1),n.next()))},i=this;r=n.next();)o();return this.addNewLine(),this.buffer.join("")},e.prototype.renderHTMLNode=function(e){switch(e.type){case"openTag":case"closeTag":this.renderElementNode(e);break;case"text":this.renderTextNode(e);break;case"html":this.renderRawHtmlNode(e)}},e.prototype.generateOpenTagString=function(e){var t=this,n=e.tagName,r=e.classNames,o=e.attributes;this.buffer.push("<"+n),r&&r.length>0&&this.buffer.push(' class="'+r.join(" ")+'"'),o&&Object.keys(o).forEach((function(e){var n=o[e];t.buffer.push(" "+e+'="'+n+'"')})),e.selfClose&&this.buffer.push(" /"),this.buffer.push(">")},e.prototype.generateCloseTagString=function(e){var t=e.tagName;this.buffer.push("</"+t+">")},e.prototype.addNewLine=function(){this.buffer.length&&"\n"!==xd(xd(this.buffer))&&this.buffer.push("\n")},e.prototype.addOuterNewLine=function(e){e.outerNewLine&&this.addNewLine()},e.prototype.addInnerNewLine=function(e){e.innerNewLine&&this.addNewLine()},e.prototype.renderTextNode=function(e){this.buffer.push(Hu(e.content))},e.prototype.renderRawHtmlNode=function(e){this.addOuterNewLine(e),this.buffer.push(e.content),this.addOuterNewLine(e)},e.prototype.renderElementNode=function(e){"openTag"===e.type?(this.addOuterNewLine(e),this.generateOpenTagString(e),e.selfClose?this.addOuterNewLine(e):this.addInnerNewLine(e)):(this.addInnerNewLine(e),this.generateCloseTagString(e),this.addOuterNewLine(e))},e}(),Qp=n(368),Yp=n.n(Qp),eh=["iframe","embed"],th=[];function nh(e){Ue(eh,e)&&th.push(e.toLowerCase())}function rh(e,t){return Yp().sanitize(e,o({ADD_TAGS:th,ADD_ATTR:["rel","target","hreflang","type"],FORBID_TAGS:["input","script","textarea","form","button","select","meta","style","link","title","object","base"]},t))}function oh(e,t){return e.literal.replace(new RegExp("(<\\s*"+t+"[^>]*>)|(</"+t+"\\s*[>])","ig"),"").trim()}function ih(e){var t=(e=e.match(ga)[0]).match(new RegExp(ha,"g"));return t?t.reduce((function(e,t){var n=t.trim().split("="),r=n[0],o=n.slice(1);return o.length&&(e[r]=o.join("=").replace(/'|"/g,"").trim()),e}),{}):{}}function sh(e){return vi()(e.attributes).reduce((function(e,t){return e[t.nodeName]=t.nodeValue,e}),{})}function ah(e,t,n,r){var o=r.getToDOMNode(t)(e),i=n(o.outerHTML),s=document.createElement("div");return s.innerHTML=i,{dom:o=s.firstChild,htmlAttrs:sh(o)}}var lh={htmlBlock:function(e,t,n){return{atom:!0,content:"block+",group:"block",attrs:{htmlAttrs:{default:{}},childrenHTML:{default:""},htmlBlock:{default:!0}},parseDOM:[{tag:e,getAttrs:function(e){return{htmlAttrs:sh(e),childrenHTML:e.innerHTML}}}],toDOM:function(r){var o=ah(r,e,t,n),s=o.dom,a=o.htmlAttrs;return a.class=a.class?a.class+" html-block":"html-block",i([e,a],vi()(s.childNodes))}}},htmlInline:function(e,t,n){return{attrs:{htmlAttrs:{default:{}},htmlInline:{default:!0}},parseDOM:[{tag:e,getAttrs:function(e){return{htmlAttrs:sh(e)}}}],toDOM:function(r){var o=ah(r,e,t,n).htmlAttrs;return[e,o,0]}}}};var ch=/^\s*<\s*\//,uh={paragraph:function(e,t){var n=t.entering,r=t.origin;return t.options.nodeId?{type:n?"openTag":"closeTag",outerNewLine:!0,tagName:"p"}:r()},softbreak:function(e){return{type:"html",content:e.prev&&"htmlInline"===e.prev.type&&/<br ?\/?>/.test(e.prev.literal)?"\n":"<br>\n"}},item:function(e,t){if(t.entering){var n={},r=[];return e.listData.task&&(n["data-task"]="",r.push("task-list-item"),e.listData.checked&&(r.push("checked"),n["data-task-checked"]="")),{type:"openTag",tagName:"li",classNames:r,attributes:n,outerNewLine:!0}}return{type:"closeTag",tagName:"li",outerNewLine:!0}},code:function(e){return[{type:"openTag",tagName:"code",attributes:{"data-backticks":String(e.tickCount)}},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"}]},codeBlock:function(e){var t=e,n=t.fenceLength,r=t.info,o=r?r.split(/\s+/):[],i=[],s={};if(n>3&&(s["data-backticks"]=n),o.length>0&&o[0].length>0){var a=o[0];i.push("lang-"+a),s["data-language"]=a}return[{type:"openTag",tagName:"pre",classNames:i},{type:"openTag",tagName:"code",attributes:s},{type:"text",content:e.literal},{type:"closeTag",tagName:"code"},{type:"closeTag",tagName:"pre"}]},customInline:function(e,t){var n=t.origin,r=t.entering,o=t.skipChildren,i=e.info;return-1!==i.indexOf("widget")&&r?(o(),[{type:"openTag",tagName:"span",classNames:["tui-widget"]},{type:"html",content:Ys(i,oa(e)).outerHTML},{type:"closeTag",tagName:"span"}]):n()}};function dh(e,t){var n=o({},uh);return e&&(n.link=function(t,n){var r=n.entering,i=(0,n.origin)();return r&&(i.attributes=o(o({},i.attributes),e)),i}),t&&Object.keys(t).forEach((function(e){var r=n[e],i=t[e];r&&Ga()(i)?n[e]=function(e,t){var n=o({},t);return n.origin=function(){return r(e,t)},i(e,n)}:Ue(["htmlBlock","htmlInline"],e)&&!Ga()(i)?n[e]=function(e,t){var n=e.literal.match(ga);if(n){var r=n[0],s=n[1],a=n[3],l=(s||a).toLowerCase(),c=i[l],u=oh(e,l);if(c){var d=o({},e);return d.attrs=ih(r),d.childrenHTML=u,d.type=l,t.entering=!ch.test(e.literal),c(d,t)}}return t.origin()}:n[e]=i})),n}var ph=["list","item","blockQuote"],hh=["UL","OL","BLOCKQUOTE"];function fh(e,t){var n,r=e.child(t);return!r.childCount||1===r.childCount&&!(null===(n=r.firstChild.text)||void 0===n?void 0:n.trim())}function mh(e,t,n){var r=Is(t)-1,o=Rs(t)-1,i=n[r].getBoundingClientRect(),s=n[o].offsetTop-n[r].offsetTop+n[o].clientHeight;return{height:s<=0?n[r].clientHeight:s+gh(e,n,Math.min(o+1,e.childCount-1)),rect:i}}function gh(e,t,n){for(var r=e.childCount-1,o=0;n<=r&&fh(e,n);)o+=t[n].clientHeight,n+=1;return o}function vh(e,t){for(var n=0;e&&e!==t&&(Ue(hh,e.tagName)||(n+=e.offsetTop),e.offsetParent!==t.offsetParent);)e=e.parentElement;return n}function yh(e,t,n){return e&&t>n+e.offsetTop?yh(e.nextElementSibling,t,n)||e:null}function bh(e,t){for(var n=e.querySelector('[data-nodeid="'+t.id+'"]');!n||Fs(t);)t=t.parent,n=e.querySelector('[data-nodeid="'+t.id+'"]');return function(e){var t=e.mdNode,n=e.el;for(;(Ue(ph,t.type)||"table"===t.type)&&t.firstChild;)t=t.firstChild,n=n.firstElementChild;return{mdNode:t,el:n}}({mdNode:t,el:n})}var wh={};function kh(e){e&&(delete wh[Number(e.getAttribute("data-nodeid"))],vi()(e.children).forEach((function(e){kh(e)})))}function xh(e,t,n){var r,o=wh[r=n]&&wh[r].height,i=function(e){return wh[e]&&wh[e].offsetTop}(n),s=o||e.clientHeight,a=i||vh(e,t)||e.offsetTop;return o||function(e,t){wh[e]=wh[e]||{},wh[e].height=t}(n,s),i||function(e,t){wh[e]=wh[e]||{},wh[e].offsetTop=t}(n,a),{nodeHeight:s,offsetTop:a}}var Ch=xa("md-preview-highlight");var Th=function(){function e(e,t){var n=document.createElement("div");this.el=n,this.eventEmitter=e,this.isViewer=!!t.isViewer,this.el.className=xa("md-preview");var r=t.linkAttributes,o=t.customHTMLRenderer,i=t.sanitizer,s=t.highlight,a=void 0!==s&&s;this.renderer=new Xp({gfm:!0,nodeId:!0,convertors:dh(r,o)}),this.cursorNodeId=null,this.sanitizer=i,this.initEvent(a),this.initContentSection(),this.isViewer&&(this.previewContent.style.overflowWrap="break-word")}return e.prototype.initContentSection=function(){this.previewContent=Ea('<div class="'+xa("contents")+'"></div>'),this.isViewer||this.el.appendChild(this.previewContent)},e.prototype.toggleActive=function(e){Sa(this.el,"active",e)},e.prototype.initEvent=function(e){var t=this;this.eventEmitter.listen("updatePreview",this.update.bind(this)),this.isViewer||(e&&(this.eventEmitter.listen("changeToolbarState",(function(e){var n=e.mdNode,r=e.cursorPos;t.updateCursorNode(n,r)})),this.eventEmitter.listen("blur",(function(){t.removeHighlight()}))),Vc()(this.el,"scroll",(function(e){t.eventEmitter.emit("scroll","preview",function(e,t){for(var n=t,r=null;n;){var o=n.firstElementChild;if(!o)break;r=n,n=yh(o,e,vh(n,t))}var i=n||r;return i===t?null:i}(e.target.scrollTop,t.previewContent))})),this.eventEmitter.listen("changePreviewTabPreview",(function(){return t.toggleActive(!0)})),this.eventEmitter.listen("changePreviewTabWrite",(function(){return t.toggleActive(!1)})))},e.prototype.removeHighlight=function(){if(this.cursorNodeId){var e=this.getElementByNodeId(this.cursorNodeId);e&&Ce()(e,Ch)}},e.prototype.updateCursorNode=function(e,t){e&&("tableRow"===(e=js(e,(function(e){return!function(e){switch(e.type){case"code":case"text":case"emph":case"strong":case"strike":case"link":case"image":case"htmlInline":case"linebreak":case"softbreak":case"customInline":return!0;default:return!1}}(e)}))).type?e=function(e,t){for(var n=e.firstChild;n&&n.next&&!(Ps(n.next)>t+1);)n=n.next;return n}(e,t[1]):"tableBody"===e.type&&(e=null));var n=e?e.id:null;if(this.cursorNodeId!==n){var r=this.getElementByNodeId(this.cursorNodeId),o=this.getElementByNodeId(n);r&&Ce()(r,Ch),o&&ke()(o,Ch),this.cursorNodeId=n}},e.prototype.getElementByNodeId=function(e){return e?this.previewContent.querySelector('[data-nodeid="'+e+'"]'):null},e.prototype.update=function(e){var t=this;e.forEach((function(e){return t.replaceRangeNodes(e)})),this.eventEmitter.emit("afterPreviewRender",this)},e.prototype.replaceRangeNodes=function(e){var t=this,n=e.nodes,r=e.removedNodeRange,o=this.previewContent,i=this.eventEmitter.emitReduce("beforePreviewRender",this.sanitizer(n.map((function(e){return t.renderer.render(e)})).join("")));if(r){var s=r.id,a=s[0],l=s[1],c=this.getElementByNodeId(a),u=this.getElementByNodeId(l);if(c){c.insertAdjacentHTML("beforebegin",i);for(var d=c;d&&d!==u;){var p=d.nextElementSibling;Ma(d),kh(d),d=p}(null==d?void 0:d.parentNode)&&(Ma(d),kh(d))}}else o.insertAdjacentHTML("afterbegin",i)},e.prototype.getRenderer=function(){return this.renderer},e.prototype.destroy=function(){zc()(this.el,"scroll"),this.el=null},e.prototype.getElement=function(){return this.el},e.prototype.getHTML=function(){return La(this.previewContent.innerHTML)},e.prototype.setHTML=function(e){this.previewContent.innerHTML=e},e.prototype.setHeight=function(e){be()(this.el,{height:e+"px"})},e.prototype.setMinHeight=function(e){be()(this.el,{minHeight:e+"px"})},e}(),Mh=Th;function Sh(e,t){for(var n=e.depth;n;){var r=e.node(n);if(t(r,n))return{node:r,depth:n,offset:n>0?e.before(n):0};n-=1}return null}function Eh(e){return!!Sh(e,(function(e){var t=e.type;return"listItem"===t.name||"bulletList"===t.name||"orderedList"===t.name}))}function Nh(e){return!!Sh(e,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}))}function Oh(e){return Sh(e,(function(e){return"listItem"===e.type.name}))}function Dh(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}function Ah(e){return Object.keys(e).reduce((function(t,n){return"rawHTML"!==n&&e[n]&&(t[n="className"===n?"class":n]=e[n]),t}),{})}function Lh(e){return{tag:e,getAttrs:function(e){return["rawHTML","colspan","rowspan","extended"].reduce((function(t,n){var r="rawHTML"===n?"data-raw-html":n,o=e.getAttribute(r);return o&&(t[n]=Ue(["rawHTML","extended"],n)?o:Number(o)),t}),{})}}}function Ih(e){var t=e.htmlAttrs,n=e.classNames;return o(o({},t),{class:n?n.join(" "):null})}function Rh(e,t,n,r){var o=t.$from,i=t.$to,s=t.depth,a=t,l=!1;if(s>=2&&o.node(s-1).type.compatibleContent(n)&&0===t.startIndex&&o.index(s-1)){var c=e.doc.resolve(t.start-2);a=new I(c,c,s),t.endIndex<t.parent.childCount&&(t=new I(o,e.doc.resolve(i.end(s)),s)),l=!0}var u=function(e,t,n,r){var o=function(e,t){var n=e.parent,r=e.startIndex,o=e.endIndex,i=n.contentMatchAt(r).findWrapping(t);if(i){var s=i.length?i[0]:t;return n.canReplaceWith(r,o,s)?i:null}return null}(e,n),i=function(e,t){var n=e.parent,r=e.startIndex,o=e.endIndex,i=n.child(r),s=t.contentMatch.findWrapping(i.type);if(s){for(var a=(s.length?s[s.length-1]:t).contentMatch,l=r;a&&l<o;l+=1)a=a.matchType(n.child(l).type);if(a&&a.validEnd)return s}return null}(t,n);if(o&&i){var s=o.map((function(e){return{type:e}})),a=i.map((function(e){return{type:e,attrs:r}}));return s.concat({type:n}).concat(a)}return null}(a,t,n,r);return u?function(e,t,n,r,o){for(var i=t.start,s=t.end,a=t.startIndex,l=t.endIndex,c=t.parent,u=d.empty,p=n.length-1;p>=0;p-=1)u=d.from(n[p].type.create(n[p].attrs,u));e.step(new wt(i-(r?2:0),s,i,s,new v(u,0,0),n.length,!0));var h=0;for(p=0;p<n.length;p+=1)if(n[p].type===o){h=p+1;break}for(var f=n.length-h,m=i+n.length-(r?2:0),g=(p=a,l);p<g;p+=1)!(p===a)&&Mt(e.doc,m,f)&&(e.split(m,f),m+=2*f),m+=c.child(p).nodeSize;return e}(e,t,u,l,n):e}function Ph(e,t){for(var n=e.resolve(t);"paragraph"!==n.node().type.name;)t-=2,n=e.resolve(t);return Oh(n)}function Bh(e){return function(t,n){var r=t.selection,o=t.tr,i=r.$from,s=r.$to,a=i.blockRange(s);if(a){var l=Eh(i)?function(e,t,n){var r=t.$from,o=t.$to,i=Oh(r),s=Oh(o);if(i&&s)for(;s;){var a=s.offset,l=s.node,c=s.depth;l.attrs.task&&e.setNodeMarkup(a,null,{task:!1,checked:!1});var u=e.doc.resolve(a);if(u.parent.type!==n){var d=u.before(c-1);e.setNodeMarkup(d,n)}if(a===i.offset)break;s=Ph(e.doc,a)}return e}(o,a,e):Rh(o,a,e);return n(l),!0}return!1}}function Fh(){return function(e,t){var n=e.selection,r=e.tr,o=e.schema,i=n.$from,s=n.$to,a=i.blockRange(s);if(a){var l=Eh(i)?function(e,t){var n=t.$from,r=t.$to,o=Oh(n),i=Oh(r);if(o&&i)for(;i;){var s=i.offset,a={task:!i.node.attrs.task,checked:!1};if(e.setNodeMarkup(s,null,a),s===o.offset)break;i=Ph(e.doc,s)}return e}(r,a):Rh(r,a,o.nodes.bulletList,{task:!0});return t(l),!0}return!1}}function Hh(e){return function(t,n){var r=t.tr,o=t.selection,i=o.$from,s=o.$to,a=i.blockRange(s,(function(t){var n=t.childCount,r=t.firstChild;return!!n&&r.type===e}));if(a){var l=i.node(a.depth-1).type===e?function(e,t,n){var r=t.$from,o=t.$to,i=t.end,s=t.depth,a=t.parent,l=o.end(s);return i<l&&(e.step(new wt(i-1,l,i,l,new v(d.from(n.create(null,a.copy())),1,0),1,!0)),t=new I(e.doc.resolve(r.pos),e.doc.resolve(l),s)),e.lift(t,Ct(t)),e}(r,a,e):function(e,t){for(var n=t.parent,r=t.end,o=t.endIndex-1,i=t.startIndex;o>i;o-=1)r-=n.child(o).nodeSize,e.delete(r-1,r+1);var s=e.doc.resolve(t.start),a=s.nodeAfter,l=0===t.startIndex,c=t.endIndex===n.childCount,u=s.node(-1),p=s.index(-1),h=u.canReplace(p+(l?0:1),p+1,null==a?void 0:a.content.append(c?d.empty:d.from(n)));if(a&&h){var f=s.pos,m=f+a.nodeSize;e.step(new wt(f-(l?1:0),m+(c?1:0),f+1,m-1,new v((l?d.empty:d.from(n.copy(d.empty))).append(c?d.empty:d.from(n.copy(d.empty))),l?0:1,c?0:1),l?0:1))}return e}(r,a);return n(l),!0}return!1}}function zh(){return function(){return function(e,t){var n=e.selection,r=e.schema,o=n.$from,i=n.$to;return!(!o.blockRange(i)||!Eh(o))&&function(e){return function(t,n){var r=t.tr,o=t.selection,i=o.$from,s=o.$to,a=i.blockRange(s,(function(t){var n=t.childCount,r=t.firstChild;return!!n&&r.type===e}));if(a&&a.startIndex>0){var l=a.parent,c=l.child(a.startIndex-1);if(c.type!==e)return!1;var u=c.lastChild&&c.lastChild.type===l.type,p=u?d.from(e.create()):null,h=new v(d.from(e.create(null,d.from(l.type.create(null,p)))),u?3:1,0),f=a.start,m=a.end;return r.step(new wt(f-(u?3:1),m,f,m,h,1,!0)),n(r),!0}return!1}}(r.nodes.listItem)(e,t)}}}function qh(){return{indent:zh(),outdent:function(){return function(e,t){var n=e.selection,r=e.schema,o=n.$from,i=n.$to;return!(!o.blockRange(i)||!Eh(o))&&Hh(r.nodes.listItem)(e,t)}}}}var Vh=new Map,jh=function(){function e(e,t,n,r){this.table=e,this.tableRows=t,this.tableStartPos=n,this.rowInfo=r}return e.create=function(t){var n=Sh(t,(function(e){return"table"===e.type.name}));if(n){var r=n.node,o=n.depth,i=n.offset,s=Vh.get(r);if((null==s?void 0:s.tableStartPos)===i+1)return s;var a=[],l=t.start(o),c=r.child(0),u=r.child(1),d=$h(c,l),p=$h(u,l+c.nodeSize);c.forEach((function(e){return a.push(e)})),u.forEach((function(e){return a.push(e)}));var h=new e(r,a,l,d.concat(p));return Vh.set(r,h),h}return null},Object.defineProperty(e.prototype,"totalRowCount",{get:function(){return this.rowInfo.length},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"totalColumnCount",{get:function(){return this.rowInfo[0].length},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"tableStartOffset",{get:function(){return this.tableStartPos},enumerable:!1,configurable:!0}),Object.defineProperty(e.prototype,"tableEndOffset",{get:function(){return this.tableStartPos+this.table.nodeSize-1},enumerable:!1,configurable:!0}),e.prototype.getCellInfo=function(e,t){return this.rowInfo[e][t]},e.prototype.posAt=function(e,t){for(var n=0,r=this.tableStartPos;;n+=1){var o=r+this.tableRows[n].nodeSize;if(n===e){for(var i=t;i<this.totalColumnCount&&this.rowInfo[n][i].offset<r;)i+=1;return i===this.totalColumnCount?o:this.rowInfo[n][i].offset}r=o}},e.prototype.getNodeAndPos=function(e,t){var n=this.rowInfo[e][t];return{node:this.table.nodeAt(n.offset-this.tableStartOffset),pos:n.offset}},e.prototype.extendedRowspan=function(e,t){return!1},e.prototype.extendedColspan=function(e,t){return!1},e.prototype.getRowspanCount=function(e,t){return 0},e.prototype.getColspanCount=function(e,t){return 0},e.prototype.decreaseColspanCount=function(e,t){return 0},e.prototype.decreaseRowspanCount=function(e,t){return 0},e.prototype.getColspanStartInfo=function(e,t){return null},e.prototype.getRowspanStartInfo=function(e,t){return null},e.prototype.getCellStartOffset=function(e,t){var n=this.rowInfo[e][t].offset;return this.extendedRowspan(e,t)?this.posAt(e,t):n},e.prototype.getCellEndOffset=function(e,t){var n=this.rowInfo[e][t],r=n.offset,o=n.nodeSize;return this.extendedRowspan(e,t)?this.posAt(e,t):r+o},e.prototype.getCellIndex=function(e){for(var t=0;t<this.totalRowCount;t+=1)for(var n=this.rowInfo[t],r=0;r<this.totalColumnCount;r+=1)if(n[r].offset+1>e.pos)return[t,r];return[0,0]},e.prototype.getRectOffsets=function(e,t){var n,r,o;void 0===t&&(t=e),e.pos>t.pos&&(e=(n=[t,e])[0],t=n[1]);var i=this.getCellIndex(e),s=i[0],a=i[1],l=this.getCellIndex(t),c=l[0],u=l[1];return s=(r=st(s,c))[0],c=r[1],a=(o=st(a,u))[0],u=o[1],this.getSpannedOffsets({startRowIdx:s,startColIdx:a,endRowIdx:c,endColIdx:u})},e.prototype.getSpannedOffsets=function(e){return e},e}(),$h=function(e,t){var n=[];return e.forEach((function(e,r){var o={rowspanMap:{},colspanMap:{},length:0};e.forEach((function(e,n){for(var i=e.nodeSize,s=0;o[s];)s+=1;o[s]={offset:t+r+n+2,nodeSize:i},o.length+=1})),n.push(o)})),n};function _h(e,t){return it(jh.prototype,e),$h=t,jh}var Uh=function(e){function n(t,n){void 0===n&&(n=t);var r=this,o=t.node(0),i=jh.create(t),s=i.getRectOffsets(t,n),a=function(e,t,n){for(var r=n.startRowIdx,o=n.startColIdx,i=n.endRowIdx,s=n.endColIdx,a=[],l=r;l<=i;l+=1)for(var c=o;c<=s;c+=1){var u=t.getCellInfo(l,c),d=u.offset,p=u.nodeSize;a.push(new jt(e.resolve(d+1),e.resolve(d+p-1)))}return a}(o,i,s);return(r=e.call(this,a[0].$from,a[0].$to,a)||this).startCell=t,r.endCell=n,r.offsetMap=i,r.isCellSelection=!0,r.visible=!1,r}return t(n,e),n.prototype.map=function(e,t){var r=this.startCell.pos,o=this.endCell.pos,i=e.resolve(t.map(r)),s=e.resolve(t.map(o)),a=jh.create(i);if(this.offsetMap.totalColumnCount>a.totalColumnCount||this.offsetMap.totalRowCount>a.totalRowCount){var l={tableBody:1,tableRow:2,tableCell:3,paragraph:4}[s.parent.type.name],c=s.end(s.depth-l),u=Math.min(c-4,s.pos);return Ut.create(e,u)}return new n(i,s)},n.prototype.eq=function(e){return e instanceof n&&e.startCell.pos===this.startCell.pos&&e.endCell.pos===this.endCell.pos},n.prototype.content=function(){for(var e=this.startCell.node(-2),t=this.startCell.start(-2),n=e.child(1).firstChild,r=e.child(0).type.create(),o=e.child(1).type.create(),i=jh.create(this.startCell),s=i.getRectOffsets(this.startCell,this.endCell),a=s.startRowIdx,l=s.startColIdx,c=s.endRowIdx,u=s.endColIdx,p=!1,h=a;h<=c;h+=1){for(var f=[],m=l;m<=u;m+=1){var g=i.getCellInfo(h,m).offset,y=e.nodeAt(g-t);y&&(p="tableHeadCell"===y.type.name,i.extendedRowspan(h,m)||i.extendedColspan(h,m)?f.push(y.type.create({extended:!0})):f.push(y.copy(y.content)))}var b=n.copy(d.from(f)),w=p?r:o;w.content=w.content.append(d.from(b))}return new v(function(e,t){var n=[];return e.childCount&&n.push(e),t.childCount&&n.push(t),d.from(n)}(r,o),1,1)},n.prototype.toJSON=function(){return JSON.stringify(this)},n}(Vt),Wh=Uh;function Jh(e,t,n,r){for(var o=n.nodes,i=o.tableRow,s=o.tableBodyCell,a=o.paragraph,l=[],c=0;c<e;c+=1){for(var u=[],d=0;d<t;d+=1){var p=r&&r[c*t+d],h=a.create(null,p?n.text(p):[]);u.push(s.create(null,h))}l.push(i.create(null,u))}return l}function Gh(e,t,n,r){void 0===r&&(r=null);for(var o=n.nodes,i=o.tableHeadCell,s=o.tableBodyCell,a=o.paragraph,l=0===t?i:s,c=[],u=0;u<e;u+=1)c.push(l.create(r,a.create()));return c}function Kh(e,t){for(;e&&e!==t;){if("TD"===e.nodeName||"TH"===e.nodeName)return e;e=e.parentNode}return null}function Zh(e){return Sh(e,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}))}function Xh(e){if(e instanceof Ut){var t=e.$anchor,n=Zh(t);if(n){var r=t.node(0).resolve(t.before(n.depth));return{anchor:r,head:r}}}var o=e;return{anchor:o.startCell,head:o.endCell}}function Qh(e){var t;if(e.size){var n=e.content,r=e.openStart,o=e.openEnd;if(1!==n.childCount)return null;for(;1===n.childCount&&(r>0&&o>0||"table"===(null===(t=n.firstChild)||void 0===t?void 0:t.type.name));)r-=1,o-=1,n=n.firstChild.content;if("tableHead"===n.firstChild.type.name||"tableBody"===n.firstChild.type.name)return n}return null}function Yh(e){var t=e.startRowIdx,n=e.startColIdx;return{rowCount:e.endRowIdx-t+1,columnCount:e.endColIdx-n+1}}function ef(e,t){return o(o({},e.attrs),t)}var tf=new un("cellSelection"),nf=function(){function e(e){this.view=e,this.handlers={mousedown:this.handleMousedown.bind(this),mousemove:this.handleMousemove.bind(this),mouseup:this.handleMouseup.bind(this)},this.startCellPos=null,this.init()}return e.prototype.init=function(){this.view.dom.addEventListener("mousedown",this.handlers.mousedown)},e.prototype.handleMousedown=function(e){var t=Kh(e.target,this.view.dom);if(2!==e.button){if(t){var n=this.getCellPos(e);n&&(this.startCellPos=n),this.bindEvent()}}else e.preventDefault()},e.prototype.handleMousemove=function(e){var t,n=tf.getState(this.view.state),r=this.getCellPos(e),o=this.startCellPos;n?t=this.view.state.doc.resolve(n):o!==r&&(t=o),t&&o&&r&&this.setCellSelection(o,r)},e.prototype.handleMouseup=function(){this.startCellPos=null,this.unbindEvent(),null!==tf.getState(this.view.state)&&this.view.dispatch(this.view.state.tr.setMeta(tf,-1))},e.prototype.bindEvent=function(){var e=this.view.dom;e.addEventListener("mousemove",this.handlers.mousemove),e.addEventListener("mouseup",this.handlers.mouseup)},e.prototype.unbindEvent=function(){var e=this.view.dom;e.removeEventListener("mousemove",this.handlers.mousemove),e.removeEventListener("mouseup",this.handlers.mouseup)},e.prototype.getCellPos=function(e){var t=e.clientX,n=e.clientY,r=this.view.posAtCoords({left:t,top:n});if(r){var o=this.view.state.doc,i=o.resolve(r.pos),s=Zh(i);if(s){var a=i.before(s.depth);return o.resolve(a)}}return null},e.prototype.setCellSelection=function(e,t){var n=this.view.state,r=n.selection,o=n.tr,i=null===tf.getState(this.view.state),s=new Wh(e,t);if(i||!r.eq(s)){var a=o.setSelection(s);i&&a.setMeta(tf,t.pos),this.view.dispatch(a)}},e.prototype.destroy=function(){this.view.dom.removeEventListener("mousedown",this.handlers.mousedown)},e}(),rf=nf,of=xa("cell-selected");function sf(e){var t=e.selection,n=e.doc;if(t instanceof Wh){var r=[];return t.ranges.forEach((function(e){var t=e.$from,n=e.$to;r.push(Vo.node(t.pos-1,n.pos+1,{class:of}))})),_o.create(n,r)}return null}var af=n(928),lf=n.n(af),cf=function(){function e(){this.keys=[],this.values=[]}return e.prototype.getKeyIndex=function(e){return lf()(e,this.keys)},e.prototype.get=function(e){return this.values[this.getKeyIndex(e)]},e.prototype.set=function(e,t){var n=this.getKeyIndex(e);return n>-1?this.values[n]=t:(this.keys.push(e),this.values.push(t)),this},e.prototype.has=function(e){return this.getKeyIndex(e)>-1},e.prototype.delete=function(e){var t=this.getKeyIndex(e);return t>-1&&(this.keys.splice(t,1),this.values.splice(t,1),!0)},e.prototype.forEach=function(e,t){var n=this;void 0===t&&(t=this),this.values.forEach((function(r,o){r&&n.keys[o]&&e.call(t,r,n.keys[o],n)}))},e.prototype.clear=function(){this.keys=[],this.values=[]},e}(),uf=cf,df="en-US",pf=function(){function e(){this.code=df,this.langs=new uf}return e.prototype.setCode=function(e){this.code=e||df},e.prototype.setLanguage=function(e,t){var n=this;(e=[].concat(e)).forEach((function(e){if(n.langs.has(e)){var r=n.langs.get(e);n.langs.set(e,ve()(r,t))}else n.langs.set(e,t)}))},e.prototype.get=function(e,t){t||(t=this.code);var n=this.langs.get(t);n||(n=this.langs.get(df));var r=n[e];if(!r)throw new Error('There is no text key "'+e+'" in '+t);return r},e}(),hf=new pf,ff=[[{action:"Add row to up",command:"addRowToUp",disableInThead:!0,className:"add-row-up"},{action:"Add row to down",command:"addRowToDown",disableInThead:!0,className:"add-row-down"},{action:"Remove row",command:"removeRow",disableInThead:!0,className:"remove-row"}],[{action:"Add column to left",command:"addColumnToLeft",className:"add-column-left"},{action:"Add column to right",command:"addColumnToRight",className:"add-column-right"},{action:"Remove column",command:"removeColumn",className:"remove-column"}],[{action:"Align column to left",command:"alignColumn",payload:{align:"left"},className:"align-column-left"},{action:"Align column to center",command:"alignColumn",payload:{align:"center"},className:"align-column-center"},{action:"Align column to right",command:"alignColumn",payload:{align:"right"},className:"align-column-right"}],[{action:"Remove table",command:"removeTable",className:"remove-table"}]];function mf(e,t){return ff.map((function(n){return n.map((function(n){var r=n.action,o=n.command,i=n.payload,s=n.disableInThead,a=n.className;return{label:hf.get(r),onClick:function(){e.emit("command",o,i)},disabled:t&&!!s,className:a}}))})).concat()}function gf(e){return new an({props:{handleDOMEvents:{contextmenu:function(t,n){var r=Kh(n.target,t.dom);if(r){n.preventDefault();var o=n,i=o.clientX,s=o.clientY,a=t.dom.parentNode.getBoundingClientRect(),l=a.left,c=a.top,u="TH"===r.nodeName;return e.emit("contextmenu",{pos:{left:i-l+10+"px",top:s-c+30+"px"},menuGroups:mf(e,u),tableCell:r}),!0}return!1}}}})}var vf=["image","link","customBlock","frontMatter"],yf=["strong","strike","emph","code"],bf=["bulletList","orderedList","taskList"];function wf(e,t,n){var r=e.$from,o=e.$to,i=e.from,s=e.to,a={indent:{active:!1,disabled:!0},outdent:{active:!1,disabled:!0}};return t.nodesBetween(i,s,(function(e,t,i){var s=function(e,t){var n=e.type.name;return"listItem"===n?e.attrs.task?"taskList":t.type.name:-1!==n.indexOf("table")?"table":n}(e,i);Ue(vf,s)||(Ue(bf,s)?(!function(e,t){t[e]={active:!0},bf.filter((function(t){return t!==e})).forEach((function(e){t[e]&&delete t[e]}))}(s,a),a.indent.disabled=!1,a.outdent.disabled=!1):"paragraph"===s||"text"===s?function(e,t,n,r){yf.forEach((function(o){var i=n.marks[o],s=e.marksAcross(t)||[];i.isInSet(s)&&(r[o]={active:!0})}))}(r,o,n,a):a[s]={active:!0})})),a}function kf(e){return new an({view:function(){return{update:function(t){var n=t.state,r=n.selection,o=n.doc,i=n.schema;e.emit("changeToolbarState",{toolbarState:wf(r,o,i)})}}}})}var xf=function(){function e(e,t,n,r){var o=this;this.openEditor=function(){if(o.innerEditorView)throw new Error("The editor is already opened.");o.dom.draggable=!1,o.wrapper.style.display="none",o.innerViewContainer.style.display="block",o.innerEditorView=new ui(o.innerViewContainer,{state:on.create({doc:o.node,plugins:[Ai({"Mod-z":function(){return Ms(o.innerEditorView.state,o.innerEditorView.dispatch)},"Shift-Mod-z":function(){return Ss(o.innerEditorView.state,o.innerEditorView.dispatch)},Tab:function(e,t){return t(e.tr.insertText("\t")),!0},Enter:Hi,Escape:function(){return o.cancelEditing(),!0},"Ctrl-Enter":function(){return o.saveAndFinishEditing(),!0}}),Ts()]}),dispatchTransaction:function(e){return o.dispatchInner(e)},handleDOMEvents:{mousedown:function(){return o.editorView.hasFocus()&&o.innerEditorView.focus(),!0},blur:function(){return o.saveAndFinishEditing(),!0}}}),o.innerEditorView.focus()},this.node=e,this.editorView=t,this.getPos=n,this.toDOMAdaptor=r,this.innerEditorView=null,this.canceled=!1,this.dom=document.createElement("div"),this.dom.className=xa("custom-block"),this.wrapper=document.createElement("div"),this.wrapper.className=xa("custom-block-view"),this.createInnerViewContainer(),this.renderCustomBlock(),this.dom.appendChild(this.innerViewContainer),this.dom.appendChild(this.wrapper)}return e.prototype.renderToolArea=function(){var e=this,t=document.createElement("div"),n=document.createElement("span"),r=document.createElement("button");t.className="tool",n.textContent=this.node.attrs.info,n.className="info",r.type="button",r.addEventListener("click",(function(){return e.openEditor()})),t.appendChild(n),t.appendChild(r),this.wrapper.appendChild(t)},e.prototype.renderCustomBlock=function(){var e=this.toDOMAdaptor.getToDOMNode(this.node.attrs.info);if(e){for(var t=e(this.node);this.wrapper.hasChildNodes();)this.wrapper.removeChild(this.wrapper.lastChild);t&&this.wrapper.appendChild(t),this.renderToolArea()}},e.prototype.createInnerViewContainer=function(){this.innerViewContainer=document.createElement("div"),this.innerViewContainer.className=xa("custom-block-editor"),this.innerViewContainer.style.display="none"},e.prototype.closeEditor=function(){this.innerEditorView&&(this.innerEditorView.destroy(),this.innerEditorView=null,this.innerViewContainer.style.display="none"),this.wrapper.style.display="block"},e.prototype.saveAndFinishEditing=function(){var e=this.editorView.state.selection.to,t=this.editorView.state;this.editorView.dispatch(t.tr.setSelection(Os(t.tr,e))),this.editorView.focus(),this.renderCustomBlock(),this.closeEditor()},e.prototype.cancelEditing=function(){var e=function(e){let t=xs.getState(e);return t?t.done.eventCount:0}(this.innerEditorView.state);for(this.canceled=!0;e--;)Ms(this.innerEditorView.state,this.innerEditorView.dispatch),Ms(this.editorView.state,this.editorView.dispatch);this.canceled=!1;var t=this.editorView.state.selection.to,n=this.editorView.state;this.editorView.dispatch(n.tr.setSelection(Ut.create(n.doc,t))),this.editorView.focus(),this.closeEditor()},e.prototype.dispatchInner=function(e){var t=this.innerEditorView.state.applyTransaction(e),n=t.state,r=t.transactions;if(this.innerEditorView.updateState(n),!this.canceled&&Ga()(this.getPos)){for(var o=this.editorView.state.tr,i=dt.offset(this.getPos()+1),s=0;s<r.length;s+=1)for(var a=r[s].steps,l=0;l<a.length;l+=1)o.step(a[l].map(i));o.docChanged&&this.editorView.dispatch(o)}},e.prototype.update=function(e){return!!e.sameMarkup(this.node)&&(this.node=e,this.innerEditorView||this.renderCustomBlock(),!0)},e.prototype.stopEvent=function(e){return!!this.innerEditorView&&!!e.target&&this.innerEditorView.dom.contains(e.target)},e.prototype.ignoreMutation=function(){return!0},e.prototype.destroy=function(){this.dom.removeEventListener("dblclick",this.openEditor),this.closeEditor()},e}(),Cf="image-link",Tf=function(){function e(e,t,n,r){var o,i=this;this.handleMousedown=function(e){e.preventDefault();var t=e.target,n=e.offsetX,r=e.offsetY;if(i.imageLink&&Ga()(i.getPos)&&ca()(t,Cf)){var o=getComputedStyle(t,":before");if(e.stopPropagation(),wa(o,n,r)){var s=i.view.state.tr,a=i.getPos();s.setSelection(Os(s,a,a+1)),i.view.dispatch(s),i.eventEmitter.emit("openPopup","link",i.imageLink.attrs)}}},this.node=e,this.view=t,this.getPos=n,this.eventEmitter=r,this.imageLink=null!==(o=e.marks.filter((function(e){return"link"===e.type.name}))[0])&&void 0!==o?o:null,this.dom=this.createElement(),this.bindEvent()}return e.prototype.createElement=function(){var e=this.createImageElement(this.node);if(this.imageLink){var t=document.createElement("span");return t.className=Cf,t.appendChild(e),t}return e},e.prototype.createImageElement=function(e){var t=document.createElement("img"),n=e.attrs,r=n.imageUrl,o=n.altText,i=Ih(e.attrs);return t.src=r,o&&(t.alt=o),Aa(i,t),t},e.prototype.bindEvent=function(){this.imageLink&&this.dom.addEventListener("mousedown",this.handleMousedown)},e.prototype.stopEvent=function(){return!0},e.prototype.destroy=function(){this.imageLink&&this.dom.removeEventListener("mousedown",this.handleMousedown)},e}(),Mf=function(){function e(e,t,n,r){var o=this;this.contentDOM=null,this.input=null,this.timer=null,this.handleMousedown=function(e){var t=e.target;if("none"!==getComputedStyle(t,":after").backgroundImage&&Ga()(o.getPos)){var n=o.view.coordsAtPos(o.getPos()),r=n.top,i=n.right;o.createLanguageEditor({top:r,right:i})}},this.handleKeydown=function(e){"Enter"===e.key&&o.input&&(e.preventDefault(),o.changeLanguage())},this.node=e,this.view=t,this.getPos=n,this.eventEmitter=r,this.createElement(),this.bindDOMEvent(),this.bindEvent()}return e.prototype.createElement=function(){var e=this.node.attrs.language,t=document.createElement("div");t.setAttribute("data-language",e||"text"),t.className="toastui-editor-ww-code-block";var n=this.createCodeBlockElement(),r=n.firstChild;t.appendChild(n),this.dom=t,this.contentDOM=r},e.prototype.createCodeBlockElement=function(){var e=document.createElement("pre"),t=document.createElement("code"),n=this.node.attrs.language,r=Ih(this.node.attrs);return n&&t.setAttribute("data-language",n),Aa(r,e),e.appendChild(t),e},e.prototype.createLanguageEditor=function(e){var t=this,n=e.top,r=e.right,o=document.createElement("span");o.className="toastui-editor-ww-code-block-language";var i=document.createElement("input");i.type="text",i.value=this.node.attrs.language,o.appendChild(i),this.view.dom.parentElement.appendChild(o);var s=o.clientWidth;be()(o,{top:n+10+"px",left:r-s-10+"px",width:s+"px"}),this.input=i,this.input.addEventListener("blur",(function(){return t.changeLanguage()})),this.input.addEventListener("keydown",this.handleKeydown),this.clearTimer(),this.timer=setTimeout((function(){t.input.focus()}))},e.prototype.bindDOMEvent=function(){this.dom&&this.dom.addEventListener("click",this.handleMousedown)},e.prototype.bindEvent=function(){var e=this;this.eventEmitter.listen("scroll",(function(){e.input&&e.reset()}))},e.prototype.changeLanguage=function(){if(this.input&&Ga()(this.getPos)){var e=this.input.value;this.reset();var t=this.getPos(),n=this.view.state.tr;n.setNodeMarkup(t,null,{language:e}),this.view.dispatch(n)}},e.prototype.reset=function(){var e;if(null===(e=this.input)||void 0===e?void 0:e.parentElement){var t=this.input.parentElement;this.input=null,Ma(t)}},e.prototype.clearTimer=function(){this.timer&&(clearTimeout(this.timer),this.timer=null)},e.prototype.stopEvent=function(){return!0},e.prototype.update=function(e){return!!e.sameMarkup(this.node)&&(this.node=e,!0)},e.prototype.destroy=function(){this.reset(),this.clearTimer(),this.dom&&this.dom.removeEventListener("click",this.handleMousedown)},e}(),Sf=/MsoListParagraph/,Ef=/style=(.|\n)*mso-/,Nf=/mso-list:(.*)/,Of=/O:P/,Df=/^(n|u|l)/;function Af(e){for(var t=[],n=document.createTreeWalker(e,1,null,!1);n.nextNode();){var r=n.currentNode;if(Ta(r)){var o=r,i=o.outerHTML,s=o.textContent,a=Ef.test(i),l=Nf.test(i);a&&!l&&s?t.push([r,!0]):(Of.test(r.nodeName)||a&&!s||l)&&t.push([r,!1])}}return t.forEach((function(e){var t=e[0];e[1]?function(e){for(var t=[];e.firstChild;)t.push(e.firstChild),e.parentNode&&e.parentNode.insertBefore(e.firstChild,e);Ma(e)}(t):Ma(t)})),e.innerHTML.trim()}function Lf(e){var t=[];return e.forEach((function(e,n){var r=t[n-1],o=function(e,t){var n=e.getAttribute("style");if(n){var r=n.match(Nf)[1].trim().split(" ")[1];return{id:t,level:parseInt(r.replace("level",""),10),prev:null,parent:null,children:[],unordered:Df.test(e.textContent||""),contents:Af(e)}}return null}(e,n);o&&(r&&function(e,t){if(t.level<e.level)t.children.push(e),e.parent=t;else{for(;t&&t.level!==e.level;)t=t.parent;t&&(e.prev=t,e.parent=t.parent,e.parent&&e.parent.children.push(e))}}(o,r),t.push(o))})),t}function If(e){var t=e[0].unordered?"ul":"ol",n=document.createElement(t);return e.forEach((function(e){var t=e.children,r=e.contents,o=document.createElement("li");o.innerHTML=r,n.appendChild(o),t.length&&n.appendChild(If(t))})),n}function Rf(e){return If(Lf(e).filter((function(e){return!e.parent})))}function Pf(e){var t=document.createElement("div");t.innerHTML=e;var n,r,o,i=[],s=(n=t,r="p.MsoListParagraph",(o=vi()(n.querySelectorAll(r))).length?o:[]);return s.forEach((function(e){var n=function(e){for(;e&&!Ta(e);)e=e.nextSibling;return!e||!Sf.test(e.className)}(e.nextSibling);if(i.push(e),n){var r=Rf(i),o=e.nextSibling;o?function(e,t){t.parentNode&&t.parentNode.insertBefore(e,t)}(r,o):function(e,t){(t=aa()(t)?vi()(t):[t]).forEach((function(t){e.appendChild(t)}))}(t,r),i=[]}Ma(e)})),""+(s.length?"<p></p>":"")+t.innerHTML}var Bf="\x3c!--StartFragment--\x3e";function Ff(e){return function(e){return Ef.test(e)}(e=function(e){return/<\/td>((?!<\/tr>)[\s\S])*$/i.test(e)&&(e="<tr>"+e+"</tr>"),/<\/tr>((?!<\/table>)[\s\S])*$/i.test(e)&&(e="<table>"+e+"</table>"),e}(e=function(e){var t=e.indexOf(Bf),n=e.lastIndexOf("\x3c!--EndFragment--\x3e");return t>-1&&n>-1&&(e=e.slice(t+Bf.length,n)),e.replace(/<br[^>]*>/g,ba)}(e)))&&(e=Pf(e)),e}function Hf(e,t,n){for(var r=[],o=e.childCount,i=0;i<o;i+=1)if(!e.child(i).attrs.extended){var s=i<o?n.create(e.child(i).attrs,e.child(i).content):n.createAndFill();r.push(s)}return r}function zf(e,t,n){var r=n.nodes,o=r.tableRow,i=Hf(e,0,r.tableHeadCell);return o.create(null,i)}function qf(e,t,n){var r=n.nodes,o=r.tableRow,i=Hf(e,0,r.tableBodyCell);return o.create(null,i)}function Vf(e){var t=[],n=[];"tableHead"===e.firstChild.type.name&&e.firstChild.forEach((function(e){return t.push(e)}));"tableBody"===e.lastChild.type.name&&e.lastChild.forEach((function(e){return n.push(e)}));return i(i([],t),n)}function jf(e,t,n){var r=zf(e,0,n);return n.nodes.tableHead.create(null,r)}function $f(e,t,n){var r=e.map((function(e){return qf(e,0,n)}));if(!e.length){var o=function(e,t){for(var n=t.nodes,r=n.tableRow,o=n.tableBodyCell,i=[],s=0;s<e;s+=1){var a=o.createAndFill();i.push(a)}return r.create({dummyRowForPasting:!0},i)}(t,n);r.push(o)}return n.nodes.tableBody.create(null,r)}function _f(e,t,n){var r=[],o=e.content,i=e.openStart,s=e.openEnd;return o.forEach((function(e){if("table"===e.type.name){var o=Qh(new v(d.from(e),0,0));if(o){var i=Vf(o),s="tableBody"===o.firstChild.type.name,a=function(e,t,n,r){var o=function(e){return e.reduce((function(e,t){return e.childCount>t.childCount?e:t})).childCount}(e);if(n&&r)return t.nodes.table.create(null,[$f(e,o,t)]);var i=e[0],s=e.slice(1),a=[jf(i,0,t)];return s.length&&a.push($f(s,o,t)),t.nodes.table.create(null,a)}(i,t,s,n);r.push(a)}}else r.push(e)})),new v(d.from(r),i,s)}function Uf(e){return 4*e}function Wf(e,t){var n=e.state,r=n.selection,o=n.schema,i=n.tr,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){var c=Qh(t);if(!c)return!1;var u=jh.create(a),d=u.getRectOffsets(a,l),p=function(e,t,n){var r=[],o=Vf(e),i=(o[0].childCount,o.length),s=0===t.startRowIdx,a=o.slice(0,i);if(s){var l=a.shift();if(l){var c=zf(l,0,n).content;r.push(c)}}return a.forEach((function(e){if(!e.attrs.dummyRowForPasting){var t=qf(e,0,n).content;r.push(t)}})),r}(c,d,o),h=function(e,t,n){for(var r=t.startRowIdx,o=t.startColIdx,i=n.length,s=0,a=function(e){var t=n[e].childCount;n[e].forEach((function(e){var n=e.attrs.colspan;n>1&&(t+=n-1)})),s=Math.max(s,t)},l=0;l<i;l+=1)a(l);var c=r+i-1,u=o+s-1;return{startRowIdx:r,startColIdx:o,endRowIdx:c,endColIdx:u,addedRowCount:Math.max(c+1-e.totalRowCount,0),addedColumnCount:Math.max(u+1-e.totalColumnCount,0)}}(u,d,p),f=[];return function(e,t){var n=Yh(e.getSpannedOffsets(t)),r=n.rowCount,o=n.columnCount,i=Yh(t),s=i.rowCount,a=i.columnCount;return r===s&&o===a}(u,h)&&(function(e,t){for(var n=e.startRowIdx,r=e.startColIdx,o=e.endRowIdx,i=e.endColIdx,s=e.addedRowCount,a=e.addedColumnCount,l=n;l<=o-s;l+=1)t.push({rowIdx:l,startColIdx:r,endColIdx:i-a})}(h,f),h.addedColumnCount&&function(e,t,n,r,o){for(var i=r.startRowIdx,s=r.startColIdx,a=r.endRowIdx,l=r.endColIdx,c=r.addedRowCount,u=r.addedColumnCount,d=n.totalRowCount,p=0,h=0;h<d;h+=1){var f=n.getCellInfo(h,l-u),m=f.offset,g=f.nodeSize,v=e.mapping.map(m+g),y=Gh(u,h,t);if(e.insert(v,y),h>=i&&h<=a-c){var b=n.getCellInfo(h,l-u),w=e.mapping.map(b.offset),k=v+Uf(u);o[p]={rowIdx:h,startColIdx:s,endColIdx:l,dummyOffsets:[w,k]},p+=1}}}(i,o,u,h,f),h.addedRowCount&&function(e,t,n,r,o){var i=r.addedRowCount,s=r.addedColumnCount,a=r.startColIdx,l=r.endColIdx,c=e.mapping.maps.length,u=n.tableEndOffset-2,d=Jh(i,n.totalColumnCount+s,t),p=u;e.insert(e.mapping.slice(c).map(p),d);for(var h=0;h<i;h+=1){var f=p+Uf(a)+1,m=p+Uf(l+1)+1,g=p+Uf(n.totalColumnCount+s)+2;o.push({rowIdx:h+n.totalRowCount,startColIdx:a,endColIdx:l,dummyOffsets:[f,m]}),p=g}}(i,o,u,h,f),function(e,t,n,r){var o=e.mapping.maps.length;n.forEach((function(n,i){var s=n.rowIdx,a=n.startColIdx,l=n.endColIdx,c=n.dummyOffsets,u=e.mapping.slice(o),d=new v(t[i],0,0),p=c?c[0]:r.getCellStartOffset(s,a),h=c?c[1]:r.getCellEndOffset(s,l);e.replace(u.map(p),u.map(h),d)}))}(i,p,f,u),e.dispatch(i),function(e,t,n){var r=e.state,o=r.tr,i=r.doc,s=jh.create(i.resolve(n)),a=t[0],l=a.rowIdx,c=a.startColIdx,u=et(t),d=u.rowIdx,p=u.endColIdx,h=s.getCellInfo(l,c).offset,f=s.getCellInfo(d,p).offset;e.dispatch(o.setSelection(new Wh(i.resolve(h),i.resolve(f))))}(e,f,u.getCellInfo(0,0).offset)),!0}return!1}var Jf,Gf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"doc"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"block+"}},enumerable:!1,configurable:!0}),n}(Va),Kf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"paragraph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"inline*",group:"block",attrs:o({},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"p"}],toDOM:function(e){return["p",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),Zf=/\s{1,4}$/,Xf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"text"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{group:"inline"}},enumerable:!1,configurable:!0}),n.prototype.addSpaces=function(){return function(e,t){var n=e.selection,r=e.tr,o=n.$from,i=n.$to;return!(!o.blockRange(i)||Eh(o)||Nh(o))&&(t(r.insertText("    ",o.pos,i.pos)),!0)}},n.prototype.removeSpaces=function(){return function(e,t){var n=e.selection,r=e.tr,o=n.$from,i=n.$to,s=n.from;if(o.blockRange(i)&&!Eh(o)&&!Nh(o)){var a=o.nodeBefore;if(a&&a.isText){var l=a.text,c=l.replace(Zf,""),u=l.length-c.length;return t(r.delete(s-u,s)),!0}}return!1}},n.prototype.keymaps=function(){return{Tab:this.addSpaces(),"Shift-Tab":this.removeSpaces()}},n}(Va),Qf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"heading"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"levels",{get:function(){return[1,2,3,4,5,6]},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=this.levels.map((function(e){return{tag:"h"+e,getAttrs:function(t){var n=t.getAttribute("data-raw-html");return o({level:e},n&&{rawHTML:n})}}}));return{attrs:o({level:{default:1},headingType:{default:"atx"},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),content:"inline*",group:"block",defining:!0,parseDOM:e,toDOM:function(e){var t=e.attrs;return["h"+t.level,Ih(t),0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(e){return function(t,n){return Gi(t.schema.nodes[e.level?"heading":"paragraph"],e)(t,n)}}},n}(Va),Yf=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"codeBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",attrs:o({language:{default:null},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),code:!0,defining:!0,marks:"",parseDOM:[{tag:"pre",preserveWhitespace:"full",getAttrs:function(e){var t=e.getAttribute("data-raw-html"),n=e.firstElementChild;return o({language:(null==n?void 0:n.getAttribute("data-language"))||null},t&&{rawHTML:t})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"pre",["code",o({"data-language":t.language},Ih(t)),0]]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Gi(e.schema.nodes.codeBlock)(e,t)}}},n.prototype.moveCursor=function(e){var t=this;return function(n,r){var o,i,s=n.tr,a=n.doc,l=n.schema,c=n.selection.$from;if(t.context.view.endOfTextblock(e)&&"codeBlock"===c.node().type.name){var u=c.parent.textContent.split("\n"),d="up"===e?c.start():c.end(),p="up"===e?[d,u[0].length+d]:[d-et(u).length,d],h=a.resolve("up"===e?c.before():c.after()),f="up"===e?h.nodeBefore:h.nodeAfter;if(o=c.pos,i=p[1],o>=p[0]&&o<=i&&!f){var m=Ds(s,h,l);if(m)return r(m),!0}}return!1}},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-p":e,"Shift-Mod-P":e,ArrowUp:this.moveCursor("up"),ArrowDown:this.moveCursor("down")}},n}(Va),em=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"bulletList"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"listItem+",group:"block",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[Dh("ul")],toDOM:function(e){return["ul",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n.prototype.changeList=function(){return function(e,t){return Bh(e.schema.nodes.bulletList)(e,t)}},n.prototype.commands=function(){return{bulletList:this.changeList,taskList:Fh}},n.prototype.keymaps=function(){var e=this.changeList(),t=qh(),n=t.indent,r=t.outdent;return{"Mod-u":e,"Mod-U":e,Tab:n(),"Shift-Tab":r()}},n}(Va),tm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"orderedList"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"listItem+",group:"block",attrs:o({order:{default:1},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"ol",getAttrs:function(e){var t=e.getAttribute("start"),n=e.getAttribute("data-raw-html");return o({order:e.hasAttribute("start")?Number(t):1},n&&{rawHTML:n})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"ol",o({start:1===t.order?null:t.order},Ih(t)),0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Bh(e.schema.nodes.orderedList)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()(),t=qh(),n=t.indent,r=t.outdent;return{"Mod-o":e,"Mod-O":e,Tab:n(),"Shift-Tab":r()}},n}(Va),nm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"listItem"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"paragraph block*",selectable:!1,attrs:{task:{default:!1},checked:{default:!1},rawHTML:{default:null}},defining:!0,parseDOM:[{tag:"li",getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({task:e.hasAttribute("data-task"),checked:e.hasAttribute("data-task-checked")},t&&{rawHTML:t})}}],toDOM:function(e){var t=e.attrs,n=t.task,r=t.checked;if(!n)return[t.rawHTML||"li",0];var i=["task-list-item"];return r&&i.push("checked"),[t.rawHTML||"li",o({class:i.join(" "),"data-task":n},r&&{"data-task-checked":r}),0]}}},enumerable:!1,configurable:!0}),n.prototype.liftToPrevListItem=function(){return function(e,t){var n=e.selection,r=e.tr,o=e.schema,i=n.$from,s=n.empty,a=o.nodes.listItem,l=i.parent,c=i.node(-1);if(s&&!l.childCount&&c.type===a){if(i.index(-2)>=1)return r.delete(i.start(-1)-1,i.end(-1)),t(r),!0;if(i.node(-3).type===a)return r.delete(i.start(-2)-1,i.end(-1)),t(r),!0}return!1}},n.prototype.keymaps=function(){return{Backspace:this.liftToPrevListItem(),Enter:function(e,t){return function(e){return function(t,n){var r=t.tr,o=t.selection,i=o.$from,s=o.$to;if(i.depth<2||!i.sameParent(s))return!1;var a=i.node(-1);if(a.type!==e)return!1;if(0===i.parent.content.size&&i.node(-1).childCount===i.indexAfter(-1)){if(2===i.depth||i.node(-3).type!==e||i.index(-2)!==i.node(-2).childCount-1)return!1;for(var l=i.index(-1)>0,c=d.empty,u=i.depth-(l?1:2);u>=i.depth-3;u-=1)c=d.from(i.node(u).copy(c));return c=c.append(d.from(e.createAndFill())),r.replace(l?i.before():i.before(-1),i.after(-3),new v(c,l?3:2,2)),r.setSelection(Vt.near(r.doc.resolve(i.pos+(l?3:2)))),n(r),!0}var p=s.pos===i.end()?a.contentMatchAt(0).defaultType:null,h=p&&[null,{type:p}];return r.delete(i.pos,s.pos),!!Mt(r.doc,i.pos,2,h)&&(r.split(i.pos,2,h),n(r),!0)}}(e.schema.nodes.listItem)(e,t)}}},n}(Va),rm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"blockQuote"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),content:"block+",group:"block",parseDOM:[Dh("blockquote")],toDOM:function(e){return["blockquote",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Ji(e.schema.nodes.blockQuote)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()();return{"Alt-q":e,"Alt-Q":e}},n}(Va),om={left:function(e,t){var n=e[0],r=e[1],o=t.totalColumnCount,i=0===r;if(0!==n||!i){r-=1,i&&(n-=1,r=o-1);var s=t.getCellInfo(n,r),a=s.offset,l=s.nodeSize;return a+l-2}return null},right:function(e,t){var n=e[0],r=e[1],o=t.totalRowCount,i=t.totalColumnCount,s=r===i-1;if(n!==o-1||!s){var a=r+1,l=t.getColspanStartInfo(n,r);return(null==l?void 0:l.count)>1&&(a+=l.count-1),(s||a===i)&&(n+=1,a=0),t.getCellInfo(n,a).offset+2}return null},up:function(e,t){var n=e[0],r=e[1];if(n>0){var o=t.getCellInfo(n-1,r),i=o.offset,s=o.nodeSize;return i+s-2}return null},down:function(e,t){var n=e[0],r=e[1],o=t.totalRowCount;if(n<o-1){var i=n+1,s=t.getRowspanStartInfo(n,r);return(null==s?void 0:s.count)>1&&(i+=s.count-1),t.getCellInfo(i,r).offset+2}return null}};function im(e,t,n,r){var o=t[0],i=t[1],s=o+3,a=i>=s,l=a?o+1:i,c=function(e,t,n,r,o){var i=t[0],s=t[1],a=t[2];if(e===Jf.LEFT||e===Jf.UP){if(o&&!function(e,t,n){var r=n[0],o=n[1],i=t.resolve(e.before(r-1));return o===r&&!i.nodeBefore}(n,r,[i,s]))return!1;var l=n.before(a);if(r.resolve(l).nodeBefore)return!1}return!0}(e,[i,s,l],n,r,a),u=function(e,t,n,r,o){if(e===Jf.RIGHT||e===Jf.DOWN){if(o&&!function(e){for(var t,n,r=e.depth;r&&"tableBodyCell"!==(n=e.node(r)).type.name;){if("listItem"===n.type.name){var o=e.node(r-1).lastChild===n,i="paragraph"!==(null===(t=n.lastChild)||void 0===t?void 0:t.type.name);return!!o&&!i}r-=1}return!1}(n))return!1;var i=n.after(t);if(r.resolve(i).nodeAfter)return!1}return!0}(e,l,n,r,a);return c&&u}function sm(e,t,n){var r=n[0],o=n[1],i=t.getRowspanStartInfo(r,o),s=e===Jf.UP&&0===r,a=e===Jf.DOWN&&((null==i?void 0:i.count)>1?r+i.count-1:r)===t.totalRowCount-1;return s||a}function am(e,t,n,r){void 0===r&&(r=!1);var o=e.doc.resolve(t.tableEndOffset);return r||!o.nodeAfter?Ds(e,o,n):e.setSelection(Vt.near(o,1))}function lm(e,t,n,r){var o=(0,om[e])(n,r);if(o){var i=e===Jf.RIGHT||e===Jf.DOWN?1:-1;return t.setSelection(Vt.near(t.doc.resolve(o),i))}return null}function cm(e,t,n){var r=e.getCellInfo(t,0).offset,o=e.getCellInfo(t,n-1);return{from:r,to:o.offset+o.nodeSize}}!function(e){e.LEFT="left",e.RIGHT="right",e.UP="up",e.DOWN="down"}(Jf||(Jf={}));var um=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"table"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"tableHead{1} tableBody{1}",group:"block",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[Dh("table")],toDOM:function(e){return["table",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n.prototype.addTable=function(){return function(e){return void 0===e&&(e={rowCount:2,columnCount:1,data:[]}),function(t,n){var r=e.rowCount,o=e.columnCount,i=e.data,s=t.schema,a=t.selection,l=t.tr,c=a.from,u=a.to,d=a.$from;if(c===u&&!Nh(d)){var p=s.nodes,h=p.tableHead,f=p.tableBody,m=null==i?void 0:i.slice(0,o),g=null==i?void 0:i.slice(o,i.length),v=function(e,t,n){for(var r=t.nodes,o=r.tableRow,i=r.tableHeadCell,s=r.paragraph,a=[],l=0;l<e;l+=1){var c=n&&n[l],u=s.create(null,c?t.text(c):[]);a.push(i.create(null,u))}return[o.create(null,a)]}(o,s,m),y=Jh(r-1,o,s,g),b=s.nodes.table.create(null,[h.create(null,v),f.create(null,y)]);return n(l.replaceSelectionWith(b)),!0}return!1}}},n.prototype.removeTable=function(){return function(){return function(e,t){var n=e.selection,r=e.tr,o=jh.create(n.$anchor);if(o){var i=o.tableStartOffset,s=o.tableEndOffset,a=i-1,l=Os(r.delete(a,s),a);return t(r.setSelection(l)),!0}return!1}}},n.prototype.addColumn=function(e){return function(){return function(t,n){var r=t.selection,o=t.tr,i=t.schema,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){for(var c=jh.create(a),u=c.getRectOffsets(a,l),d=e===Jf.LEFT?u.startColIdx:u.endColIdx+1,p=Yh(u).columnCount,h=c.totalRowCount,f=0;f<h;f+=1){var m=Gh(p,f,i);o.insert(o.mapping.map(c.posAt(f,d)),m)}return n(o),!0}return!1}}},n.prototype.removeColumn=function(){return function(){return function(e,t){var n=e.selection,r=e.tr,o=Xh(n),i=o.anchor,s=o.head;if(i&&s){var a=jh.create(i),l=a.getRectOffsets(i,s),c=a.totalColumnCount,u=a.totalRowCount;if(Yh(l).columnCount===c)return!1;for(var d=l.startColIdx,p=l.endColIdx,h=r.mapping.maps.length,f=0;f<u;f+=1)for(var m=p;m>=d;m-=1){var g=a.getCellInfo(f,m),v=g.offset,y=g.nodeSize,b=r.mapping.slice(h).map(v),w=b+y;r.delete(b,w)}return t(r),!0}return!1}}},n.prototype.addRow=function(e){return function(){return function(t,n){var r=t.selection,o=t.schema,i=t.tr,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){var c=jh.create(a),u=c.totalColumnCount,d=c.getRectOffsets(a,l),p=Yh(d).rowCount,h=function(e,t,n){var r,o,i;return e===Jf.UP?(r=n.startRowIdx,o=0,i=-1):(r=n.endRowIdx,o=t.totalColumnCount-1,i=t.getCellInfo(r,o).nodeSize+1),{targetRowIdx:r,insertColIdx:o,nodeSize:i}}(e,c,d),f=h.targetRowIdx,m=h.insertColIdx,g=h.nodeSize;if(!(0===f)){for(var v=[],y=i.mapping.map(c.posAt(f,m))+g,b=[],w=0;w<u;w+=1)b=b.concat(Gh(1,f,o));for(var k=0;k<p;k+=1)v.push(o.nodes.tableRow.create(null,b));return n(i.insert(y,v)),!0}}return!1}}},n.prototype.removeRow=function(){return function(){return function(e,t){var n=e.selection,r=e.tr,o=Xh(n),i=o.anchor,s=o.head;if(i&&s){var a=jh.create(i),l=a.totalRowCount,c=a.totalColumnCount,u=a.getRectOffsets(i,s),d=Yh(u).rowCount,p=u.startRowIdx,h=u.endRowIdx;if(d===l-1||0===p)return!1;for(var f=h;f>=p;f-=1){var m=cm(a,f,c),g=m.from,v=m.to;r.delete(g-1,v+1)}return t(r),!0}return!1}}},n.prototype.alignColumn=function(){return function(e){return void 0===e&&(e={align:"center"}),function(t,n){var r=e.align,o=t.selection,i=t.tr,s=Xh(o),a=s.anchor,l=s.head;if(a&&l){for(var c=jh.create(a),u=c.totalRowCount,d=c.getRectOffsets(a,l),p=d.startColIdx,h=d.endColIdx,f=0;f<u;f+=1)for(var m=p;m<=h;m+=1)if(!c.extendedRowspan(f,m)&&!c.extendedColspan(f,m)){var g=c.getNodeAndPos(f,m),v=g.node,y=g.pos,b=ef(v,{align:r});i.setNodeMarkup(y,null,b)}return n(i),!0}return!1}}},n.prototype.moveToCell=function(e){return function(t,n){var r=t.selection,o=t.tr,i=t.schema,s=Xh(r),a=s.anchor,l=s.head;if(a&&l){var c=jh.create(a),u=c.getCellIndex(a),d=void 0;if(d=sm(e,c,u)?am(o,c,i):lm(e,o,u,c))return n(d),!0}return!1}},n.prototype.moveInCell=function(e){var t=this;return function(n,r){var o=n.selection,i=n.tr,s=n.doc,a=n.schema,l=o.$from;if(!t.context.view.endOfTextblock(e))return!1;var c=Sh(l,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}));if(c){var u=Sh(l,(function(e){return"paragraph"===e.type.name})),d=c.depth;if(u&&im(e,[d,u.depth],l,s)){var p=Xh(o).anchor,h=jh.create(p),f=h.getCellIndex(p),m=void 0;if(!function(e,t,n){var r=n[0],o=n[1];if(e===Jf.UP||e===Jf.DOWN)return!1;var i=t.tableStartOffset,s=t.tableEndOffset,a=t.getCellInfo(r,o),l=a.offset,c=a.nodeSize;return(e===Jf.LEFT?i:s)===(e===Jf.LEFT?l-2:l+c+3)}(e,h,f)?sm(e,h,f)?e===Jf.UP?m=function(e,t,n){var r=e.doc.resolve(t.tableStartOffset-1);return r.nodeBefore?e.setSelection(Vt.near(r,-1)):Ds(e,r,n)}(i,h,a):e===Jf.DOWN&&(m=am(i,h,a)):m=lm(e,i,f,h):m=function(e,t,n){var r=e.doc.resolve(t.before(n-3));return e.setSelection(new Jt(r))}(i,l,d),m)return r(m),!0}}return!1}},n.prototype.deleteCells=function(){return function(e,t){var n=e.schema,r=e.selection,o=e.tr,i=Xh(r),s=i.anchor,a=i.head;if(s&&a&&!(r instanceof Ut)){for(var l=jh.create(s),c=l.getRectOffsets(s,a),u=c.startRowIdx,d=c.startColIdx,p=c.endRowIdx,h=c.endColIdx,f=u;f<=p;f+=1)for(var m=d;m<=h;m+=1)if(!l.extendedRowspan(f,m)&&!l.extendedColspan(f,m)){var g=l.getNodeAndPos(f,m),v=g.node,y=g.pos,b=Gh(1,f,n,v.attrs);o.replaceWith(o.mapping.map(y),o.mapping.map(y+v.nodeSize),b)}return t(o),!0}return!1}},n.prototype.exitTable=function(){return function(e,t){var n=e.selection,r=e.tr,o=e.schema,i=n.$from;if(Sh(i,(function(e){var t=e.type;return"tableHeadCell"===t.name||"tableBodyCell"===t.name}))&&Sh(i,(function(e){return"paragraph"===e.type.name}))){var s=Xh(n).anchor;return t(am(r,jh.create(s),o,!0)),!0}return!1}},n.prototype.commands=function(){return{addTable:this.addTable(),removeTable:this.removeTable(),addColumnToLeft:this.addColumn(Jf.LEFT),addColumnToRight:this.addColumn(Jf.RIGHT),removeColumn:this.removeColumn(),addRowToUp:this.addRow(Jf.UP),addRowToDown:this.addRow(Jf.DOWN),removeRow:this.removeRow(),alignColumn:this.alignColumn()}},n.prototype.keymaps=function(){var e=this.deleteCells();return{Tab:this.moveToCell(Jf.RIGHT),"Shift-Tab":this.moveToCell(Jf.LEFT),ArrowUp:this.moveInCell(Jf.UP),ArrowDown:this.moveInCell(Jf.DOWN),ArrowLeft:this.moveInCell(Jf.LEFT),ArrowRight:this.moveInCell(Jf.RIGHT),Backspace:e,"Mod-Backspace":e,Delete:e,"Mod-Delete":e,"Mod-Enter":this.exitTable()}},n}(Va),dm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableHead"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"tableRow{1}",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[Dh("thead")],toDOM:function(e){return["thead",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),pm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableBody"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"tableRow+",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"tbody",getAttrs:function(e){var t=e.querySelectorAll("tr")[0].children.length,n=e.getAttribute("data-raw-html");return!!t&&o({},n&&{rawHTML:n})}}],toDOM:function(e){return["tbody",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),hm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableRow"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"(tableHeadCell | tableBodyCell)*",attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"tr",getAttrs:function(e){var t=e.children.length,n=e.getAttribute("data-raw-html");return!!t&&o({},n&&{rawHTML:n})}}],toDOM:function(e){return["tr",Ih(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),fm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableHeadCell"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"paragraph+",attrs:o({align:{default:null},className:{default:null},rawHTML:{default:null},colspan:{default:null},extended:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),isolating:!0,parseDOM:[Lh("th")],toDOM:function(e){var t=e.attrs,n=Ah(t);return["th",o(o({},n),Ih(t)),0]}}},enumerable:!1,configurable:!0}),n}(Va),mm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"tableBodyCell"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"(paragraph | bulletList | orderedList)+",attrs:{align:{default:null},className:{default:null},rawHTML:{default:null},colspan:{default:null},rowspan:{default:null},extended:{default:null}},isolating:!0,parseDOM:[Lh("td")],toDOM:function(e){return["td",Ah(e.attrs),0]}}},enumerable:!1,configurable:!0}),n}(Va),gm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"image"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{inline:!0,attrs:o({imageUrl:{default:""},altText:{default:null},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),group:"inline",selectable:!1,parseDOM:[{tag:"img[src]",getAttrs:function(e){var t=rh(e,{RETURN_DOM_FRAGMENT:!0}).firstChild,n=t.getAttribute("src")||"",r=t.getAttribute("data-raw-html"),i=t.getAttribute("alt");return o({imageUrl:n,altText:i},r&&{rawHTML:r})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"img",o(o({src:_e(t.imageUrl)},t.altText&&{alt:t.altText}),Ih(t))]}}},enumerable:!1,configurable:!0}),n.prototype.addImage=function(){return function(e){return function(t,n){var r=t.schema,i=t.tr,s=e,a=s.imageUrl,l=s.altText;if(!a)return!1;var c=r.nodes.image.createAndFill(o({imageUrl:a},l&&{altText:l}));return n(i.replaceSelectionWith(c).scrollIntoView()),!0}}},n.prototype.commands=function(){return{addImage:this.addImage()}},n}(Va),vm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"thematicBreak"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),group:"block",parseDOM:[{tag:"hr"}],selectable:!1,toDOM:function(e){var t=e.attrs;return["div",Ih(t),[t.rawHTML||"hr"]]}}},enumerable:!1,configurable:!0}),n.prototype.hr=function(){var e=this;return function(){return function(t,n){var r,o=t.selection,i=o.$from;if(i===o.$to){var s=t.doc,a=t.schema.nodes,l=a.thematicBreak,c=a.paragraph,u=[l.create()],d=i.node(1),p=s.child(s.childCount-1)===d,h=s.resolve(i.after(1)),f=(null===(r=i.nodeAfter)||void 0===r?void 0:r.type.name)===e.name;return(p||f)&&u.push(c.create()),n(t.tr.insert(h.pos,u).scrollIntoView()),!0}return!1}}},n.prototype.commands=function(){return{hr:this.hr()}},n.prototype.keymaps=function(){var e=this.hr()();return{"Mod-l":e,"Mod-L":e}},n}(Va),ym=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strong"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=["b","strong"].map((function(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}));return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:e,toDOM:function(e){var t=e.attrs;return[t.rawHTML||"strong",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.bold=function(){return function(){return function(e,t){return Ki(e.schema.marks.strong)(e,t)}}},n.prototype.commands=function(){return{bold:this.bold()}},n.prototype.keymaps=function(){var e=this.bold()();return{"Mod-b":e,"Mod-B":e}},n}(Al),bm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"emph"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=["i","em"].map((function(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}));return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:e,toDOM:function(e){var t=e.attrs;return[t.rawHTML||"em",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.italic=function(){return function(){return function(e,t){return Ki(e.schema.marks.emph)(e,t)}}},n.prototype.commands=function(){return{italic:this.italic()}},n.prototype.keymaps=function(){var e=this.italic()();return{"Mod-i":e,"Mod-I":e}},n}(Al),wm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"strike"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=["s","del"].map((function(e){return{tag:e,getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}}));return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:e,toDOM:function(e){var t=e.attrs;return[t.rawHTML||"del",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Ki(e.schema.marks.strike)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()();return{"Mod-s":e,"Mod-S":e}},n}(Al),km=function(e){function n(t){var n=e.call(this)||this;return n.linkAttributes=t,n}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"link"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){var e=this;return{attrs:o({linkUrl:{default:""},title:{default:null},rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),inclusive:!1,parseDOM:[{tag:"a[href]",getAttrs:function(e){var t=rh(e,{RETURN_DOM_FRAGMENT:!0}).firstChild,n=t.getAttribute("href")||"",r=t.getAttribute("title")||"",i=t.getAttribute("data-raw-html");return o({linkUrl:n,title:r},i&&{rawHTML:i})}}],toDOM:function(t){var n=t.attrs;return[n.rawHTML||"a",o(o({href:_e(n.linkUrl)},e.linkAttributes),Ih(n))]}}},enumerable:!1,configurable:!0}),n.prototype.addLink=function(){return function(e){return function(t,n){var r=e,o=r.linkUrl,i=r.linkText,s=void 0===i?"":i,a=t.schema,l=t.tr,c=t.selection,u=c.empty,d=c.from,p=c.to;if(d&&p&&o){var h={linkUrl:o},f=a.mark("link",h);if(u&&s){var m=Ns(a,s,f);l.replaceRangeWith(d,p,m)}else l.addMark(d,p,f);return n(l.scrollIntoView()),!0}return!1}}},n.prototype.toggleLink=function(){return function(e){return function(t,n){return Ki(t.schema.marks.link,e)(t,n)}}},n.prototype.commands=function(){return{addLink:this.addLink(),toggleLink:this.toggleLink()}},n}(Al),xm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"code"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{attrs:o({rawHTML:{default:null}},{htmlAttrs:{default:null},classNames:{default:null}}),parseDOM:[{tag:"code",getAttrs:function(e){var t=e.getAttribute("data-raw-html");return o({},t&&{rawHTML:t})}}],toDOM:function(e){var t=e.attrs;return[t.rawHTML||"code",Ih(t)]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t){return Ki(e.schema.marks.code)(e,t)}}},n.prototype.keymaps=function(){var e=this.commands()();return{"Shift-Mod-c":e,"Shift-Mod-C":e}},n}(Al),Cm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"customBlock"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",attrs:{info:{default:null}},atom:!0,code:!0,defining:!0,parseDOM:[{tag:"div[data-custom-info]",getAttrs:function(e){return{info:e.getAttribute("data-custom-info")}}}],toDOM:function(e){return["div",{"data-custom-info":e.attrs.info||null},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(e){return function(t,n){return!!(null==e?void 0:e.info)&&Gi(t.schema.nodes.customBlock,e)(t,n)}}},n}(Va),Tm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"frontMatter"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",code:!0,defining:!0,parseDOM:[{preserveWhitespace:"full",tag:"div[data-front-matter]"}],toDOM:function(){return["div",{"data-front-matter":"true"},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t,n){var r=e.selection.$from;return!(!n.endOfTextblock("down")||"frontMatter"!==r.node().type.name)&&qi(e,t)}}},n.prototype.keymaps=function(){return{Enter:this.commands()()}},n}(Va),Mm=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),Object.defineProperty(n.prototype,"name",{get:function(){return"htmlComment"},enumerable:!1,configurable:!0}),Object.defineProperty(n.prototype,"schema",{get:function(){return{content:"text*",group:"block",code:!0,defining:!0,parseDOM:[{preserveWhitespace:"full",tag:"div[data-html-comment]"}],toDOM:function(){return["div",{"data-html-comment":"true"},0]}}},enumerable:!1,configurable:!0}),n.prototype.commands=function(){return function(){return function(e,t,n){var r=e.selection.$from;return!(!n.endOfTextblock("down")||"htmlComment"!==r.node().type.name)&&qi(e,t)}}},n.prototype.keymaps=function(){return{Enter:this.commands()()}},n}(Va);var Sm=xa("contents"),Em=function(e){function n(t,n){var r=e.call(this,t)||this,i=n.toDOMAdaptor,s=n.htmlSchemaMap,a=void 0===s?{}:s,l=n.linkAttributes,c=void 0===l?{}:l,u=n.useCommandShortcut,d=void 0===u||u,p=n.wwPlugins,h=void 0===p?[]:p,f=n.wwNodeViews,m=void 0===f?{}:f;return r.editorType="wysiwyg",r.el.classList.add("ww-mode"),r.toDOMAdaptor=i,r.linkAttributes=c,r.extraPlugins=h,r.pluginNodeViews=m,r.specs=r.createSpecs(),r.schema=r.createSchema(a),r.context=r.createContext(),r.keymaps=r.createKeymaps(d),r.view=r.createView(),r.commands=r.createCommands(),r.specs.setContext(o(o({},r.context),{view:r.view})),r.initEvent(),r}return t(n,e),n.prototype.createSpecs=function(){return e=this.linkAttributes,new Qa([new Gf,new Kf,new Xf,new Qf,new Yf,new em,new tm,new nm,new rm,new um,new dm,new pm,new hm,new fm,new mm,new gm,new vm,new ym,new bm,new wm,new km(e),new xm,new Cm,new Tm,new _a,new Mm]);var e},n.prototype.createContext=function(){return{schema:this.schema,eventEmitter:this.eventEmitter}},n.prototype.createSchema=function(e){return new Y({nodes:o(o({},this.specs.nodes),e.nodes),marks:o(o({},this.specs.marks),e.marks)})},n.prototype.createPlugins=function(){return i([new an({key:tf,state:{init:function(){return null},apply:function(e,t){var n=e.getMeta(tf);if(n)return-1===n?null:n;if(Ae()(t)||!e.docChanged)return t;var r=e.mapping.mapResult(t),o=r.deleted,i=r.pos;return o?null:i}},props:{decorations:sf,createSelectionBetween:function(e){var t=e.state;return Ae()(tf.getState(t))?null:t.selection}},view:function(e){return new rf(e)}}),gf(this.eventEmitter),new an({props:{handleDOMEvents:{mousedown:function(e,t){var n=t,r=n.clientX,i=n.clientY,s=e.posAtCoords({left:r,top:i});if(s){var a=e.state,l=a.doc,c=a.tr,u=l.resolve(s.pos),d=Oh(u),p=t.target,h=getComputedStyle(p,":before"),f=t,m=f.offsetX,g=f.offsetY;if(!d||!wa(h,m,g))return!1;t.preventDefault();var v=u.before(d.depth),y=d.node.attrs;return c.setNodeMarkup(v,null,o(o({},y),{checked:!y.checked})),e.dispatch(c),!0}return!1}}}}),kf(this.eventEmitter)],this.createPluginProps()).concat(this.defaultPlugins)},n.prototype.createPluginNodeViews=function(){var e=this.eventEmitter,t=this.pluginNodeViews,n={};return t&&Object.keys(t).forEach((function(r){n[r]=function(n,o,i){return t[r](n,o,i,e)}})),n},n.prototype.createView=function(){var e=this,t=this.toDOMAdaptor,n=this.eventEmitter;return new ui(this.el,{state:this.createState(),attributes:{class:Sm},nodeViews:o({customBlock:function(e,n,r){return new xf(e,n,r,t)},image:function(e,t,r){return new Tf(e,t,r,n)},codeBlock:function(e,t,r){return new Mf(e,t,r,n)},widget:ja},this.createPluginNodeViews()),dispatchTransaction:function(t){var n=e.view.state.applyTransaction(t).state;e.view.updateState(n),e.emitChangeEvent(t.scrollIntoView()),e.eventEmitter.emit("setFocusedNode",n.selection.$from.node(1))},transformPastedHTML:Ff,transformPasted:function(t){return _f(t,e.schema,Nh(e.view.state.selection.$from))},handlePaste:function(e,t,n){return Wf(e,n)},handleKeyDown:function(t,n){return e.eventEmitter.emit("keydown",e.editorType,n),!1},handleDOMEvents:{paste:function(t,n){var r=n.clipboardData||window.clipboardData,o=null==r?void 0:r.items;if(o){var i=vi()(o).some((function(e){return"string"===e.kind&&"text/rtf"===e.type}));if(!i){var s=za(o);s&&(n.preventDefault(),Ha(e.eventEmitter,s,n.type))}}return!1},keyup:function(t,n){return e.eventEmitter.emit("keyup",e.editorType,n),!1},scroll:function(){return e.eventEmitter.emit("scroll","editor"),!0}}})},n.prototype.createCommands=function(){return this.specs.commands(this.view,qh())},n.prototype.getHTML=function(){return La(this.view.dom.innerHTML)},n.prototype.getModel=function(){return this.view.state.doc},n.prototype.getSelection=function(){var e=this.view.state.selection;return[e.from,e.to]},n.prototype.getSchema=function(){return this.view.state.schema},n.prototype.replaceSelection=function(e,t,n){var r=this.view.state,o=r.schema,i=r.tr,s=e.split("\n").map((function(e){return Es(o,ra(e,o))})),a=new v(d.from(s),1,1),l=Ee()(t)&&Ee()(n)?i.replaceRange(t,n,a):i.replaceSelection(a);this.view.dispatch(l),this.focus()},n.prototype.deleteSelection=function(e,t){var n=this.view.state.tr,r=Ee()(e)&&Ee()(t)?n.deleteRange(e,t):n.deleteSelection();this.view.dispatch(r.scrollIntoView())},n.prototype.getSelectedText=function(e,t){var n=this.view.state,r=n.doc,o=n.selection,i=o.from,s=o.to;return Ee()(e)&&Ee()(t)&&(i=e,s=t),r.textBetween(i,s,"\n")},n.prototype.setModel=function(e,t){void 0===t&&(t=!1);var n=this.view.state,r=n.tr,o=n.doc;this.view.dispatch(r.replaceWith(0,o.content.size,e)),t&&this.moveCursorToEnd(!0)},n.prototype.setSelection=function(e,t){void 0===t&&(t=e);var n=this.view.state.tr,r=Os(n,e,t);this.view.dispatch(n.setSelection(r).scrollIntoView())},n.prototype.addWidget=function(e,t,n){var r=this.view,o=r.dispatch,i=r.state;o(i.tr.setMeta("widget",{pos:null!=n?n:i.selection.to,node:e,style:t}))},n.prototype.replaceWithWidget=function(e,t,n){var r=this.view.state,o=r.tr,i=ra(n,r.schema);this.view.dispatch(o.replaceWith(e,t,i))},n.prototype.getRangeInfoOfNode=function(e){var t=this.view.state,n=t.doc,r=t.selection,o=e?n.resolve(e):r.$from,i=o.marks(),s=o.node(),a=o.start(),l=o.end(),c=s.type.name;if(i.length||"paragraph"===c){var u=i[i.length-1];c=u?u.type.name:"text",s.forEach((function(e,t){var n=e.isText,r=e.nodeSize,i=e.marks,s=o.pos-a;n&&t<=s&&t+r>=s&&function(e){return!e.length||Ue(e,u)}(i)&&(l=(a+=t)+r)}))}return{range:[a,l],type:c}},n}(Wa),Nm=Em,Om=n(404),Dm=n.n(Om),Am=["afterPreviewRender","updatePreview","changeMode","needChangeMode","command","changePreviewStyle","changePreviewTabPreview","changePreviewTabWrite","scroll","contextmenu","show","hide","changeLanguage","changeToolbarState","toggleScrollSync","mixinTableOffsetMapPrototype","setFocusedNode","removePopupWidget","query","openPopup","closePopup","addImageBlobHook","beforePreviewRender","beforeConvertWysiwygToMarkdown","load","loadUI","change","caretChange","destroy","focus","blur","keydown","keyup"],Lm=function(){function e(){var e=this;this.events=new uf,this.eventTypes=Am.reduce((function(e,t){return o(o({},e),{type:t})}),{}),this.hold=!1,Am.forEach((function(t){e.addEventType(t)}))}return e.prototype.listen=function(e,t){var n=this.getTypeInfo(e),r=this.events.get(n.type)||[];if(!this.hasEventType(n.type))throw new Error("There is no event type "+n.type);n.namespace&&(t.namespace=n.namespace),r.push(t),this.events.set(n.type,r)},e.prototype.emit=function(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=this.getTypeInfo(e),o=this.events.get(r.type),i=[];return!this.hold&&o&&o.forEach((function(e){var n=e.apply(void 0,t);Oe()(n)||i.push(n)})),i},e.prototype.emitReduce=function(e,t){for(var n=[],r=2;r<arguments.length;r++)n[r-2]=arguments[r];var o=this.events.get(e);return!this.hold&&o&&o.forEach((function(e){var r=e.apply(void 0,i([t],n));Dm()(r)||(t=r)})),t},e.prototype.getTypeInfo=function(e){var t=e.split(".");return{type:t[0],namespace:t[1]}},e.prototype.hasEventType=function(e){return!Oe()(this.eventTypes[this.getTypeInfo(e).type])},e.prototype.addEventType=function(e){if(this.hasEventType(e))throw new Error("There is already have event type "+e);this.eventTypes[e]=e},e.prototype.removeEventHandler=function(e,t){var n=this,r=this.getTypeInfo(e),o=r.type,i=r.namespace;o&&t?this.removeEventHandlerWithHandler(o,t):o&&!i?this.events.delete(o):!o&&i?this.events.forEach((function(e,t){n.removeEventHandlerWithTypeInfo(t,i)})):o&&i&&this.removeEventHandlerWithTypeInfo(o,i)},e.prototype.removeEventHandlerWithHandler=function(e,t){var n=this.events.get(e);if(n){var r=n.indexOf(t);n.indexOf(t)>=0&&n.splice(r,1)}},e.prototype.removeEventHandlerWithTypeInfo=function(e,t){var n=[],r=this.events.get(e);r&&(r.map((function(e){return e.namespace!==t&&n.push(e),null})),this.events.set(e,n))},e.prototype.getEvents=function(){return this.events},e.prototype.holdEventInvoke=function(e){this.hold=!0,e(),this.hold=!1},e}(),Im=Lm,Rm=function(){function e(e,t,n,r){this.eventEmitter=e,this.mdCommands=t,this.wwCommands=n,this.getEditorType=r,this.initEvent()}return e.prototype.initEvent=function(){var e=this;this.eventEmitter.listen("command",(function(t,n){e.exec(t,n)}))},e.prototype.addCommand=function(e,t,n){"markdown"===e?this.mdCommands[t]=n:this.wwCommands[t]=n},e.prototype.deleteCommand=function(e,t){"markdown"===e?delete this.mdCommands[t]:delete this.wwCommands[t]},e.prototype.exec=function(e,t){"markdown"===this.getEditorType()?this.mdCommands[e](t):this.wwCommands[e](t)},e}(),Pm=Rm;function Bm(e){return"\n"===e[e.length-1]?e.slice(0,e.length-1):e}function Fm(e,t){var n=e.schema,r=t.literal.match(ga);if(r){var o=r[1],i=r[3],s=(o||i).toLowerCase();return"htmlInline"===t.type&&!(!n.marks[s]&&!n.nodes[s])}return!1}function Hm(e){return Ue(["text","strong","emph","strike","image","link","code"],e.type)}function zm(e){return"softbreak"===(null==e?void 0:e.type)}function qm(e){var t=e.type,n=e.literal,r="htmlInline"===t&&n.match(ga);if(r){var o=r[1],i=r[3],s=o||i;if(s)return Ue(["ul","ol","li"],s.toLowerCase())}return!1}function Vm(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];var r=document.createElement("div");r.innerHTML=rh(e);var o=r.firstChild;return t.map((function(e){return o.getAttribute(e)||""}))}var jm={"b, strong":function(e,t,n){var r=e.schema.marks.strong;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},"i, em":function(e,t,n){var r=e.schema.marks.emph;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},"s, del":function(e,t,n){var r=e.schema.marks.strike;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},code:function(e,t,n){var r=e.schema.marks.code;n?e.openMark(r.create({rawHTML:n})):e.closeMark(r)},a:function(e,t,n){var r=t.literal,o=e.schema.marks.link;if(n){var i=Vm(r,"href")[0];e.openMark(o.create({linkUrl:i,rawHTML:n}))}else e.closeMark(o)},img:function(e,t,n){var r=t.literal;if(n){var i=Vm(r,"src","alt"),s=i[0],a=i[1],l=e.schema.nodes.image;e.addNode(l,o({rawHTML:n,imageUrl:s},a&&{altText:a}))}},hr:function(e,t,n){e.addNode(e.schema.nodes.thematicBreak,{rawHTML:n})},br:function(e,t){var n=e.schema.nodes.paragraph,r=t.parent,o=t.prev,i=t.next;"paragraph"===(null==r?void 0:r.type)?(zm(o)&&e.openNode(n),zm(i)?e.closeNode():i&&(e.closeNode(),e.openNode(n))):"tableCell"===(null==r?void 0:r.type)&&(o&&(Hm(o)||Fm(e,o))&&e.closeNode(),i&&(Hm(i)||Fm(e,i))&&e.openNode(n))},pre:function(e,t,n){var r,o,i=document.createElement("div");i.innerHTML=t.literal;var s=null===(o=null===(r=i.firstChild)||void 0===r?void 0:r.firstChild)||void 0===o?void 0:o.textContent;e.openNode(e.schema.nodes.codeBlock,{rawHTML:n}),e.addText(Bm(s)),e.closeNode()},"ul, ol":function(e,t,n){if("tableCell"===t.parent.type){var r=e.schema.nodes,o=r.bulletList,i=r.orderedList,s=r.paragraph,a="ul"===n?o:i;n?(t.prev&&!qm(t.prev)&&e.closeNode(),e.openNode(a,{rawHTML:n})):(e.closeNode(),t.next&&!qm(t.next)&&e.openNode(s))}},li:function(e,t,n){var r;if("tableCell"===(null===(r=t.parent)||void 0===r?void 0:r.type)){var i=e.schema.nodes,s=i.listItem,a=i.paragraph;if(n){var l=function(e){var t=e.literal;return{task:/data-task/.test(t),checked:/data-task-checked/.test(t)}}(t);t.prev&&!qm(t.prev)&&e.closeNode(),e.openNode(s,o({rawHTML:n},l)),t.next&&!qm(t.next)&&e.openNode(a)}else t.prev&&!qm(t.prev)&&e.closeNode(),e.closeNode()}}},$m=function(e){var t={};return Object.keys(e).forEach((function(n){n.split(", ").forEach((function(r){var o=r.toLowerCase();t[o]=e[n]}))})),t}(jm);function _m(e){return"htmlInline"===e.type&&va.test(e.literal)}function Um(e){vi()(e.childNodes).forEach((function(e){if(Ta(e)){var t=e.nodeName.toLowerCase();e.setAttribute("data-raw-html",t),e.childNodes&&Um(e)}}))}var Wm={text:function(e,t){e.addText(t.literal||"")},paragraph:function(e,t,n,r){var o;if(n.entering){var i=e.schema.nodes.paragraph;"paragraph"===(null===(o=t.prev)||void 0===o?void 0:o.type)&&(e.openNode(i,r),e.closeNode()),e.openNode(i,r)}else e.closeNode()},heading:function(e,t,n,r){if(n.entering){var i=t,s=i.level,a=i.headingType;e.openNode(e.schema.nodes.heading,o({level:s,headingType:a},r))}else e.closeNode()},codeBlock:function(e,t,n){var r=e.schema.nodes.codeBlock,i=t,s=i.info,a=i.literal;e.openNode(r,o({language:s},n)),e.addText(Bm(a||"")),e.closeNode()},list:function(e,t,n,r){if(n.entering){var i=e.schema.nodes,s=i.bulletList,a=i.orderedList,l=t.listData,c=l.type,u=l.start;"bullet"===c?e.openNode(s,r):e.openNode(a,o({order:u},r))}else e.closeNode()},item:function(e,t,n,r){var i=n.entering,s=e.schema.nodes.listItem,a=t.listData,l=a.task,c=a.checked;if(i){var u=o(o(o({},l&&{task:l}),c&&{checked:c}),r);e.openNode(s,u)}else e.closeNode()},blockQuote:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.blockQuote,r):e.closeNode()},image:function(e,t,n,r){var i=n.entering,s=n.skipChildren,a=e.schema.nodes.image,l=t,c=l.destination,u=l.firstChild;i&&s&&s(),e.addNode(a,o(o({imageUrl:c},u&&{altText:u.literal}),r))},thematicBreak:function(e,t,n,r){e.addNode(e.schema.nodes.thematicBreak,r)},strong:function(e,t,n,r){var o=n.entering,i=e.schema.marks.strong;o?e.openMark(i.create(r)):e.closeMark(i)},emph:function(e,t,n,r){var o=n.entering,i=e.schema.marks.emph;o?e.openMark(i.create(r)):e.closeMark(i)},link:function(e,t,n,r){var i=n.entering,s=e.schema.marks.link,a=t,l=a.destination,c=a.title;if(i){var u=o({linkUrl:l,title:c},r);e.openMark(s.create(u))}else e.closeMark(s)},softbreak:function(e,t){if("paragraph"===t.parent.type){var n=t.prev,r=t.next;n&&!_m(n)&&e.closeNode(),r&&!_m(r)&&e.openNode(e.schema.nodes.paragraph)}},table:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.table,r):e.closeNode()},tableHead:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.tableHead,r):e.closeNode()},tableBody:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.tableBody,r):e.closeNode()},tableRow:function(e,t,n,r){n.entering?e.openNode(e.schema.nodes.tableRow,r):e.closeNode()},tableCell:function(e,t,n){var r=n.entering;if(!t.ignored){var i=function(t){return t&&(Hm(t)||Fm(e,t))};if(r){var s=e.schema.nodes,a=s.tableHeadCell,l=s.tableBodyCell,c=s.paragraph,u=t.parent.parent,d="tableHead"===u.type?a:l,p=(u.parent.columns[t.startIdx]||{}).align,h=o({},t.attrs);p&&(h.align=p),e.openNode(d,h),i(t.firstChild)&&e.openNode(c)}else i(t.lastChild)&&e.closeNode(),e.closeNode()}},strike:function(e,t,n,r){var o=n.entering,i=e.schema.marks.strike;o?e.openMark(i.create(r)):e.closeMark(i)},code:function(e,t,n,r){var o=e.schema.marks.code;e.openMark(o.create(r)),e.addText(Bm(t.literal||"")),e.closeMark(o)},customBlock:function(e,t){var n=e.schema.nodes,r=n.customBlock,o=n.paragraph,i=t,s=i.info,a=i.literal;e.openNode(r,{info:s}),e.addText(Bm(a||"")),e.closeNode(),t.next||(e.openNode(o),e.closeNode())},frontMatter:function(e,t){e.openNode(e.schema.nodes.frontMatter),e.addText(t.literal),e.closeNode()},htmlInline:function(e,t){var n=t.literal,r=n.match(ga),o=r[1],i=r[3],s=(o||i).toLowerCase(),a=e.schema.marks[s],l=rh(n);if(null==a?void 0:a.spec.attrs.htmlInline)if(o){var c=ih(l);e.openMark(a.create({htmlAttrs:c}))}else e.closeMark(a);else{var u=$m[s];u&&u(e,t,o)}},htmlBlock:function(e,t){var n=t.literal,r=document.createElement("div");if(ya.test(n))e.openNode(e.schema.nodes.htmlComment),e.addText(t.literal),e.closeNode();else{var o=n.match(ga),i=o[1],s=o[3],a=(i||s).toLowerCase(),l=e.schema.nodes[a],c=rh(n);if(null==l?void 0:l.spec.attrs.htmlBlock){var u=ih(c),d=oh(t,a);e.addNode(l,{htmlAttrs:u,childrenHTML:d})}else r.innerHTML=c,Um(r),e.convertByDOMParser(r)}},customInline:function(e,t,n){var r=n.entering,o=n.skipChildren,i=t,s=i.info,a=i.firstChild,l=e.schema;if(-1!==s.indexOf("widget")&&r){var c=oa(t);o(),e.addNode(l.nodes.widget,{info:s},[l.text(Qs(s,c))])}else{var u="$$";r&&(u+=a?s+" ":s),e.addText(u)}}};var Jm=function(){function e(e,t){this.schema=e,this.convertors=t,this.stack=[{type:this.schema.topNodeType,attrs:null,content:[]}],this.marks=m.none}return e.prototype.top=function(){return et(this.stack)},e.prototype.push=function(e){this.stack.length&&this.top().content.push(e)},e.prototype.addText=function(e){if(e){var t=this.top().content,n=et(t),r=this.schema.text(e,this.marks),o=n&&(s=r,!!((i=n).isText&&s.isText&&m.sameSet(i.marks,s.marks))&&i.withText(i.text+s.text));o?t[t.length-1]=o:t.push(r)}var i,s},e.prototype.openMark=function(e){this.marks=e.addToSet(this.marks)},e.prototype.closeMark=function(e){this.marks=e.removeFromSet(this.marks)},e.prototype.addNode=function(e,t,n){var r=e.createAndFill(t,n,this.marks);return r?(this.push(r),r):null},e.prototype.openNode=function(e,t){this.stack.push({type:e,attrs:t,content:[]})},e.prototype.closeNode=function(){this.marks.length&&(this.marks=m.none);var e=this.stack.pop(),t=e.type,n=e.attrs,r=e.content;return this.addNode(t,n,r)},e.prototype.convertByDOMParser=function(e){var t=this;te.fromSchema(this.schema).parse(e).content.forEach((function(e){return t.push(e)}))},e.prototype.closeUnmatchedHTMLInline=function(e,t){var n;if(!t&&"htmlInline"!==e.type)for(var r=this.stack.length-1;r>=0;r-=1){var o=this.stack[r];if(!(null===(n=o.attrs)||void 0===n?void 0:n.rawHTML))break;o.content.length?this.closeNode():this.stack.pop()}},e.prototype.convert=function(e,t){for(var n=e.walker(),r=n.next(),o=function(){var e=r.node,o=r.entering,s=i.convertors[e.type],a=!1;if(s){var l={entering:o,leaf:!Ws(e),getChildrenText:Js,options:{gfm:!0,nodeId:!1,tagFilter:!1,softbreak:"\n"},skipChildren:function(){a=!0}};if(i.closeUnmatchedHTMLInline(e,o),s(i,e,l),(null==t?void 0:t.node)===e){var c=i.stack.reduce((function(e,t){return e+t.content.reduce((function(e,t){return e+t.nodeSize}),0)}),0)+1;t.setMappedPos(c)}}a&&(n.resumeAt(e,!1),n.next()),r=n.next()},i=this;r;)o()},e.prototype.convertNode=function(e,t){return this.convert(e,t),this.stack.length?this.closeNode():null},e}(),Gm=Jm;var Km={text:function(e,t){var n,r=t.node,o=null!==(n=r.text)&&void 0!==n?n:"";(r.marks||[]).some((function(e){return"link"===e.type.name}))?e.text(Ze(o),!1):e.text(o)},paragraph:function(e,t){var n=t.node,r=t.parent,o=t.index,i=void 0===o?0:o;if(e.stopNewline)e.convertInline(n);else{var s=0===i,a=!s&&r.child(i-1),l=a&&0===a.childCount,c=i<r.childCount-1&&r.child(i+1),u=c&&"paragraph"===c.type.name,d=0===n.childCount;if(d&&l)e.write("<br>\n");else if(!d||l||s)e.convertInline(n),u?e.write("\n"):e.closeBlock(n);else{if("listItem"===(null==r?void 0:r.type.name)){var p=e.getDelim();e.setDelim(""),e.write("<br>"),e.setDelim(p)}e.write("\n")}}},heading:function(e,t,n){var r=t.node,o=n.delim;"atx"===r.attrs.headingType?(e.write(o+" "),e.convertInline(r),e.closeBlock(r)):(e.convertInline(r),e.ensureNewLine(),e.write(o),e.closeBlock(r))},codeBlock:function(e,t,n){var r=t.node,o=n.delim,i=n.text,s=o,a=s[0],l=s[1];e.write(a),e.ensureNewLine(),e.text(i,!1),e.ensureNewLine(),e.write(l),e.closeBlock(r)},blockQuote:function(e,t,n){var r=t.node,o=t.parent,i=n.delim;(null==o?void 0:o.type.name)===r.type.name&&e.flushClose(1),e.wrapBlock(i,null,r,(function(){return e.convertNode(r)}))},bulletList:function(e,t,n){var r=t.node,o=n.delim;e.convertList(r,Ke(" ",4),(function(){return o+" "}))},orderedList:function(e,t){var n=t.node,r=n.attrs.order||1;e.convertList(n,Ke(" ",4),(function(e){return String(r+e)+". "}))},listItem:function(e,t){var n=t.node,r=n.attrs,o=r.task,i=r.checked;o&&e.write("["+(i?"x":" ")+"] "),e.convertNode(n)},image:function(e,t,n){var r=n.attrs;e.write("!["+(null==r?void 0:r.altText)+"]("+(null==r?void 0:r.imageUrl)+")")},thematicBreak:function(e,t,n){var r=t.node,o=n.delim;e.write(o),e.closeBlock(r)},table:function(e,t){var n=t.node;e.convertNode(n),e.closeBlock(n)},tableHead:function(e,t,n){var r=t.node,o=n.delim,i=r.firstChild;e.convertNode(r);var s=null!=o?o:"";!o&&i&&i.forEach((function(e){var t=function(e,t){var n=e.length,r="",o="";return"left"===t?(r=":",n-=1):"right"===t?(o=":",n-=1):"center"===t&&(r=":",o=":",n-=2),""+r+Ke("-",Math.max(n,3))+o}(e.textContent,e.attrs.align);s+="| "+t+" "})),e.write(s+"|"),e.ensureNewLine()},tableBody:function(e,t){var n=t.node;e.convertNode(n)},tableRow:function(e,t){var n=t.node;e.convertNode(n),e.write("|"),e.ensureNewLine()},tableHeadCell:function(e,t,n){var r=t.node,o=n.delim,i=void 0===o?"| ":o;e.write(i),e.convertTableCell(r),e.write(" ")},tableBodyCell:function(e,t,n){var r=t.node,o=n.delim,i=void 0===o?"| ":o;e.write(i),e.convertTableCell(r),e.write(" ")},customBlock:function(e,t,n){var r=t.node,o=n.delim,i=n.text,s=o,a=s[0],l=s[1];e.write(a),e.ensureNewLine(),e.text(i,!1),e.ensureNewLine(),e.write(l),e.closeBlock(r)},frontMatter:function(e,t,n){var r=t.node,o=n.text;e.text(o,!1),e.closeBlock(r)},widget:function(e,t,n){var r=n.text;e.write(r)},html:function(e,t,n){var r=t.node,o=n.text;e.write(o),r.attrs.htmlBlock&&e.closeBlock(r)},htmlComment:function(e,t,n){var r=t.node,o=n.text;e.write(o),e.closeBlock(r)}};function Zm(e,t){var n=e.text,r=/`+/g,o=0;if(e.isText&&n)for(var i=r.exec(n);i;)o=Math.max(o,i[0].length),i=r.exec(n);for(var s=o>0&&t>0?" `":"`",a=0;a<o;a+=1)s+="`";return o>0&&t<0&&(s+=" "),s}function Xm(e){return e?["<"+e+">","</"+e+">"]:null}function Qm(e){return e?"<"+e+">":null}function Ym(e){return e?"</"+e+">":null}var eg={heading:function(e){var t=e.node.attrs,n=t.level,r=Ke("#",n);return"setext"===t.headingType&&(r=1===n?"===":"---"),{delim:r,rawHTML:Xm(t.rawHTML)}},codeBlock:function(e){var t=e.node,n=t.attrs,r=t.textContent;return{delim:["```"+(n.language||""),"```"],rawHTML:Xm(n.rawHTML),text:r}},blockQuote:function(e){return{delim:"> ",rawHTML:Xm(e.node.attrs.rawHTML)}},bulletList:function(e,t){var n=e.node,r=t.inTable,o=n.attrs.rawHTML;return r&&(o=o||"ul"),{delim:"*",rawHTML:Xm(o)}},orderedList:function(e,t){var n=e.node,r=t.inTable,o=n.attrs.rawHTML;return r&&(o=o||"ol"),{rawHTML:Xm(o)}},listItem:function(e,t){var n=e.node,r=t.inTable,o=n.attrs,i=o.task,s=o.checked,a=n.attrs.rawHTML;return r&&(a=a||"li"),{rawHTML:a?["<"+a+(i?' class="task-list-item'+(s?" checked":"")+'"':"")+(i?" data-task"+(s?" data-task-checked":""):"")+">","</"+a+">"]:null}},table:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableHead:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableBody:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableRow:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableHeadCell:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},tableBodyCell:function(e){return{rawHTML:Xm(e.node.attrs.rawHTML)}},image:function(e){var t=e.node.attrs,n=t.rawHTML,r=t.altText,o=t.imageUrl.replace(/&amp;/g,"&"),i=r?' alt="'+_e(r)+'"':"";return{rawHTML:n?"<"+n+' src="'+_e(o)+'"'+i+">":null,attrs:{altText:Ze(r||""),imageUrl:o}}},thematicBreak:function(e){return{delim:"***",rawHTML:Qm(e.node.attrs.rawHTML)}},customBlock:function(e){var t=e.node,n=t.attrs,r=t.textContent;return{delim:["$$"+n.info,"$$"],text:r}},frontMatter:function(e){return{text:e.node.textContent}},widget:function(e){return{text:e.node.textContent}},strong:function(e,t){var n=e.node,r=t.entering,o=n.attrs.rawHTML;return{delim:"**",rawHTML:r?Qm(o):Ym(o)}},emph:function(e,t){var n=e.node,r=t.entering,o=n.attrs.rawHTML;return{delim:"*",rawHTML:r?Qm(o):Ym(o)}},strike:function(e,t){var n=e.node,r=t.entering,o=n.attrs.rawHTML;return{delim:"~~",rawHTML:r?Qm(o):Ym(o)}},link:function(e,t){var n,r,o=e.node,i=t.entering,s=o.attrs,a=s.title,l=s.rawHTML,c=s.linkUrl.replace(/&amp;/g,"&"),u=a?' title="'+_e(a)+'"':"";return i?{delim:"[",rawHTML:l?"<"+l+' href="'+_e(c)+'"'+u+">":null}:{delim:"]("+c+(a?" "+(n=Ze(a),(r=-1===n.indexOf('"')?'""':-1===n.indexOf("'")?"''":"()")[0]+n+r[1]):"")+")",rawHTML:Ym(l)}},code:function(e,t){var n=e.node,r=e.parent,o=e.index,i=void 0===o?0:o,s=t.entering;return{delim:s?Zm(r.child(i),-1):Zm(r.child(i-1),1),rawHTML:s?Qm(n.attrs.rawHTML):Ym(n.attrs.rawHTML)}},htmlComment:function(e){return{text:e.node.textContent}},html:function(e,t){var n=e.node,r=t.entering,o=n.type.name,i=n.attrs.htmlAttrs,s="<"+o,a="</"+o+">";return Object.keys(i).forEach((function(e){s+=" "+e+'="'+i[e].replace(/"/g,"'")+'"'})),s+=">",n.attrs.htmlInline?{rawHTML:r?s:a}:{text:""+s+n.attrs.childrenHTML+a}}},tg={strong:{mixable:!0,removedEnclosingWhitespace:!0},emph:{mixable:!0,removedEnclosingWhitespace:!0},strike:{mixable:!0,removedEnclosingWhitespace:!0},code:{escape:!1},link:null,html:null};function ng(e){var t={};return Object.keys(Km).forEach((function(n){t[n]=function(t,r){if(Km[n]){var o=e[n],i=o?o(r,{inTable:t.inTable}):{};!function(e,t){var n=t.state,r=t.nodeInfo,o=t.params,i=o.rawHTML;i?lf()(e,["heading","codeBlock"])>-1?function(e,t,n){var r=n[0],o=n[1];e.write(r),e.convertInline(t),e.write(o)}(n,r.node,i):lf()(e,["image","thematicBreak"])>-1?n.write(i):function(e,t,n){var r=t.node,o=t.parent,i=n[0],s=n[1];e.stopNewline=!0,e.write(i),e.convertNode(r),e.write(s),"doc"===(null==o?void 0:o.type.name)&&(e.closeBlock(r),e.stopNewline=!1)}(n,r,i):Km[e](n,r,o)}(n,{state:t,nodeInfo:r,params:i})}}})),t}function rg(e){Object.keys(e).forEach((function(t){var n=eg[t],r=e[t];eg[t]=n?function(e,t){return t.origin=function(){return n(e,t)},r(e,t)}:r,delete e[t]}));var t=ng(eg),n=function(e){var t={};return Object.keys(tg).forEach((function(n){t[n]=function(t,r){var i=tg[n],s=e[n],a=s&&t&&!Oe()(r)?s(t,{entering:r}):{};return o(o({},a),i)}})),t}(eg);return{nodeTypeConvertors:t,markTypeConvertors:n}}var og=function(){function e(e){var t=e.nodeTypeConvertors,n=e.markTypeConvertors;this.nodeTypeConvertors=t,this.markTypeConvertors=n,this.delim="",this.result="",this.closed=!1,this.tightList=!1,this.stopNewline=!1,this.inTable=!1}return e.prototype.getMarkConvertor=function(e){var t=e.attrs.htmlInline?"html":e.type.name;return this.markTypeConvertors[t]},e.prototype.isInBlank=function(){return/(^|\n)$/.test(this.result)},e.prototype.markText=function(e,t,n,r){var o=this.getMarkConvertor(e);if(o){var i=o({node:e,parent:n,index:r},t),s=i.delim;return i.rawHTML||s}return""},e.prototype.setDelim=function(e){this.delim=e},e.prototype.getDelim=function(){return this.delim},e.prototype.flushClose=function(e){if(!this.stopNewline&&this.closed){if(this.isInBlank()||(this.result+="\n"),e||(e=2),e>1){var t=this.delim,n=/\s+$/.exec(t);n&&(t=t.slice(0,t.length-n[0].length));for(var r=1;r<e;r+=1)this.result+=t+"\n"}this.closed=!1}},e.prototype.wrapBlock=function(e,t,n,r){var o=this.getDelim();this.write(t||e),this.setDelim(this.getDelim()+e),r(),this.setDelim(o),this.closeBlock(n)},e.prototype.ensureNewLine=function(){this.isInBlank()||(this.result+="\n")},e.prototype.write=function(e){void 0===e&&(e=""),this.flushClose(),this.delim&&this.isInBlank()&&(this.result+=this.delim),e&&(this.result+=e)},e.prototype.closeBlock=function(e){this.closed=e},e.prototype.text=function(e,t){void 0===t&&(t=!0);for(var n=e.split("\n"),r=0;r<n.length;r+=1)this.write(),this.result+=t?Xe(n[r]):n[r],r!==n.length-1&&(this.result+="\n")},e.prototype.convertBlock=function(e,t,n){var r=e.type.name,o=this.nodeTypeConvertors[r],i={node:e,parent:t,index:n};e.attrs.htmlBlock?this.nodeTypeConvertors.html(this,i):o&&o(this,i)},e.prototype.convertInline=function(e){var t=this,n=[],r="",o=function(o,i,s){var a=o?o.marks:[],l=r;r="";var c=o&&o.isText&&a.some((function(e){var n=t.getMarkConvertor(e),r=n&&n();return r&&r.removedEnclosingWhitespace}));if(c&&o&&o.text){var u=/^(\s*)(.*?)(\s*)$/m.exec(o.text),d=u[1],p=u[2],h=u[3];l+=d,r=h,(d||h)&&((o=p?o.withText(p):null)||(a=n))}for(var f=a.length&&et(a),m=f&&t.getMarkConvertor(f),g=m&&m(),v=g&&!1===g.escape,y=a.length-(v?1:0),b=0;b<y;b+=1){p=a[b];if(g&&!g.mixable)break;for(var w=0;w<n.length;w+=1){var k=n[w];if(g&&!g.mixable)break;if(p.eq(k)){b>w?a=a.slice(0,w).concat(p).concat(a.slice(w,b)).concat(a.slice(b+1,y)):w>b&&(a=a.slice(0,b).concat(a.slice(b+1,w)).concat(p).concat(a.slice(w,y)));break}}}for(var x=0;x<Math.min(n.length,y)&&a[x].eq(n[x]);)x+=1;for(;x<n.length;){var C=n.pop();C&&t.text(t.markText(C,!1,e,s),!1)}if(l&&t.text(l),o){for(;n.length<y;){p=a[n.length];n.push(p),t.text(t.markText(p,!0,e,s),!1)}v&&o.isText?t.text(t.markText(f,!0,e,s)+o.text+t.markText(f,!1,e,s+1),!1):t.convertBlock(o,e,s)}};e.forEach(o),o(null,0,e.childCount)},e.prototype.convertList=function(e,t,n){var r,o=this;this.closed&&this.closed.type===e.type?this.flushClose(3):this.tightList&&this.flushClose(1);var i=null===(r=e.attrs.tight)||void 0===r||r,s=this.tightList;this.tightList=i,e.forEach((function(r,s,a){a&&i&&o.flushClose(1),o.wrapBlock(t,n(a),e,(function(){return o.convertBlock(r,e,a)}))})),this.tightList=s},e.prototype.convertTableCell=function(e){var t=this;this.stopNewline=!0,this.inTable=!0,e.forEach((function(n,r,o){Ue(["bulletList","orderedList"],n.type.name)?(t.convertBlock(n,e,o),t.closed=!1):(t.convertInline(n),o<e.childCount-1&&"paragraph"===e.child(o+1).type.name&&t.write("<br>"))})),this.stopNewline=!1,this.inTable=!1},e.prototype.convertNode=function(e,t){var n=this;return e.forEach((function(r,o,i){if(n.convertBlock(r,e,i),(null==t?void 0:t.node)===r){var s=n.result.split("\n");t.setMappedPos([s.length,et(s).length+1])}})),this.result},e}(),ig=og,sg=function(){function e(e,t,n,r){var i=this;this.setMappedPos=function(e){i.mappedPosWhenConverting=e},this.schema=e,this.eventEmitter=r,this.focusedNode=null,this.mappedPosWhenConverting=null,this.toWwConvertors=function(e){var t=Object.keys(e),n=o({},Wm),r=new Xp({gfm:!0,nodeId:!0,convertors:e}).getConvertors();return t.forEach((function(t){var o=Wm[t];o&&!Ue(["htmlBlock","htmlInline"],t)&&(n[t]=function(n,i,s){s.origin=function(){return r[t](i,s,r)};var a,l=e[t](i,s);if(l){var c=Array.isArray(l)?l[0]:l;a={htmlAttrs:c.attributes,classNames:c.classNames}}o(n,i,s,a)})})),n}(n),this.toMdConvertors=rg(t||{}),this.eventEmitter.listen("setFocusedNode",(function(e){return i.focusedNode=e}))}return e.prototype.getMappedPos=function(){return this.mappedPosWhenConverting},e.prototype.getInfoForPosSync=function(){return{node:this.focusedNode,setMappedPos:this.setMappedPos}},e.prototype.toWysiwygModel=function(e){return new Gm(this.schema,this.toWwConvertors).convertNode(e,this.getInfoForPosSync())},e.prototype.toMarkdownText=function(e){var t=new ig(this.toMdConvertors).convertNode(e,this.getInfoForPosSync());return t=this.eventEmitter.emitReduce("beforeConvertWysiwygToMarkdown",t)},e}(),ag=sg;function lg(e){var t=e.plugins,n=e.eventEmitter,r=e.usageStatistics,i=e.instance;return n.listen("mixinTableOffsetMapPrototype",_h),(null!=t?t:[]).reduce((function(e,t){var s=function(e){var t=e.plugin,n={eventEmitter:e.eventEmitter,usageStatistics:e.usageStatistics,instance:e.instance,pmState:{Plugin:an,PluginKey:un,Selection:Vt,TextSelection:Ut},pmView:{Decoration:Vo,DecorationSet:_o},pmModel:{Fragment:d},pmRules:{InputRule:ns,inputRules:rs,undoInputRule:ss},pmKeymap:{keymap:Ai},i18n:hf};if(aa()(t)){var r=t[0],o=t[1];return r(n,void 0===o?{}:o)}return t(n)}({plugin:t,eventEmitter:n,usageStatistics:r,instance:i});if(!s)throw new Error("The return value of the executed plugin is empty.");var a=s.markdownParsers,l=s.toHTMLRenderers,c=s.toMarkdownRenderers,u=s.markdownPlugins,p=s.wysiwygPlugins,h=s.wysiwygNodeViews,f=s.markdownCommands,m=s.wysiwygCommands,g=s.toolbarItems;return l&&(e.toHTMLRenderers=nt(e.toHTMLRenderers,l)),c&&(e.toMarkdownRenderers=nt(e.toMarkdownRenderers,c)),u&&(e.mdPlugins=e.mdPlugins.concat(u)),p&&(e.wwPlugins=e.wwPlugins.concat(p)),h&&(e.wwNodeViews=o(o({},e.wwNodeViews),h)),f&&(e.mdCommands=o(o({},e.mdCommands),f)),m&&(e.wwCommands=o(o({},e.wwCommands),m)),g&&(e.toolbarItems=e.toolbarItems.concat(g)),a&&(e.markdownParsers=o(o({},e.markdownParsers),a)),e}),{toHTMLRenderers:{},toMarkdownRenderers:{},mdPlugins:[],wwPlugins:[],wwNodeViews:{},mdCommands:{},wwCommands:{},toolbarItems:[],markdownParsers:{}})}var cg=function(){function e(e){var t=this;this.options=ve()({linkAttributes:null,extendedAutolinks:!1,customHTMLRenderer:null,referenceDefinition:!1,customHTMLSanitizer:null,frontMatter:!1,usageStatistics:!0,theme:"light"},e),this.eventEmitter=new Im;var n,r=Ge(this.options.linkAttributes),i=lg({plugins:this.options.plugins,eventEmitter:this.eventEmitter,usageStatistics:this.options.usageStatistics,instance:this})||{},s=i.toHTMLRenderers,a=i.markdownParsers,l=this.options,c=l.customHTMLRenderer,u=l.extendedAutolinks,d=l.referenceDefinition,p=l.frontMatter,h=l.customHTMLSanitizer,f={linkAttributes:r,customHTMLRenderer:o(o({},s),c),extendedAutolinks:u,referenceDefinition:d,frontMatter:p,sanitizer:h||rh};n=f.customHTMLRenderer,["htmlBlock","htmlInline"].forEach((function(e){n[e]&&Object.keys(n[e]).forEach((function(e){return nh(e)}))})),this.options.events&&me()(this.options.events,(function(e,n){t.on(n,e)}));var m=this.options,g=m.el,v=m.initialValue,y=m.theme,b=g.innerHTML;"light"!==y&&g.classList.add(xa(y)),g.innerHTML="",this.toastMark=new _p("",{disallowedHtmlBlockTags:["br","img"],extendedAutolinks:u,referenceDefinition:d,disallowDeepHeading:!0,frontMatter:p,customParser:a}),this.preview=new Mh(this.eventEmitter,o(o({},f),{isViewer:!0})),Vc()(this.preview.previewContent,"mousedown",this.toggleTask.bind(this)),v?this.setMarkdown(v):b&&this.preview.setHTML(b),g.appendChild(this.preview.previewContent),this.eventEmitter.emit("load",this)}return e.prototype.toggleTask=function(e){var t=e.target,n=getComputedStyle(t,":before");!t.hasAttribute("data-task-disabled")&&t.hasAttribute("data-task")&&wa(n,e.offsetX,e.offsetY)&&(Sa(t,"checked"),this.eventEmitter.emit("change",{source:"viewer",date:e}))},e.prototype.setMarkdown=function(e){var t=this.toastMark.getLineTexts(),n=[t.length,et(t).length+1],r=this.toastMark.editMarkdown([1,1],n,e||"");this.eventEmitter.emit("updatePreview",r)},e.prototype.on=function(e,t){this.eventEmitter.listen(e,t)},e.prototype.off=function(e){this.eventEmitter.removeEventHandler(e)},e.prototype.addHook=function(e,t){this.eventEmitter.removeEventHandler(e),this.eventEmitter.listen(e,t)},e.prototype.destroy=function(){zc()(this.preview.el,"mousedown",this.toggleTask.bind(this)),this.preview.destroy(),this.eventEmitter.emit("destroy")},e.prototype.isViewer=function(){return!0},e.prototype.isMarkdownMode=function(){return!1},e.prototype.isWysiwygMode=function(){return!1},e}(),ug=cg;function dg(e){return e instanceof P}function pg(e){return Ue(["document","blockQuote","bulletList","orderedList","listItem","paragraph","heading","emph","strong","strike","link","image","table","tableHead","tableBody","tableRow","tableHeadCell","tableBodyCell"],e)}var hg={openTag:function(e,t){var n=e,r=n.tagName,i=n.classNames,s=n.attributes,a=document.createElement(r),l={};i&&(a.className=i.join(" ")),s&&(l=o(o({},l),s)),Aa(l,a),t.push(a)},closeTag:function(e,t){if(t.length>1){var n=t.pop();et(t).appendChild(n)}},html:function(e,t){et(t).insertAdjacentHTML("beforeend",e.content)},text:function(e,t){var n=document.createTextNode(e.content);et(t).appendChild(n)}},fg=function(){function e(e,t){var n=dh(e,t),r=o(o({},t.htmlBlock),t.htmlInline);this.customConvertorKeys=Object.keys(t).concat(Object.keys(r)),this.renderer=new Xp({gfm:!0,convertors:o(o({},n),r)}),this.convertors=this.renderer.getConvertors()}return e.prototype.generateTokens=function(e){var t=function(e){var t=e.attrs,n=e.type.name,r={type:n,wysiwygNode:!0,literal:!pg(n)&&dg(e)?e.textContent:null},i={heading:{level:t.level},link:{destination:t.linkUrl,title:t.title},image:{destination:t.imageUrl},codeBlock:{info:t.language},bulletList:{type:"list",listData:{type:"bullet"}},orderedList:{type:"list",listData:{type:"ordered",start:t.order}},listItem:{type:"item",listData:{task:t.task,checked:t.checked}},tableHeadCell:{type:"tableCell",cellType:"head",align:t.align},tableBodyCell:{type:"tableCell",cellType:"body",align:t.align},customBlock:{info:t.info}}[n],s=o(o({},r),i),a=e.attrs,l=a.htmlAttrs,c=a.childrenHTML;return l?o(o({},s),{attrs:l,childrenHTML:c}):s}(e),n={entering:!0,leaf:!!dg(e)&&e.isLeaf,options:this.renderer.getOptions(),getChildrenText:function(){return dg(e)?e.textContent:""},skipChildren:function(){return!1}},r=this.convertors[e.type.name],i=r(t,n,this.convertors),s=aa()(i)?i:[i];return(pg(e.type.name)||e.attrs.htmlInline)&&(n.entering=!1,s.push({type:"text",content:dg(e)?e.textContent:""}),s=s.concat(r(t,n,this.convertors))),s},e.prototype.toDOMNode=function(e){var t=this.generateTokens(e),n=[];return t.forEach((function(e){return hg[e.type](e,n)})),n[0]},e.prototype.getToDOMNode=function(e){return Ue(this.customConvertorKeys,e)?this.toDOMNode.bind(this):null},e}(),mg=null,gg=null;function vg(e,t){var n=t.syncScrollTop,r=t.releaseEventBlock;gg&&clearTimeout(gg),n(e),gg=setTimeout((function(){r()}),15)}var yg=function(){function e(e,t,n){this.latestEditorScrollTop=null,this.latestPreviewScrollTop=null,this.blockedScroll=null,this.active=!0,this.timer=null;var r=t.previewContent,o=t.el;this.previewRoot=r,this.previewEl=o,this.mdEditor=e,this.editorView=e.view,this.toastMark=e.getToastMark(),this.eventEmitter=n,this.addScrollSyncEvent()}return e.prototype.addScrollSyncEvent=function(){var e=this;this.eventEmitter.listen("afterPreviewRender",(function(){e.clearTimer(),e.timer=setTimeout((function(){e.syncPreviewScrollTop(!0)}),200)})),this.eventEmitter.listen("scroll",(function(t,n){e.active&&("editor"===t&&"editor"!==e.blockedScroll?e.syncPreviewScrollTop():"preview"===t&&"preview"!==e.blockedScroll&&e.syncEditorScrollTop(n))})),this.eventEmitter.listen("toggleScrollSync",(function(t){e.active=t}))},e.prototype.getMdNodeAtPos=function(e,t){var n=e.content.findIndex(t.pos).index;return this.toastMark.findFirstNodeAtLine(n+1)},e.prototype.getScrollTopByCaretPos=function(){var e=this.mdEditor.getSelection(),t=this.toastMark.findFirstNodeAtLine(e[0][0]),n=this.previewEl.clientHeight,r=bh(this.previewRoot,t).el,o=(vh(r,this.previewRoot)||r.offsetTop)+r.clientHeight-.5*n;return this.latestEditorScrollTop=null,r.getBoundingClientRect().top-this.previewEl.getBoundingClientRect().top<n?null:o},e.prototype.syncPreviewScrollTop=function(e){void 0===e&&(e=!1);var t=this,n=t.editorView,r=t.previewEl,o=t.previewRoot,i=n.dom.getBoundingClientRect(),s=i.left,a=i.top,l=n.posAtCoords({left:s,top:a}),c=n.state.doc,u=this.getMdNodeAtPos(c,l);if(u&&!function(e){var t=e.type;return"htmlBlock"===t||"htmlInline"===t}(u)){var d=r.scrollTop,p=n.dom,h=p.scrollTop,f=p.scrollHeight,m=p.clientHeight,g=p.children,v=f-h<=m+18,y=v?r.scrollHeight:0;if(h&&!v){if(e){var b=this.getScrollTopByCaretPos();if(!b)return;y=b}else{var w=bh(this.previewRoot,u),k=w.el,x=mh(c,w.mdNode,g),C=x.height,T=x.rect;y=(vh(k,o)||k.offsetTop)+k.clientHeight*(a>T.top?Math.min((a-T.top)/C,1):0)}y=this.getResolvedScrollTop("editor",h,y,d),this.latestEditorScrollTop=h}y!==d&&this.run("editor",y,d)}},e.prototype.syncEditorScrollTop=function(e){var t=this,n=t.toastMark,r=t.editorView,o=t.previewRoot,i=t.previewEl,s=r.dom,a=r.state,l=i.scrollTop,c=i.clientHeight,u=i.scrollHeight-l<=c,d=s.scrollTop,p=u?s.scrollHeight:0;if(l&&e&&!u){if(e=function(e,t){for(;!e.getAttribute("data-nodeid")&&e.parentElement!==t;)e=e.parentElement;return e}(e,o),!e.getAttribute("data-nodeid"))return;var h=s.children,f=Number(e.getAttribute("data-nodeid")),m=bh(this.previewRoot,n.findNodeById(f)),g=m.mdNode,v=m.el;p=h[Is(g)-1].offsetTop;var y=mh(a.doc,g,h).height,b=xh(v,o,f),w=b.nodeHeight;p+=function(e,t,n,r){return Math.min((e-t)/n,1)*r}(l,b.offsetTop,w,y),p=this.getResolvedScrollTop("preview",l,p,d),this.latestPreviewScrollTop=l}p!==d&&this.run("preview",p,d)},e.prototype.getResolvedScrollTop=function(e,t,n,r){var o="editor"===e?this.latestEditorScrollTop:this.latestPreviewScrollTop;return null===o?n:o<t?Math.max(n,r):Math.min(n,r)},e.prototype.run=function(e,t,n){var r,o=this;"editor"===e?(r=this.previewEl,this.blockedScroll="preview"):(r=this.editorView.dom,this.blockedScroll="editor"),function(e,t,n){var r=t-e,o=Date.now(),i=function(){var s,a=(Date.now()-o)/100;mg&&clearTimeout(mg),a<1?(s=e+r*Math.cos((1-a)*Math.PI/2),vg(Math.ceil(s),n),mg=setTimeout(i,1)):(vg(t,n),mg=null)};i()}(n,t,{syncScrollTop:function(e){return r.scrollTop=e},releaseEventBlock:function(){return o.blockedScroll=null}})},e.prototype.clearTimer=function(){this.timer&&(clearTimeout(this.timer),this.timer=null)},e.prototype.destroy=function(){this.clearTimer(),this.eventEmitter.removeEventHandler("scroll"),this.eventEmitter.removeEventHandler("afterPreviewRender")},e}(),bg={getPopupInitialValues:function(e,t){return"link"===t.popupName?{linkText:e.getSelectedText()}:{}}};var wg=function(){function e(e){var t=this;this.initialHTML=e.el.innerHTML,e.el.innerHTML="",this.options=ve()({previewStyle:"tab",previewHighlight:!0,initialEditType:"markdown",height:"300px",minHeight:"200px",language:"en-US",useCommandShortcut:!0,usageStatistics:!0,toolbarItems:[["heading","bold","italic","strike"],["hr","quote"],["ul","ol","task","indent","outdent"],["table","image","link"],["code","codeblock"],["scrollSync"]],hideModeSwitch:!1,linkAttributes:null,extendedAutolinks:!1,customHTMLRenderer:null,customMarkdownRenderer:null,referenceDefinition:!1,customHTMLSanitizer:null,frontMatter:!1,widgetRules:[],theme:"light",autofocus:!0},e);var n=this.options,r=n.customHTMLRenderer,i=n.extendedAutolinks,s=n.referenceDefinition,a=n.frontMatter,l=n.customMarkdownRenderer,c=n.useCommandShortcut,u=n.initialEditType,d=n.widgetRules,p=n.customHTMLSanitizer;this.mode=u||"markdown",this.mdPreviewStyle=this.options.previewStyle,this.i18n=hf,this.i18n.setCode(this.options.language),this.eventEmitter=new Im,ta(d);var h=Ge(this.options.linkAttributes);this.pluginInfo=lg({plugins:this.options.plugins,eventEmitter:this.eventEmitter,usageStatistics:this.options.usageStatistics,instance:this});var f=this.pluginInfo,m=f.toHTMLRenderers,g=f.toMarkdownRenderers,v=f.mdPlugins,y=f.wwPlugins,b=f.wwNodeViews,w=f.mdCommands,k=f.wwCommands,x=f.markdownParsers,C={linkAttributes:h,customHTMLRenderer:nt(m,r),extendedAutolinks:i,referenceDefinition:s,frontMatter:a,sanitizer:p||rh},T=new fg(h,C.customHTMLRenderer),M=function(e,t,n){var r={nodes:{},marks:{}};return["htmlBlock","htmlInline"].forEach((function(o){e[o]&&Object.keys(e[o]).forEach((function(e){var i="htmlBlock"===o?"nodes":"marks";nh(e),r[i][e]=lh[o](e,t,n)}))})),r}(C.customHTMLRenderer,C.sanitizer,T);this.toastMark=new _p("",{disallowedHtmlBlockTags:["br","img"],extendedAutolinks:i,referenceDefinition:s,disallowDeepHeading:!0,frontMatter:a,customParser:x}),this.mdEditor=new Fc(this.eventEmitter,{toastMark:this.toastMark,useCommandShortcut:c,mdPlugins:v}),this.preview=new Mh(this.eventEmitter,o(o({},C),{isViewer:!1,highlight:this.options.previewHighlight})),this.wwEditor=new Nm(this.eventEmitter,{toDOMAdaptor:T,useCommandShortcut:c,htmlSchemaMap:M,linkAttributes:h,wwPlugins:y,wwNodeViews:b}),this.convertor=new ag(this.wwEditor.getSchema(),o(o({},g),l),dh(h,C.customHTMLRenderer),this.eventEmitter),this.setMinHeight(this.options.minHeight),this.setHeight(this.options.height),this.setMarkdown(this.options.initialValue,!1),this.options.placeholder&&this.setPlaceholder(this.options.placeholder),this.options.initialValue||this.setHTML(this.initialHTML,!1),this.commandManager=new Pm(this.eventEmitter,this.mdEditor.commands,this.wwEditor.commands,(function(){return t.mode})),this.options.usageStatistics&&Ie()("editor","UA-129966929-1"),this.scrollSync=new yg(this.mdEditor,this.preview,this.eventEmitter),this.addInitEvent(),this.addInitCommand(w,k),function(e){e.eventEmitter.listen("query",(function(t,n){return bg[t](e,n)}))}(this),this.options.hooks&&me()(this.options.hooks,(function(e,n){return t.addHook(n,e)})),this.options.events&&me()(this.options.events,(function(e,n){return t.on(n,e)})),this.eventEmitter.emit("load",this),this.moveCursorToStart(this.options.autofocus)}return e.prototype.addInitEvent=function(){var e=this;this.on("needChangeMode",this.changeMode.bind(this)),this.on("loadUI",(function(){if("auto"!==e.height){var t=Math.min(parseInt(e.minHeight,10),parseInt(e.height,10)-75)+"px";e.setMinHeight(t)}})),function(e){e.listen("addImageBlobHook",(function(e,t){var n=new FileReader;n.onload=function(e){var n=e.target;return t(n.result)},n.readAsDataURL(e)}))}(this.eventEmitter)},e.prototype.addInitCommand=function(e,t){var n=this,r=function(e,t){Object.keys(t).forEach((function(r){n.addCommand(e,r,t[r])}))};this.addCommand("markdown","toggleScrollSync",(function(e){return n.eventEmitter.emit("toggleScrollSync",e.active),!0})),r("markdown",e),r("wysiwyg",t)},e.prototype.getCurrentModeEditor=function(){return this.isMarkdownMode()?this.mdEditor:this.wwEditor},e.factory=function(t){return t.viewer?new ug(t):new e(t)},e.setLanguage=function(e,t){hf.setLanguage(e,t)},e.prototype.changePreviewStyle=function(e){this.mdPreviewStyle!==e&&(this.mdPreviewStyle=e,this.eventEmitter.emit("changePreviewStyle",e))},e.prototype.exec=function(e,t){this.commandManager.exec(e,t)},e.prototype.addCommand=function(e,t,n){var r=this;this.commandManager.addCommand(e,t,(function(t){void 0===t&&(t={});var o=("markdown"===e?r.mdEditor:r.wwEditor).view;n(t,o.state,o.dispatch,o)}))},e.prototype.on=function(e,t){this.eventEmitter.listen(e,t)},e.prototype.off=function(e){this.eventEmitter.removeEventHandler(e)},e.prototype.addHook=function(e,t){this.eventEmitter.removeEventHandler(e),this.eventEmitter.listen(e,t)},e.prototype.removeHook=function(e){this.eventEmitter.removeEventHandler(e)},e.prototype.focus=function(){this.getCurrentModeEditor().focus()},e.prototype.blur=function(){this.getCurrentModeEditor().blur()},e.prototype.moveCursorToEnd=function(e){void 0===e&&(e=!0),this.getCurrentModeEditor().moveCursorToEnd(e)},e.prototype.moveCursorToStart=function(e){void 0===e&&(e=!0),this.getCurrentModeEditor().moveCursorToStart(e)},e.prototype.setMarkdown=function(e,t){if(void 0===e&&(e=""),void 0===t&&(t=!0),this.mdEditor.setMarkdown(e,t),this.isWysiwygMode()){var n=this.toastMark.getRootNode(),r=this.convertor.toWysiwygModel(n);this.wwEditor.setModel(r,t)}},e.prototype.setHTML=function(e,t){void 0===e&&(e=""),void 0===t&&(t=!0);var n=document.createElement("div");n.innerHTML=function(e){var t=e.replace(/<p><br\s*\/*><\/p>/gi,"<p></p>"),n=new RegExp(ma,"ig"),r=t.match(n);return null==r||r.forEach((function(e,n){if(va.test(e)){var o=ba;if(n){var i=r[n-1].match(fa);if(i&&!/br/i.test(i[1])){var s=i[1];o="</"+s+"><"+s+">"}}t=t.replace(va,o)}})),t}(e);var r=te.fromSchema(this.wwEditor.schema).parse(n);this.isMarkdownMode()?this.mdEditor.setMarkdown(this.convertor.toMarkdownText(r),t):this.wwEditor.setModel(r,t)},e.prototype.getMarkdown=function(){return this.isMarkdownMode()?this.mdEditor.getMarkdown():this.convertor.toMarkdownText(this.wwEditor.getModel())},e.prototype.getHTML=function(){var e=this;this.eventEmitter.holdEventInvoke((function(){if(e.isMarkdownMode()){var t=e.toastMark.getRootNode(),n=e.convertor.toWysiwygModel(t);e.wwEditor.setModel(n)}}));var t=La(this.wwEditor.view.dom.innerHTML);if(this.placeholder){var n=new RegExp('<span class="placeholder[^>]+>'+this.placeholder+"</span>","i");return t.replace(n,"")}return t},e.prototype.insertText=function(e){this.getCurrentModeEditor().replaceSelection(e)},e.prototype.setSelection=function(e,t){this.getCurrentModeEditor().setSelection(e,t)},e.prototype.replaceSelection=function(e,t,n){this.getCurrentModeEditor().replaceSelection(e,t,n)},e.prototype.deleteSelection=function(e,t){this.getCurrentModeEditor().deleteSelection(e,t)},e.prototype.getSelectedText=function(e,t){return this.getCurrentModeEditor().getSelectedText(e,t)},e.prototype.getRangeInfoOfNode=function(e){return this.getCurrentModeEditor().getRangeInfoOfNode(e)},e.prototype.addWidget=function(e,t,n){this.getCurrentModeEditor().addWidget(e,t,n)},e.prototype.replaceWithWidget=function(e,t,n){this.getCurrentModeEditor().replaceWithWidget(e,t,n)},e.prototype.setHeight=function(e){var t=this.options.el;Me()(e)&&("auto"===e?ke()(t,"auto-height"):Ce()(t,"auto-height"),this.setMinHeight(this.getMinHeight())),be()(t,{height:e}),this.height=e},e.prototype.getHeight=function(){return this.height},e.prototype.setMinHeight=function(e){if(e!==this.minHeight){var t=this.height||this.options.height;"auto"!==t&&this.options.el.querySelector("."+xa("main"))&&(e=Math.min(parseInt(e,10),parseInt(t,10)-75)+"px");var n=parseInt(e,10);this.minHeight=e,this.wwEditor.setMinHeight(n),this.mdEditor.setMinHeight(n),this.preview.setMinHeight(n)}},e.prototype.getMinHeight=function(){return this.minHeight},e.prototype.isMarkdownMode=function(){return"markdown"===this.mode},e.prototype.isWysiwygMode=function(){return"wysiwyg"===this.mode},e.prototype.isViewer=function(){return!1},e.prototype.getCurrentPreviewStyle=function(){return this.mdPreviewStyle},e.prototype.changeMode=function(e,t){if(this.mode!==e){if(this.mode=e,this.isWysiwygMode()){var n=this.toastMark.getRootNode(),r=this.convertor.toWysiwygModel(n);this.wwEditor.setModel(r)}else{r=this.wwEditor.getModel();this.mdEditor.setMarkdown(this.convertor.toMarkdownText(r),!t)}if(this.eventEmitter.emit("removePopupWidget"),this.eventEmitter.emit("changeMode",e),!t){var o=this.convertor.getMappedPos();this.focus(),this.isWysiwygMode()&&Ee()(o)?this.wwEditor.setSelection(o):Array.isArray(o)&&this.mdEditor.setSelection(o)}}},e.prototype.destroy=function(){var e=this;this.wwEditor.destroy(),this.mdEditor.destroy(),this.preview.destroy(),this.scrollSync.destroy(),this.eventEmitter.emit("destroy"),this.eventEmitter.getEvents().forEach((function(t,n){return e.off(n)}))},e.prototype.hide=function(){this.eventEmitter.emit("hide")},e.prototype.show=function(){this.eventEmitter.emit("show")},e.prototype.setScrollTop=function(e){this.getCurrentModeEditor().setScrollTop(e)},e.prototype.getScrollTop=function(){return this.getCurrentModeEditor().getScrollTop()},e.prototype.reset=function(){this.wwEditor.setModel([]),this.mdEditor.setMarkdown("")},e.prototype.getSelection=function(){return this.getCurrentModeEditor().getSelection()},e.prototype.setPlaceholder=function(e){this.placeholder=e,this.mdEditor.setPlaceholder(e),this.wwEditor.setPlaceholder(e)},e.prototype.getEditorElements=function(){return{mdEditor:this.mdEditor.getElement(),mdPreview:this.preview.getElement(),wwEditor:this.wwEditor.getElement()}},e.prototype.convertPosToMatchEditorMode=function(e,t,n){var r,o;void 0===t&&(t=e),void 0===n&&(n=this.mode);var i=this.mdEditor.view.state.doc,s=Array.isArray(e),a=Array.isArray(t),l=e,c=t;if(s!==a)throw new Error("Types of arguments must be same");return"markdown"!==n||s||a?"wysiwyg"===n&&s&&a&&(l=(o=ol(i,e,t))[0],c=o[1]):(l=(r=nl(i,e,t))[0],c=r[1]),[l,c]},e}(),kg=wg;var xg=n(326),Cg=n.n(xg),Tg=function(){function e(e){this.current=e,this.root=e,this.entering=!0}return e.prototype.walk=function(){var e=this.entering,t=this.current;return t?(e?t.firstChild?(this.current=t.firstChild,this.entering=!0):this.entering=!1:t===this.root?this.current=null:t.next?(this.current=t.next,this.entering=!0):(this.current=t.parent,this.entering=!1),{vnode:t,entering:e}):null},e}(),Mg=function(){function e(e,t,n){this.parent=null,this.old=null,this.firstChild=null,this.next=null,this.skip=!1,this.type=e,this.props=t,this.children=n,this.props.children=n,t.ref&&(this.ref=t.ref,delete t.ref),t.key&&(this.key=t.key,delete t.key)}return e.prototype.walker=function(){return new Tg(this)},e.removalNodes=[],e}();function Sg(e,t){var n,r=e;Cg()(e)||null==e?r=null:(Me()(e)||Ee()(e))&&(n=String(e),r=new Mg("TEXT_NODE",{nodeValue:n},[])),r&&t.push(r)}var Eg=function(e){for(var t,n,r=arguments,o=1,i="",s="",a=[0],l=function(e){1===o&&(e||(i=i.replace(/^\s*\n\s*|\s*\n\s*$/g,"")))?a.push(e?r[e]:i):3===o&&(e||i)?(a[1]=e?r[e]:i,o=2):2===o&&"..."===i&&e?a[2]=it(a[2]||{},r[e]):2===o&&i&&!e?(a[2]=a[2]||{})[i]=!0:o>=5&&(5===o?((a[2]=a[2]||{})[n]=e?i?i+r[e]:r[e]:i,o=6):(e||i)&&(a[2][n]+=e?i+r[e]:i)),i=""},c=0;c<e.length;c++){c&&(1===o&&l(),l(c));for(var u=0;u<e[c].length;u++)t=e[c][u],1===o?"<"===t?(l(),a=[a,"",null],o=3):i+=t:4===o?"--"===i&&">"===t?(o=1,i=""):i=t+i[0]:s?t===s?s="":i+=t:'"'===t||"'"===t?s=t:">"===t?(l(),o=1):o&&("="===t?(o=5,n=i,i=""):"/"===t&&(o<5||">"===e[c][u+1])?(l(),3===o&&(a=a[0]),o=a,(a=a[0]).push(this.apply(null,o.slice(1))),o=0):" "===t||"\t"===t||"\n"===t||"\r"===t?(l(),o=2):i+=t),3===o&&"!--"===i&&(o=4,a=a[0])}return l(),a.length>2?a.slice(1):a[1]}.bind((function(e,t){for(var n=[],r=2;r<arguments.length;r++)n[r-2]=arguments[r];var o=[];return n.forEach((function(e){Array.isArray(e)?e.forEach((function(e){Sg(e,o)})):Sg(e,o)})),new Mg(e,t||{},o)})),Ng=n(73),Og=n.n(Ng);function Dg(e){var t;return"TEXT_NODE"===e.type?t=document.createTextNode(e.props.nodeValue):Rg(t=document.createElement(e.type),{},e.props),t}function Ag(e,t){e.node?t.removeChild(e.node):Ag(e.firstChild,t)}function Lg(e,t,n){Object.keys(t).forEach((function(r){if(/^on/.test(r)){if(!n[r]||t[r]!==n[r]){var o=r.slice(2).toLowerCase();e.removeEventListener(o,t[r])}}else"children"===r||n[r]||function(e){return(null==e?void 0:e.nodeType)===Node.TEXT_NODE}(e)||e.removeAttribute(r)})),Rg(e,t,n,(function(e){return!Ye(t[e],n[e])}))}var Ig=/acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;function Rg(e,t,n,r){Object.keys(n).forEach((function(o){if(!r||r(o))if(/^on/.test(o)){var i=o.slice(2).toLowerCase();e.addEventListener(i,n[o])}else"nodeValue"===o?e[o]=n[o]:"style"===o&&Og()(n[o])?function(e,t,n){t&&Object.keys(t).forEach((function(t){e.style[t]=""}));Object.keys(n).forEach((function(t){var r=n[t];e.style[t]=Ee()(r)&&!Ig.test(t)?r+"px":r}))}(e,t[o],n[o]):"children"!==o&&(!1===n[o]?e.removeAttribute(o):e.setAttribute(o,n[o]))}))}function Pg(e){if(Mg.removalNodes.forEach((function(e){return Fg(e)})),e)for(var t=void 0,n=e.walker();t=n.walk();)if(e=t.vnode,t.entering)Fg(e);else if(Ga()(e.type)){var r=e.component;if(!e.old&&r.mounted&&r.mounted(),e.old&&r.updated){var o=r.prevProps||{};r.updated(o)}}}function Bg(e){for(var t=e.parent;!t.node;)t=t.parent;return t.node}function Fg(e){if(e&&e.parent){if(e.node){var t=Bg(e);"A"===e.effect?t.appendChild(e.node):"U"===e.effect&&Lg(e.node,e.old.props,e.props)}if("D"===e.effect)for(var n=void 0,r=e.walker();n=r.walk();)if(e=n.vnode,!n.entering)if(Ga()(e.type)){var o=e.component;o.beforeDestroy&&o.beforeDestroy()}else{Ag(e,t=Bg(e))}e.ref&&(e.component?e.ref(e.component):e.node&&e.ref(e.node))}}function Hg(e,t){var n=t.props,r=t.component;return r?(r.prevProps=r.props,r.props=t.props,r):new e(n)}function zg(e){for(var t=e;e&&!e.skip;){if(Ga()(e.type)){var n=Hg(e.type,e);n.vnode=e,e.component=n,e.props.children=e.children=[n.render()],qg(e)}else e.node||(e.node=Dg(e)),qg(e);if(e.firstChild)e=e.firstChild;else{for(;e&&e.parent&&!e.next&&(e=e.parent)!==t;);e=e.next}}}function qg(e){var t=e.children,n=e.old?e.old.firstChild:null,r=null;t.forEach((function(t,o){var i=function(e,t){return e&&t&&t.type===e.type&&(!t.key||t.key===e.key)}(n,t);i&&(t.old=n,t.parent=e,t.node=n.node,t.component=n.component,t.effect="U"),t&&!i&&(t.old=null,t.parent=e,t.node=null,t.effect="A"),n&&!i&&(Mg.removalNodes.push(n),n.effect="D"),n&&(n=n.next),0===o?e.firstChild=t:t&&(r.next=t),r=t}));var o=et(t);if(!t.length)for(;n;)Mg.removalNodes.push(n),n.effect="D",n=n.next;for(;n&&o;)n&&o.old!==n&&(Mg.removalNodes.push(n),n.effect="D",n=n.next)}function Vg(e,t){var n=new Mg(e.tagName.toLowerCase(),{},[t]);return n.node=e,Mg.removalNodes=[],zg(n),Pg(n),function(){return function(e){e.effect="D",Mg.removalNodes=[e],Pg(),Mg.removalNodes=[]}(n.firstChild)}}var jg,$g=function(){function e(e){this.props=e,this.state={},this.refs={}}return e.prototype.setState=function(e){var t=o(o({},this.state),e);Ye(this.state,t)||(this.state=t,function(e){var t=e.vnode;t.effect="U",t.old=t,t.next&&(t.next.skip=!0),Mg.removalNodes=[],zg(t),Pg(t),t.next&&(t.next.skip=!1)}(this))},e}(),_g=function(e){function n(t){var n=e.call(this,t)||this;return n.state={hide:!1},n}return t(n,e),n.prototype.show=function(){this.setState({hide:!1})},n.prototype.hide=function(){this.setState({hide:!0})},n.prototype.render=function(){var e=this.props,t=e.editorType,n=e.eventEmitter;return Eg(jg||(jg=s(['\n      <div class="','" style="display: ','">\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ",'\n        </div>\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ","\n        </div>\n      </div>\n    "],['\n      <div class="','" style="display: ','">\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ",'\n        </div>\n        <div\n          class="tab-item','"\n          onClick=',"\n        >\n          ","\n        </div>\n      </div>\n    "])),xa("mode-switch"),this.state.hide?"none":"block","markdown"===t?" active":"",(function(){n.emit("needChangeMode","markdown")}),hf.get("Markdown"),"wysiwyg"===t?" active":"",(function(){n.emit("needChangeMode","wysiwyg")}),hf.get("WYSIWYG"))},n}($g),Ug=n(423),Wg=n.n(Ug),Jg=function(){if("undefined"!=typeof Map)return Map;function e(e,t){var n=-1;return e.some((function(e,r){return e[0]===t&&(n=r,!0)})),n}return function(){function t(){this.__entries__=[]}return Object.defineProperty(t.prototype,"size",{get:function(){return this.__entries__.length},enumerable:!0,configurable:!0}),t.prototype.get=function(t){var n=e(this.__entries__,t),r=this.__entries__[n];return r&&r[1]},t.prototype.set=function(t,n){var r=e(this.__entries__,t);~r?this.__entries__[r][1]=n:this.__entries__.push([t,n])},t.prototype.delete=function(t){var n=this.__entries__,r=e(n,t);~r&&n.splice(r,1)},t.prototype.has=function(t){return!!~e(this.__entries__,t)},t.prototype.clear=function(){this.__entries__.splice(0)},t.prototype.forEach=function(e,t){void 0===t&&(t=null);for(var n=0,r=this.__entries__;n<r.length;n++){var o=r[n];e.call(t,o[1],o[0])}},t}()}(),Gg="undefined"!=typeof window&&"undefined"!=typeof document&&window.document===document,Kg=void 0!==n.g&&n.g.Math===Math?n.g:"undefined"!=typeof self&&self.Math===Math?self:"undefined"!=typeof window&&window.Math===Math?window:Function("return this")(),Zg="function"==typeof requestAnimationFrame?requestAnimationFrame.bind(Kg):function(e){return setTimeout((function(){return e(Date.now())}),1e3/60)};var Xg=["top","right","bottom","left","width","height","size","weight"],Qg="undefined"!=typeof MutationObserver,Yg=function(){function e(){this.connected_=!1,this.mutationEventsAdded_=!1,this.mutationsObserver_=null,this.observers_=[],this.onTransitionEnd_=this.onTransitionEnd_.bind(this),this.refresh=function(e,t){var n=!1,r=!1,o=0;function i(){n&&(n=!1,e()),r&&a()}function s(){Zg(i)}function a(){var e=Date.now();if(n){if(e-o<2)return;r=!0}else n=!0,r=!1,setTimeout(s,t);o=e}return a}(this.refresh.bind(this),20)}return e.prototype.addObserver=function(e){~this.observers_.indexOf(e)||this.observers_.push(e),this.connected_||this.connect_()},e.prototype.removeObserver=function(e){var t=this.observers_,n=t.indexOf(e);~n&&t.splice(n,1),!t.length&&this.connected_&&this.disconnect_()},e.prototype.refresh=function(){this.updateObservers_()&&this.refresh()},e.prototype.updateObservers_=function(){var e=this.observers_.filter((function(e){return e.gatherActive(),e.hasActive()}));return e.forEach((function(e){return e.broadcastActive()})),e.length>0},e.prototype.connect_=function(){Gg&&!this.connected_&&(document.addEventListener("transitionend",this.onTransitionEnd_),window.addEventListener("resize",this.refresh),Qg?(this.mutationsObserver_=new MutationObserver(this.refresh),this.mutationsObserver_.observe(document,{attributes:!0,childList:!0,characterData:!0,subtree:!0})):(document.addEventListener("DOMSubtreeModified",this.refresh),this.mutationEventsAdded_=!0),this.connected_=!0)},e.prototype.disconnect_=function(){Gg&&this.connected_&&(document.removeEventListener("transitionend",this.onTransitionEnd_),window.removeEventListener("resize",this.refresh),this.mutationsObserver_&&this.mutationsObserver_.disconnect(),this.mutationEventsAdded_&&document.removeEventListener("DOMSubtreeModified",this.refresh),this.mutationsObserver_=null,this.mutationEventsAdded_=!1,this.connected_=!1)},e.prototype.onTransitionEnd_=function(e){var t=e.propertyName,n=void 0===t?"":t;Xg.some((function(e){return!!~n.indexOf(e)}))&&this.refresh()},e.getInstance=function(){return this.instance_||(this.instance_=new e),this.instance_},e.instance_=null,e}(),ev=function(e,t){for(var n=0,r=Object.keys(t);n<r.length;n++){var o=r[n];Object.defineProperty(e,o,{value:t[o],enumerable:!1,writable:!1,configurable:!0})}return e},tv=function(e){return e&&e.ownerDocument&&e.ownerDocument.defaultView||Kg},nv=lv(0,0,0,0);function rv(e){return parseFloat(e)||0}function ov(e){for(var t=[],n=1;n<arguments.length;n++)t[n-1]=arguments[n];return t.reduce((function(t,n){return t+rv(e["border-"+n+"-width"])}),0)}function iv(e){var t=e.clientWidth,n=e.clientHeight;if(!t&&!n)return nv;var r=tv(e).getComputedStyle(e),o=function(e){for(var t={},n=0,r=["top","right","bottom","left"];n<r.length;n++){var o=r[n],i=e["padding-"+o];t[o]=rv(i)}return t}(r),i=o.left+o.right,s=o.top+o.bottom,a=rv(r.width),l=rv(r.height);if("border-box"===r.boxSizing&&(Math.round(a+i)!==t&&(a-=ov(r,"left","right")+i),Math.round(l+s)!==n&&(l-=ov(r,"top","bottom")+s)),!function(e){return e===tv(e).document.documentElement}(e)){var c=Math.round(a+i)-t,u=Math.round(l+s)-n;1!==Math.abs(c)&&(a-=c),1!==Math.abs(u)&&(l-=u)}return lv(o.left,o.top,a,l)}var sv="undefined"!=typeof SVGGraphicsElement?function(e){return e instanceof tv(e).SVGGraphicsElement}:function(e){return e instanceof tv(e).SVGElement&&"function"==typeof e.getBBox};function av(e){return Gg?sv(e)?function(e){var t=e.getBBox();return lv(0,0,t.width,t.height)}(e):iv(e):nv}function lv(e,t,n,r){return{x:e,y:t,width:n,height:r}}var cv=function(){function e(e){this.broadcastWidth=0,this.broadcastHeight=0,this.contentRect_=lv(0,0,0,0),this.target=e}return e.prototype.isActive=function(){var e=av(this.target);return this.contentRect_=e,e.width!==this.broadcastWidth||e.height!==this.broadcastHeight},e.prototype.broadcastRect=function(){var e=this.contentRect_;return this.broadcastWidth=e.width,this.broadcastHeight=e.height,e},e}(),uv=function(e,t){var n=function(e){var t=e.x,n=e.y,r=e.width,o=e.height,i="undefined"!=typeof DOMRectReadOnly?DOMRectReadOnly:Object,s=Object.create(i.prototype);return ev(s,{x:t,y:n,width:r,height:o,top:n,right:t+r,bottom:o+n,left:t}),s}(t);ev(this,{target:e,contentRect:n})},dv=function(){function e(e,t,n){if(this.activeObservations_=[],this.observations_=new Jg,"function"!=typeof e)throw new TypeError("The callback provided as parameter 1 is not a function.");this.callback_=e,this.controller_=t,this.callbackCtx_=n}return e.prototype.observe=function(e){if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");if("undefined"!=typeof Element&&Element instanceof Object){if(!(e instanceof tv(e).Element))throw new TypeError('parameter 1 is not of type "Element".');var t=this.observations_;t.has(e)||(t.set(e,new cv(e)),this.controller_.addObserver(this),this.controller_.refresh())}},e.prototype.unobserve=function(e){if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");if("undefined"!=typeof Element&&Element instanceof Object){if(!(e instanceof tv(e).Element))throw new TypeError('parameter 1 is not of type "Element".');var t=this.observations_;t.has(e)&&(t.delete(e),t.size||this.controller_.removeObserver(this))}},e.prototype.disconnect=function(){this.clearActive(),this.observations_.clear(),this.controller_.removeObserver(this)},e.prototype.gatherActive=function(){var e=this;this.clearActive(),this.observations_.forEach((function(t){t.isActive()&&e.activeObservations_.push(t)}))},e.prototype.broadcastActive=function(){if(this.hasActive()){var e=this.callbackCtx_,t=this.activeObservations_.map((function(e){return new uv(e.target,e.broadcastRect())}));this.callback_.call(e,t,e),this.clearActive()}},e.prototype.clearActive=function(){this.activeObservations_.splice(0)},e.prototype.hasActive=function(){return this.activeObservations_.length>0},e}(),pv="undefined"!=typeof WeakMap?new WeakMap:new Jg,hv=function e(t){if(!(this instanceof e))throw new TypeError("Cannot call a class as a function.");if(!arguments.length)throw new TypeError("1 argument required, but only 0 present.");var n=Yg.getInstance(),r=new dv(t,n,this);pv.set(this,r)};["observe","unobserve","disconnect"].forEach((function(e){hv.prototype[e]=function(){var t;return(t=pv.get(this))[e].apply(t,arguments)}}));var fv,mv,gv,vv,yv,bv,wv,kv,xv,Cv,Tv,Mv,Sv,Ev,Nv,Ov,Dv=void 0!==Kg.ResizeObserver?Kg.ResizeObserver:hv,Av=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.execCommand=function(e){var t=Oa(e.target,"li");this.props.execCommand("heading",{level:Number(t.getAttribute("data-level"))})},n.prototype.render=function(){var e=this;return Eg(mv||(mv=s(["\n      <ul\n        onClick=",'\n        aria-role="menu"\n        aria-label="','"\n      >\n        ','\n        <li data-type="Paragraph" aria-role="menuitem">\n          <div>',"</div>\n        </li>\n      </ul>\n    "],["\n      <ul\n        onClick=",'\n        aria-role="menu"\n        aria-label="','"\n      >\n        ','\n        <li data-type="Paragraph" aria-role="menuitem">\n          <div>',"</div>\n        </li>\n      </ul>\n    "])),(function(t){return e.execCommand(t)}),hf.get("Headings"),[1,2,3,4,5,6].map((function(e){return Eg(fv||(fv=s(['\n              <li data-level="','" data-type="Heading" aria-role="menuitem">\n                <',">"," ","</$>\n              </li>\n            "],['\n              <li data-level="','" data-type="Heading" aria-role="menuitem">\n                <',">"," ","</$>\n              </li>\n            "])),e,"h"+e,hf.get("Heading"),e)})),hf.get("Paragraph"))},n}($g),Lv=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.toggleTab=function(e,t){this.props.onClick(e,t)},n.prototype.render=function(){var e=this;return Eg(vv||(vv=s(['\n      <div class="','" aria-role="tabpanel">\n        ',"\n      </div>\n    "],['\n      <div class="','" aria-role="tabpanel">\n        ',"\n      </div>\n    "])),xa("tabs"),this.props.tabs.map((function(t){var n=t.name,r=t.text,o=e.props.activeTab===n;return Eg(gv||(gv=s(['\n            <div\n              class="tab-item','"\n              onClick=','\n              aria-role="tab"\n              aria-label="','"\n              aria-selected="','"\n              tabindex="','"\n            >\n              ',"\n            </div>\n          "],['\n            <div\n              class="tab-item','"\n              onClick=','\n              aria-role="tab"\n              aria-label="','"\n              aria-selected="','"\n              tabindex="','"\n            >\n              ',"\n            </div>\n          "])),o?" active":"",(function(t){return e.toggleTab(t,n)}),hf.get(r),o?"true":"false",o?"0":"-1",hf.get(r))})))},n}($g),Iv=function(e){function n(t){var n=e.call(this,t)||this;return n.initialize=function(e){void 0===e&&(e="file");var t=n.refs.url;t.value="",n.refs.altText.value="",n.refs.file.value="",Ce()(t,"wrong"),n.setState({activeTab:e,file:null,fileNameElClassName:""})},n.execCommand=function(){"file"===n.state.activeTab?n.emitAddImageBlob():n.emitAddImage()},n.toggleTab=function(e,t){t!==n.state.activeTab&&n.initialize(t)},n.showFileSelectBox=function(){n.refs.file.click()},n.changeFile=function(e){var t=e.target.files;(null==t?void 0:t.length)&&n.setState({file:t[0]})},n.state={activeTab:"file",file:null,fileNameElClassName:""},n.tabs=[{name:"file",text:"File"},{name:"url",text:"URL"}],n}return t(n,e),n.prototype.emitAddImageBlob=function(){var e=this,t=this.refs.file.files,n=this.refs.altText,r=" wrong";if(null==t?void 0:t.length){r="";var o=t.item(0);this.props.eventEmitter.emit("addImageBlobHook",o,(function(t,r){return e.props.execCommand("addImage",{imageUrl:t,altText:r||n.value})}),"ui")}this.setState({fileNameElClassName:r})},n.prototype.emitAddImage=function(){var e=this.refs.url,t=this.refs.altText,n=e.value,r=t.value||"image";Ce()(e,"wrong"),n.length?n&&this.props.execCommand("addImage",{imageUrl:n,altText:r}):ke()(e,"wrong")},n.prototype.preventSelectStart=function(e){e.preventDefault()},n.prototype.updated=function(){this.props.show||this.initialize()},n.prototype.render=function(){var e=this,t=this.state,n=t.activeTab,r=t.file,o=t.fileNameElClassName;return Eg(yv||(yv=s(['\n      <div aria-label="','">\n        <'," tabs="," activeTab="," onClick=",' />\n        <div style="display:','">\n          <label for="toastuiImageUrlInput">','</label>\n          <input\n            id="toastuiImageUrlInput"\n            type="text"\n            ref=','\n          />\n        </div>\n        <div style="display:',';position: relative;">\n          <label for="toastuiImageFileInput">','</label>\n          <span\n            class="',"",'"\n            onClick=',"\n            onSelectstart=","\n          >\n            ",'\n          </span>\n          <button\n            type="button"\n            class="','"\n            onClick=',"\n          >\n            ",'\n          </button>\n          <input\n            id="toastuiImageFileInput"\n            type="file"\n            accept="image/*"\n            onChange=',"\n            ref=",'\n          />\n        </div>\n        <label for="toastuiAltTextInput">','</label>\n        <input\n          id="toastuiAltTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "],['\n      <div aria-label="','">\n        <'," tabs="," activeTab="," onClick=",' />\n        <div style="display:','">\n          <label for="toastuiImageUrlInput">','</label>\n          <input\n            id="toastuiImageUrlInput"\n            type="text"\n            ref=','\n          />\n        </div>\n        <div style="display:',';position: relative;">\n          <label for="toastuiImageFileInput">','</label>\n          <span\n            class="',"",'"\n            onClick=',"\n            onSelectstart=","\n          >\n            ",'\n          </span>\n          <button\n            type="button"\n            class="','"\n            onClick=',"\n          >\n            ",'\n          </button>\n          <input\n            id="toastuiImageFileInput"\n            type="file"\n            accept="image/*"\n            onChange=',"\n            ref=",'\n          />\n        </div>\n        <label for="toastuiAltTextInput">','</label>\n        <input\n          id="toastuiAltTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "])),hf.get("Insert image"),Lv,this.tabs,n,this.toggleTab,"url"===n?"block":"none",hf.get("Image URL"),(function(t){return e.refs.url=t}),"file"===n?"block":"none",hf.get("Select image file"),xa("file-name"),r?" has-file":o,this.showFileSelectBox,this.preventSelectStart,r?r.name:hf.get("No file"),xa("file-select-button"),this.showFileSelectBox,hf.get("Choose a file"),this.changeFile,(function(t){return e.refs.file=t}),hf.get("Description"),(function(t){return e.refs.altText=t}),xa("button-container"),xa("close-button"),this.props.hidePopup,hf.get("Cancel"),xa("ok-button"),this.execCommand,hf.get("OK"))},n}($g),Rv=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.execCommand=function(){var e=t.refs.url,n=t.refs.text;(Ce()(e,"wrong"),Ce()(n,"wrong"),e.value.length<1)?ke()(e,"wrong"):Oe()(t.props.initialValues.linkUrl)&&n.value.length<1?ke()(n,"wrong"):t.props.execCommand("addLink",{linkUrl:e.value,linkText:n.value})},t}return t(n,e),n.prototype.initialize=function(){var e=this.props.initialValues,t=e.linkUrl,n=e.linkText,r=this.refs.url,o=this.refs.text;Ce()(r,"wrong"),Ce()(o,"wrong","disabled"),o.removeAttribute("disabled"),t&&(ke()(o,"disabled"),o.setAttribute("disabled","disabled")),r.value=t||"",o.value=n||""},n.prototype.mounted=function(){this.initialize()},n.prototype.updated=function(e){!e.show&&this.props.show&&this.initialize()},n.prototype.render=function(){var e=this;return Eg(bv||(bv=s(['\n      <div aria-label="','">\n        <label for="toastuiLinkUrlInput">','</label>\n        <input\n          id="toastuiLinkUrlInput"\n          type="text"\n          ref=','\n        />\n        <label for="toastuiLinkTextInput">','</label>\n        <input\n          id="toastuiLinkTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "],['\n      <div aria-label="','">\n        <label for="toastuiLinkUrlInput">','</label>\n        <input\n          id="toastuiLinkUrlInput"\n          type="text"\n          ref=','\n        />\n        <label for="toastuiLinkTextInput">','</label>\n        <input\n          id="toastuiLinkTextInput"\n          type="text"\n          ref=','\n        />\n        <div class="','">\n          <button type="button" class="','" onClick=',">\n            ",'\n          </button>\n          <button type="button" class="','" onClick=',">\n            ","\n          </button>\n        </div>\n      </div>\n    "])),hf.get("Insert link"),hf.get("URL"),(function(t){return e.refs.url=t}),hf.get("Link text"),(function(t){return e.refs.text=t}),xa("button-container"),xa("close-button"),this.props.hidePopup,hf.get("Cancel"),xa("ok-button"),this.execCommand,hf.get("OK"))},n}($g),Pv=function(e){function n(t){var n=e.call(this,t)||this;return n.extendSelectionRange=function(e){var t=e.pageX,r=e.pageY,i=t-n.offsetRect.left,s=r-n.offsetRect.top,a=n.getSelectionRangeByOffset(i,s);n.setState(o({},a))},n.execCommand=function(){n.props.execCommand("addTable",{rowCount:n.state.rowIdx+1,columnCount:n.state.colIdx+1})},n.state={rowIdx:-1,colIdx:-1},n}return t(n,e),n.prototype.getDescription=function(){return-1===this.state.colIdx?"":this.state.colIdx+1+" x "+(this.state.rowIdx+1)},n.prototype.getBoundByRange=function(e,t){return{width:20*(e+1),height:20*(t+1)}},n.prototype.getRangeByOffset=function(e,t){return{colIdx:Math.floor(e/20),rowIdx:Math.floor(t/20)}},n.prototype.getTableRange=function(){var e=this.state,t=e.colIdx,n=e.rowIdx,r=Math.max(t,5),o=Math.max(n,5);return t>=5&&r<9&&(r+=1),n>=5&&o<14&&(o+=1),{colIdx:r+1,rowIdx:o+1}},n.prototype.getSelectionAreaBound=function(){var e=this.getBoundByRange(this.state.colIdx,this.state.rowIdx),t=e.width,n=e.height;return t||n?{width:t-1,height:n-1,display:"block"}:{display:"none"}},n.prototype.getSelectionRangeByOffset=function(e,t){var n=this.getRangeByOffset(e,t);return n.rowIdx=Math.min(Math.max(n.rowIdx,1),14),n.colIdx=Math.min(Math.max(n.colIdx,1),9),n},n.prototype.updated=function(){if(this.props.show){if(-1===this.state.colIdx&&-1===this.state.rowIdx){var e=this.refs.tableEl.getBoundingClientRect(),t=e.left,n=e.top;this.offsetRect={left:window.pageXOffset+t,top:window.pageYOffset+n}}}else this.setState({colIdx:-1,rowIdx:-1})},n.prototype.createTableArea=function(e){for(var t=e.colIdx,n=e.rowIdx,r=[],o=0;o<n;o+=1){for(var i=[],a=0;a<t;a+=1){var l=xa("table-cell")+(o>0?"":" header");i.push(Eg(wv||(wv=s(['<div class="','"></div>'],['<div class="','"></div>'])),l))}r.push(Eg(kv||(kv=s(['<div class="','">',"</div>"],['<div class="','">',"</div>"])),xa("table-row"),i))}return Eg(xv||(xv=s(['<div class="','">',"</div>"],['<div class="','">',"</div>"])),xa("table"),r)},n.prototype.render=function(){var e=this,t=this.getTableRange(),n=this.getSelectionAreaBound();return Eg(Cv||(Cv=s(['\n      <div aria-label="','">\n        <div\n          class="','"\n          ref=',"\n          onMousemove=","\n          onClick=","\n        >\n          ",'\n          <div class="','" style=','></div>\n        </div>\n        <p class="','">',"</p>\n      </div>\n    "],['\n      <div aria-label="','">\n        <div\n          class="','"\n          ref=',"\n          onMousemove=","\n          onClick=","\n        >\n          ",'\n          <div class="','" style=','></div>\n        </div>\n        <p class="','">',"</p>\n      </div>\n    "])),hf.get("Insert table"),xa("table-selection"),(function(t){return e.refs.tableEl=t}),this.extendSelectionRange,this.execCommand,this.createTableArea(t),xa("table-selection-layer"),n,xa("table-description"),this.getDescription())},n}($g),Bv=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.mounted=function(){this.refs.el.appendChild(this.props.body)},n.prototype.updated=function(e){this.refs.el.replaceChild(this.props.body,e.body)},n.prototype.render=function(){var e=this;return Eg(Tv||(Tv=s(["<div ref=","></div>"],["<div ref=","></div>"])),(function(t){return e.refs.el=t}))},n}($g);function Fv(e){return Me()(e)?function(e){var t;switch(e){case"heading":t={name:"heading",className:"heading",tooltip:hf.get("Headings"),state:"heading"};break;case"bold":t={name:"bold",className:"bold",command:"bold",tooltip:hf.get("Bold"),state:"strong"};break;case"italic":t={name:"italic",className:"italic",command:"italic",tooltip:hf.get("Italic"),state:"emph"};break;case"strike":t={name:"strike",className:"strike",command:"strike",tooltip:hf.get("Strike"),state:"strike"};break;case"hr":t={name:"hr",className:"hrline",command:"hr",tooltip:hf.get("Line"),state:"thematicBreak"};break;case"quote":t={name:"quote",className:"quote",command:"blockQuote",tooltip:hf.get("Blockquote"),state:"blockQuote"};break;case"ul":t={name:"ul",className:"bullet-list",command:"bulletList",tooltip:hf.get("Unordered list"),state:"bulletList"};break;case"ol":t={name:"ol",className:"ordered-list",command:"orderedList",tooltip:hf.get("Ordered list"),state:"orderedList"};break;case"task":t={name:"task",className:"task-list",command:"taskList",tooltip:hf.get("Task"),state:"taskList"};break;case"table":t={name:"table",className:"table",tooltip:hf.get("Insert table"),state:"table"};break;case"image":t={name:"image",className:"image",tooltip:hf.get("Insert image")};break;case"link":t={name:"link",className:"link",tooltip:hf.get("Insert link")};break;case"code":t={name:"code",className:"code",command:"code",tooltip:hf.get("Code"),state:"code"};break;case"codeblock":t={name:"codeblock",className:"codeblock",command:"codeBlock",tooltip:hf.get("Insert CodeBlock"),state:"codeBlock"};break;case"indent":t={name:"indent",className:"indent",command:"indent",tooltip:hf.get("Indent"),state:"indent"};break;case"outdent":t={name:"outdent",className:"outdent",command:"outdent",tooltip:hf.get("Outdent"),state:"outdent"};break;case"scrollSync":t=function(){var e=document.createElement("label"),t=document.createElement("input"),n=document.createElement("span");e.className="scroll-sync active",t.type="checkbox",t.checked=!0,n.className="switch";var r=function(n){return t.addEventListener("change",(function(t){var r=t.target.checked;r?ke()(e,"active"):Ce()(e,"active"),n("toggleScrollSync",{active:r})}))};return e.appendChild(t),e.appendChild(n),{name:"scrollSync",el:e,onMounted:r}}();break;case"more":t={name:"more",className:"more",tooltip:hf.get("More")}}"scrollSync"!==t.name&&(t.className+=" "+xa("toolbar-icons"));return t}(e):e}function Hv(e,t){var n=t.el,r=t.pos,i=t.popup,a=t.initialValues;switch(e){case"heading":return{render:function(e){return Eg(Mv||(Mv=s(["<"," ..."," />"],["<"," ..."," />"])),Av,e)},className:xa("popup-add-heading"),fromEl:n,pos:r};case"link":return{render:function(e){return Eg(Sv||(Sv=s(["<"," ..."," />"],["<"," ..."," />"])),Rv,e)},className:xa("popup-add-link"),fromEl:n,pos:r,initialValues:a};case"image":return{render:function(e){return Eg(Ev||(Ev=s(["<"," ..."," />"],["<"," ..."," />"])),Iv,e)},className:xa("popup-add-image"),fromEl:n,pos:r};case"table":return{render:function(e){return Eg(Nv||(Nv=s(["<"," ..."," />"],["<"," ..."," />"])),Pv,e)},className:xa("popup-add-table"),fromEl:n,pos:r};case"customPopupBody":return i?o({render:function(e){return Eg(Ov||(Ov=s(["<"," ..."," body="," />"],["<"," ..."," body="," />"])),Bv,e,i.body)},fromEl:n,pos:r},i):null;default:return null}}function zv(e){e.hidden=e.length===e.filter((function(e){return e.hidden})).length}function qv(e,t){return e.reduce((function(e,n){e.push(n.map((function(e){return function(e){return e.hidden="scrollSync"===e.name&&t,e}(Fv(e))})));var r=e[(e.length||1)-1];return r&&zv(r),e}),[])}var Vv,jv,$v=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.handleMousedown=function(e){Oa(e.target,"."+xa("popup"))||Oa(e.target,t.props.info.fromEl)||t.props.hidePopup()},t}return t(n,e),n.prototype.mounted=function(){document.addEventListener("mousedown",this.handleMousedown),this.props.eventEmitter.listen("closePopup",this.props.hidePopup)},n.prototype.beforeDestroy=function(){document.removeEventListener("mousedown",this.handleMousedown)},n.prototype.updated=function(e){var t=this.props,n=t.show,r=t.info;if(n&&r.pos&&e.show!==n){var i=o({},r.pos),s=this.refs.el.offsetWidth,a=Oa(this.refs.el,"."+xa("toolbar")).offsetWidth;i.left+s>=a&&(i.left=a-s-20),Ye(this.state.popupPos,i)||this.setState({popupPos:i})}},n.prototype.render=function(){var e=this,t=this.props,n=t.info,r=t.show,i=t.hidePopup,a=t.eventEmitter,l=t.execCommand,c=n||{},u=c.className,d=void 0===u?"":u,p=c.style,h=c.render,f=c.initialValues,m=void 0===f?{}:f,g=o(o({display:r?"block":"none"},p),this.state.popupPos);return Eg(Vv||(Vv=s(['\n      <div\n        class="'," ",'"\n        style=',"\n        ref=",'\n        aria-role="dialog"\n      >\n        <div class="','">\n          ',"\n        </div>\n      </div>\n    "],['\n      <div\n        class="'," ",'"\n        style=',"\n        ref=",'\n        aria-role="dialog"\n      >\n        <div class="','">\n          ',"\n        </div>\n      </div>\n    "])),xa("popup"),d,g,(function(t){return e.refs.el=t}),xa("popup-body"),h&&h({eventEmitter:a,show:r,hidePopup:i,execCommand:l,initialValues:m}))},n}($g);function _v(e){return function(n){function r(e){var t=n.call(this,e)||this;return t.showTooltip=function(e){var n=t.props.item.tooltip;if(!t.props.disabled&&n){var r=t.getBound(e),o=r.left+6+"px",i=r.top+6+"px";be()(t.props.tooltipRef.current,{display:"block",left:o,top:i}),t.props.tooltipRef.current.querySelector(".text").textContent=n}},t.hideTooltip=function(){be()(t.props.tooltipRef.current,"display","none")},t.state={active:!1,disabled:e.disabled},t.addEvent(),t}return t(r,n),r.prototype.addEvent=function(){var e=this,t=this.props,n=t.item,r=t.eventEmitter;n.state&&r.listen("changeToolbarState",(function(t){var r,o=null!==(r=t.toolbarState[n.state])&&void 0!==r?r:{},i=o.active,s=o.disabled;e.setState({active:!!i,disabled:null!=s?s:e.props.disabled})}))},r.prototype.getBound=function(e){var t=Da(e,Oa(e,"."+xa("toolbar"))),n=t.offsetLeft,r=t.offsetTop;return{left:n,top:e.offsetHeight+r}},r.prototype.render=function(){return Eg(jv||(jv=s(["\n        <","\n          ...","\n          active=","\n          showTooltip=","\n          hideTooltip=","\n          getBound=","\n          disabled=","\n        />\n      "],["\n        <","\n          ...","\n          active=","\n          showTooltip=","\n          hideTooltip=","\n          getBound=","\n          disabled=","\n        />\n      "])),e,this.props,this.state.active,this.showTooltip,this.hideTooltip,this.getBound,this.state.disabled||this.props.disabled)},r}($g)}var Uv,Wv,Jv,Gv,Kv,Zv,Xv,Qv,Yv,ey,ty,ny,ry,oy,iy=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.showTooltip=function(){t.props.showTooltip(t.refs.el)},t.execCommand=function(){var e=t.props,n=e.item,r=e.execCommand,o=e.setPopupInfo,i=e.getBound,s=e.eventEmitter,a=n.command,l=n.name,c=n.popup;if(a)r(a);else{var u=c?"customPopupBody":l,d=s.emit("query","getPopupInitialValues",{popupName:u})[0],p=Hv(u,{el:t.refs.el,pos:i(t.refs.el),popup:c,initialValues:d});p&&o(p)}},t}return t(n,e),n.prototype.mounted=function(){this.setItemWidth()},n.prototype.updated=function(e){e.item.name!==this.props.item.name&&this.setItemWidth()},n.prototype.setItemWidth=function(){var e=this.props,t=e.setItemWidth,n=e.item;t&&t(n.name,Na(this.refs.el)+(n.hidden?80:0))},n.prototype.render=function(){var e=this,t=this.props,n=t.hideTooltip,r=t.disabled,i=t.item,a=t.active,l=o({display:i.hidden?"none":null},i.style),c=(i.className||"")+(a?" active":"");return Eg(Uv||(Uv=s(["\n      <button\n        ref=",'\n        type="button"\n        style=',"\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n        disabled=","\n        aria-label=","\n      >\n        ","\n      </button>\n    "],["\n      <button\n        ref=",'\n        type="button"\n        style=',"\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n        disabled=","\n        aria-label=","\n      >\n        ","\n      </button>\n    "])),(function(t){return e.refs.el=t}),l,c,this.execCommand,this.showTooltip,n,!!r,i.text||i.tooltip||"",i.text||"")},n}($g),sy=_v(iy),ay=function(e){function n(){var t=null!==e&&e.apply(this,arguments)||this;return t.showTooltip=function(){t.props.showTooltip(t.refs.el)},t.showPopup=function(){var e=Hv("customPopupBody",{el:t.refs.el,pos:t.props.getBound(t.refs.el),popup:t.props.item.popup});e&&t.props.setPopupInfo(e)},t}return t(n,e),n.prototype.mounted=function(){var e=this.props,t=e.setItemWidth,n=e.item;this.refs.el.appendChild(n.el),t&&t(n.name,Na(this.refs.el)),n.onMounted&&n.onMounted(this.props.execCommand)},n.prototype.updated=function(e){var t,n=this.props,r=n.item,o=n.active,i=n.disabled;e.active===o&&e.disabled===i||null===(t=r.onUpdated)||void 0===t||t.call(r,{active:o,disabled:i})},n.prototype.render=function(){var e=this,t=this.props,n=t.disabled,r={display:t.item.hidden?"none":"inline-block"},o=function(e){return n?null:e};return Eg(Wv||(Wv=s(["\n      <div\n        ref=","\n        style=","\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n      ></div>\n    "],["\n      <div\n        ref=","\n        style=","\n        class=","\n        onClick=","\n        onMouseover=","\n        onMouseout=","\n      ></div>\n    "])),(function(t){return e.refs.el=t}),r,xa("toolbar-item-wrapper"),o(this.showPopup),o(this.showTooltip),o(this.props.hideTooltip))},n}($g),ly=_v(ay),cy=function(e){function n(){return null!==e&&e.apply(this,arguments)||this}return t(n,e),n.prototype.render=function(){var e=this,t=this.props,n=t.group,r=t.hiddenDivider,o=n.hidden?{display:"none"}:null,i=r?{display:"none"}:null;return Eg(Gv||(Gv=s(['\n      <div class="','" style=',">\n        ",'\n        <div class="','" style=',"></div>\n      </div>\n    "],['\n      <div class="','" style=',">\n        ",'\n        <div class="','" style=',"></div>\n      </div>\n    "])),xa("toolbar-group"),o,n.map((function(t){var n=t.el?ly:sy;return Eg(Jv||(Jv=s(["<"," key="," ..."," item="," />"],["<"," key="," ..."," item="," />"])),n,t.name,e.props,t)})),xa("toolbar-divider"),i)},n}($g),uy=function(e){function n(t){var n=e.call(this,t)||this;return n.handleClickDocument=function(e){var t=e.target;Oa(t,"."+xa("dropdown-toolbar"))||Oa(t,".more")||n.setState({showDropdown:!1,dropdownPos:null})},n.showTooltip=function(){n.props.showTooltip(n.refs.el)},n.state={showDropdown:!1,dropdownPos:null},n}return t(n,e),n.prototype.getBound=function(){var e=this.props.getBound(this.refs.el);return e.top+=4,o(o({},e),{left:null,right:10})},n.prototype.mounted=function(){document.addEventListener("click",this.handleClickDocument)},n.prototype.updated=function(){this.state.showDropdown&&!this.state.dropdownPos&&this.setState({dropdownPos:this.getBound()})},n.prototype.beforeDestroy=function(){document.removeEventListener("click",this.handleClickDocument)},n.prototype.render=function(){var e=this,t=this.state,n=t.showDropdown,r=t.dropdownPos,i=this.props,a=i.disabled,l=i.item,c=i.items,u=i.hideTooltip,d=c.filter((function(e){return!e.hidden})),p=d.length?null:{display:"none"},h=n?null:{display:"none"};return Eg(Zv||(Zv=s(['\n      <div class="','" style=',">\n        <button\n          ref=",'\n          type="button"\n          class=',"\n          onClick=","\n          onMouseover=","\n          onMouseout=","\n          disabled=",'\n        ></button>\n        <div\n          class="','"\n          style=',"\n          ref=","\n        >\n          ","\n        </div>\n      </div>\n    "],['\n      <div class="','" style=',">\n        <button\n          ref=",'\n          type="button"\n          class=',"\n          onClick=","\n          onMouseover=","\n          onMouseout=","\n          disabled=",'\n        ></button>\n        <div\n          class="','"\n          style=',"\n          ref=","\n        >\n          ","\n        </div>\n      </div>\n    "])),xa("toolbar-group"),p,(function(t){return e.refs.el=t}),l.className,(function(){return e.setState({showDropdown:!0})}),this.showTooltip,u,a,xa("dropdown-toolbar"),o(o({},h),r),(function(t){return e.refs.dropdownEl=t}),d.length?d.map((function(t,n){var r;return Eg(Kv||(Kv=s(["\n                  <","\n                    group=","\n                    hiddenDivider=","\n                    ...","\n                  />\n                "],["\n                  <","\n                    group=","\n                    hiddenDivider=","\n                    ...","\n                  />\n                "])),cy,t,n===d.length-1||(null===(r=d[n+1])||void 0===r?void 0:r.hidden),e.props)})):null)},n}($g),dy=_v(uy),py=function(e){function n(t){var n=e.call(this,t)||this;return n.toggleTab=function(e,t){var r=n.props.eventEmitter;if(n.state.activeTab!==t){var o="write"===t?"changePreviewTabWrite":"changePreviewTabPreview";r.emit(o),n.setState({activeTab:t})}},n.setItemWidth=function(e,t){n.itemWidthMap[e]=t},n.setPopupInfo=function(e){n.setState({showPopup:!0,popupInfo:e})},n.openPopup=function(e,t){void 0===t&&(t={});var r=n.refs.el.querySelector("."+xa("toolbar-group")+" ."+e);if(r){var o=Da(r,Oa(r,"."+xa("toolbar"))),i=o.offsetLeft,s=o.offsetTop,a=Hv(e,{el:r,pos:{left:i,top:r.offsetHeight+s},initialValues:t});a&&n.setPopupInfo(a)}},n.hidePopup=function(){n.state.showPopup&&n.setState({showPopup:!1})},n.execCommand=function(e,t){n.props.eventEmitter.emit("command",e,t),n.hidePopup()},n.tabs=[{name:"write",text:"Write"},{name:"preview",text:"Preview"}],n.itemWidthMap={},n.initialItems=qv(t.toolbarItems||[],n.hiddenScrollSync()),n.state={items:n.initialItems,dropdownItems:[],showPopup:!1,popupInfo:{},activeTab:"write"},n.tooltipRef={current:null},n.resizeObserver=new Dv((function(){return n.handleResize()})),n.addEvent(),n}return t(n,e),n.prototype.insertToolbarItem=function(e,t){var n=e.groupIndex,r=e.itemIndex,o=this.initialItems[n];t=Fv(t),o?o.splice(r,0,t):this.initialItems.push([t]),this.setState(this.classifyToolbarItems())},n.prototype.removeToolbarItem=function(e){var t=this;Fa()(this.initialItems,(function(n){var r=!1;return Fa()(n,(function(o,i){return o.name!==e||(r=!0,n.splice(i,1),t.setState(t.classifyToolbarItems()),!1)})),!r}))},n.prototype.addEvent=function(){var e=this,t=this.props.eventEmitter;this.handleResize=Wg()((function(){e.setState({items:e.initialItems,dropdownItems:[]}),e.setState(e.classifyToolbarItems())}),200),t.listen("openPopup",this.openPopup)},n.prototype.appendTooltipToRoot=function(){var e='<div class="'+xa("tooltip")+'" style="display:none">\n        <div class="arrow"></div>\n        <span class="text"></span>\n      </div>';this.tooltipRef.current=Ea(e,this.refs.el)},n.prototype.hiddenScrollSync=function(){return"wysiwyg"===this.props.editorType||"tab"===this.props.previewStyle},n.prototype.movePrevItemToDropdownToolbar=function(e,t,n,r){var o=function(e){var t=e.pop();t&&r.push(t)};if(e>1)o(n);else{var i=et(t);i&&o(i)}},n.prototype.classifyToolbarItems=function(){var e=this,t=0,n=this.refs.el.clientWidth,r=this.refs.el.querySelector("."+xa("toolbar-divider")),o=r?Na(r):0,i=[],s=[],a=!1;return this.initialItems.forEach((function(r,l){var c=[],u=[];r.forEach((function(r,o){r.hidden||((t+=e.itemWidthMap[r.name])>n-50?(a||(e.movePrevItemToDropdownToolbar(o,i,c,u),a=!0),u.push(r)):c.push(r))})),c.length&&(zv(c),i.push(c)),u.length&&(zv(u),s.push(u)),l<e.state.items.length-1&&(t+=o)})),{items:i,dropdownItems:s}},n.prototype.mounted=function(){"tab"===this.props.previewStyle&&this.props.eventEmitter.emit("changePreviewTabWrite",!0),this.setState(this.classifyToolbarItems()),this.appendTooltipToRoot(),this.resizeObserver.observe(this.refs.el)},n.prototype.updated=function(e){var t,n,r=this.props,o=r.editorType,i=r.previewStyle,s=r.eventEmitter,a=i!==e.previewStyle,l=o!==e.editorType;if(a||l){t=this.initialItems,n=this.hiddenScrollSync(),t.forEach((function(e){e.forEach((function(e){return e.hidden="scrollSync"===e.name&&n})),zv(e)}));var c=this.classifyToolbarItems();(a||"tab"===i&&"markdown"===o)&&(s.emit("changePreviewTabWrite"),c.activeTab="write"),this.setState(c)}},n.prototype.beforeDestroy=function(){window.removeEventListener("resize",this.handleResize),this.resizeObserver.disconnect(),Ma(this.tooltipRef.current)},n.prototype.render=function(){var e=this,t=this.props,n=t.previewStyle,r=t.eventEmitter,o=t.editorType,i=this.state,a=i.popupInfo,l=i.showPopup,c=i.activeTab,u=i.items,d=i.dropdownItems,p={eventEmitter:r,tooltipRef:this.tooltipRef,disabled:"markdown"===o&&"tab"===n&&"preview"===c,execCommand:this.execCommand,setPopupInfo:this.setPopupInfo},h="tab"===n?{borderTopLeftRadius:0}:null;return Eg(Qv||(Qv=s(['\n      <div class="','">\n        <div\n          class="','"\n          style="display: ','"\n        >\n          <'," tabs="," activeTab="," onClick=",' />\n        </div>\n        <div\n          class="','"\n          ref=',"\n          style=","\n        >\n          ","\n          <","\n            item=","\n            items=","\n            ...","\n          />\n        </div>\n        <","\n          info=","\n          show=","\n          eventEmitter=","\n          hidePopup=","\n          execCommand=","\n        />\n      </div>\n    "],['\n      <div class="','">\n        <div\n          class="','"\n          style="display: ','"\n        >\n          <'," tabs="," activeTab="," onClick=",' />\n        </div>\n        <div\n          class="','"\n          ref=',"\n          style=","\n        >\n          ","\n          <","\n            item=","\n            items=","\n            ...","\n          />\n        </div>\n        <","\n          info=","\n          show=","\n          eventEmitter=","\n          hidePopup=","\n          execCommand=","\n        />\n      </div>\n    "])),xa("toolbar"),xa("md-tab-container"),"wysiwyg"===o||"vertical"===n?"none":"block",Lv,this.tabs,c,this.toggleTab,xa("defaultUI-toolbar"),(function(t){return e.refs.el=t}),h,u.map((function(t,n){var r;return Eg(Xv||(Xv=s(["\n              <","\n                group=","\n                hiddenDivider=","\n                setItemWidth=","\n                ...","\n              />\n            "],["\n              <","\n                group=","\n                hiddenDivider=","\n                setItemWidth=","\n                ...","\n              />\n            "])),cy,t,n===u.length-1||(null===(r=u[n+1])||void 0===r?void 0:r.hidden),e.setItemWidth,p)})),dy,Fv("more"),d,p,$v,a,l,r,this.hidePopup,this.execCommand)},n}($g),hy=function(e){function n(t){var n=e.call(this,t)||this;return n.handleClickDocument=function(e){Oa(e.target,"."+xa("context-menu"))||n.setState({pos:null})},n.state={pos:null,menuGroups:[]},n.addEvent(),n}return t(n,e),n.prototype.addEvent=function(){var e=this;this.props.eventEmitter.listen("contextmenu",(function(t){var n=t.pos,r=t.menuGroups;e.setState({pos:n,menuGroups:r})}))},n.prototype.mounted=function(){document.addEventListener("click",this.handleClickDocument)},n.prototype.beforeDestroy=function(){document.removeEventListener("click",this.handleClickDocument)},n.prototype.getMenuGroupElements=function(){var e=this,t=this.state,n=t.pos,r=t.menuGroups;return n?r.reduce((function(t,n){var r=[];return n.forEach((function(t){var n=t.label,o=t.className,i=void 0!==o&&o,a=t.disabled,l=t.onClick;r.push(Eg(Yv||(Yv=s(["\n                <li\n                  onClick=",'\n                  class="menu-item','"\n                  aria-role="menuitem"\n                >\n                  <span class="','">',"</span>\n                </li>\n              "],["\n                <li\n                  onClick=",'\n                  class="menu-item','"\n                  aria-role="menuitem"\n                >\n                  <span class="','">',"</span>\n                </li>\n              "])),(function(){a||(l(),e.setState({pos:null}))}),a?" disabled":"",i,n))})),t.push(Eg(ey||(ey=s(['<ul class="menu-group">\n              ',"\n            </ul>"],['<ul class="menu-group">\n              ',"\n            </ul>"])),r)),t}),[]):[]},n.prototype.render=function(){var e=o({display:this.state.pos?"block":"none"},this.state.pos);return Eg(ty||(ty=s(['<div class="','" style=',' aria-role="menu">\n      ',"\n    </div>"],['<div class="','" style=',' aria-role="menu">\n      ',"\n    </div>"])),xa("context-menu"),e,this.getMenuGroupElements())},n}($g),fy=function(e){function n(t){var n=e.call(this,t)||this;n.changeMode=function(e){e!==n.state.editorType&&n.setState({editorType:e})},n.changePreviewStyle=function(e){e!==n.state.previewStyle&&n.setState({previewStyle:e})},n.hide=function(){n.setState({hide:!0})},n.show=function(){n.setState({hide:!1})};var r=t.editorType,o=t.previewStyle;return n.state={editorType:r,previewStyle:o,hide:!1},n.addEvent(),n}return t(n,e),n.prototype.mounted=function(){var e=this.props.slots,t=e.wwEditor,n=e.mdEditor,r=e.mdPreview;this.refs.wwContainer.appendChild(t),this.refs.mdContainer.insertAdjacentElement("afterbegin",n),this.refs.mdContainer.appendChild(r)},n.prototype.insertToolbarItem=function(e,t){this.toolbar.insertToolbarItem(e,t)},n.prototype.removeToolbarItem=function(e){this.toolbar.removeToolbarItem(e)},n.prototype.render=function(){var e=this,t=this.props,n=t.eventEmitter,r=t.hideModeSwitch,o=t.toolbarItems,i=t.theme,a=this.state,l=a.hide,c=a.previewStyle,u=a.editorType,d=l?" hidden":"",p=xa("markdown"===u?"md-mode":"ww-mode"),h=xa("md")+"-"+c+"-style",f=xa(["light"!==i,i+" "]);return Eg(ry||(ry=s(['\n      <div\n        class="',"","",'"\n        ref=',"\n      >\n        <","\n          ref=","\n          eventEmitter=","\n          previewStyle=","\n          toolbarItems=","\n          editorType=",'\n        />\n        <div\n          class="'," ",'"\n          ref=','\n        >\n          <div class="','">\n            <div\n              class="'," ",'"\n              ref=','\n            >\n              <div class="','"></div>\n            </div>\n            <div\n              class="','"\n              ref=',"\n            />\n          </div>\n        </div>\n        ","\n        <"," eventEmitter="," />\n      </div>\n    "],['\n      <div\n        class="',"","",'"\n        ref=',"\n      >\n        <","\n          ref=","\n          eventEmitter=","\n          previewStyle=","\n          toolbarItems=","\n          editorType=",'\n        />\n        <div\n          class="'," ",'"\n          ref=','\n        >\n          <div class="','">\n            <div\n              class="'," ",'"\n              ref=','\n            >\n              <div class="','"></div>\n            </div>\n            <div\n              class="','"\n              ref=',"\n            />\n          </div>\n        </div>\n        ","\n        <"," eventEmitter="," />\n      </div>\n    "])),f,xa("defaultUI"),d,(function(t){return e.refs.el=t}),py,(function(t){return e.toolbar=t}),n,c,o,u,xa("main"),p,(function(t){return e.refs.editorSection=t}),xa("main-container"),xa("md-container"),h,(function(t){return e.refs.mdContainer=t}),xa("md-splitter"),xa("ww-container"),(function(t){return e.refs.wwContainer=t}),!r&&Eg(ny||(ny=s(["<"," eventEmitter="," editorType="," />"],["<"," eventEmitter="," editorType="," />"])),_g,n,u),hy,n)},n.prototype.addEvent=function(){var e=this.props.eventEmitter;e.listen("hide",this.hide),e.listen("show",this.show),e.listen("changeMode",this.changeMode),e.listen("changePreviewStyle",this.changePreviewStyle)},n}($g),my=function(e){function n(t){var n,r,o=e.call(this,t)||this,i=Vg(o.options.el,Eg(oy||(oy=s(["\n        <","\n          ref=","\n          eventEmitter=","\n          slots=","\n          hideModeSwitch=","\n          toolbarItems=","\n          previewStyle=","\n          editorType=","\n          theme=","\n        />\n      "],["\n        <","\n          ref=","\n          eventEmitter=","\n          slots=","\n          hideModeSwitch=","\n          toolbarItems=","\n          previewStyle=","\n          editorType=","\n          theme=","\n        />\n      "])),fy,(function(e){return r=e}),o.eventEmitter,o.getEditorElements(),o.options.hideModeSwitch,o.options.toolbarItems,o.options.previewStyle,o.options.initialEditType,o.options.theme));return o.setMinHeight(o.options.minHeight),o.setHeight(o.options.height),o.defaultUI={insertToolbarItem:r.insertToolbarItem.bind(r),removeToolbarItem:r.removeToolbarItem.bind(r),destroy:i},null===(n=o.pluginInfo.toolbarItems)||void 0===n||n.forEach((function(e){var t=e.groupIndex,n=e.itemIndex,r=e.item;o.defaultUI.insertToolbarItem({groupIndex:t,itemIndex:n},r)})),o.eventEmitter.emit("loadUI",o),o}return t(n,e),n.factory=function(e){return e.viewer?new ug(e):new n(e)},n.prototype.insertToolbarItem=function(e,t){this.defaultUI.insertToolbarItem(e,t)},n.prototype.removeToolbarItem=function(e){this.defaultUI.removeToolbarItem(e)},n.prototype.destroy=function(){e.prototype.destroy.call(this),this.defaultUI.destroy()},n}(kg),gy=my;kg.setLanguage(["en","en-US"],{Markdown:"Markdown",WYSIWYG:"WYSIWYG",Write:"Write",Preview:"Preview",Headings:"Headings",Paragraph:"Paragraph",Bold:"Bold",Italic:"Italic",Strike:"Strike",Code:"Inline code",Line:"Line",Blockquote:"Blockquote","Unordered list":"Unordered list","Ordered list":"Ordered list",Task:"Task",Indent:"Indent",Outdent:"Outdent","Insert link":"Insert link","Insert CodeBlock":"Insert codeBlock","Insert table":"Insert table","Insert image":"Insert image",Heading:"Heading","Image URL":"Image URL","Select image file":"Select image file","Choose a file":"Choose a file","No file":"No file",Description:"Description",OK:"OK",More:"More",Cancel:"Cancel",File:"File",URL:"URL","Link text":"Link text","Add row to up":"Add row to up","Add row to down":"Add row to down","Add column to left":"Add column to left","Add column to right":"Add column to right","Remove row":"Remove row","Remove column":"Remove column","Align column to left":"Align column to left","Align column to center":"Align column to center","Align column to right":"Align column to right","Remove table":"Remove table","Would you like to paste as table?":"Would you like to paste as table?","Text color":"Text color","Auto scroll enabled":"Auto scroll enabled","Auto scroll disabled":"Auto scroll disabled","Choose language":"Choose language"});var vy=gy}(),r=r.default}()}));
+</script>
+    <style>
+/*
+ * Tailwind utility subset for mdedit
+ *
+ * This file replaces the Tailwind Play CDN. It contains only the utility
+ * classes actually used in template.html, hand-written to match Tailwind v3
+ * output exactly. If new Tailwind classes are needed in template.html, add
+ * them here and remove the class from this comment.
+ *
+ * Generated from: grep -o 'class="[^"]*"' template.html | tr ' ' '\n' | sort -u
+ * Tailwind version parity: v3.x (default spacing scale, gray palette, etc.)
+ */
+
+/* ── Reset ── */
+*, ::before, ::after { box-sizing: border-box; }
+
+/* ── Display ── */
+.flex          { display: flex; }
+.inline-flex   { display: inline-flex; }
+/* .hidden lives in shared/base.css (uses !important) */
+
+/* ── Flex direction ── */
+.flex-col      { flex-direction: column; }
+.flex-row      { flex-direction: row; }
+
+/* ── Flex grow ── */
+.flex-1        { flex: 1 1 0%; }
+
+/* ── Alignment ── */
+.items-center     { align-items: center; }
+.justify-between  { justify-content: space-between; }
+.justify-center   { justify-content: center; }
+
+/* ── Gap ── */
+.gap-1  { gap: 0.25rem; }
+.gap-2  { gap: 0.5rem; }
+.gap-4  { gap: 1rem; }
+.gap-6  { gap: 1.5rem; }
+
+/* ── Overflow ── */
+.overflow-hidden { overflow: hidden; }
+.overflow-auto   { overflow: auto; }
+
+/* ── Sizing ── */
+.h-screen { height: 100vh; }
+.h-full   { height: 100%; }
+.h-12     { height: 3rem; }
+.h-6      { height: 1.5rem; }
+.h-3\.5   { height: 0.875rem; }
+.h-24     { height: 6rem; }
+
+/* ── Resize ── */
+.resize-none { resize: none; }
+
+/* ── Border ── */
+.border-0 { border-width: 0; }
+
+/* ── Outline ── */
+.focus\:outline-none:focus { outline: none; }
+.w-full   { width: 100%; }
+.w-1      { width: 0.25rem; }
+.w-3\.5   { width: 0.875rem; }
+
+/* ── Positioning ── */
+.relative { position: relative; }
+.z-10     { z-index: 10; }
+
+/* ── Spacing ── */
+.p-4  { padding: 1rem; }
+.p-6  { padding: 1.5rem; }
+.px-2 { padding-left: 0.5rem;  padding-right: 0.5rem; }
+.pl-2 { padding-left: 0.5rem; }
+.px-3 { padding-left: 0.75rem; padding-right: 0.75rem; }
+.px-4 { padding-left: 1rem;    padding-right: 1rem; }
+.py-1 { padding-top: 0.25rem;  padding-bottom: 0.25rem; }
+.py-2 { padding-top: 0.5rem;   padding-bottom: 0.5rem; }
+.mt-2 { margin-top: 0.5rem; }
+.mb-2 { margin-bottom: 0.5rem; }
+.mb-4 { margin-bottom: 1rem; }
+
+/* ── Typography ── */
+.text-xl   { font-size: 1.25rem;  line-height: 1.75rem; }
+.text-sm   { font-size: 0.875rem; line-height: 1.25rem; }
+.text-xs   { font-size: 0.75rem;  line-height: 1rem; }
+.font-semibold { font-weight: 600; }
+.font-medium   { font-weight: 500; }
+.text-center   { text-align: center; }
+.leading-none  { line-height: 1; }
+.select-none   { user-select: none; }
+
+/* ── Colors — text ── */
+.text-white      { color: #ffffff; }
+.text-gray-800   { color: #1f2937; }
+.text-gray-700   { color: #374151; }
+.text-gray-500   { color: #6b7280; }
+.text-amber-600  { color: #d97706; }
+
+/* ── Colors — background ── */
+.bg-white        { background-color: #ffffff; }
+.bg-gray-100     { background-color: #f3f4f6; }
+.bg-gray-200     { background-color: #e5e7eb; }
+.bg-transparent  { background-color: transparent; }
+.bg-blue-500     { background-color: #3b82f6; }
+
+/* ── Borders ── */
+.border   { border-width: 1px; border-style: solid; }
+.border-b { border-bottom-width: 1px; border-bottom-style: solid; }
+.border-t { border-top-width: 1px;    border-top-style: solid; }
+.border-gray-200 { border-color: #e5e7eb; }
+.border-gray-300 { border-color: #d1d5db; }
+.rounded  { border-radius: 0.25rem; }
+
+/* ── Opacity ── */
+.opacity-70 { opacity: 0.7; }
+.opacity-80 { opacity: 0.8; }
+
+/* ── SVG ── */
+.fill-current { fill: currentColor; }
+
+/* ── Cursor ── */
+.cursor-pointer    { cursor: pointer; }
+.cursor-col-resize { cursor: col-resize; }
+
+/* ── Transitions ── */
+.transition-all      { transition-property: all;              transition-timing-function: cubic-bezier(0.4,0,0.2,1); transition-duration: 150ms; }
+.transition-colors   { transition-property: color, background-color, border-color, outline-color, text-decoration-color, fill, stroke; transition-timing-function: cubic-bezier(0.4,0,0.2,1); transition-duration: 150ms; }
+.transition-opacity  { transition-property: opacity;          transition-timing-function: cubic-bezier(0.4,0,0.2,1); transition-duration: 150ms; }
+
+/* ── Pseudo-class: hover ── */
+.hover\:bg-blue-500:hover  { background-color: #3b82f6; }
+.hover\:bg-blue-600:hover  { background-color: #2563eb; }
+.hover\:bg-gray-200:hover  { background-color: #e5e7eb; }
+.hover\:opacity-80:hover   { opacity: 0.8; }
+
+/* ── Pseudo-class: disabled ── */
+.disabled\:bg-gray-400:disabled   { background-color: #9ca3af; }
+.disabled\:cursor-not-allowed:disabled { cursor: not-allowed; }
+
+/* ── Dark mode (prefers-color-scheme or manual [data-theme="dark"]) ── */
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]) .dark\:bg-gray-700  { background-color: #374151; }
+  :root:not([data-theme="light"]) .dark\:bg-gray-800  { background-color: #1f2937; }
+  :root:not([data-theme="light"]) .dark\:bg-gray-900  { background-color: #111827; }
+  :root:not([data-theme="light"]) .dark\:border-gray-600 { border-color: #4b5563; }
+  :root:not([data-theme="light"]) .dark\:border-gray-700 { border-color: #374151; }
+  :root:not([data-theme="light"]) .dark\:text-gray-200   { color: #e5e7eb; }
+  :root:not([data-theme="light"]) .dark\:text-gray-400   { color: #9ca3af; }
+  :root:not([data-theme="light"]) .dark\:hover\:bg-gray-700:hover { background-color: #374151; }
+  :root:not([data-theme="light"]) .dark\:hover\:bg-gray-800:hover { background-color: #1f2937; }
+}
+
+/* Manual dark override */
+[data-theme="dark"] .dark\:bg-gray-700  { background-color: #374151; }
+[data-theme="dark"] .dark\:bg-gray-800  { background-color: #1f2937; }
+[data-theme="dark"] .dark\:bg-gray-900  { background-color: #111827; }
+[data-theme="dark"] .dark\:border-gray-600 { border-color: #4b5563; }
+[data-theme="dark"] .dark\:border-gray-700 { border-color: #374151; }
+[data-theme="dark"] .dark\:text-gray-200   { color: #e5e7eb; }
+[data-theme="dark"] .dark\:text-gray-400   { color: #9ca3af; }
+[data-theme="dark"] .dark\:hover\:bg-gray-700:hover { background-color: #374151; }
+[data-theme="dark"] .dark\:hover\:bg-gray-800:hover { background-color: #1f2937; }
+
+/* Manual light override — ensure bg-white/bg-gray-100 are NOT overridden by above */
+[data-theme="light"] .dark\:bg-gray-700,
+[data-theme="light"] .dark\:bg-gray-800,
+[data-theme="light"] .dark\:bg-gray-900 { background-color: revert; }
+
+/* ── Directional spacing (used in JS-generated elements) ── */
+.ml-1  { margin-left: 0.25rem; }
+.ml-4  { margin-left: 1rem; }
+.mr-1  { margin-right: 0.25rem; }
+.pl-0  { padding-left: 0; }
+.pl-4  { padding-left: 1rem; }
+
+/* ── Additional missing utilities ── */
+.whitespace-nowrap  { white-space: nowrap; }
+.text-ellipsis      { text-overflow: ellipsis; }
+.font-bold          { font-weight: 700; }
+.border-r           { border-right-width: 1px; border-right-style: solid; }
+.mt-1               { margin-top: 0.25rem; }
+.text-amber-500     { color: #f59e0b; }
+.text-blue-600      { color: #2563eb; }
+.hover\:bg-gray-100:hover  { background-color: #f3f4f6; }
+.hover\:text-blue-800:hover { color: #1e40af; }
+.hover\:underline:hover    { text-decoration: underline; }
+
+/* ==========================================================================
+   ZDDC Shared Base — single source of truth for tokens and primitives
+   Included first by every tool's build.sh via ../shared/base.css
+   ========================================================================== */
+
+/* ── CSS custom properties ────────────────────────────────────────────────── */
+:root {
+    /* Brand / accent (matches zddc.varasys.io website --accent) */
+    --primary:        #2a5a8a;
+    --primary-hover:  #1d4060;
+    --primary-active: #163352;
+    --primary-light:  #e8f0f7;
+
+    /* Semantic colours */
+    --success: #28a745;
+    --warning: #d97706;
+    --danger:  #dc3545;
+    --info:    #17a2b8;
+
+    /* Backgrounds */
+    --bg:           #ffffff;
+    --bg-secondary: #f8f9fa;
+    --bg-hover:     #f0f4f8;
+    --bg-selected:  var(--primary-light);
+
+    /* Text */
+    --text:       #212529;
+    --text-muted: #6c757d;
+    --text-light: #ffffff;
+
+    /* Borders */
+    --border:      #dee2e6;
+    --border-dark: #adb5bd;
+
+    /* Shape */
+    --radius: 4px;
+
+    /* Typography */
+    --font:      -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    --font-mono: 'SF Mono', 'Fira Code', 'Consolas', 'Courier New', monospace;
+}
+
+/* ── Dark mode tokens ─────────────────────────────────────────────────────── */
+/* Applied via: OS preference (auto) or [data-theme="dark"] on <html>          */
+/* The [data-theme="light"] selector locks light mode regardless of OS pref.   */
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+        --primary:        #4a90c4;
+        --primary-hover:  #5ba3d9;
+        --primary-active: #6ab5e8;
+        --primary-light:  #1a3550;
+
+        --bg:           #1e1e1e;
+        --bg-secondary: #252526;
+        --bg-hover:     #2d2d30;
+        --bg-selected:  #1a3550;
+
+        --text:       #d4d4d4;
+        --text-muted: #9d9d9d;
+        --text-light: #ffffff;
+
+        --border:      #3e3e42;
+        --border-dark: #6e6e72;
+    }
+}
+
+/* Manual dark override — wins over media query */
+[data-theme="dark"] {
+    --primary:        #4a90c4;
+    --primary-hover:  #5ba3d9;
+    --primary-active: #6ab5e8;
+    --primary-light:  #1a3550;
+
+    --bg:           #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover:     #2d2d30;
+    --bg-selected:  #1a3550;
+
+    --text:       #d4d4d4;
+    --text-muted: #9d9d9d;
+    --text-light: #ffffff;
+
+    --border:      #3e3e42;
+    --border-dark: #6e6e72;
+}
+
+/* ── Reset ────────────────────────────────────────────────────────────────── */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* ── Base document ────────────────────────────────────────────────────────── */
+html, body {
+    height: 100%;
+    font-family: var(--font);
+    font-size: 16px;
+    line-height: 1.5;
+    color: var(--text);
+    background-color: var(--bg-secondary);
+}
+
+/* ── Typography ───────────────────────────────────────────────────────────── */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 600;
+    line-height: 1.2;
+}
+
+a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+/* ── Utility ──────────────────────────────────────────────────────────────── */
+.hidden {
+    display: none !important;
+}
+
+.truncate {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* ── Scrollbars (webkit) ──────────────────────────────────────────────────── */
+::-webkit-scrollbar {
+    width: 7px;
+    height: 7px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a0a0a0;
+}
+
+/* ── Button primitive ─────────────────────────────────────────────────────── */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.4rem 0.85rem;
+    font-family: var(--font);
+    font-size: 0.875rem;
+    font-weight: 500;
+    line-height: 1.4;
+    text-align: center;
+    text-decoration: none;
+    white-space: nowrap;
+    vertical-align: middle;
+    cursor: pointer;
+    border: 1px solid transparent;
+    border-radius: var(--radius);
+    transition: background 0.15s, box-shadow 0.15s, border-color 0.15s, color 0.15s;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.btn:disabled,
+.btn[disabled] {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:not(:disabled):hover {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.12);
+}
+
+.btn:not(:disabled):active {
+    box-shadow: none;
+}
+
+/* Variants */
+.btn-primary {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-primary:not(:disabled):hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+    color: var(--text-light);
+}
+
+.btn-primary:not(:disabled):active {
+    background: var(--primary-active);
+    border-color: var(--primary-active);
+}
+
+.btn-secondary {
+    background: var(--bg);
+    color: var(--text);
+    border-color: var(--border);
+}
+
+.btn-secondary:not(:disabled):hover {
+    background: var(--bg-secondary);
+}
+
+.btn-success {
+    background: var(--success);
+    color: var(--text-light);
+    border-color: var(--success);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: var(--text-light);
+    border-color: var(--danger);
+}
+
+/* Sizes */
+.btn-sm {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.75rem;
+}
+
+.btn-lg {
+    padding: 0.6rem 1.4rem;
+    font-size: 1rem;
+}
+
+.btn-link {
+    background: transparent;
+    border-color: transparent;
+    color: var(--primary);
+    padding-left: 0;
+    padding-right: 0;
+}
+
+.btn-link:not(:disabled):hover {
+    text-decoration: underline;
+    box-shadow: none;
+}
+
+/* ── App header chrome ────────────────────────────────────────────────────── */
+.app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.35rem 1rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+/* Tool name inside the header */
+.app-header__title {
+    font-size: 17px;
+    font-weight: 600;
+    color: var(--text);
+    letter-spacing: 0.01em;
+    white-space: nowrap;
+}
+
+/* ── Build timestamp ──────────────────────────────────────────────────────── */
+.build-timestamp {
+    font-size: 0.55rem;
+    color: var(--text-muted);
+    opacity: 0.7;
+    font-weight: 300;
+    white-space: nowrap;
+    padding-top: 0.15rem;
+}
+
+/* Title + timestamp stacked vertically on the left side of the header */
+.header-title-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    line-height: 1;
+}
+
+/* ── Icon buttons (help, theme, refresh) ─────────────────────────────────── */
+/* Square, centered — overrides the asymmetric text-button padding/line-height */
+#help-btn,
+#theme-btn,
+#refreshHeaderBtn {
+    width: 2rem;
+    height: 2rem;
+    padding: 0;
+    line-height: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1rem;
+}
+
+/* Toast CSS lives in classifier/css/base.css — only that tool uses toasts. */
+
+/* ── Theme and help icon buttons ─────────────────────────────────────────── */
+#theme-btn,
+#help-btn {
+    font-size: 1rem;
+}
+
+/* ── Help panel (shared slide-out drawer) ─────────────────────────────────── */
+/* Used by all four tools. Toggle open/close via shared/help.js.               */
+
+.help-panel {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: min(420px, 85vw);
+    height: 100vh;
+    z-index: 1000;
+    background: var(--bg);
+    border-left: 1px solid var(--border);
+    box-shadow: -2px 0 12px rgba(0, 0, 0, 0.08);
+    display: flex;
+    flex-direction: column;
+    transform: translateX(100%);
+    transition: transform 0.25s ease;
+}
+
+.help-panel:not([hidden]) {
+    transform: translateX(0);
+}
+
+.help-panel[hidden] {
+    display: flex;
+    transform: translateX(100%);
+    pointer-events: none;
+}
+
+.help-panel__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+    background: var(--bg);
+}
+
+.help-panel__title {
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.help-panel__close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1.35rem;
+    cursor: pointer;
+    padding: 0.25rem 0.5rem;
+    border-radius: var(--radius);
+    line-height: 1;
+    transition: background 0.15s, color 0.15s;
+}
+
+.help-panel__close:hover {
+    color: var(--text);
+    background: var(--bg-secondary);
+}
+
+.help-panel__body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem 1rem 2rem;
+    font-size: 0.85rem;
+    line-height: 1.6;
+    color: var(--text);
+}
+
+.help-panel__body h3 {
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin: 1.25rem 0 0.35rem;
+    color: var(--text);
+    border-bottom: 1px solid var(--border);
+    padding-bottom: 0.15rem;
+}
+
+.help-panel__body h3:first-child {
+    margin-top: 0;
+}
+
+.help-panel__body h4 {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    margin: 1.25rem 0 0.3rem;
+    padding-left: 0.5rem;
+    border-left: 3px solid var(--border-dark);
+    color: var(--text-muted);
+}
+
+.help-panel__body p {
+    margin: 0 0 0.5rem;
+}
+
+.help-panel__body ol,
+.help-panel__body ul {
+    padding-left: 1.5rem;
+    margin: 0.3rem 0 0.5rem;
+}
+
+.help-panel__body li {
+    margin-bottom: 0.3rem;
+}
+
+.help-panel__body dl {
+    margin: 0.3rem 0;
+}
+
+.help-panel__body dt {
+    font-weight: 600;
+    color: var(--text);
+}
+
+.help-panel__body dd {
+    margin: 0 0 0.5rem 1rem;
+    color: var(--text-muted);
+}
+
+.help-panel__body code {
+    font-family: var(--font-mono);
+    font-size: 0.8em;
+    background: var(--bg-secondary);
+    padding: 0.1em 0.3em;
+    border-radius: 3px;
+}
+
+.help-badge {
+    font-size: 0.7rem;
+    font-weight: 600;
+    padding: 0.1rem 0.35rem;
+    border-radius: var(--radius);
+    vertical-align: middle;
+    letter-spacing: 0.02em;
+}
+
+.help-badge--draft {
+    color: #2563eb;
+    background: #eff6ff;
+}
+
+.help-badge--published {
+    color: #7c3aed;
+    background: #f5f3ff;
+}
+
+/* Shrink main content when help panel is open */
+body.help-open .app-header {
+    margin-right: min(420px, 85vw);
+}
+
+/* ── Column filter inputs (shared across archive, classifier, transmittal) ─── */
+.column-filter {
+    display: block;
+    width: 100%;
+    box-sizing: border-box;
+    margin-top: 0.25rem;
+    padding: 0.2rem 0.4rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.15s;
+}
+
+.column-filter:focus {
+    border-color: var(--primary);
+    outline: none;
+    box-shadow: 0 0 0 1px rgba(42, 90, 138, 0.35);
+}
+
+.column-filter::placeholder {
+    color: var(--text-muted);
+}
+
+/* mdedit component styles — reset and tokens from shared/base.css */
+
+/* Pane resizer */
+.pane-resizer:hover {
+    background-color: var(--primary) !important;
+}
+
+/* File tree */
+.file-tree {
+    font-size: 0.9rem;
+}
+
+.directory-item,
+.file-item {
+    transition: background-color 0.15s ease;
+}
+
+.dir-icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    transform: rotate(90deg);
+    transition: transform 0.2s ease;
+    vertical-align: middle;
+}
+
+.dir-icon svg {
+    width: 12px;
+    height: 12px;
+    stroke: currentColor;
+    stroke-width: 2;
+}
+
+.directory-item.collapsed .dir-icon {
+    transform: rotate(0deg);
+}
+
+/* Two-line filename styles */
+.filename-main {
+    font-size: 0.9rem;
+    font-weight: 500;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+.filename-secondary {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* Active file highlighting */
+.active-file {
+    background-color: var(--primary) !important;
+    color: var(--text-light) !important;
+    font-weight: 500;
+}
+
+.active-file * {
+    color: var(--text-light) !important;
+}
+
+/* ── File Tree Action Buttons ──────────────────────────────────────────────── */
+.tree-actions {
+    display: flex;
+    gap: 0.25rem;
+    align-items: center;
+    margin-left: auto;
+    opacity: 0;
+    transition: opacity 0.2s ease;
+}
+
+.directory-item:hover .tree-actions,
+.file-item:hover .tree-actions,
+.active-file .tree-actions {
+    opacity: 1;
+}
+
+.tree-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.25rem;
+    height: 1.25rem;
+    padding: 0;
+    border: none;
+    background-color: transparent;
+    color: var(--text-muted);
+    cursor: pointer;
+    border-radius: 0.25rem;
+    transition: background-color 0.15s ease, color 0.15s ease;
+}
+
+.tree-btn:hover {
+    background-color: var(--bg-secondary);
+    color: var(--text);
+}
+
+.tree-btn--danger:hover {
+    background-color: #fee2e2;
+    color: #dc2626;
+}
+
+[data-theme="dark"] .tree-btn--danger:hover {
+    background-color: rgba(127, 29, 29, 0.5);
+    color: #fca5a5;
+}
+
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) .tree-btn--danger:hover {
+        background-color: rgba(127, 29, 29, 0.5);
+        color: #fca5a5;
+    }
+}
+
+.tree-btn svg {
+    width: 1rem;
+    height: 1rem;
+    stroke: currentColor;
+    stroke-width: 2;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+/* Directory toggle indicator */
+.directory-item {
+    position: relative;
+}
+
+.directory-item.collapsed .directory-contents {
+    display: none;
+}
+
+/* File view container */
+.file-view-container {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    width: 100%;
+}
+
+/* File header */
+.file-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.5rem 1rem;
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+}
+
+.file-title {
+    font-size: 1.125rem;
+    font-weight: 500;
+    color: var(--text);
+    margin: 0;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* File content area */
+.file-content-area {
+    display: flex;
+    flex: 1;
+    overflow: hidden;
+}
+
+/* Content container */
+#content-container {
+    flex-direction: column;
+    height: 100%;
+}
+
+/* Image preview */
+.image-preview-container {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--bg-secondary);
+}
+
+.image-preview {
+    max-width: 100%;
+    max-height: 100%;
+    object-fit: contain;
+}
+
+/* HTML preview iframe */
+.html-preview-container {
+    width: 100%;
+    height: 100%;
+}
+
+.html-preview-iframe {
+    width: 100%;
+    height: 100%;
+    border: 0;
+}
+
+/* Dirty indicator */
+.dirty-indicator {
+    margin-left: 0.25rem;
+    color: var(--warning);
+    font-weight: bold;
+}
+
+.is-dirty {
+    font-style: italic;
+}
+
+/* ── App header layout ────────────────────────────────────────────────────── */
+.header-left,
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+/* ── Tailwind class overrides: use CSS tokens instead of hardcoded colours ── */
+/* bg-white / bg-gray-100 are used on the pane backgrounds in template.html.  */
+/* Override them here so they follow the design-token system (light + dark).   */
+.bg-white     { background-color: var(--bg) !important; }
+.bg-gray-100  { background-color: var(--bg-secondary) !important; }
+
+/* ── Front matter nav bar ──────────────────────────────────────────────────── */
+.front-matter-nav {
+    border-bottom: 1px solid var(--border);
+    background-color: var(--bg-secondary);
+}
+
+.front-matter-nav__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.5rem 1rem;
+    cursor: pointer;
+    transition: background-color 0.15s ease;
+}
+
+.front-matter-nav__header:hover {
+    background-color: var(--bg-hover);
+}
+
+.front-matter-toggle {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.25rem;
+    height: 1.25rem;
+    padding: 0;
+    border: none;
+    background: transparent;
+    color: var(--text-muted);
+    cursor: pointer;
+    border-radius: 4px;
+    transition: transform 0.2s ease, color 0.15s ease;
+}
+
+.front-matter-toggle:hover {
+    background-color: var(--bg-secondary);
+    color: var(--text);
+}
+
+.front-matter-toggle svg {
+    width: 0.75rem;
+    height: 0.75rem;
+    stroke: currentColor;
+    stroke-width: 2;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+/* Toggle arrow rotation for collapsed state */
+.front-matter-nav.collapsed .front-matter-toggle .arrow-down {
+    transform: rotate(-90deg);
+}
+
+/* Front matter content area */
+.front-matter-content {
+    overflow: hidden;
+    transition: max-height 0.25s ease, padding 0.25s ease, opacity 0.25s ease;
+    max-height: 500px;
+    padding: 0 1rem;
+}
+
+/* When collapsed, hide content completely */
+.front-matter-nav.collapsed {
+    border-bottom: none;
+}
+
+.front-matter-nav.collapsed .front-matter-content {
+    display: none;
+}
+
+/* Front matter textarea */
+.front-matter-textarea {
+    color: var(--text);
+    background-color: var(--bg);
+    border: none;
+    resize: none;
+    font-family: var(--font-mono);
+    font-size: 0.8rem;
+    white-space: pre;     /* preserve yaml structure, enables horiz scroll */
+    overflow-x: auto;
+    overflow-y: hidden;   /* height is set by JS to fit content exactly */
+    width: 100%;
+    box-sizing: border-box;
+    display: block;
+}
+
+/* ── Hidden utility (for disabled buttons) ─────────────────────────────────── */
+.hide { display: none; }
+
+/* ── File tree row layout ───────────────────────────────────────────────────── */
+.tree-row {
+    display: flex;
+    align-items: center;
+    min-width: 0;
+}
+
+.tree-row__label {
+    flex: 1;
+    min-width: 0;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+}
+
+/* ── New-file modal ─────────────────────────────────────────────────────────── */
+.modal-overlay {
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,0.4);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+}
+.modal-overlay.hidden { display: none; }
+.modal-box {
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    padding: 1.5rem;
+    min-width: 20rem;
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    box-shadow: 0 4px 24px rgba(0,0,0,0.18);
+}
+.modal-title {
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text);
+    margin: 0;
+}
+.modal-input {
+    width: 100%;
+    padding: 0.4rem 0.6rem;
+    border: 1px solid var(--border);
+    border-radius: 0.25rem;
+    font-size: 0.9rem;
+    color: var(--text);
+    background: var(--bg);
+    box-sizing: border-box;
+}
+.modal-input:focus {
+    outline: 2px solid var(--primary);
+    outline-offset: 1px;
+}
+.modal-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.5rem;
+}
+
+/* Toast UI Editor styles */
+#markdown-editor {
+    display: block !important;
+    height: 100% !important;
+    min-height: 500px !important;
+    width: 100% !important;
+    position: relative !important;
+    z-index: 10;
+}
+
+.editor-instance {
+    height: 100% !important;
+    min-height: 500px !important;
+}
+
+.toastui-editor-defaultUI {
+    height: 100% !important;
+}
+
+.toastui-editor-defaultUI-toolbar,
+.toastui-editor-main,
+.toastui-editor-main .ProseMirror,
+.toastui-editor-main .toastui-editor-md-preview {
+    height: 100% !important;
+}
+
+/* Table of Contents styles */
+.toc-pane {
+    height: 100%;
+    display: flex;
+    flex-direction: column;
+}
+
+.toc-container,
+.toc-content {
+    flex: 1;
+    overflow-y: auto;
+}
+
+.toc-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px 12px;
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    font-weight: bold;
+}
+
+.toc-depth-selector {
+    font-size: 0.85rem;
+    padding: 2px 6px;
+    border-radius: 3px;
+    border: 1px solid var(--border);
+    background: var(--bg);
+    color: var(--text);
+}
+
+.toc-list {
+    list-style: none;
+    padding-left: 0;
+    margin: 0;
+    font-size: 0.8rem;
+}
+
+.toc-item {
+    padding: 0;
+    margin: 0;
+    line-height: 1.2;
+}
+
+/* TOC heading level styles */
+.toc-level-1 > a {
+    font-size: 0.9rem;
+    font-weight: 600;
+    color: var(--text);
+}
+
+.toc-level-2 > a {
+    font-size: 0.85rem;
+    font-weight: 600;
+    color: var(--text);
+}
+
+.toc-level-3 > a {
+    font-size: 0.8rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+.toc-level-4 > a {
+    font-size: 0.75rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+.toc-level-5 > a,
+.toc-level-6 > a {
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+/* Nested list spacing */
+.toc-list ul {
+    list-style: none;
+    padding-left: 6px;
+    margin: 0;
+}
+
+.toc-list li {
+    margin-bottom: 1px;
+    line-height: 1.2;
+}
+
+.toc-list li a {
+    display: block;
+    padding: 2px 6px;
+    color: var(--text-muted);
+    text-decoration: none;
+    border-radius: 3px;
+    transition: background-color 0.15s ease;
+}
+
+.toc-list li a:hover {
+    background-color: var(--bg-hover);
+    color: var(--text);
+}
+
+/* Active TOC item highlighting */
+.toc-list li.toc-active {
+    background-color: var(--primary);
+    border-radius: 3px;
+}
+
+/* Use high-specificity selectors to override per-level color rules */
+.toc-list li.toc-active > a,
+.toc-list li.toc-active > a:hover,
+.toc-list li.toc-level-1.toc-active > a,
+.toc-list li.toc-level-2.toc-active > a,
+.toc-list li.toc-level-3.toc-active > a,
+.toc-list li.toc-level-4.toc-active > a,
+.toc-list li.toc-level-5.toc-active > a,
+.toc-list li.toc-level-6.toc-active > a {
+    color: var(--text-light);
+    border-bottom-color: transparent;
+    background-color: transparent;
+}
+
+.toc-list li.toc-level-1 {
+    font-weight: 700;
+    font-size: 1rem;
+    padding-left: 0px;
+}
+
+.toc-list li.toc-level-1 a {
+    color: var(--text);
+    border-bottom: 1px solid var(--primary);
+    padding-bottom: 2px;
+}
+
+/* Tree-style connecting lines for TOC hierarchy */
+.toc-list li.toc-level-2 {
+    font-weight: 650;
+    font-size: 0.9rem;
+    padding-left: 16px;
+    position: relative;
+}
+
+.toc-list li.toc-level-2::before {
+    content: '';
+    position: absolute;
+    left: 6px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-2 a {
+    color: var(--text);
+}
+
+.toc-list li.toc-level-3 {
+    font-weight: 600;
+    font-size: 0.8rem;
+    padding-left: 32px;
+    position: relative;
+}
+
+.toc-list li.toc-level-3::before {
+    content: '';
+    position: absolute;
+    left: 22px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-3 a {
+    color: var(--text-muted);
+}
+
+.toc-list li.toc-level-4 {
+    font-weight: 600;
+    font-size: 0.75rem;
+    padding-left: 48px;
+    position: relative;
+}
+
+.toc-list li.toc-level-4::before {
+    content: '';
+    position: absolute;
+    left: 38px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-4 a {
+    color: var(--text-muted);
+}
+
+.toc-list li.toc-level-5 {
+    font-weight: 600;
+    font-size: 0.7rem;
+    padding-left: 64px;
+    font-style: italic;
+    position: relative;
+}
+
+.toc-list li.toc-level-5::before {
+    content: '';
+    position: absolute;
+    left: 54px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-5 a {
+    color: var(--text-muted);
+}
+
+.toc-list li.toc-level-6 {
+    font-weight: 600;
+    font-size: 0.65rem;
+    padding-left: 80px;
+    font-style: italic;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    position: relative;
+}
+
+.toc-list li.toc-level-6::before {
+    content: '';
+    position: absolute;
+    left: 70px;
+    top: 0;
+    bottom: 50%;
+    border-left: 1px solid var(--border);
+    border-bottom: 1px solid var(--border);
+    width: 8px;
+}
+
+.toc-list li.toc-level-6 a {
+    color: var(--text-muted);
+}
+
+/* Vertical connecting lines */
+.toc-list li:not(.toc-level-1)::after {
+    content: '';
+    position: absolute;
+    left: 6px;
+    top: 50%;
+    bottom: -2px;
+    border-left: 1px solid var(--border);
+    z-index: -1;
+}
+
+.toc-list li.toc-level-3::after {
+    left: 22px;
+}
+
+.toc-list li.toc-level-4::after {
+    left: 38px;
+}
+
+.toc-list li.toc-level-5::after {
+    left: 54px;
+}
+
+.toc-list li.toc-level-6::after {
+    left: 70px;
+}
+
+/* Markdown content rendering styles */
+.markdown-content {
+    line-height: 1.6;
+}
+
+.markdown-content h1,
+.toastui-editor-contents h1 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 2em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 24px;
+    margin-bottom: 16px;
+    padding-bottom: 0.3em;
+    border-bottom: 1px solid var(--border);
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h2,
+.toastui-editor-contents h2 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 1.5em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 24px;
+    margin-bottom: 16px;
+    padding-bottom: 0.3em;
+    border-bottom: 1px solid var(--border);
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h3,
+.toastui-editor-contents h3 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 1.25em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h4,
+.toastui-editor-contents h4 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 1em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h5,
+.toastui-editor-contents h5 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 0.875em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text);
+    word-wrap: break-word;
+}
+
+.markdown-content h6,
+.toastui-editor-contents h6 {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    font-size: 0.85em;
+    font-weight: 600;
+    line-height: 1.25;
+    margin-top: 16px;
+    margin-bottom: 16px;
+    color: var(--text-muted);
+    word-wrap: break-word;
+}
+
+/* Reset margin-top for first-child headings */
+.markdown-content h1:first-child,
+.markdown-content h2:first-child,
+.markdown-content h3:first-child,
+.markdown-content h4:first-child,
+.markdown-content h5:first-child,
+.markdown-content h6:first-child,
+.toastui-editor-contents h1:first-child,
+.toastui-editor-contents h2:first-child,
+.toastui-editor-contents h3:first-child,
+.toastui-editor-contents h4:first-child,
+.toastui-editor-contents h5:first-child,
+.toastui-editor-contents h6:first-child {
+    margin-top: 0;
+}
+
+/* Reduce spacing between consecutive headings */
+.markdown-content h1 + h2,
+.toastui-editor-contents h1 + h2 {
+    margin-top: 1rem;
+}
+
+.markdown-content h2 + h3,
+.toastui-editor-contents h2 + h3 {
+    margin-top: 1.5rem;
+}
+
+.markdown-content h3 + h4,
+.toastui-editor-contents h3 + h4 {
+    margin-top: 1.25rem;
+}
+
+.markdown-content h4 + h5,
+.toastui-editor-contents h4 + h5 {
+    margin-top: 1rem;
+}
+
+.markdown-content h5 + h6,
+.toastui-editor-contents h5 + h6 {
+    margin-top: 0.75rem;
+}
+
+.markdown-content p,
+.toastui-editor-contents p {
+    margin-bottom: 1rem;
+}
+
+.markdown-content ul,
+.markdown-content ol,
+.toastui-editor-contents ul,
+.toastui-editor-contents ol {
+    margin-bottom: 1rem;
+    padding-left: 2rem;
+}
+
+.markdown-content ul,
+.toastui-editor-contents ul {
+    list-style-type: disc;
+}
+
+.markdown-content ol,
+.toastui-editor-contents ol {
+    list-style-type: decimal;
+}
+
+.markdown-content li,
+.toastui-editor-contents li {
+    margin-bottom: 0.25rem;
+}
+
+.markdown-content code,
+.toastui-editor-contents code {
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    font-size: 0.9em;
+    padding: 0.2em 0.4em;
+    background-color: var(--bg-secondary);
+    border-radius: 0.25rem;
+}
+
+.markdown-content pre,
+.toastui-editor-contents pre {
+    margin-bottom: 1rem;
+    padding: 1rem;
+    background-color: var(--bg-secondary);
+    border-radius: 0.375rem;
+    overflow-x: auto;
+}
+
+.markdown-content pre code,
+.toastui-editor-contents pre code {
+    background-color: transparent;
+    padding: 0;
+    border-radius: 0;
+}
+
+.markdown-content blockquote,
+.toastui-editor-contents blockquote {
+    border-left: 4px solid var(--border);
+    padding-left: 1rem;
+    margin-left: 0;
+    margin-right: 0;
+    margin-bottom: 1rem;
+    color: var(--text-muted);
+}
+
+.markdown-content a,
+.toastui-editor-contents a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+.markdown-content a:hover,
+.toastui-editor-contents a:hover {
+    text-decoration: underline;
+}
+
+.markdown-content table,
+.toastui-editor-contents table {
+    border-collapse: collapse;
+    width: 100%;
+    margin-bottom: 1rem;
+}
+
+.markdown-content th,
+.markdown-content td,
+.toastui-editor-contents th,
+.toastui-editor-contents td {
+    border: 1px solid var(--border);
+    padding: 0.5rem;
+    text-align: left;
+}
+
+.markdown-content th,
+.toastui-editor-contents th {
+    background-color: var(--bg-secondary);
+    font-weight: 600;
+}
+
+.markdown-content tr:nth-child(even),
+.toastui-editor-contents tr:nth-child(even) {
+    background-color: var(--bg-hover);
+}
+
+    </style>
+</head>
+<body>
+    <div id="app" class="flex flex-col h-screen w-full overflow-hidden">
+        <header class="app-header">
+            <div class="header-left">
+                <div class="header-title-group">
+                    <span class="app-header__title">ZDDC Markdown</span>
+                    <span class="build-timestamp">v0.0.1</span>
+                </div>
+                <button id="select-directory" class="btn btn-primary" title="Select a Directory">Select Directory</button>
+            </div>
+            <div class="header-right">
+                <button id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+                <button id="help-btn" class="btn btn-secondary" title="Help">?</button>
+            </div>
+        </header>
+
+        <main class="flex-1 overflow-hidden relative">
+            <div class="resizable-pane horizontal flex flex-row relative w-full h-full overflow-hidden" id="root-pane" data-pane-type="root">
+                <div class="pane nav-pane relative flex flex-col bg-white dark:bg-gray-900 overflow-hidden" id="file-nav" data-pane-type="file-nav" style="width: 450px; min-width: 200px;">
+                    <div class="pane-header flex flex-col px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700 select-none">
+                        <div class="flex justify-between items-center w-full">
+                            <span>Files</span>
+                            <div class="flex items-center gap-1">
+                                <button id="new-file-root" class="btn btn-secondary btn-sm hidden" title="New file in root directory">+</button>
+                                <button id="refresh-directory" class="btn btn-secondary btn-sm hidden" title="Refresh directory">↻</button>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="pane-content flex-1 overflow-auto p-4">
+                        <div id="file-tree" class="file-tree py-2">
+                        </div>
+                    </div>
+                </div>
+
+                <div class="pane-resizer bg-gray-200 dark:bg-gray-700 transition-colors relative z-10 w-1 cursor-col-resize hover:bg-blue-500" data-resizer-for="file-nav"></div>
+
+                <div class="pane content-pane flex-1 relative flex flex-col bg-white dark:bg-gray-900 overflow-hidden" id="main-content">
+                    <div id="welcome-screen" class="welcome-screen flex flex-col items-center justify-center h-full text-gray-500 dark:text-gray-400 text-center p-6">
+                        <h2 class="mb-2 text-xl">Welcome to ZDDC Markdown</h2>
+                        <p class="mb-4">All files are edited on your local computer.</p>
+                        <p id="welcome-hint" class="text-sm">Click <strong>Scratchpad</strong> to start editing,<br>or <strong>Select Directory</strong> to work with files.</p>
+                        <p id="welcome-firefox" class="text-sm text-amber-600 hidden mt-2">Your browser doesn't support the File System API.<br>Use <strong>Scratchpad</strong> to edit markdown and save via download.</p>
+                    </div>
+
+                    <div id="content-container" class="content-container flex flex-col h-full hidden">
+                    </div>
+                </div>
+            </div>
+        </main>
+
+        <footer class="status-bar flex justify-between items-center px-4 h-6 text-xs bg-gray-100 dark:bg-gray-800 border-t border-gray-200 dark:border-gray-700">
+            <div class="status-left flex items-center gap-6 py-1">
+                <button id="save-all" class="btn inline-flex items-center gap-2 px-3 py-1 text-sm bg-transparent border border-gray-300 dark:border-gray-600 rounded text-gray-800 dark:text-gray-200 cursor-pointer transition-all hover:bg-gray-200 dark:hover:bg-gray-700 h-6 leading-none" title="Save All">
+                    <svg class="btn-icon w-3.5 h-3.5 fill-current opacity-80" viewBox="0 0 16 16" fill="currentColor">
+                        <path d="M11.5 1H4.5a1.5 1.5 0 0 0-1.5 1.5v11a1.5 1.5 0 0 0 1.5 1.5h7a1.5 1.5 0 0 0 1.5-1.5v-11a1.5 1.5 0 0 0-1.5-1.5zm-7 1h7a.5.5 0 0 1 .5.5V9H4V2.5a.5.5 0 0 1 .5-.5zM4 10h8v3.5a.5.5 0 0 1-.5.5h-7a.5.5 0 0 1-.5-.5V10z"></path>
+                        <path d="M6.5 0a.5.5 0 0 1 .5.5V2h2V.5a.5.5 0 0 1 1 0V2h1.5a.5.5 0 0 1 0 1H10v2.5a.5.5 0 0 1-1 0V3H7v2.5a.5.5 0 0 1-1 0V3H4.5a.5.5 0 0 1 0-1H6V.5a.5.5 0 0 1 .5-.5z"></path>
+                    </svg>
+                    Save All
+                </button>
+                <span id="folder-count" class="status-message text-sm text-gray-800 dark:text-gray-200 opacity-80">0 folders</span>
+                <span id="file-count" class="status-message text-sm text-gray-800 dark:text-gray-200 opacity-80">0 files</span>
+                <span id="unsaved-count" class="status-message text-sm text-gray-800 dark:text-gray-200 opacity-80">0 unsaved</span>
+            </div>
+            <div class="status-right flex items-center gap-4">
+                <a href="https://codeberg.org/VARASYS/ZDDC" target="_blank" rel="noopener noreferrer" class="source-link" title="View source code">
+                    <svg class="source-icon fill-current transition-opacity hover:opacity-80" viewBox="0 0 16 16" width="16" height="16" aria-hidden="true">
+                        <path d="M5.5 11.5L1 8l4.5-3.5L4.4 3 0 8l4.4 5 1.1-1.5zm5 0L15 8l-4.5-3.5L11.6 3 16 8l-4.4 5-1.1-1.5z"></path>
+                    </svg>
+                </a>
+            </div>
+        </footer>
+
+        <!-- Help Panel -->
+        <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+            <div class="help-panel__header">
+                <h2 id="help-panel-title" class="help-panel__title">Help — ZDDC Markdown</h2>
+                <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+            </div>
+            <div class="help-panel__body">
+                <h3>What is ZDDC Markdown?</h3>
+                <p>ZDDC Markdown is a browser-based Markdown editor that reads and writes files directly on your local file system. Everything runs locally — no data is sent to any server.</p>
+
+                <h3>Getting Started</h3>
+                <ol>
+                    <li>Click <strong>Select Directory</strong> to open a folder. The file tree on the left will populate with all files in that folder.</li>
+                    <li>Click any Markdown file (<code>.md</code>) in the tree to open it in the editor.</li>
+                    <li>Use the <strong>Scratchpad</strong> entry (always visible at the top of the tree) for temporary notes without saving to disk.</li>
+                </ol>
+
+                <h3>Editor Modes</h3>
+                <dl>
+                    <dt>WYSIWYG</dt>
+                    <dd>A rich-text view where formatting is rendered live. Good for composing content.</dd>
+                    <dt>Markdown</dt>
+                    <dd>A plain-text view showing raw Markdown syntax. Good for precise control.</dd>
+                </dl>
+                <p>Switch between modes using the toolbar buttons at the top-right of the editor.</p>
+
+                <h3>Saving Files</h3>
+                <dl>
+                    <dt>Auto-save indicator</dt>
+                    <dd>A bullet (•) next to the filename in the tree indicates unsaved changes.</dd>
+                    <dt>Save (Ctrl+S)</dt>
+                    <dd>Saves the currently active file.</dd>
+                    <dt>Save All</dt>
+                    <dd>Saves all files that have unsaved changes in one operation.</dd>
+                </dl>
+
+                <h3>Table of Contents</h3>
+                <p>When a Markdown file is open, a table of contents is generated from its headings and shown on the right side. Use the depth selector to control how many heading levels appear.</p>
+
+                <h3>Browser Compatibility</h3>
+                <p>File system access requires a Chromium-based browser (Chrome, Edge, Brave). In Firefox and other browsers, the <strong>Scratchpad</strong> is available for editing, and files can be saved via download.</p>
+
+                <h3>Keyboard Shortcuts</h3>
+                <dl>
+                    <dt><kbd>Ctrl+S</kbd></dt>
+                    <dd>Save the current file.</dd>
+                    <dt><kbd>Escape</kbd></dt>
+                    <dd>Close this help panel.</dd>
+                </dl>
+            </div>
+        </aside>
+
+        <!-- New-file modal -->
+        <div id="new-file-modal" class="modal-overlay hidden" role="dialog" aria-modal="true" aria-labelledby="new-file-modal-title">
+            <div class="modal-box">
+                <h3 id="new-file-modal-title" class="modal-title">New file name</h3>
+                <input id="new-file-input" type="text" class="modal-input" value="untitled.md" autocomplete="off" spellcheck="false">
+                <div class="modal-actions">
+                    <button id="new-file-cancel" class="btn btn-secondary">Cancel</button>
+                    <button id="new-file-confirm" class="btn btn-primary">Create</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+/**
+ * ZDDC — shared naming convention library
+ *
+ * Canonical implementation of all ZDDC filename, folder name, tracking number,
+ * revision, and status logic.  Included in every tool's build via shared/zddc.js.
+ *
+ * Exposed as window.zddc (plain global) so it works with every tool's module
+ * pattern (archive globals, classifier IIFE, transmittal IIFE, mdedit globals).
+ *
+ * Public API
+ * ----------
+ *   zddc.parseFilename(str)        → ParsedFile | null
+ *   zddc.parseFolder(str)          → ParsedFolder | null
+ *   zddc.parseRevision(str)        → ParsedRevision
+ *   zddc.formatFilename(parts)     → string
+ *   zddc.formatFolder(parts)       → string
+ *   zddc.compareRevisions(a, b)    → number  (-1 | 0 | 1)
+ *   zddc.isValidStatus(str)        → boolean
+ *   zddc.STATUSES                  → string[]
+ *
+ * ParsedFile   { trackingNumber, revision, status, title, extension }
+ * ParsedFolder { date, trackingNumber, status, title }
+ * ParsedRevision { base, modifier, modifierType, modifierNumber, isDraft, full }
+ */
+
+(function (root) {
+    'use strict';
+
+    // ── Valid status codes ───────────────────────────────────────────────────
+
+    /**
+     * Complete list of valid ZDDC document status codes.
+     * '---' denotes an unknown or not-yet-assigned status.
+     */
+    var STATUSES = [
+        '---',
+        'IFA', 'IFB', 'IFC', 'IFD', 'IFI', 'IFP', 'IFR', 'IFU',
+        'REC',
+        'RSA', 'RSB', 'RSC', 'RSD', 'RSI',
+    ];
+
+    var STATUS_SET = {};
+    for (var _i = 0; _i < STATUSES.length; _i++) {
+        STATUS_SET[STATUSES[_i]] = true;
+    }
+
+    function isValidStatus(str) {
+        return !!STATUS_SET[str];
+    }
+
+    // ── Filename parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Canonical file regex.
+     * Matches: TRACKING_REVISION (STATUS) - TITLE.EXT
+     *
+     * Tracking number: no underscores, no whitespace.
+     * Revision:        no whitespace, no parentheses.
+     * Status:          anything inside parentheses (validated separately).
+     * Title:           everything up to the last dot.
+     * Extension:       after the last dot (lowercased by parseFilename).
+     */
+    var FILE_RE = /^([^_\s]+)_([^\s()_]+)\s*\(([^)]+)\)\s*-\s*(\S.*\S|\S)\.\s*([^\s.]+)$/;
+
+    /**
+     * Parse a ZDDC filename.
+     *
+     * @param {string} filename
+     * @returns {{ trackingNumber: string, revision: string, status: string,
+     *             title: string, extension: string, valid: boolean } | null}
+     *   null only if filename is falsy.
+     *   `valid` is true when all fields matched the ZDDC pattern.
+     */
+    function parseFilename(filename) {
+        if (!filename) { return null; }
+
+        var match = filename.match(FILE_RE);
+
+        if (!match) {
+            var lastDot = filename.lastIndexOf('.');
+            return {
+                trackingNumber: '',
+                revision:       '',
+                status:         '',
+                title:          lastDot > 0 ? filename.substring(0, lastDot) : filename,
+                extension:      lastDot > 0 ? filename.substring(lastDot + 1).toLowerCase() : '',
+                valid:          false,
+            };
+        }
+
+        return {
+            trackingNumber: match[1].trim(),
+            revision:       match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            extension:      match[5].toLowerCase(),
+            valid:          true,
+        };
+    }
+
+    // ── Folder name parsing ──────────────────────────────────────────────────
+
+    /**
+     * Transmittal folder regex.
+     * Matches: YYYY-MM-DD_TRACKING (STATUS) - TITLE
+     */
+    var FOLDER_RE = /^(\d{4}-\d{2}-\d{2})_([^_\s(]+)\s*\(([^)]+)\)\s*-\s*(.+)$/;
+
+    /**
+     * Parse a ZDDC transmittal folder name.
+     *
+     * @param {string} foldername
+     * @returns {{ date: string, trackingNumber: string, status: string,
+     *             title: string, valid: boolean } | null}
+     *   null only if foldername is falsy.
+     */
+    function parseFolder(foldername) {
+        if (!foldername) { return null; }
+
+        var match = foldername.match(FOLDER_RE);
+
+        if (!match) {
+            return {
+                date:            '',
+                trackingNumber:  '',
+                status:          '',
+                title:           foldername,
+                valid:           false,
+            };
+        }
+
+        return {
+            date:           match[1],
+            trackingNumber: match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            valid:          true,
+        };
+    }
+
+    // ── Revision parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Modifier sub-regex: +LETTER DIGITS  e.g. +C1, +B2, +N1, +Q1
+     * The draft prefix (~) may appear inside the modifier: A+~C1
+     */
+    var MODIFIER_RE = /^\+(~?)([A-Za-z])(\d+)$/;
+
+    /**
+     * Parse a ZDDC revision string.
+     *
+     * Revision grammar:
+     *   revision     = ['~'] base ['+' ['~'] modifier_letter modifier_number]
+     *   base         = letter(s) | digit(s) | date(YYYY-MM-DD)
+     *   modifier     = letter + digits   e.g. C1, B2, N1, Q1
+     *
+     * @param {string} revision
+     * @returns {{
+     *   base: string,
+     *   modifier: string,       full modifier string e.g. '+C1', '' if none
+     *   modifierType: string,   modifier letter e.g. 'C', '' if none
+     *   modifierNumber: number, modifier number e.g. 1, 0 if none
+     *   modifierIsDraft: boolean,
+     *   isDraft: boolean,       true if base revision starts with ~
+     *   full: string,           original input
+     * }}
+     */
+    function parseRevision(revision) {
+        var raw = (revision || '').toString();
+
+        // Split on '+' to separate base from optional modifier
+        var plusIdx = raw.indexOf('+');
+        var basePart     = plusIdx === -1 ? raw : raw.substring(0, plusIdx);
+        var modifierPart = plusIdx === -1 ? ''  : raw.substring(plusIdx);
+
+        // Draft flag on the base part
+        var isDraft = basePart.startsWith('~');
+        var base    = isDraft ? basePart.substring(1) : basePart;
+
+        // Parse modifier
+        var modifier        = '';
+        var modifierType    = '';
+        var modifierNumber  = 0;
+        var modifierIsDraft = false;
+
+        if (modifierPart) {
+            var mMatch = modifierPart.match(MODIFIER_RE);
+            if (mMatch) {
+                modifierIsDraft = mMatch[1] === '~';
+                modifierType    = mMatch[2].toUpperCase();
+                modifierNumber  = parseInt(mMatch[3], 10);
+                modifier        = modifierPart;
+            } else {
+                // Unrecognised modifier — preserve as-is
+                modifier = modifierPart;
+            }
+        }
+
+        return {
+            base:           base,
+            modifier:       modifier,
+            modifierType:   modifierType,
+            modifierNumber: modifierNumber,
+            modifierIsDraft: modifierIsDraft,
+            isDraft:        isDraft,
+            full:           raw,
+        };
+    }
+
+    // ── Revision comparison ──────────────────────────────────────────────────
+
+    /**
+     * Classify a base revision string into a sort tier:
+     *   0 = date (YYYY-MM-DD)
+     *   1 = letter(s)   A, B, AA …
+     *   2 = number(s)   0, 1, 2, 1.5 …
+     *   3 = other
+     */
+    function _baseTier(base) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(base)) { return 0; }
+        if (/^[A-Za-z]+$/.test(base))          { return 1; }
+        if (/^\d+(\.\d+)?$/.test(base))         { return 2; }
+        return 3;
+    }
+
+    /**
+     * Compare two base revision strings.
+     * Sort order: dates < letters < numbers < other.
+     */
+    function _compareBase(a, b) {
+        var ta = _baseTier(a);
+        var tb = _baseTier(b);
+        if (ta !== tb) { return ta - tb; }
+
+        if (ta === 0) { return a < b ? -1 : a > b ? 1 : 0; }       // date lexicographic = chronological
+        if (ta === 1) { return a.toUpperCase() < b.toUpperCase() ? -1 : a.toUpperCase() > b.toUpperCase() ? 1 : 0; }
+        if (ta === 2) { return parseFloat(a) - parseFloat(b); }
+        return a.localeCompare(b);
+    }
+
+    /**
+     * Compare two ZDDC revision strings for sort ordering.
+     *
+     * Canonical order (ascending = older → newer):
+     *   ~A  <  A  <  A+B1  <  A+C1  <  A+~C2  <  A+C2  <  A+N1  <  A+Q1
+     *   <  ~B  <  B  < … < 0 < 1 < 2
+     *
+     * Rules:
+     *   1. Compare base revisions first (dates < letters < numbers).
+     *   2. For equal bases, draft (isDraft=true) comes before final.
+     *   3. For equal base+draft, no-modifier < has-modifier.
+     *   4. For equal base+draft+modifier presence:
+     *      a. modifier draft comes before modifier final (modifierIsDraft).
+     *      b. Sort modifier by type letter then by number.
+     *
+     * @param {string} a
+     * @param {string} b
+     * @returns {number}  negative if a < b, 0 if equal, positive if a > b
+     */
+    function compareRevisions(a, b) {
+        var pa = parseRevision(a);
+        var pb = parseRevision(b);
+
+        // 1. Base revision
+        var baseCmp = _compareBase(pa.base, pb.base);
+        if (baseCmp !== 0) { return baseCmp; }
+
+        // 2. Draft before final (for same base)
+        if (pa.isDraft !== pb.isDraft) { return pa.isDraft ? -1 : 1; }
+
+        // 3. No modifier before any modifier
+        var aHasMod = pa.modifier !== '';
+        var bHasMod = pb.modifier !== '';
+        if (aHasMod !== bHasMod) { return aHasMod ? 1 : -1; }
+
+        if (!aHasMod) { return 0; } // both have no modifier
+
+        // 4. Compare modifiers: type → number → draft (draft is a tie-breaker only)
+        // 4a. Modifier type letter (B < C < N < Q …)
+        if (pa.modifierType !== pb.modifierType) {
+            return pa.modifierType < pb.modifierType ? -1 : 1;
+        }
+
+        // 4b. Modifier number (1 < 2 …)
+        if (pa.modifierNumber !== pb.modifierNumber) {
+            return pa.modifierNumber - pb.modifierNumber;
+        }
+
+        // 4c. Draft of a modifier comes before the final modifier (same type+number)
+        if (pa.modifierIsDraft !== pb.modifierIsDraft) {
+            return pa.modifierIsDraft ? -1 : 1;
+        }
+
+        return 0;
+    }
+
+    // ── Filename / folder formatting ─────────────────────────────────────────
+
+    /**
+     * Build a ZDDC filename from its components.
+     *
+     * @param {{ trackingNumber: string, revision: string, status: string,
+     *           title: string, extension: string }} parts
+     * @returns {string}  e.g. "123456-EL-SPC-2623_A (IFR) - Specification.pdf"
+     */
+    function formatFilename(parts) {
+        var tn  = (parts.trackingNumber || '').trim();
+        var rev = (parts.revision       || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+        var ext = (parts.extension      || '').replace(/^\./, '');
+
+        if (!tn || !rev || !st || !ttl) { return ''; }
+
+        var name = tn + '_' + rev + ' (' + st + ') - ' + ttl;
+        return ext ? name + '.' + ext : name;
+    }
+
+    /**
+     * Build a ZDDC transmittal folder name from its components.
+     *
+     * @param {{ date: string, trackingNumber: string, status: string,
+     *           title: string }} parts
+     * @returns {string}  e.g. "2025-10-31_123456-EM-SUB-0001 (IFR) - Title"
+     */
+    function formatFolder(parts) {
+        var dt  = (parts.date           || '').trim();
+        var tn  = (parts.trackingNumber || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+
+        if (!dt || !tn || !st || !ttl) { return ''; }
+
+        return dt + '_' + tn + ' (' + st + ') - ' + ttl;
+    }
+
+    // ── Filename / extension splitting ───────────────────────────────────────
+
+    /**
+     * Split a filename into its base name and extension (no leading dot).
+     * Treats leading dot ('.gitignore') as no extension.
+     *
+     * @param {string} filename
+     * @returns {{ name: string, extension: string }}
+     */
+    function splitExtension(filename) {
+        if (!filename) { return { name: '', extension: '' }; }
+        var lastDot = filename.lastIndexOf('.');
+        if (lastDot <= 0) { return { name: filename, extension: '' }; }
+        return {
+            name:      filename.substring(0, lastDot),
+            extension: filename.substring(lastDot + 1).toLowerCase(),
+        };
+    }
+
+    /**
+     * Join a base name and extension. Tolerant of either form ('pdf' or '.pdf').
+     * Returns just the name when extension is empty.
+     */
+    function joinExtension(name, extension) {
+        var ext = (extension || '').replace(/^\./, '');
+        return ext ? name + '.' + ext : name;
+    }
+
+    // ── Public API ───────────────────────────────────────────────────────────
+
+    root.zddc = {
+        STATUSES:         STATUSES,
+        isValidStatus:    isValidStatus,
+        parseFilename:    parseFilename,
+        parseFolder:      parseFolder,
+        parseRevision:    parseRevision,
+        formatFilename:   formatFilename,
+        formatFolder:     formatFolder,
+        compareRevisions: compareRevisions,
+        splitExtension:   splitExtension,
+        joinExtension:    joinExtension,
+    };
+
+}(typeof window !== 'undefined' ? window : this));
+
+/**
+ * ZDDC shared theme toggle — light / dark / auto.
+ * Persists choice to localStorage under 'zddc-theme'.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #theme-btn in the DOM (optional — skips gracefully if absent).
+ *
+ * Theme cycle: auto → light → dark → auto …
+ * 'auto' honours the OS prefers-color-scheme media query (CSS handles it).
+ * 'light' sets data-theme="light" on <html> (overrides dark media query).
+ * 'dark'  sets data-theme="dark"  on <html>.
+ */
+(function () {
+    'use strict';
+
+    var STORAGE_KEY = 'zddc-theme';
+    var THEMES = ['auto', 'light', 'dark'];
+
+    var LABELS = {
+        auto:  '◐',
+        light: '☀',
+        dark:  '☾'
+    };
+
+    var TITLES = {
+        auto:  'Theme: auto (follows OS)',
+        light: 'Theme: light',
+        dark:  'Theme: dark'
+    };
+
+    function load() {
+        var stored = localStorage.getItem(STORAGE_KEY);
+        return THEMES.indexOf(stored) !== -1 ? stored : 'auto';
+    }
+
+    function apply(theme) {
+        if (theme === 'dark') {
+            document.documentElement.setAttribute('data-theme', 'dark');
+        } else if (theme === 'light') {
+            document.documentElement.setAttribute('data-theme', 'light');
+        } else {
+            document.documentElement.removeAttribute('data-theme');
+        }
+    }
+
+    function save(theme) {
+        try { localStorage.setItem(STORAGE_KEY, theme); } catch (e) {}
+    }
+
+    function updateButton(btn, theme) {
+        btn.textContent = LABELS[theme];
+        btn.title = TITLES[theme];
+        btn.setAttribute('aria-label', TITLES[theme]);
+    }
+
+    function next(theme) {
+        return THEMES[(THEMES.indexOf(theme) + 1) % THEMES.length];
+    }
+
+    function init() {
+        var current = load();
+        apply(current);
+
+        var btn = document.getElementById('theme-btn');
+        if (!btn) { return; }
+
+        updateButton(btn, current);
+
+        btn.addEventListener('click', function () {
+            current = next(current);
+            apply(current);
+            save(current);
+            updateButton(btn, current);
+        });
+    }
+
+    /* Apply theme immediately (before DOM ready) to avoid flash */
+    apply(load());
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+/**
+ * Global application state and constants
+ */
+
+// Set to true to enable verbose console logging for development.
+const DEBUG = false;
+
+// Check if File System Access API is available
+const hasFileSystemAccess = 'showDirectoryPicker' in window;
+
+// Directory and file handles
+let directoryHandle = null;
+let fileTree = {};
+let currentFileHandle = null;
+
+// Map to store editor instances for each file
+// Key: file path, Value: { editor, container, tocContainer, etc. }
+const editorInstances = new Map();
+
+// Current TOC max depth (1-6)
+let tocMaxDepth = 3;
+
+// Scratchpad ID constant
+const SCRATCHPAD_ID = '__scratchpad__';
+
+/**
+ * Utility functions
+ */
+
+/**
+ * Debounce function calls
+ * @param {Function} func - Function to debounce
+ * @param {number} wait - Wait time in milliseconds
+ * @returns {Function} Debounced function
+ */
+function debounce(func, wait) {
+    let timeout;
+    return function () {
+        const context = this;
+        const args = arguments;
+        clearTimeout(timeout);
+        timeout = setTimeout(() => func.apply(context, args), wait);
+    };
+}
+
+/**
+ * Get file type icon based on file extension
+ * @param {string} fileName - Name of the file
+ * @returns {string} Emoji icon for the file type
+ */
+function getFileTypeIcon(fileName) {
+    const extension = zddc.splitExtension(fileName).extension;
+    
+    const iconMap = {
+        // Documents
+        'md': '📝',
+        'markdown': '📝',
+        'txt': '📄',
+        'rtf': '📄',
+        'doc': '📘',
+        'docx': '📘',
+        'odt': '📘',
+        
+        // Web files
+        'html': '🌐',
+        'htm': '🌐',
+        'css': '🎨',
+        'js': '⚡',
+        'json': '📋',
+        'xml': '📊',
+        'yaml': '⚙️',
+        'yml': '⚙️',
+        
+        // PDFs and presentations
+        'pdf': '📕',
+        'ppt': '📊',
+        'pptx': '📊',
+        'odp': '📊',
+        
+        // Spreadsheets
+        'xls': '📗',
+        'xlsx': '📗',
+        'csv': '📊',
+        'ods': '📗',
+        
+        // Images
+        'png': '🖼️',
+        'jpg': '🖼️',
+        'jpeg': '🖼️',
+        'gif': '🖼️',
+        'svg': '🖼️',
+        'webp': '🖼️',
+        'bmp': '🖼️',
+        
+        // Archives
+        'zip': '📦',
+        'rar': '📦',
+        'tar': '📦',
+        'gz': '📦',
+        '7z': '📦',
+        
+        // Code files
+        'py': '🐍',
+        'java': '☕',
+        'cpp': '⚙️',
+        'c': '⚙️',
+        'h': '⚙️',
+        'php': '🔧',
+        'rb': '💎',
+        'go': '🔵',
+        'rs': '🦀',
+        'swift': '🧡',
+        'kt': '💜',
+        
+        // Configuration
+        'ini': '⚙️',
+        'conf': '⚙️',
+        'cfg': '⚙️',
+        'env': '⚙️',
+        
+        // Other
+        'log': '📃',
+        'sql': '🗄️',
+        'db': '🗄️',
+        'sqlite': '🗄️',
+    };
+    
+    return iconMap[extension] || '📄';
+}
+
+/**
+ * YAML front matter parsing and stringification
+ */
+
+/**
+ * Parse YAML front matter from markdown content
+ * @param {string} content - Full markdown content with potential front matter
+ * @returns {{data: Object, content: string}} Parsed front matter data and remaining content
+ */
+function parseFrontMatter(content) {
+    if (!content || !content.startsWith('---\n')) {
+        return {
+            data: {},
+            content: content || ''
+        };
+    }
+    
+    const endMatch = content.indexOf('\n---\n', 4);
+    if (endMatch === -1) {
+        return {
+            data: {},
+            content: content
+        };
+    }
+    
+    const frontMatterText = content.substring(4, endMatch);
+    const markdownBody = content.substring(endMatch + 5);
+    
+    // Parse YAML front matter (basic key: value parsing)
+    const frontMatterData = {};
+    const lines = frontMatterText.split('\n');
+    
+    for (const line of lines) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine || trimmedLine.startsWith('#')) continue;
+        
+        const colonIndex = trimmedLine.indexOf(':');
+        if (colonIndex > 0) {
+            const key = trimmedLine.substring(0, colonIndex).trim();
+            let value = trimmedLine.substring(colonIndex + 1).trim();
+            
+            // Remove quotes
+            value = value.replace(/^["']|["']$/g, '');
+            
+            // Handle arrays (basic support for [item1, item2])
+            if (value.startsWith('[') && value.endsWith(']')) {
+                value = value.slice(1, -1).split(',').map(item => item.trim().replace(/^["']|["']$/g, ''));
+            }
+            
+            frontMatterData[key] = value;
+        }
+    }
+    
+    return {
+        data: frontMatterData,
+        content: markdownBody
+    };
+}
+
+/**
+ * Stringify front matter data and combine with markdown content
+ * @param {string} content - Markdown content
+ * @param {Object} data - Front matter data object
+ * @returns {string} Combined YAML front matter and markdown
+ */
+function stringifyFrontMatter(content, data) {
+    if (!data || Object.keys(data).length === 0) {
+        return content;
+    }
+    
+    let yamlString = '---\n';
+    
+    for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value)) {
+            yamlString += `${key}: [${value.map(v => `"${v}"`).join(', ')}]\n`;
+        } else {
+            yamlString += `${key}: "${value}"\n`;
+        }
+    }
+    
+    yamlString += '---\n';
+    
+    return yamlString + content;
+}
+
+/**
+ * Convert front matter data to YAML string for textarea display (without delimiters)
+ * @param {Object} data - Front matter data
+ * @returns {string} YAML string for textarea
+ */
+function stringifyFrontMatterToTextarea(data) {
+    if (!data || Object.keys(data).length === 0) {
+        return '';
+    }
+    
+    let yamlString = '';
+    for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value)) {
+            yamlString += `${key}: [${value.map(v => `"${v}"`).join(', ')}]\n`;
+        } else {
+            yamlString += `${key}: "${value}"\n`;
+        }
+    }
+    
+    return yamlString.trim();
+}
+
+/**
+ * File management operations (create, rename, delete)
+ * Plain functions, no module wrapper
+ */
+
+/**
+ * Resolve a node in fileTree by filePath
+ * @param {string} filePath - Path like 'subdir/file.md' or ''
+ * @returns {Object|null} The node object or null if not found
+ */
+function resolveNode(filePath) {
+    if (!filePath) return fileTree;
+    const parts = filePath.split('/');
+    let node = fileTree;
+    for (const part of parts) {
+        if (!node.entries || !node.entries[part]) return null;
+        node = node.entries[part];
+    }
+    return node;
+}
+
+/**
+ * Resolve the parent directory handle for a given file path
+ * @param {string} filePath - Full path like 'subdir/file.md'
+ * @returns {FileSystemDirectoryHandle|null} Parent directory handle or null
+ */
+function resolveParentDirHandle(filePath) {
+    const parts = filePath.split('/');
+    if (parts.length === 1) return directoryHandle;
+    let node = fileTree;
+    for (let i = 0; i < parts.length - 1; i++) {
+        node = node.entries[parts[i]];
+        if (!node) return null;
+    }
+    return node.handle;
+}
+
+/**
+ * Create a new file
+ * @param {string} parentDirPath - '' for root, or 'subdir', 'a/b/c'
+ */
+async function createNewFile(parentDirPath) {
+    // Resolve parent directory handle first (no user activation needed for reads)
+    let parentHandle;
+    if (parentDirPath === '') {
+        parentHandle = directoryHandle;
+    } else {
+        const node = resolveNode(parentDirPath);
+        if (!node || !node.handle) {
+            alert('Could not locate parent directory.');
+            return;
+        }
+        parentHandle = node.handle;
+    }
+
+    // Show in-page modal and wait for user to confirm or cancel.
+    // Returns the filename string, or null if cancelled.
+    const name = await new Promise((resolve) => {
+        const modal = document.getElementById('new-file-modal');
+        const input = document.getElementById('new-file-input');
+        const confirmBtn = document.getElementById('new-file-confirm');
+        const cancelBtn = document.getElementById('new-file-cancel');
+
+        input.value = 'untitled.md';
+        modal.classList.remove('hidden');
+        input.focus();
+        input.select();
+
+        function cleanup() {
+            modal.classList.add('hidden');
+            confirmBtn.removeEventListener('click', onConfirm);
+            cancelBtn.removeEventListener('click', onCancel);
+            input.removeEventListener('keydown', onKey);
+        }
+
+        function onConfirm() {
+            const val = input.value.trim();
+            cleanup();
+            resolve(val || null);
+        }
+
+        function onCancel() {
+            cleanup();
+            resolve(null);
+        }
+
+        function onKey(e) {
+            if (e.key === 'Enter') onConfirm();
+            if (e.key === 'Escape') onCancel();
+        }
+
+        confirmBtn.addEventListener('click', onConfirm);
+        cancelBtn.addEventListener('click', onCancel);
+        input.addEventListener('keydown', onKey);
+    });
+
+    if (!name) {
+        if (DEBUG) console.log('New file creation cancelled');
+        return;
+    }
+
+    // Validate name
+    if (name.includes('/') || name.includes('\\')) {
+        alert('Invalid filename: cannot contain / or \\.');
+        return;
+    }
+
+    // Check if file already exists
+    try {
+        await parentHandle.getFileHandle(name);
+        const overwrite = window.confirm('A file named "' + name + '" already exists. Overwrite it?');
+        if (!overwrite) return;
+    } catch (e) {
+        if (e.name !== 'NotFoundError') throw e;
+    }
+
+    // Create the file — this must happen after the modal's button click
+    // which is the user activation token.
+    try {
+        const newHandle = await parentHandle.getFileHandle(name, { create: true });
+
+        const writable = await newHandle.createWritable();
+        await writable.write('');
+        await writable.close();
+
+        if (DEBUG) console.log(`Created new file: ${parentDirPath ? parentDirPath + '/' : ''}${name}`);
+
+        await refreshDirectory();
+
+        const newFilePath = parentDirPath ? parentDirPath + '/' + name : name;
+        const element = document.querySelector('.file-item[data-path="' + CSS.escape(newFilePath) + '"]');
+        if (element) {
+            handleFileClick(newHandle, newFilePath, element);
+        }
+    } catch (error) {
+        console.error('Error creating new file:', error);
+        alert('Error creating file: ' + error.message);
+    }
+}
+
+/**
+ * Rename a file or directory
+ * @param {string} filePath - Full path like 'subdir/file.md'
+ * @param {boolean} isDirectory - true if renaming a directory (not supported on Chrome)
+ */
+async function renameEntry(filePath, isDirectory) {
+    const currentName = filePath.split('/').pop();
+    const newName = window.prompt('Rename to:', currentName);
+    
+    if (newName === null || newName === currentName) {
+        if (DEBUG) console.log('Rename cancelled or unchanged');
+        return;
+    }
+    
+    // Validate name
+    if (newName.includes('/') || newName.includes('\\') || newName.trim() === '') {
+        alert('Invalid filename: cannot contain / or \\ and must not be empty.');
+        return;
+    }
+    
+    // Resolve parent directory handle
+    const parentHandle = resolveParentDirHandle(filePath);
+    if (!parentHandle) {
+        alert('Could not locate parent directory.');
+        return;
+    }
+    
+    // For files: rename via File System Access API
+    if (!isDirectory) {
+        try {
+            // Check if new name already exists (file or directory)
+            try {
+                const existing = await parentHandle.getFileHandle(newName);
+                // A file with that name exists
+                const overwrite = window.confirm('A file named "' + newName + '" already exists. Overwrite?');
+                if (!overwrite) return;
+            } catch (fileErr) {
+                if (fileErr.name === 'TypeMismatchError') {
+                    // A directory with that name exists
+                    window.alert('A folder named "' + newName + '" already exists. Choose a different name.');
+                    return;
+                }
+                if (fileErr.name !== 'NotFoundError') throw fileErr;
+                // NotFoundError = safe to create
+            }
+            
+            const oldHandle = resolveNode(filePath);
+            if (!oldHandle || !oldHandle.handle) {
+                alert('Could not find file to rename.');
+                return;
+            }
+            
+            const file = await oldHandle.handle.getFile();
+            const content = await file.text();
+            
+            const newHandle = await parentHandle.getFileHandle(newName, { create: true });
+            const writable = await newHandle.createWritable();
+            await writable.write(content);
+            await writable.close();
+            const newFile = await newHandle.getFile();
+            
+            await parentHandle.removeEntry(currentName);
+            
+            // Update editor instances
+            if (editorInstances.has(filePath)) {
+                const instance = editorInstances.get(filePath);
+                const newFilePath = filePath.substring(0, filePath.length - currentName.length) + newName;
+                
+                // Remove old instance
+                const data = editorInstances.get(filePath);
+                if (data.fileViewContainer) {
+                    data.fileViewContainer.classList.add('hidden');
+                }
+                editorInstances.delete(filePath);
+                
+                // Re-add with new path
+                editorInstances.set(newFilePath, { ...data, fileHandle: newHandle, lastModified: newFile.lastModified });
+                
+                // Update active state
+                if (instance.fileViewContainer) {
+                    instance.fileViewContainer.classList.remove('hidden');
+                    instance.fileViewContainer.dataset.path = newFilePath;
+                }
+                
+                // Update fileTree entries
+                const parts = filePath.split('/');
+                const fileName = parts.pop();
+                const dirPath = parts.join('/');
+                let targetEntries = fileTree.entries;
+                if (dirPath) {
+                    const dirParts = dirPath.split('/');
+                    let current = fileTree;
+                    for (const part of dirParts) {
+                        current = current.entries[part];
+                    }
+                    targetEntries = current.entries;
+                }
+                if (targetEntries && targetEntries[currentName]) {
+                    delete targetEntries[currentName];
+                    targetEntries[newName] = {
+                        name: newName,
+                        type: 'file',
+                        handle: newHandle
+                    };
+                }
+                
+                renderFileTree();
+                restoreActiveFile(newFilePath);
+            } else {
+                renderFileTree();
+            }
+            
+        } catch (error) {
+            console.error('Error renaming file:', error);
+            alert('Error renaming file: ' + error.message);
+        }
+    } else {
+        // For directories: not supported by browser API
+        alert('Directory rename is not supported by the browser File System API. Please rename the folder in your OS file manager and refresh.');
+    }
+}
+
+/**
+ * Delete a file or directory
+ * @param {string} filePath - Full path like 'subdir/file.md' or 'subdir'
+ * @param {boolean} isDirectory - true if deleting a directory
+ */
+async function deleteEntry(filePath, isDirectory) {
+    const name = filePath.split('/').pop();
+    
+    const message = isDirectory 
+        ? 'Delete folder "' + name + '" and all its contents?'
+        : 'Delete "' + name + '"?';
+    
+    const ok = window.confirm(message);
+    if (!ok) {
+        if (DEBUG) console.log('Delete cancelled by user');
+        return;
+    }
+    
+    // Resolve parent directory handle
+    const parentHandle = resolveParentDirHandle(filePath);
+    if (!parentHandle) {
+        alert('Could not locate parent directory.');
+        return;
+    }
+    
+    let deleted = false;
+    try {
+        await parentHandle.removeEntry(name, { recursive: isDirectory });
+        deleted = true;
+    } catch (error) {
+        if (error.name === 'NotFoundError') {
+            // Already gone — treat as success for cleanup purposes
+            deleted = true;
+        } else {
+            console.error('Error deleting entry:', error);
+            alert('Error deleting entry: ' + error.message);
+        }
+    }
+
+    if (deleted) {
+        // Close editor if open
+        if (!isDirectory && editorInstances.has(filePath)) {
+            closeEditorInstance(filePath);
+        } else if (isDirectory) {
+            // Close any editors under this directory
+            const dirsToClose = [];
+            editorInstances.forEach(function(instance, key) {
+                if (key === filePath || key.startsWith(filePath + '/')) {
+                    dirsToClose.push(key);
+                }
+            });
+            dirsToClose.forEach(function(key) {
+                closeEditorInstance(key);
+            });
+        }
+        
+        // Remove from fileTree entries
+        const parts = filePath.split('/');
+        const entryName = parts.pop();
+        const dirPath = parts.join('/');
+        let targetEntries = fileTree.entries;
+        if (dirPath) {
+            const dirParts = dirPath.split('/');
+            let current = fileTree;
+            for (const part of dirParts) {
+                current = current.entries[part];
+            }
+            targetEntries = current.entries;
+        }
+        if (targetEntries && targetEntries[entryName]) {
+            delete targetEntries[entryName];
+        }
+        
+        renderFileTree();
+        updateStatusCountsFromTree();
+    }
+}
+
+/**
+ * Close an editor instance and show welcome screen if no files open
+ * @param {string} filePath - Path of file to close
+ */
+function closeEditorInstance(filePath) {
+    const instance = editorInstances.get(filePath);
+    if (!instance) return;
+    
+    if (instance.fileViewContainer) {
+        instance.fileViewContainer.classList.add('hidden');
+    }
+    editorInstances.delete(filePath);
+    
+    // Check if any visible file-view-container children remain
+    const contentContainer = document.getElementById('content-container');
+    if (contentContainer) {
+        const visibleChildren = Array.from(contentContainer.querySelectorAll('.file-view-container'))
+            .filter(function(el) { return !el.classList.contains('hidden'); });
+        if (visibleChildren.length === 0) {
+            document.getElementById('welcome-screen').classList.remove('hidden');
+            contentContainer.classList.add('hidden');
+        }
+    }
+}
+
+/**
+ * Restore active file state after rename
+ * @param {string} newFilePath - New path of the file
+ */
+function restoreActiveFile(newFilePath) {
+    const element = document.querySelector('.file-item[data-path="' + CSS.escape(newFilePath) + '"]');
+    if (element) {
+        element.classList.add('active-file');
+        element.style.backgroundColor = '';
+        element.style.color = '';
+    }
+}
+
+/**
+ * Update status counts from fileTree
+ */
+function updateStatusCountsFromTree() {
+    let folderCount = 0;
+    let fileCount = 0;
+    
+    function countEntries(entries) {
+        if (!entries) return;
+        for (const [name, item] of Object.entries(entries)) {
+            if (item.type === 'directory') {
+                folderCount++;
+                countEntries(item.entries);
+            } else if (item.type === 'file') {
+                fileCount++;
+            }
+        }
+    }
+    
+    countEntries(fileTree.entries);
+    updateStatusCounts(folderCount, fileCount);
+}
+
+/**
+ * File system operations using File System Access API
+ */
+
+/**
+ * Open the scratchpad editor
+ */
+function openScratchpad() {
+    // Check if scratchpad already exists
+    if (editorInstances.has(SCRATCHPAD_ID)) {
+        // Just show it
+        const instance = editorInstances.get(SCRATCHPAD_ID);
+        document.getElementById('welcome-screen').classList.add('hidden');
+        document.getElementById('content-container').classList.remove('hidden');
+        
+        // Hide all other editors, show scratchpad
+        editorInstances.forEach((data, path) => {
+            if (data.fileViewContainer) {
+                data.fileViewContainer.style.display = path === SCRATCHPAD_ID ? 'flex' : 'none';
+            }
+        });
+        return;
+    }
+    
+    // Hide welcome screen, show content container
+    document.getElementById('welcome-screen').classList.add('hidden');
+    document.getElementById('content-container').classList.remove('hidden');
+    
+    // Initialize editor with no file handle
+    initializeEditor('', true, SCRATCHPAD_ID, 'Scratchpad', null, null);
+    
+    // Mark as scratchpad
+    const instance = editorInstances.get(SCRATCHPAD_ID);
+    if (instance) {
+        instance.isScratchpad = true;
+    }
+    
+    if (DEBUG) console.log('Opened scratchpad');
+}
+
+/**
+ * Save file using Save As dialog (for scratchpads or new saves)
+ * @param {string} content - Content to save
+ * @param {string} suggestedName - Suggested filename
+ * @returns {Promise<FileSystemFileHandle|null>} File handle if saved, null otherwise
+ */
+async function saveFileAs(content, suggestedName = 'untitled.md') {
+    if (hasFileSystemAccess) {
+        try {
+            const fileHandle = await window.showSaveFilePicker({
+                suggestedName: suggestedName,
+                types: [{
+                    description: 'Markdown files',
+                    accept: { 'text/markdown': ['.md', '.markdown'] }
+                }]
+            });
+            
+            const writable = await fileHandle.createWritable();
+            await writable.write(content);
+            await writable.close();
+            
+            if (DEBUG) console.log(`File saved as: ${fileHandle.name}`);
+            return fileHandle;
+        } catch (error) {
+            if (error.name === 'AbortError') {
+                if (DEBUG) console.log('Save cancelled by user');
+                return null;
+            }
+            throw error;
+        }
+    } else {
+        // Fallback: download as blob
+        const blob = new Blob([content], { type: 'text/markdown' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = suggestedName;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        if (DEBUG) console.log(`File downloaded as: ${suggestedName}`);
+        return null;
+    }
+}
+
+/**
+ * Open directory picker and handle selection
+ */
+async function openDirectory() {
+    try {
+        if (!('showDirectoryPicker' in window)) {
+            throw new Error('The File System API is not supported in this browser.');
+        }
+
+        directoryHandle = await window.showDirectoryPicker();
+        if (DEBUG) console.log('Directory selected:', directoryHandle.name);
+
+        updateDirectoryStatus(directoryHandle.name);
+        await readDirectory(directoryHandle);
+
+    } catch (error) {
+        if (error.name === 'AbortError') {
+            if (DEBUG) console.log('User cancelled the directory selection');
+        } else {
+            console.error('Error selecting directory:', error);
+            alert(`Error: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Update UI to show selected directory
+ * @param {string} directoryName - Name of the selected directory
+ */
+function updateDirectoryStatus(directoryName) {
+    const selectDirectoryBtn = document.getElementById('select-directory');
+    if (selectDirectoryBtn) {
+        selectDirectoryBtn.textContent = `Directory: ${directoryName}`;
+    }
+
+    const refreshBtn = document.getElementById('refresh-directory');
+    if (refreshBtn) {
+        refreshBtn.classList.remove('hidden');
+    }
+
+    // Show new file button when directory is selected
+    const newFileRootBtn = document.getElementById('new-file-root');
+    if (newFileRootBtn) {
+        newFileRootBtn.classList.remove('hidden');
+    }
+}
+
+/**
+ * Read directory contents and build tree structure
+ * @param {FileSystemDirectoryHandle} dirHandle - Directory handle
+ * @param {Object} parentNode - Parent node in tree (for recursion)
+ * @returns {Object} Statistics about the directory
+ */
+async function readDirectory(dirHandle, parentNode = null) {
+    if (parentNode === null) {
+        fileTree = {
+            name: dirHandle.name,
+            type: 'directory',
+            handle: dirHandle,
+            entries: {}
+        };
+
+        const fileTreeElement = document.getElementById('file-tree');
+        if (fileTreeElement) {
+            fileTreeElement.innerHTML = '';
+        }
+
+        parentNode = fileTree;
+    }
+
+    try {
+        let stats = { folderCount: 0, fileCount: 0 };
+
+        for await (const entry of dirHandle.values()) {
+            if (entry.kind === 'file' && !entry.name.startsWith('_')) {
+                parentNode.entries[entry.name] = {
+                    name: entry.name,
+                    type: 'file',
+                    handle: entry
+                };
+                stats.fileCount++;
+            } else if (entry.kind === 'directory' && !entry.name.startsWith('_')) {
+                const dirNode = {
+                    name: entry.name,
+                    type: 'directory',
+                    handle: entry,
+                    entries: {}
+                };
+
+                parentNode.entries[entry.name] = dirNode;
+
+                const subStats = await readDirectory(entry, dirNode);
+                stats.folderCount += subStats.folderCount + 1;
+                stats.fileCount += subStats.fileCount;
+            }
+        }
+
+        if (parentNode === fileTree) {
+            renderFileTree();
+            updateStatusCounts(stats.folderCount, stats.fileCount);
+        }
+
+        return stats;
+    } catch (error) {
+        console.error('Error reading directory:', error);
+        return { folderCount: 0, fileCount: 0 };
+    }
+}
+
+/**
+ * Save a file by its path
+ * @param {string} filePath - Path of the file to save
+ * @returns {Promise<boolean>} Whether save was successful
+ */
+async function saveFile(filePath) {
+    if (!filePath && currentFileHandle) {
+        filePath = currentFileHandle.name;
+    } else if (!filePath) {
+        alert('No file is currently open');
+        return false;
+    }
+
+    try {
+        const editorInstance = editorInstances.get(filePath);
+        if (!editorInstance) {
+            throw new Error('No editor instance found for this file');
+        }
+
+        if (!editorInstance.isDirty) {
+            if (DEBUG) console.log(`File ${filePath} is not dirty, skipping save`);
+            return true;
+        }
+
+        const fileHandle = editorInstance.fileHandle;
+        if (!fileHandle) {
+            throw new Error('No file handle available for this file');
+        }
+
+        // Check for external modifications
+        const file = await fileHandle.getFile();
+        const currentLastModified = file.lastModified;
+        const storedLastModified = editorInstance.lastModified;
+
+        if (storedLastModified && currentLastModified !== storedLastModified) {
+            const confirmSave = confirm(
+                'Warning: This file has been modified outside of the application since you opened it. ' +
+                'Saving will overwrite those changes. Do you want to continue?'
+            );
+
+            if (!confirmSave) {
+                if (DEBUG) console.log('Save aborted by user due to external file modifications');
+                return false;
+            }
+        }
+
+        // Get markdown content from editor
+        const markdownContent = editorInstance.editor.getMarkdown();
+        
+        // Get front matter from textarea
+        let frontMatterData = {};
+        if (editorInstance.frontMatterTextarea) {
+            const frontMatterText = editorInstance.frontMatterTextarea.value.trim();
+            if (frontMatterText) {
+                try {
+                    const yamlContent = `---\n${frontMatterText}\n---\n`;
+                    const parsed = parseFrontMatter(yamlContent);
+                    frontMatterData = parsed.data;
+                } catch (error) {
+                    console.error('Error parsing front matter:', error);
+                    throw new Error(`Invalid YAML front matter: ${error.message}`);
+                }
+            }
+        }
+
+        // Apply before save hooks
+        frontMatterData = await applyBeforeSaveHooks(frontMatterData, markdownContent, fileHandle);
+
+        // Combine front matter with markdown
+        const finalContent = frontMatterData && Object.keys(frontMatterData).length > 0
+            ? stringifyFrontMatter(markdownContent, frontMatterData)
+            : markdownContent;
+
+        // Write to file
+        const writable = await fileHandle.createWritable();
+        await writable.write(finalContent);
+        await writable.close();
+
+        // Update state
+        const updatedFile = await fileHandle.getFile();
+        editorInstance.lastModified = updatedFile.lastModified;
+        editorInstance.isDirty = false;
+        updateFileDirtyStatus(filePath, false);
+        updateUnsavedCount();
+
+        if (editorInstance.saveButton) {
+            editorInstance.saveButton.disabled = true;
+        }
+
+        if (DEBUG) console.log(`File ${filePath} saved successfully!`);
+        
+        await applyAfterSaveHooks(frontMatterData, markdownContent, fileHandle);
+        
+        return true;
+    } catch (error) {
+        console.error(`Error saving file ${filePath}:`, error);
+        alert(`Error saving file: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Save all files with unsaved changes
+ * @returns {Promise<{saved: number, failed: number}>}
+ */
+async function saveAllFiles() {
+    let saved = 0;
+    let failed = 0;
+
+    const dirtyFiles = [];
+    editorInstances.forEach((instance, filePath) => {
+        if (instance.isDirty) {
+            dirtyFiles.push(filePath);
+        }
+    });
+
+    if (dirtyFiles.length === 0) {
+        if (DEBUG) console.log('No files with unsaved changes');
+        return { saved, failed };
+    }
+
+    for (const filePath of dirtyFiles) {
+        try {
+            const success = await saveFile(filePath);
+            if (success) {
+                saved++;
+            } else {
+                failed++;
+            }
+        } catch (error) {
+            console.error(`Error saving file ${filePath}:`, error);
+            failed++;
+        }
+    }
+
+    if (failed === 0) {
+        if (DEBUG) console.log(`All ${saved} files saved successfully`);
+    } else {
+        if (DEBUG) console.log(`Saved ${saved} files, ${failed} files failed to save`);
+    }
+
+    return { saved, failed };
+}
+
+/**
+ * Reload file from disk
+ * @param {string} filePath - Path of file to reload
+ * @returns {Promise<boolean>} Whether reload was successful
+ */
+async function reloadFileFromDisk(filePath) {
+    try {
+        const editorInstance = editorInstances.get(filePath);
+        if (!editorInstance) {
+            throw new Error('No editor instance found for this file');
+        }
+
+        if (editorInstance.isDirty) {
+            const confirmReload = confirm(
+                'This file has unsaved changes. Reloading will discard all changes. ' +
+                'Do you want to continue?'
+            );
+            
+            if (!confirmReload) {
+                if (DEBUG) console.log('Reload cancelled by user');
+                return false;
+            }
+        }
+
+        const fileHandle = editorInstance.fileHandle;
+        if (!fileHandle) {
+            throw new Error('No file handle available for this file');
+        }
+
+        const file = await fileHandle.getFile();
+        const fileContent = await file.text();
+        
+        editorInstance.lastModified = file.lastModified;
+
+        if (filePath.endsWith('.md') || filePath.endsWith('.markdown')) {
+            const parsed = parseFrontMatter(fileContent);
+            
+            if (editorInstance.frontMatterTextarea) {
+                const frontMatterYaml = stringifyFrontMatterToTextarea(parsed.data);
+                editorInstance.frontMatterTextarea.value = frontMatterYaml;
+            }
+            
+            let currentScrollTop = 0;
+            try {
+                currentScrollTop = editorInstance.editor.getScrollTop();
+            } catch (error) {
+                if (DEBUG) console.debug('Could not get scroll position:', error);
+            }
+
+            editorInstance.editor.setMarkdown(parsed.content);
+
+            setTimeout(() => {
+                try {
+                    editorInstance.editor.setScrollTop(currentScrollTop);
+                } catch (error) {
+                    if (DEBUG) console.debug('Could not restore scroll position:', error);
+                }
+            }, 100);
+            
+            if (editorInstance.tocContainer && window.updateToc) {
+                try {
+                    window.updateToc(parsed.content, editorInstance.tocContainer, editorInstance.editor, tocMaxDepth);
+                } catch (error) {
+                    console.error('Error updating TOC during reload:', error);
+                }
+            }
+        } else {
+            editorInstance.editor.setMarkdown(fileContent);
+        }
+
+        editorInstance.isDirty = false;
+        updateFileDirtyStatus(filePath, false);
+        updateUnsavedCount();
+
+        if (editorInstance.saveButton) {
+            editorInstance.saveButton.disabled = true;
+        }
+
+        if (DEBUG) console.log(`File ${filePath} reloaded successfully from disk!`);
+        return true;
+    } catch (error) {
+        console.error(`Error reloading file ${filePath}:`, error);
+        alert(`Error reloading file: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Before save hook - apply modifications before saving
+ */
+async function applyBeforeSaveHooks(frontMatter, markdownContent, fileHandle) {
+    frontMatter.lastModified = new Date().toISOString();
+    
+    if (!frontMatter.title) {
+        const firstHeading = markdownContent.match(/^#\s+(.+)$/m);
+        if (firstHeading) {
+            frontMatter.title = firstHeading[1];
+        }
+    }
+    
+    const customTags = (markdownContent.match(/<(deliverable|meeting|report|trkno)>/g) || []).length;
+    if (customTags > 0) {
+        frontMatter.customTagCount = customTags;
+    }
+    
+    return frontMatter;
+}
+
+/**
+ * After save hook - perform actions after saving
+ */
+async function applyAfterSaveHooks(frontMatter, markdownContent, fileHandle) {
+    const tags = ['deliverable', 'meeting', 'report', 'trkno'];
+    const preservedTags = tags.filter(tag => markdownContent.includes(`<${tag}>`));
+    if (preservedTags.length > 0) {
+        if (DEBUG) console.log(`Preserved custom tags: ${preservedTags.join(', ')}`);
+    }
+}
+
+/**
+ * Refresh directory from disk without losing unsaved work
+ */
+async function refreshDirectory() {
+    if (!directoryHandle) {
+        if (DEBUG) console.log('No directory selected, cannot refresh');
+        return;
+    }
+
+    // Get active file path from DOM before refresh
+    const activeFileEl = document.querySelector('.file-item.active-file');
+    const activeFilePath = activeFileEl ? activeFileEl.dataset.path : null;
+
+    // Get dirty files from editorInstances
+    const dirtyFiles = new Set();
+    editorInstances.forEach((instance, filePath) => {
+        if (instance.isDirty) {
+            dirtyFiles.add(filePath);
+        }
+    });
+
+    // Re-read directory (calls renderFileTree at the end)
+    await readDirectory(directoryHandle);
+
+    // Restore active file state
+    if (activeFilePath) {
+        const activeElement = document.querySelector(`.file-item[data-path="${activeFilePath}"]`);
+        if (activeElement) {
+            activeElement.classList.add('active-file');
+        }
+    }
+
+    // Restore dirty indicators
+    dirtyFiles.forEach(filePath => {
+        updateFileDirtyStatus(filePath, true);
+    });
+}
+
+/**
+ * Start monitoring files for external changes
+ */
+function startFileChangeMonitoring() {
+    setInterval(async () => {
+        for (const [filePath, editorInstance] of editorInstances) {
+            try {
+                const fileHandle = editorInstance.fileHandle;
+                if (!fileHandle) continue;
+
+                const file = await fileHandle.getFile();
+                const currentLastModified = file.lastModified;
+                const storedLastModified = editorInstance.lastModified;
+
+                if (storedLastModified && currentLastModified !== storedLastModified) {
+                    if (DEBUG) console.log(`File ${filePath} changed externally`);
+                    
+                    const action = confirm(
+                        `File "${filePath}" has been modified by another application.\n\n` +
+                        'Click OK to reload from disk (discards unsaved changes)\n' +
+                        'Click Cancel to keep current version'
+                    );
+
+                    if (action) {
+                        await reloadFileFromDisk(filePath);
+                    } else {
+                        editorInstance.lastModified = currentLastModified;
+                    }
+                }
+            } catch (error) {
+                if (DEBUG) console.debug(`Error checking file ${filePath}:`, error.message);
+            }
+        }
+    }, 3000);
+}
+
+/**
+ * File tree rendering and navigation
+ */
+
+// Cache for lazily loaded CDN libraries
+const loadedLibraries = new Map();
+
+/**
+ * Lazily load a script from CDN. Returns a promise that resolves when loaded.
+ * Caches the promise so subsequent calls return immediately.
+ */
+function loadLibrary(url) {
+    if (loadedLibraries.has(url)) return loadedLibraries.get(url);
+    const promise = new Promise((resolve, reject) => {
+        const script = document.createElement('script');
+        script.src = url;
+        script.onload = resolve;
+        script.onerror = () => reject(new Error(`Failed to load library: ${url}`));
+        document.head.appendChild(script);
+    });
+    loadedLibraries.set(url, promise);
+    return promise;
+}
+
+/**
+ * Render the file tree in the UI
+ */
+/**
+ * Create action buttons for file/directory items
+ * @param {string} filePath - Full path of the file/dir
+ * @param {string} type - 'file' or 'directory'
+ */
+function createActionButtons(filePath, type) {
+    const actionsDiv = document.createElement('div');
+    actionsDiv.className = 'tree-actions';
+
+    if (type === 'directory') {
+        // Directory: + (new file) + ✕ (delete)
+        const newFileBtn = document.createElement('button');
+        newFileBtn.className = 'tree-btn';
+        newFileBtn.setAttribute('title', 'New file');
+        newFileBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 5v14M5 12h14"/></svg>';
+        newFileBtn.onclick = (e) => {
+            e.stopPropagation();
+            createNewFile(filePath);
+        };
+
+        const deleteBtn = document.createElement('button');
+        deleteBtn.className = 'tree-btn tree-btn--danger';
+        deleteBtn.setAttribute('title', 'Delete');
+        deleteBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>';
+        deleteBtn.onclick = (e) => {
+            e.stopPropagation();
+            deleteEntry(filePath, true);
+        };
+
+        actionsDiv.appendChild(newFileBtn);
+        actionsDiv.appendChild(deleteBtn);
+    } else {
+        // File: ✎ (rename) + ✕ (delete)
+        const renameBtn = document.createElement('button');
+        renameBtn.className = 'tree-btn';
+        renameBtn.setAttribute('title', 'Rename');
+        renameBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z"/></svg>';
+        renameBtn.onclick = (e) => {
+            e.stopPropagation();
+            renameEntry(filePath, false);
+        };
+
+        const deleteBtn = document.createElement('button');
+        deleteBtn.className = 'tree-btn tree-btn--danger';
+        deleteBtn.setAttribute('title', 'Delete');
+        deleteBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 6h18M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>';
+        deleteBtn.onclick = (e) => {
+            e.stopPropagation();
+            deleteEntry(filePath, false);
+        };
+
+        actionsDiv.appendChild(renameBtn);
+        actionsDiv.appendChild(deleteBtn);
+    }
+
+    return actionsDiv;
+}
+
+function renderFileTree() {
+    const fileTreeElement = document.getElementById('file-tree');
+    if (!fileTreeElement) return;
+
+    fileTreeElement.innerHTML = '';
+    
+    // Always show scratchpad at top
+    const scratchpadElement = document.createElement('div');
+    scratchpadElement.className = 'file-item px-2 py-1 cursor-pointer rounded whitespace-nowrap overflow-hidden hover:bg-gray-100 dark:hover:bg-gray-800 border-b border-gray-200 dark:border-gray-700 mb-2';
+    scratchpadElement.dataset.type = 'file';
+    scratchpadElement.dataset.path = SCRATCHPAD_ID;
+    scratchpadElement.dataset.name = 'Scratchpad';
+    scratchpadElement.innerHTML = '<div class="filename-main">📝 Scratchpad</div><div class="filename-secondary">Quick editing (no file)</div>';
+    
+    scratchpadElement.addEventListener('click', (event) => {
+        event.stopPropagation();
+        openScratchpad();
+        
+        // Update active state
+        document.querySelectorAll('.file-item').forEach(el => el.classList.remove('active-file'));
+        scratchpadElement.classList.add('active-file');
+    });
+    
+    fileTreeElement.appendChild(scratchpadElement);
+
+    function createFileTreeHTML(directory, parentElement, path = '') {
+        if (!directory || !directory.entries) return;
+
+        // Sort entries: files first, then directories, alphabetically
+        const sortedEntries = Object.entries(directory.entries).sort((a, b) => {
+            const [nameA, itemA] = a;
+            const [nameB, itemB] = b;
+
+            if (itemA.type !== itemB.type) {
+                return itemA.type === 'file' ? -1 : 1;
+            }
+
+            return nameA.localeCompare(nameB);
+        });
+
+        for (const [name, item] of sortedEntries) {
+            if (item.type === 'directory') {
+                const dirElement = document.createElement('div');
+                dirElement.className = 'directory-item tree-row px-2 py-1 cursor-pointer rounded hover:bg-gray-100 dark:hover:bg-gray-800 collapsed';
+                dirElement.dataset.type = 'directory';
+                const currentPath = path ? `${path}/${name}` : name;
+                dirElement.dataset.path = currentPath;
+
+                const dirIcon = document.createElement('span');
+                dirIcon.className = 'dir-icon mr-1';
+                dirIcon.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="9 18 15 12 9 6"></polyline></svg>';
+
+                const dirName = document.createElement('span');
+                dirName.textContent = `📁 ${name}`;
+
+                const dirLabel = document.createElement('span');
+                dirLabel.className = 'tree-row__label';
+                dirLabel.appendChild(dirIcon);
+                dirLabel.appendChild(dirName);
+
+                const dirActions = createActionButtons(currentPath, 'directory');
+
+                dirElement.appendChild(dirLabel);
+                dirElement.appendChild(dirActions);
+                parentElement.appendChild(dirElement);
+
+                const contentsElement = document.createElement('div');
+                contentsElement.className = 'directory-contents ml-4';
+                contentsElement.style.display = 'none';
+                parentElement.appendChild(contentsElement);
+
+                dirElement.addEventListener('click', (event) => {
+                    event.stopPropagation();
+                    dirElement.classList.toggle('collapsed');
+
+                    const contents = dirElement.nextElementSibling;
+                    if (contents && contents.classList.contains('directory-contents')) {
+                        contents.style.display = dirElement.classList.contains('collapsed') ? 'none' : 'block';
+                    }
+                });
+
+                createFileTreeHTML(item, contentsElement, currentPath);
+            } else if (item.type === 'file') {
+                const fileElement = document.createElement('div');
+                fileElement.className = 'file-item tree-row px-2 py-1 cursor-pointer rounded hover:bg-gray-100 dark:hover:bg-gray-800';
+                fileElement.dataset.type = 'file';
+                const filePath = path ? `${path}/${name}` : name;
+                fileElement.dataset.path = filePath;
+                fileElement.dataset.name = name;
+
+                const fileIcon = getFileTypeIcon(name);
+
+                let fileNameDisplay;
+                const parsed = zddc.parseFilename(name);
+                if (parsed && parsed.valid) {
+                    // Strip extension from title for display (it's already in the icon)
+                    const titleDisplay = parsed.title;
+                    const metaDisplay = `${parsed.trackingNumber}_${parsed.revision} (${parsed.status})`;
+                    fileNameDisplay = `<div class="filename-main">${fileIcon} ${titleDisplay}</div><div class="filename-secondary">${metaDisplay}</div>`;
+                } else if (name.includes(' - ')) {
+                    // Fallback: simple split for files with ' - ' but not fully ZDDC-compliant
+                    const dashIdx = name.lastIndexOf(' - ');
+                    const secondary = name.substring(0, dashIdx);
+                    const primary = name.substring(dashIdx + 3).replace(/\.[^.]+$/, '');
+                    fileNameDisplay = `<div class="filename-main">${fileIcon} ${primary}</div><div class="filename-secondary">${secondary}</div>`;
+                } else {
+                    fileNameDisplay = `<span>${fileIcon} ${name}</span>`;
+                }
+
+                const fileLabel = document.createElement('span');
+                fileLabel.className = 'tree-row__label';
+                fileLabel.innerHTML = fileNameDisplay;
+
+                const fileActions = createActionButtons(filePath, 'file');
+
+                fileElement.innerHTML = '';
+                fileElement.appendChild(fileLabel);
+                fileElement.appendChild(fileActions);
+
+                fileElement.addEventListener('click', (event) => {
+                    event.stopPropagation();
+                    handleFileClick(item.handle, filePath, fileElement);
+                });
+
+                parentElement.appendChild(fileElement);
+            }
+        }
+    }
+
+    createFileTreeHTML(fileTree, fileTreeElement);
+}
+
+/**
+ * Handle click on a file in the file tree
+ * @param {FileSystemFileHandle} fileHandle - The file handle
+ * @param {string} filePath - Path of the file
+ * @param {HTMLElement} fileElement - The clicked element
+ */
+async function handleFileClick(fileHandle, filePath, fileElement) {
+    try {
+        currentFileHandle = fileHandle;
+
+        // Remove active class from all file items
+        const allFileItems = document.querySelectorAll('.file-item');
+        allFileItems.forEach(item => {
+            item.classList.remove('active-file');
+            item.style.backgroundColor = '';
+            item.style.color = '';
+        });
+
+        // Add active class to clicked file
+        fileElement.classList.add('active-file');
+        fileElement.style.backgroundColor = '#3b82f6';
+        fileElement.style.color = 'white';
+
+        await displayFileContent(fileHandle, filePath);
+
+    } catch (error) {
+        console.error('Error handling file click:', error);
+        alert(`Error opening file: ${error.message}`);
+    }
+}
+
+/**
+ * Display file content in main area
+ * @param {FileSystemFileHandle} fileHandle - File handle
+ * @param {string} filePath - Path of the file
+ */
+async function displayFileContent(fileHandle, filePath) {
+    try {
+        currentFileHandle = fileHandle;
+
+        const file = await fileHandle.getFile();
+        const fileName = file.name;
+        const lastModified = file.lastModified;
+
+        document.getElementById('welcome-screen').classList.add('hidden');
+        document.getElementById('content-container').classList.remove('hidden');
+
+        const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg'];
+        const isImage = imageExtensions.some(ext => fileName.toLowerCase().endsWith(ext));
+
+        const isHtml = fileName.toLowerCase().endsWith('.html') || fileName.toLowerCase().endsWith('.htm');
+        const isDocx = fileName.toLowerCase().endsWith('.docx');
+        const isXlsx = fileName.toLowerCase().endsWith('.xlsx') || fileName.toLowerCase().endsWith('.xls');
+        const isPdf = fileName.toLowerCase().endsWith('.pdf');
+
+        if (isImage) {
+            displayImagePreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isHtml) {
+            displayHtmlPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isDocx) {
+            displayDocxPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isXlsx) {
+            displayXlsxPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else if (isPdf) {
+            displayPdfPreview(file, filePath, fileName, fileHandle, lastModified);
+        } else {
+            const content = await file.text();
+
+            if (fileName.toLowerCase().endsWith('.md')) {
+                initializeEditor(content, true, filePath, fileName, fileHandle, lastModified);
+            } else {
+                initializeEditor(content, false, filePath, fileName, fileHandle, lastModified);
+            }
+        }
+    } catch (error) {
+        console.error('Error displaying file content:', error);
+        alert(`Error opening file: ${error.message}`);
+    }
+}
+
+/**
+ * Display image preview
+ */
+async function displayImagePreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const imageContainer = document.createElement('div');
+    imageContainer.className = 'image-preview-container flex-1 overflow-auto p-4';
+
+    const imageElement = document.createElement('img');
+    imageElement.className = 'image-preview';
+    imageElement.alt = fileName;
+
+    const objectUrl = URL.createObjectURL(file);
+    imageElement.src = objectUrl;
+
+    imageContainer.appendChild(imageElement);
+    fileViewContainer.appendChild(imageContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false,
+        objectUrl: objectUrl
+    };
+
+    editorInstances.set(filePath, instanceData);
+}
+
+/**
+ * Display HTML preview in sandboxed iframe
+ */
+async function displayHtmlPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const htmlContent = await file.text();
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const htmlContainer = document.createElement('div');
+    htmlContainer.className = 'html-preview-container flex-1 overflow-hidden';
+
+    const iframe = document.createElement('iframe');
+    iframe.className = 'html-preview-iframe w-full h-full border-0';
+
+    iframe.setAttribute('sandbox', 'allow-same-origin allow-scripts allow-forms allow-popups allow-modals');
+    iframe.setAttribute('loading', 'lazy');
+
+    iframe.srcdoc = htmlContent;
+
+    htmlContainer.appendChild(iframe);
+    fileViewContainer.appendChild(htmlContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false,
+        iframe: iframe
+    };
+
+    editorInstances.set(filePath, instanceData);
+
+    iframe.addEventListener('load', () => {
+        try {
+            const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
+            if (iframeDoc) {
+                iframeDoc.addEventListener('click', function (e) {
+                    const link = e.target.closest('a');
+                    if (link && link.getAttribute('href')) {
+                        const href = link.getAttribute('href');
+                        if (href.startsWith('#')) {
+                            e.preventDefault();
+                            const targetId = href.substring(1);
+                            const targetElement = iframeDoc.getElementById(targetId);
+                            if (targetElement) {
+                                targetElement.scrollIntoView({ behavior: 'smooth' });
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (error) {
+            if (DEBUG) console.log('Cannot access iframe content for navigation handling:', error);
+        }
+    });
+}
+
+/**
+ * Display DOCX preview in main content area
+ */
+async function displayDocxPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const docxContainer = document.createElement('div');
+    docxContainer.className = 'flex-1 overflow-auto p-4';
+    docxContainer.innerHTML = '<div style="text-align:center;padding:2rem;color:#666;">Loading preview...</div>';
+    fileViewContainer.appendChild(docxContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false
+    };
+    editorInstances.set(filePath, instanceData);
+
+    try {
+        await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+        await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+
+        const arrayBuffer = await file.arrayBuffer();
+        docxContainer.innerHTML = '';
+        await window.docx.renderAsync(arrayBuffer, docxContainer);
+    } catch (err) {
+        console.error('Error rendering DOCX:', err);
+        docxContainer.innerHTML = `<div style="text-align:center;padding:2rem;color:#c00;">Error rendering DOCX: ${err.message}</div>`;
+    }
+}
+
+/**
+ * Display XLSX/XLS preview in main content area
+ */
+async function displayXlsxPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    const xlsxContainer = document.createElement('div');
+    xlsxContainer.className = 'flex-1 overflow-auto';
+    xlsxContainer.innerHTML = '<div style="text-align:center;padding:2rem;color:#666;">Loading preview...</div>';
+    fileViewContainer.appendChild(xlsxContainer);
+
+    contentContainer.appendChild(fileViewContainer);
+
+    const instanceData = {
+        fileViewContainer: fileViewContainer,
+        fileHandle: fileHandle,
+        lastModified: lastModified,
+        isDirty: false
+    };
+    editorInstances.set(filePath, instanceData);
+
+    try {
+        await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+
+        const arrayBuffer = await file.arrayBuffer();
+        const workbook = XLSX.read(arrayBuffer, { type: 'array' });
+
+        xlsxContainer.innerHTML = '';
+
+        if (workbook.SheetNames.length > 1) {
+            const tabs = document.createElement('div');
+            tabs.style.cssText = 'display:flex;gap:0;border-bottom:1px solid #ddd;background:#f5f5f5;';
+            const tableArea = document.createElement('div');
+            tableArea.className = 'flex-1 overflow-auto';
+
+            workbook.SheetNames.forEach((name, i) => {
+                const tab = document.createElement('button');
+                tab.textContent = name;
+                tab.style.cssText = 'padding:0.4rem 1rem;cursor:pointer;border:1px solid transparent;border-bottom:none;font-size:0.85rem;background:transparent;';
+                if (i === 0) tab.style.cssText += 'background:white;border-color:#ddd;border-bottom-color:white;margin-bottom:-1px;font-weight:500;';
+                tab.onclick = () => {
+                    tabs.querySelectorAll('button').forEach(t => { t.style.background = 'transparent'; t.style.borderColor = 'transparent'; t.style.fontWeight = 'normal'; });
+                    tab.style.cssText = 'padding:0.4rem 1rem;cursor:pointer;border:1px solid #ddd;border-bottom-color:white;font-size:0.85rem;background:white;margin-bottom:-1px;font-weight:500;';
+                    renderXlsxSheet(workbook, name, tableArea);
+                };
+                tabs.appendChild(tab);
+            });
+
+            xlsxContainer.appendChild(tabs);
+            xlsxContainer.appendChild(tableArea);
+            renderXlsxSheet(workbook, workbook.SheetNames[0], tableArea);
+        } else {
+            renderXlsxSheet(workbook, workbook.SheetNames[0], xlsxContainer);
+        }
+    } catch (err) {
+        console.error('Error rendering XLSX:', err);
+        xlsxContainer.innerHTML = `<div style="text-align:center;padding:2rem;color:#c00;">Error rendering spreadsheet: ${err.message}</div>`;
+    }
+}
+
+/**
+ * Render a single XLSX sheet as an HTML table
+ */
+function renderXlsxSheet(workbook, sheetName, container) {
+    const sheet = workbook.Sheets[sheetName];
+    const html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+    container.innerHTML = html;
+    const table = container.querySelector('table');
+    if (table) {
+        table.style.cssText = 'border-collapse:collapse;width:100%;font-size:0.85rem;';
+        table.querySelectorAll('th,td').forEach(cell => {
+            cell.style.cssText = 'border:1px solid #ddd;padding:0.35rem 0.5rem;text-align:left;white-space:nowrap;';
+        });
+        table.querySelectorAll('th').forEach(th => {
+            th.style.background = '#f0f0f0';
+            th.style.fontWeight = '600';
+        });
+    }
+}
+
+/**
+ * Display PDF preview using browser's built-in PDF viewer
+ */
+async function displayPdfPreview(file, filePath, fileName, fileHandle, lastModified) {
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) return;
+
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return;
+    }
+
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName;
+    fileHeader.appendChild(fileTitle);
+    fileViewContainer.appendChild(fileHeader);
+
+    const pdfContainer = document.createElement('div');
+    pdfContainer.className = 'flex-1 overflow-hidden';
+
+    const objectUrl = URL.createObjectURL(file);
+
+    const iframe = document.createElement('iframe');
+    iframe.className = 'w-full h-full border-0';
+    iframe.src = objectUrl;
+    iframe.setAttribute('title', fileName);
+
+    pdfContainer.appendChild(iframe);
+    fileViewContainer.appendChild(pdfContainer);
+    contentContainer.appendChild(fileViewContainer);
+
+    editorInstances.set(filePath, {
+        fileViewContainer,
+        fileHandle,
+        lastModified,
+        isDirty: false,
+        objectUrl
+    });
+}
+
+/**
+ * Update status bar counts
+ */
+function updateStatusCounts(folderCount, fileCount) {
+    const folderCountElement = document.getElementById('folder-count');
+    const fileCountElement = document.getElementById('file-count');
+
+    if (folderCountElement) {
+        folderCountElement.textContent = `${folderCount} folder${folderCount !== 1 ? 's' : ''}`;
+    }
+
+    if (fileCountElement) {
+        fileCountElement.textContent = `${fileCount} file${fileCount !== 1 ? 's' : ''}`;
+    }
+
+    updateUnsavedCount();
+}
+
+/**
+ * Update unsaved count in status bar
+ */
+function updateUnsavedCount() {
+    const unsavedCountElement = document.getElementById('unsaved-count');
+    if (!unsavedCountElement) return;
+
+    let dirtyCount = 0;
+    editorInstances.forEach(instance => {
+        if (instance.isDirty) {
+            dirtyCount++;
+        }
+    });
+
+    unsavedCountElement.textContent = `${dirtyCount} unsaved`;
+
+    if (dirtyCount > 0) {
+        unsavedCountElement.classList.add('text-amber-500', 'font-medium');
+    } else {
+        unsavedCountElement.classList.remove('text-amber-500', 'font-medium');
+    }
+}
+
+/**
+ * Update file dirty status indicator in tree
+ */
+function updateFileDirtyStatus(filePath, isDirty) {
+    const fileElement = document.querySelector(`.file-item[data-path="${filePath}"]`);
+    if (!fileElement) return;
+
+    if (isDirty) {
+        if (!fileElement.querySelector('.dirty-indicator')) {
+            const indicator = document.createElement('span');
+            indicator.className = 'dirty-indicator ml-1 text-amber-500 font-bold';
+            indicator.textContent = '●';
+            fileElement.appendChild(indicator);
+        }
+        fileElement.classList.add('is-dirty');
+    } else {
+        const indicator = fileElement.querySelector('.dirty-indicator');
+        if (indicator) {
+            fileElement.removeChild(indicator);
+        }
+        fileElement.classList.remove('is-dirty');
+    }
+}
+
+/**
+ * Toast UI Editor initialization and management
+ */
+
+/**
+ * Initialize or update the Toast UI Editor for a file
+ * @param {string} content - Content to display
+ * @param {boolean} isMarkdown - Whether content is markdown
+ * @param {string} filePath - Path of the file
+ * @param {string} fileName - Name of the file
+ * @param {FileSystemFileHandle} fileHandle - File handle for saving
+ * @param {number} lastModified - Timestamp of last modification
+ */
+function initializeEditor(content, isMarkdown = true, filePath = '', fileName = '', fileHandle = null, lastModified = null) {
+    // Parse front matter
+    let frontMatterData = {};
+    let markdownBody = content;
+    
+    if (isMarkdown && content) {
+        try {
+            const parsed = parseFrontMatter(content);
+            frontMatterData = parsed.data;
+            markdownBody = parsed.content;
+        } catch (error) {
+            console.error('Failed to parse front matter:', error);
+        }
+    }
+    
+    const contentContainer = document.getElementById('content-container');
+    if (!contentContainer) {
+        alert('Error: content-container element not found!');
+        return;
+    }
+
+    // Hide all file view containers
+    document.querySelectorAll('.file-view-container').forEach(container => {
+        container.style.display = 'none';
+    });
+
+    // Check if file already has an instance
+    if (editorInstances.has(filePath)) {
+        const existingInstance = editorInstances.get(filePath);
+        if (existingInstance.fileViewContainer) {
+            existingInstance.fileViewContainer.style.display = 'flex';
+        }
+        return existingInstance.editor;
+    }
+
+    // Create file view container
+    const fileViewContainer = document.createElement('div');
+    fileViewContainer.className = 'file-view-container flex flex-col h-full';
+
+    // Create file header
+    const fileHeader = document.createElement('div');
+    fileHeader.className = 'file-header flex justify-between items-center px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+    const fileTitle = document.createElement('span');
+    fileTitle.textContent = fileName || 'No file selected';
+    fileHeader.appendChild(fileTitle);
+
+    // Button container for alignment
+    const buttonContainer = document.createElement('div');
+    buttonContainer.className = 'flex gap-2';
+
+    // Determine if this is a scratchpad (no file handle)
+    const isScratchpad = !fileHandle;
+
+    // Save button (or Save As for scratchpads)
+    const saveButton = document.createElement('button');
+    saveButton.className = 'btn btn-primary btn-sm';
+    saveButton.textContent = isScratchpad ? 'Save As...' : 'Save File';
+    saveButton.disabled = !isScratchpad; // Scratchpads can always save
+    buttonContainer.appendChild(saveButton);
+
+    // Reload button (only for files, not scratchpads)
+    let reloadButton = null;
+    if (!isScratchpad) {
+        reloadButton = document.createElement('button');
+        reloadButton.className = 'btn btn-secondary btn-sm';
+        reloadButton.textContent = 'Reload from Disk';
+        reloadButton.title = 'Reload file from disk (discards unsaved changes)';
+        buttonContainer.appendChild(reloadButton);
+    }
+
+    fileHeader.appendChild(buttonContainer);
+
+    fileViewContainer.appendChild(fileHeader);
+
+    // Content area
+    const contentArea = document.createElement('div');
+    contentArea.className = 'flex flex-col flex-1 overflow-hidden';
+    
+    // Editor area with TOC
+    const editorArea = document.createElement('div');
+    editorArea.className = 'flex flex-row flex-1 overflow-hidden';
+
+    // TOC pane (markdown only)
+    let tocContainer = null;
+    let frontMatterTextarea = null;
+    if (isMarkdown) {
+        const tocPane = document.createElement('div');
+        tocPane.className = 'toc-pane bg-white dark:bg-gray-900 border-r border-gray-200 dark:border-gray-700';
+        tocPane.style.width = '325px';
+        tocPane.style.minWidth = '150px';
+
+        // Front matter nav bar (collapsible)
+        const frontMatterNav = document.createElement('div');
+        frontMatterNav.className = 'front-matter-nav border-b border-gray-200 dark:border-gray-700';
+        
+        const frontMatterHeader = document.createElement('div');
+        frontMatterHeader.className = 'front-matter-header px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700 cursor-pointer flex items-center gap-2';
+        
+        const toggleIcon = document.createElement('span');
+        toggleIcon.textContent = '▼';
+        toggleIcon.className = 'toggle-icon text-sm';
+        frontMatterHeader.appendChild(toggleIcon);
+        
+        const headerText = document.createElement('span');
+        headerText.textContent = 'YAML Front Matter';
+        frontMatterHeader.appendChild(headerText);
+        
+        frontMatterNav.appendChild(frontMatterHeader);
+        
+        frontMatterTextarea = document.createElement('textarea');
+        frontMatterTextarea.className = 'front-matter-textarea w-full px-4 py-2 text-sm focus:outline-none resize-none overflow-x-auto';
+        frontMatterTextarea.placeholder = 'title: Document Title\ndate: 2024-01-01\ntags: [example]';
+        
+        // Set front matter content
+        if (frontMatterData && Object.keys(frontMatterData).length > 0) {
+            try {
+                let yamlText = '';
+                for (const [key, value] of Object.entries(frontMatterData)) {
+                    if (Array.isArray(value)) {
+                        yamlText += `${key}: [${value.map(v => `"${v}"`).join(', ')}]\n`;
+                    } else {
+                        yamlText += `${key}: ${value}\n`;
+                    }
+                }
+                frontMatterTextarea.value = yamlText.trim();
+            } catch (error) {
+                console.warn('Failed to stringify front matter:', error);
+                frontMatterTextarea.value = '';
+            }
+        }
+        
+        frontMatterNav.appendChild(frontMatterTextarea);
+        tocPane.appendChild(frontMatterNav);
+
+        const tocHeader = document.createElement('div');
+        tocHeader.className = 'toc-header px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 font-medium border-b border-gray-200 dark:border-gray-700';
+
+        const tocTitle = document.createElement('span');
+        tocTitle.textContent = 'Table of Contents';
+        tocHeader.appendChild(tocTitle);
+
+        const tocDepthSelector = document.createElement('select');
+        tocDepthSelector.className = 'toc-depth-selector';
+        tocDepthSelector.innerHTML = `
+            <option value="6">All Levels</option>
+            <option value="1">H1 Only</option>
+            <option value="2">H1-H2</option>
+            <option value="3" selected>H1-H3</option>
+            <option value="4">H1-H4</option>
+            <option value="5">H1-H5</option>
+        `;
+        tocHeader.appendChild(tocDepthSelector);
+
+        tocPane.appendChild(tocHeader);
+
+        tocContainer = document.createElement('div');
+        tocContainer.className = 'toc-container toc-content p-4 h-full overflow-auto';
+        tocPane.appendChild(tocContainer);
+        
+        // Set up TOC container overflow when front matter is toggled
+        let fmIsCollapsed = false;
+        frontMatterHeader.addEventListener('click', () => {
+            fmIsCollapsed = !fmIsCollapsed;
+            frontMatterNav.classList.toggle('collapsed', fmIsCollapsed);
+            toggleIcon.textContent = fmIsCollapsed ? '▶' : '▼';
+        });
+        
+        // Auto-size textarea: no vertical scroll, horizontal scroll for long lines
+        frontMatterTextarea.style.overflowY = 'hidden';
+        frontMatterTextarea.style.overflowX = 'auto';
+        const autoResizeFm = () => {
+            frontMatterTextarea.style.height = 'auto';
+            frontMatterTextarea.style.height = frontMatterTextarea.scrollHeight + 'px';
+        };
+        frontMatterTextarea.addEventListener('input', autoResizeFm);
+        // Defer initial resize until element is in the DOM and has layout
+        requestAnimationFrame(() => requestAnimationFrame(autoResizeFm));
+
+        editorArea.appendChild(tocPane);
+
+        // TOC resizer
+        const tocResizer = document.createElement('div');
+        tocResizer.className = 'pane-resizer bg-gray-200 dark:bg-gray-700 transition-colors relative z-10 w-1 cursor-col-resize hover:bg-blue-500';
+        tocResizer.setAttribute('data-resizer-for', 'toc-pane');
+        contentArea.appendChild(tocResizer);
+
+        makeResizable(tocResizer, tocPane);
+
+        // TOC depth selector event
+        tocDepthSelector.addEventListener('change', function () {
+            const depth = parseInt(this.value);
+            if (window.updateToc && editorInstance) {
+                const currentContent = editorInstance.getMarkdown();
+                window.updateToc(currentContent, tocContainer, editorInstance, depth);
+            }
+        });
+    }
+
+    // Editor container
+    const editorContainer = document.createElement('div');
+    editorContainer.className = 'editor-instance flex-1 overflow-hidden';
+    editorArea.appendChild(editorContainer);
+    
+    contentArea.appendChild(editorArea);
+    fileViewContainer.appendChild(contentArea);
+    contentContainer.appendChild(fileViewContainer);
+
+    // Check Toast UI availability
+    if (typeof toastui === 'undefined') {
+        alert('Error: Toast UI library not loaded!');
+        editorContainer.innerHTML = '<div style="padding: 20px; background: #ffeeee; color: red;">Error: Toast UI library not loaded!</div>';
+        return;
+    }
+
+    let editorInstance;
+
+    try {
+        // Initialize Toast UI Editor
+        const editor = new toastui.Editor({
+            el: editorContainer,
+            height: '100%',
+            initialEditType: 'markdown',
+            previewStyle: 'vertical',
+            initialValue: markdownBody,
+            toolbarItems: [
+                ['heading', 'bold', 'italic', 'strike'],
+                ['hr', 'quote'],
+                ['ul', 'ol', 'task', 'indent', 'outdent'],
+                ['table', 'image', 'link'],
+                ['code', 'codeblock']
+            ]
+        });
+
+        editorInstance = editor;
+        
+        if (!isMarkdown) {
+            editorInstance.changeMode('wysiwyg');
+        }
+
+        // Generate initial TOC
+        if (isMarkdown && window.updateToc && tocContainer) {
+            try {
+                window.updateToc(markdownBody, tocContainer, editorInstance, tocMaxDepth);
+            } catch (error) {
+                console.error('Error generating TOC:', error);
+            }
+
+            const debouncedUpdateToc = debounce(() => {
+                const currentContent = editorInstance.getMarkdown();
+                window.updateToc(currentContent, tocContainer, editorInstance, tocMaxDepth);
+            }, 300);
+
+            editorInstance.on('change', () => {
+                debouncedUpdateToc();
+
+                const instanceData = editorInstances.get(filePath);
+                if (instanceData && !instanceData.isDirty) {
+                    instanceData.isDirty = true;
+                    updateFileDirtyStatus(filePath, true);
+                    updateUnsavedCount();
+                }
+                saveButton.disabled = false;
+            });
+
+            // Scroll listener for TOC highlighting
+            const mdPreview = editorInstance.getEditorElements().mdPreview;
+            if (mdPreview) {
+                let activeTimeout = null;
+                let lastHeader = null;
+
+                const updateActiveHeader = () => {
+                    // Re-query live headings (TOC may have been regenerated)
+                    const liveHeaders = mdPreview.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    const previewRect = mdPreview.getBoundingClientRect();
+                    // Use a threshold slightly below the top so a header touching
+                    // the top edge counts as "active"
+                    const threshold = previewRect.top + 4;
+                    let activeHeader = null;
+                    for (const header of liveHeaders) {
+                        if (header.getBoundingClientRect().top <= threshold) {
+                            activeHeader = header.textContent.trim();
+                        } else {
+                            break;
+                        }
+                    }
+                    if (activeHeader !== lastHeader) {
+                        lastHeader = activeHeader;
+                        setActiveTocItem(tocContainer, activeHeader);
+                    }
+                };
+
+                const onScroll = () => {
+                    cancelAnimationFrame(activeTimeout);
+                    activeTimeout = requestAnimationFrame(updateActiveHeader);
+                };
+
+                mdPreview.addEventListener('scroll', onScroll);
+            }
+        } else {
+            editorInstance.on('change', () => {
+                const instanceData = editorInstances.get(filePath);
+                if (instanceData && !instanceData.isDirty) {
+                    instanceData.isDirty = true;
+                    updateFileDirtyStatus(filePath, true);
+                    updateUnsavedCount();
+                }
+                saveButton.disabled = false;
+            });
+        }
+
+        // Front matter change listener
+        if (frontMatterTextarea) {
+            frontMatterTextarea.addEventListener('input', () => {
+                const instanceData = editorInstances.get(filePath);
+                if (instanceData && !instanceData.isDirty) {
+                    instanceData.isDirty = true;
+                    updateFileDirtyStatus(filePath, true);
+                    updateUnsavedCount();
+                }
+                saveButton.disabled = false;
+            });
+        }
+
+        // Button event listeners
+        saveButton.addEventListener('click', async () => {
+            if (isScratchpad) {
+                // For scratchpads, use Save As
+                const content = editorInstance.getMarkdown();
+                const savedHandle = await saveFileAs(content, 'untitled.md');
+                if (savedHandle && hasFileSystemAccess) {
+                    // Check if saved to current directory - add to file tree
+                    if (directoryHandle) {
+                        try {
+                            // Try to get the file from the directory to verify it's there
+                            const checkHandle = await directoryHandle.getFileHandle(savedHandle.name);
+                            // File is in current directory, add to tree
+                            fileTree.entries[savedHandle.name] = {
+                                name: savedHandle.name,
+                                type: 'file',
+                                handle: checkHandle
+                            };
+                            renderFileTree();
+
+                        } catch (e) {
+                            // File not in current directory, that's fine
+                        }
+                    }
+                    // Clear scratchpad content after successful save
+                    editorInstance.setMarkdown('');
+                    saveButton.disabled = true;
+                    const instanceData = editorInstances.get(filePath);
+                    if (instanceData) {
+                        instanceData.isDirty = false;
+                    }
+                }
+            } else {
+                saveFile(filePath);
+            }
+        });
+
+        if (reloadButton) {
+            reloadButton.addEventListener('click', async () => {
+                await reloadFileFromDisk(filePath);
+            });
+        }
+
+        // Store instance data
+        const instanceData = {
+            editor: editor,
+            fileViewContainer: fileViewContainer,
+            tocContainer: tocContainer,
+            saveButton: saveButton,
+            reloadButton: reloadButton,
+            frontMatterTextarea: frontMatterTextarea,
+            frontMatterData: frontMatterData,
+            fileHandle: fileHandle,
+            lastModified: lastModified,
+            isDirty: false
+        };
+
+        editorInstances.set(filePath, instanceData);
+
+        return editorInstance;
+    } catch (error) {
+        console.error('Error initializing editor:', error);
+        alert(`Error initializing Toast UI Editor: ${error}`);
+        return null;
+    }
+}
+
+/**
+ * Table of Contents generation and scroll functionality
+ */
+
+/**
+ * Scroll to header service - uses line numbers for reliable targeting
+ */
+const ScrollToHeaderService = {
+    /**
+     * Scroll to a specific header in the editor by line number
+     * @param {Object} editorInstance - Toast UI Editor instance
+     * @param {string} headerText - Text content of the header (for highlighting)
+     * @param {number} lineIndex - 0-based line index of the header in markdown
+     */
+    scrollToHeader(editorInstance, headerText, lineIndex) {
+        if (!editorInstance) {
+            console.warn('Editor instance not available for scrolling');
+            return;
+        }
+
+        try {
+            const editorElements = editorInstance.getEditorElements();
+            const isWysiwygMode = editorInstance.isWysiwygMode();
+
+            if (isWysiwygMode) {
+                // In WYSIWYG mode, find header by text (no line numbers available)
+                const wysiwygEditor = editorElements.wwEditor;
+                if (wysiwygEditor) {
+                    const headers = wysiwygEditor.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    for (const header of headers) {
+                        if (header.textContent.trim() === headerText.trim()) {
+                            // Scroll the editor container directly with 10px offset
+                            const headerPosition = header.getBoundingClientRect().top - wysiwygEditor.getBoundingClientRect().top;
+                            const offset = 10; // Account for fixed headers or padding
+                            wysiwygEditor.scrollTop = headerPosition - offset;
+                            this._highlightHeader(header);
+                            break;
+                        }
+                    }
+                }
+            } else {
+                // In markdown mode, use line number to position cursor, then scroll preview
+                const lineNumber = lineIndex + 1; // Convert to 1-based
+                
+                // Move cursor to the heading line in the editor
+                try {
+                    editorInstance.setSelection([lineNumber, 1], [lineNumber, 1]);
+                } catch (e) {
+                    if (DEBUG) console.debug('Could not set selection:', e);
+                }
+
+                // Scroll preview to matching header
+                const previewElement = editorElements.mdPreview;
+                if (previewElement) {
+                    const headers = previewElement.querySelectorAll('h1, h2, h3, h4, h5, h6');
+                    
+                    for (const header of headers) {
+                        if (header.textContent.trim() === headerText.trim()) {
+                            // Scroll the preview container directly with 10px offset
+                            const headerPosition = header.getBoundingClientRect().top - previewElement.getBoundingClientRect().top;
+                            const offset = 10; // Account for fixed headers or padding
+                            previewElement.scrollTop = headerPosition - offset;
+                            this._highlightHeader(header);
+                            break;
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            console.error('Error scrolling to header:', error);
+        }
+    },
+
+    /**
+     * Highlight header briefly for visual feedback
+     * @param {HTMLElement} headerElement - Header to highlight
+     */
+    _highlightHeader(headerElement) {
+        if (!headerElement) return;
+        
+        headerElement.style.transition = 'background-color 0.3s ease';
+        headerElement.style.backgroundColor = '#fef3c7';
+        
+        setTimeout(() => {
+            headerElement.style.backgroundColor = '';
+            setTimeout(() => {
+                headerElement.style.transition = '';
+            }, 300);
+        }, 1500);
+    }
+};
+
+/**
+ * Generate and update the TOC from markdown content
+ * @param {string} content - Markdown content
+ * @param {HTMLElement} tocContainer - Container for the TOC
+ * @param {Object} editorInstance - Toast UI Editor instance
+ * @param {number} maxDepth - Maximum heading level (1-6)
+ */
+function updateToc(content, tocContainer, editorInstance, maxDepth = 6) {
+    if (content === undefined || content === null || !tocContainer) {
+        console.warn('Missing required params for updateToc');
+        return;
+    }
+
+    tocContainer.innerHTML = '';
+
+    const tocList = document.createElement('ul');
+    tocList.className = 'toc-list pl-0 text-sm';
+
+    if (!content.trim()) {
+        const emptyMessage = document.createElement('p');
+        emptyMessage.className = 'text-gray-500 p-4';
+        emptyMessage.textContent = 'This file is empty.';
+        tocContainer.appendChild(emptyMessage);
+        return;
+    }
+
+    const headings = [];
+    const lines = content.split('\n');
+    
+    lines.forEach((line, index) => {
+        const match = line.match(/^(#{1,6})\s+(.+)$/);
+        if (match) {
+            const level = match[1].length;
+            let text = match[2].trim();
+            
+            // Clean markdown formatting
+            text = text
+                .replace(/\\(.)/g, '$1')
+                .replace(/\*\*(.*?)\*\*/g, '$1')
+                .replace(/\*(.*?)\*/g, '$1')
+                .replace(/`(.*?)`/g, '$1')
+                .replace(/\[(.*?)\]\(.*?\)/g, '$1')
+                .replace(/~~(.*?)~~/g, '$1')
+                .trim();
+            
+            const id = text.toLowerCase().replace(/\s+/g, '-').replace(/[^\w-]/g, '');
+            
+            headings.push({
+                level,
+                text,
+                id,
+                lineIndex: index
+            });
+        }
+    });
+
+    let currentList = tocList;
+    let currentLevel = 0;
+    let listsStack = [tocList];
+
+    const filteredHeadings = headings.filter(heading => heading.level <= maxDepth);
+
+    if (filteredHeadings.length === 0) {
+        const noHeadings = document.createElement('p');
+        noHeadings.className = 'text-gray-500 p-4';
+        noHeadings.textContent = maxDepth === 6 ? 'No headings found in this document.' :
+            'No headings at or below level H' + maxDepth + ' found.';
+        tocContainer.appendChild(noHeadings);
+        return;
+    }
+
+    filteredHeadings.forEach(heading => {
+        const li = document.createElement('li');
+        li.className = `toc-item toc-level-${heading.level} py-1`;
+
+        const a = document.createElement('a');
+        a.innerHTML = heading.text;
+        a.href = '#';
+        a.className = 'text-blue-600 hover:text-blue-800 hover:underline cursor-pointer';
+        a.dataset.headerText = heading.text;
+        a.dataset.lineIndex = heading.lineIndex;
+
+        a.addEventListener('click', function(e) {
+            e.preventDefault();
+            
+            if (editorInstance && ScrollToHeaderService) {
+                try {
+                    ScrollToHeaderService.scrollToHeader(
+                        editorInstance, 
+                        heading.text, 
+                        parseInt(heading.lineIndex)
+                    );
+                } catch (error) {
+                    console.error('Error in ScrollToHeaderService.scrollToHeader:', error);
+                }
+            }
+        });
+
+        li.appendChild(a);
+
+        if (heading.level > currentLevel) {
+            const nestedUl = document.createElement('ul');
+            nestedUl.className = 'pl-4 mt-1';
+            listsStack[listsStack.length - 1].appendChild(nestedUl);
+            listsStack.push(nestedUl);
+            currentList = nestedUl;
+            currentLevel = heading.level;
+        } else if (heading.level < currentLevel) {
+            while (heading.level < currentLevel && listsStack.length > 1) {
+                listsStack.pop();
+                currentLevel--;
+            }
+            currentList = listsStack[listsStack.length - 1];
+        }
+
+        currentList.appendChild(li);
+    });
+
+    tocContainer.appendChild(tocList);
+    clearActiveTocItem(tocContainer);
+}
+
+/**
+ * Clear active TOC item from all items within the container
+ * @param {HTMLElement} tocContainer - Container element holding the TOC
+ */
+function clearActiveTocItem(tocContainer) {
+    if (!tocContainer) return;
+    
+    const activeItems = tocContainer.querySelectorAll('.toc-active');
+    activeItems.forEach(item => {
+        item.classList.remove('toc-active');
+    });
+}
+
+/**
+ * Set active TOC item by finding the link matching the header text
+ * @param {HTMLElement} tocContainer - Container element holding the TOC
+ * @param {string} headerText - Text of the header to match and activate
+ */
+function setActiveTocItem(tocContainer, headerText) {
+    if (!tocContainer || !headerText) return;
+    
+    // First clear any existing active items
+    clearActiveTocItem(tocContainer);
+    
+    // Find the link matching the header text
+    const links = tocContainer.querySelectorAll('a[data-header-text]');
+    for (const link of links) {
+        if (link.dataset.headerText === headerText) {
+            // Add toc-active class to the parent li element
+            const li = link.parentElement;
+            if (li) {
+                li.classList.add('toc-active');
+            }
+            break;
+        }
+    }
+}
+
+// Export globally
+window.updateToc = updateToc;
+window.clearActiveTocItem = clearActiveTocItem;
+window.setActiveTocItem = setActiveTocItem;
+
+/**
+ * Pane resizing functionality
+ */
+
+/**
+ * Make an element resizable by dragging its resizer
+ * @param {HTMLElement} resizer - The resizer element
+ * @param {HTMLElement} pane - The pane to resize
+ */
+function makeResizable(resizer, pane) {
+    const initialWidth = pane.offsetWidth;
+
+    let x = 0;
+    let paneWidth = initialWidth;
+
+    const mouseDownHandler = function (e) {
+        x = e.clientX;
+        paneWidth = pane.offsetWidth;
+
+        document.addEventListener('mousemove', mouseMoveHandler);
+        document.addEventListener('mouseup', mouseUpHandler);
+
+        resizer.classList.add('active');
+        document.body.style.cursor = 'col-resize';
+        document.body.style.userSelect = 'none';
+    };
+
+    const mouseMoveHandler = function (e) {
+        const dx = e.clientX - x;
+        const newWidth = Math.max(150, paneWidth + dx);
+
+        pane.style.width = `${newWidth}px`;
+    };
+
+    const mouseUpHandler = function () {
+        document.removeEventListener('mousemove', mouseMoveHandler);
+        document.removeEventListener('mouseup', mouseUpHandler);
+
+        resizer.classList.remove('active');
+        document.body.style.cursor = '';
+        document.body.style.userSelect = '';
+    };
+
+    resizer.addEventListener('mousedown', mouseDownHandler);
+}
+
+/**
+ * Initialize the file navigation pane resizer
+ */
+function initializeFileNavResizer() {
+    const fileNavResizer = document.querySelector('.pane-resizer[data-resizer-for="file-nav"]');
+
+    if (fileNavResizer && !fileNavResizer.hasAttribute('data-resizer-initialized')) {
+        fileNavResizer.setAttribute('data-resizer-initialized', 'true');
+
+        let x = 0;
+        let navWidth = 0;
+
+        const mouseDownHandler = function (e) {
+            x = e.clientX;
+
+            const navPane = document.getElementById('file-nav');
+            navWidth = navPane.getBoundingClientRect().width;
+
+            document.addEventListener('mousemove', mouseMoveHandler);
+            document.addEventListener('mouseup', mouseUpHandler);
+
+            fileNavResizer.classList.add('bg-blue-500');
+        };
+
+        const mouseMoveHandler = function (e) {
+            const dx = e.clientX - x;
+
+            const navPane = document.getElementById('file-nav');
+
+            const newWidth = navWidth + dx;
+
+            if (newWidth >= 200) {
+                navPane.style.width = `${newWidth}px`;
+            }
+        };
+
+        const mouseUpHandler = function () {
+            document.removeEventListener('mousemove', mouseMoveHandler);
+            document.removeEventListener('mouseup', mouseUpHandler);
+
+            fileNavResizer.classList.remove('bg-blue-500');
+        };
+
+        fileNavResizer.addEventListener('mousedown', mouseDownHandler);
+    }
+}
+
+
+/**
+ * Event listeners setup
+ */
+
+/**
+ * Set up all event listeners for the application
+ */
+function setupEventListeners() {
+    // Select directory button
+    const selectDirectoryBtn = document.getElementById('select-directory');
+    if (selectDirectoryBtn) {
+        selectDirectoryBtn.addEventListener('click', openDirectory);
+    }
+
+    // Refresh directory button
+    const refreshDirectoryBtn = document.getElementById('refresh-directory');
+    if (refreshDirectoryBtn) {
+        refreshDirectoryBtn.addEventListener('click', refreshDirectory);
+    }
+
+    // New file (root) button
+    const newFileRootBtn = document.getElementById('new-file-root');
+    if (newFileRootBtn) {
+        newFileRootBtn.addEventListener('click', () => {
+            if (directoryHandle) {
+                createNewFile('');
+            }
+        });
+    }
+
+    // Save All button
+    const saveAllBtn = document.getElementById('save-all');
+    if (saveAllBtn) {
+        saveAllBtn.addEventListener('click', saveAllFiles);
+    }
+
+    // Warn when leaving with unsaved changes
+    window.addEventListener('beforeunload', function (e) {
+        let hasUnsavedChanges = false;
+
+        editorInstances.forEach((instanceData) => {
+            if (instanceData.isDirty) {
+                hasUnsavedChanges = true;
+            }
+        });
+
+        if (hasUnsavedChanges) {
+            e.preventDefault();
+            return 'You have unsaved changes. If you leave now, your changes will be lost.';
+        }
+    });
+}
+
+/**
+ * Set up TOC depth selector
+ */
+function setupTocDepthSelector() {
+    const depthSelector = document.getElementById('toc-depth-selector');
+    if (!depthSelector) return;
+
+    depthSelector.value = tocMaxDepth.toString();
+
+    depthSelector.addEventListener('change', function () {
+        tocMaxDepth = parseInt(this.value, 10);
+
+        if (currentFileHandle && currentFileHandle.name.match(/\.(md|markdown)$/i)) {
+            const filePath = currentFileHandle.name;
+            const instance = editorInstances.get(filePath);
+
+            if (instance && instance.editor && instance.tocContainer) {
+                const content = instance.editor.getMarkdown();
+
+                try {
+                    window.updateToc(content, instance.tocContainer, instance.editor, tocMaxDepth);
+                } catch (error) {
+                    console.error('Error updating TOC depth:', error);
+                }
+            }
+        }
+    });
+}
+
+/**
+ * Application initialization
+ */
+
+// Initialize when DOM is loaded
+document.addEventListener('DOMContentLoaded', function () {
+    // Check File System API availability and update UI
+    initializeApiAvailability();
+    
+    setupEventListeners();
+    initializeFileNavResizer();
+    setupTocDepthSelector();
+    startFileChangeMonitoring();
+    
+    // Show scratchpad in file tree on startup
+    renderFileTree();
+    
+
+});
+
+/**
+ * Initialize UI based on File System API availability
+ */
+function initializeApiAvailability() {
+    const selectDirectoryBtn = document.getElementById('select-directory');
+    const welcomeHint = document.getElementById('welcome-hint');
+    const welcomeFirefox = document.getElementById('welcome-firefox');
+    
+    if (!hasFileSystemAccess) {
+        // Disable file system buttons in Firefox and other unsupported browsers
+        if (selectDirectoryBtn) {
+            selectDirectoryBtn.disabled = true;
+            selectDirectoryBtn.title = 'File System API not supported in this browser';
+        }
+        // Show Firefox warning, hide normal hint
+        if (welcomeHint) welcomeHint.classList.add('hidden');
+        if (welcomeFirefox) welcomeFirefox.classList.remove('hidden');
+        
+    }
+}
+
+/**
+ * ZDDC shared help panel — open/close logic.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #help-btn, #help-panel, #help-panel-close in the DOM.
+ */
+(function () {
+    'use strict';
+
+    function init() {
+        var helpBtn   = document.getElementById('help-btn');
+        var panel     = document.getElementById('help-panel');
+        var closeBtn  = document.getElementById('help-panel-close');
+
+        if (!helpBtn || !panel) { return; }
+
+        function isOpen() { return !panel.hidden; }
+
+        function openPanel() {
+            panel.hidden = false;
+            document.body.classList.add('help-open');
+        }
+
+        function closePanel() {
+            panel.hidden = true;
+            document.body.classList.remove('help-open');
+        }
+
+        helpBtn.addEventListener('click', function () {
+            if (isOpen()) { closePanel(); } else { openPanel(); }
+        });
+
+        if (closeBtn) {
+            closeBtn.addEventListener('click', closePanel);
+        }
+
+        document.addEventListener('keydown', function (e) {
+            if (e.key === 'Escape' && isOpen()) { closePanel(); }
+        });
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+    </script>
+</body>
+</html>
diff --git a/website/releases/transmittal_latest.html b/website/releases/transmittal_latest.html
new file mode 120000
index 0000000..0ee4389
--- /dev/null
+++ b/website/releases/transmittal_latest.html
@@ -0,0 +1 @@
+transmittal_v0.0.1.html
\ No newline at end of file
diff --git a/website/releases/transmittal_v0.0.1.html b/website/releases/transmittal_v0.0.1.html
new file mode 100644
index 0000000..93f91a6
--- /dev/null
+++ b/website/releases/transmittal_v0.0.1.html
@@ -0,0 +1,10998 @@
+<!--
+This is a html transmittal template.
+It is meant to be an editable form to fill out transmittal information and
+scan documents to be included in the transmittal, and then complete the
+transmittal files table by parsing the file names according to ZDDC naming
+conventions at https://codeberg.org/VARASYS/ZDDC#file-naming-convention.
+-->
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+<style>
+/* ==========================================================================
+   ZDDC Shared Base — single source of truth for tokens and primitives
+   Included first by every tool's build.sh via ../shared/base.css
+   ========================================================================== */
+
+/* ── CSS custom properties ────────────────────────────────────────────────── */
+:root {
+    /* Brand / accent (matches zddc.varasys.io website --accent) */
+    --primary:        #2a5a8a;
+    --primary-hover:  #1d4060;
+    --primary-active: #163352;
+    --primary-light:  #e8f0f7;
+
+    /* Semantic colours */
+    --success: #28a745;
+    --warning: #d97706;
+    --danger:  #dc3545;
+    --info:    #17a2b8;
+
+    /* Backgrounds */
+    --bg:           #ffffff;
+    --bg-secondary: #f8f9fa;
+    --bg-hover:     #f0f4f8;
+    --bg-selected:  var(--primary-light);
+
+    /* Text */
+    --text:       #212529;
+    --text-muted: #6c757d;
+    --text-light: #ffffff;
+
+    /* Borders */
+    --border:      #dee2e6;
+    --border-dark: #adb5bd;
+
+    /* Shape */
+    --radius: 4px;
+
+    /* Typography */
+    --font:      -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    --font-mono: 'SF Mono', 'Fira Code', 'Consolas', 'Courier New', monospace;
+}
+
+/* ── Dark mode tokens ─────────────────────────────────────────────────────── */
+/* Applied via: OS preference (auto) or [data-theme="dark"] on <html>          */
+/* The [data-theme="light"] selector locks light mode regardless of OS pref.   */
+@media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+        --primary:        #4a90c4;
+        --primary-hover:  #5ba3d9;
+        --primary-active: #6ab5e8;
+        --primary-light:  #1a3550;
+
+        --bg:           #1e1e1e;
+        --bg-secondary: #252526;
+        --bg-hover:     #2d2d30;
+        --bg-selected:  #1a3550;
+
+        --text:       #d4d4d4;
+        --text-muted: #9d9d9d;
+        --text-light: #ffffff;
+
+        --border:      #3e3e42;
+        --border-dark: #6e6e72;
+    }
+}
+
+/* Manual dark override — wins over media query */
+[data-theme="dark"] {
+    --primary:        #4a90c4;
+    --primary-hover:  #5ba3d9;
+    --primary-active: #6ab5e8;
+    --primary-light:  #1a3550;
+
+    --bg:           #1e1e1e;
+    --bg-secondary: #252526;
+    --bg-hover:     #2d2d30;
+    --bg-selected:  #1a3550;
+
+    --text:       #d4d4d4;
+    --text-muted: #9d9d9d;
+    --text-light: #ffffff;
+
+    --border:      #3e3e42;
+    --border-dark: #6e6e72;
+}
+
+/* ── Reset ────────────────────────────────────────────────────────────────── */
+*, *::before, *::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+/* ── Base document ────────────────────────────────────────────────────────── */
+html, body {
+    height: 100%;
+    font-family: var(--font);
+    font-size: 16px;
+    line-height: 1.5;
+    color: var(--text);
+    background-color: var(--bg-secondary);
+}
+
+/* ── Typography ───────────────────────────────────────────────────────────── */
+h1, h2, h3, h4, h5, h6 {
+    font-weight: 600;
+    line-height: 1.2;
+}
+
+a {
+    color: var(--primary);
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+
+/* ── Utility ──────────────────────────────────────────────────────────────── */
+.hidden {
+    display: none !important;
+}
+
+.truncate {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+
+/* ── Scrollbars (webkit) ──────────────────────────────────────────────────── */
+::-webkit-scrollbar {
+    width: 7px;
+    height: 7px;
+}
+
+::-webkit-scrollbar-track {
+    background: var(--bg-secondary);
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a0a0a0;
+}
+
+/* ── Button primitive ─────────────────────────────────────────────────────── */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.4rem 0.85rem;
+    font-family: var(--font);
+    font-size: 0.875rem;
+    font-weight: 500;
+    line-height: 1.4;
+    text-align: center;
+    text-decoration: none;
+    white-space: nowrap;
+    vertical-align: middle;
+    cursor: pointer;
+    border: 1px solid transparent;
+    border-radius: var(--radius);
+    transition: background 0.15s, box-shadow 0.15s, border-color 0.15s, color 0.15s;
+    background: var(--bg-secondary);
+    color: var(--text);
+}
+
+.btn:disabled,
+.btn[disabled] {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn:not(:disabled):hover {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.12);
+}
+
+.btn:not(:disabled):active {
+    box-shadow: none;
+}
+
+/* Variants */
+.btn-primary {
+    background: var(--primary);
+    color: var(--text-light);
+    border-color: var(--primary);
+}
+
+.btn-primary:not(:disabled):hover {
+    background: var(--primary-hover);
+    border-color: var(--primary-hover);
+    color: var(--text-light);
+}
+
+.btn-primary:not(:disabled):active {
+    background: var(--primary-active);
+    border-color: var(--primary-active);
+}
+
+.btn-secondary {
+    background: var(--bg);
+    color: var(--text);
+    border-color: var(--border);
+}
+
+.btn-secondary:not(:disabled):hover {
+    background: var(--bg-secondary);
+}
+
+.btn-success {
+    background: var(--success);
+    color: var(--text-light);
+    border-color: var(--success);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: var(--text-light);
+    border-color: var(--danger);
+}
+
+/* Sizes */
+.btn-sm {
+    padding: 0.25rem 0.5rem;
+    font-size: 0.75rem;
+}
+
+.btn-lg {
+    padding: 0.6rem 1.4rem;
+    font-size: 1rem;
+}
+
+.btn-link {
+    background: transparent;
+    border-color: transparent;
+    color: var(--primary);
+    padding-left: 0;
+    padding-right: 0;
+}
+
+.btn-link:not(:disabled):hover {
+    text-decoration: underline;
+    box-shadow: none;
+}
+
+/* ── App header chrome ────────────────────────────────────────────────────── */
+.app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.35rem 1rem;
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+}
+
+/* Tool name inside the header */
+.app-header__title {
+    font-size: 17px;
+    font-weight: 600;
+    color: var(--text);
+    letter-spacing: 0.01em;
+    white-space: nowrap;
+}
+
+/* ── Build timestamp ──────────────────────────────────────────────────────── */
+.build-timestamp {
+    font-size: 0.55rem;
+    color: var(--text-muted);
+    opacity: 0.7;
+    font-weight: 300;
+    white-space: nowrap;
+    padding-top: 0.15rem;
+}
+
+/* Title + timestamp stacked vertically on the left side of the header */
+.header-title-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0;
+    line-height: 1;
+}
+
+/* ── Icon buttons (help, theme, refresh) ─────────────────────────────────── */
+/* Square, centered — overrides the asymmetric text-button padding/line-height */
+#help-btn,
+#theme-btn,
+#refreshHeaderBtn {
+    width: 2rem;
+    height: 2rem;
+    padding: 0;
+    line-height: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 1rem;
+}
+
+/* Toast CSS lives in classifier/css/base.css — only that tool uses toasts. */
+
+/* ── Theme and help icon buttons ─────────────────────────────────────────── */
+#theme-btn,
+#help-btn {
+    font-size: 1rem;
+}
+
+/* ── Help panel (shared slide-out drawer) ─────────────────────────────────── */
+/* Used by all four tools. Toggle open/close via shared/help.js.               */
+
+.help-panel {
+    position: fixed;
+    top: 0;
+    right: 0;
+    width: min(420px, 85vw);
+    height: 100vh;
+    z-index: 1000;
+    background: var(--bg);
+    border-left: 1px solid var(--border);
+    box-shadow: -2px 0 12px rgba(0, 0, 0, 0.08);
+    display: flex;
+    flex-direction: column;
+    transform: translateX(100%);
+    transition: transform 0.25s ease;
+}
+
+.help-panel:not([hidden]) {
+    transform: translateX(0);
+}
+
+.help-panel[hidden] {
+    display: flex;
+    transform: translateX(100%);
+    pointer-events: none;
+}
+
+.help-panel__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 0.75rem 1rem;
+    border-bottom: 1px solid var(--border);
+    flex-shrink: 0;
+    background: var(--bg);
+}
+
+.help-panel__title {
+    font-size: 1rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.help-panel__close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    font-size: 1.35rem;
+    cursor: pointer;
+    padding: 0.25rem 0.5rem;
+    border-radius: var(--radius);
+    line-height: 1;
+    transition: background 0.15s, color 0.15s;
+}
+
+.help-panel__close:hover {
+    color: var(--text);
+    background: var(--bg-secondary);
+}
+
+.help-panel__body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 1rem 1rem 2rem;
+    font-size: 0.85rem;
+    line-height: 1.6;
+    color: var(--text);
+}
+
+.help-panel__body h3 {
+    font-size: 0.95rem;
+    font-weight: 700;
+    margin: 1.25rem 0 0.35rem;
+    color: var(--text);
+    border-bottom: 1px solid var(--border);
+    padding-bottom: 0.15rem;
+}
+
+.help-panel__body h3:first-child {
+    margin-top: 0;
+}
+
+.help-panel__body h4 {
+    font-size: 0.7rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    margin: 1.25rem 0 0.3rem;
+    padding-left: 0.5rem;
+    border-left: 3px solid var(--border-dark);
+    color: var(--text-muted);
+}
+
+.help-panel__body p {
+    margin: 0 0 0.5rem;
+}
+
+.help-panel__body ol,
+.help-panel__body ul {
+    padding-left: 1.5rem;
+    margin: 0.3rem 0 0.5rem;
+}
+
+.help-panel__body li {
+    margin-bottom: 0.3rem;
+}
+
+.help-panel__body dl {
+    margin: 0.3rem 0;
+}
+
+.help-panel__body dt {
+    font-weight: 600;
+    color: var(--text);
+}
+
+.help-panel__body dd {
+    margin: 0 0 0.5rem 1rem;
+    color: var(--text-muted);
+}
+
+.help-panel__body code {
+    font-family: var(--font-mono);
+    font-size: 0.8em;
+    background: var(--bg-secondary);
+    padding: 0.1em 0.3em;
+    border-radius: 3px;
+}
+
+.help-badge {
+    font-size: 0.7rem;
+    font-weight: 600;
+    padding: 0.1rem 0.35rem;
+    border-radius: var(--radius);
+    vertical-align: middle;
+    letter-spacing: 0.02em;
+}
+
+.help-badge--draft {
+    color: #2563eb;
+    background: #eff6ff;
+}
+
+.help-badge--published {
+    color: #7c3aed;
+    background: #f5f3ff;
+}
+
+/* Shrink main content when help panel is open */
+body.help-open .app-header {
+    margin-right: min(420px, 85vw);
+}
+
+/* ── Column filter inputs (shared across archive, classifier, transmittal) ─── */
+.column-filter {
+    display: block;
+    width: 100%;
+    box-sizing: border-box;
+    margin-top: 0.25rem;
+    padding: 0.2rem 0.4rem;
+    font-size: 0.8rem;
+    font-family: var(--font);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    background: var(--bg);
+    color: var(--text);
+    transition: border-color 0.15s;
+}
+
+.column-filter:focus {
+    border-color: var(--primary);
+    outline: none;
+    box-shadow: 0 0 0 1px rgba(42, 90, 138, 0.35);
+}
+
+.column-filter::placeholder {
+    color: var(--text-muted);
+}
+
+/* Placeholder for contenteditable elements */
+[data-placeholder]:empty::before {
+    content: attr(data-placeholder);
+    color: var(--text-muted);
+    pointer-events: none;
+}
+
+/* Hide elements that should be hidden when JavaScript is available */
+[data-hydrate-hide] {
+    display: none;
+}
+
+@media screen {
+    body {
+        margin: 0;
+        padding: 0;
+        background: var(--bg-secondary);
+    }
+
+    .stack-below-600 {
+        display: flex;
+        flex-direction: row;
+    }
+
+    .page-container {
+        width: 100%;
+        max-width: 8.5in;
+        margin: 20px auto;
+        padding: 0.375in;
+        min-height: 0;
+        background: var(--bg);
+        box-shadow: 0 0 20px rgba(0, 0, 0, 0.1);
+        border: 1px solid var(--border);
+    }
+}
+
+@media (max-width: 600px) {
+    .stack-below-600 {
+        flex-direction: column;
+    }
+}
+
+@media (max-width: 640px) {
+    .page-container {
+        padding: 12px;
+    }
+}
+
+/* ── Dark mode overrides for transmittal-specific hardcoded colours ──────── */
+/* Covers verify cards, table rows, path-diff, integrity cards, workflow badge */
+/* and Tailwind utility classes used as attributes in template.html.           */
+@media screen {
+    /* Integrity verify cards */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .verify-card--ok    { background: #052e16; }
+        :root:not([data-theme="light"]) .verify-card--fail  { background: #2d0c0c; }
+        :root:not([data-theme="light"]) .verify-card--draft { background: #2d2305; }
+        :root:not([data-theme="light"]) .verify-card--info  { background: #0c1a2e; }
+    }
+    [data-theme="dark"] .verify-card--ok    { background: #052e16; }
+    [data-theme="dark"] .verify-card--fail  { background: #2d0c0c; }
+    [data-theme="dark"] .verify-card--draft { background: #2d2305; }
+    [data-theme="dark"] .verify-card--info  { background: #0c1a2e; }
+
+    /* Per-row verify result rows in file table */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) tr.verify-match td    { background: #052e16; }
+        :root:not([data-theme="light"]) tr.verify-mismatch td { background: #2d0c0c; }
+        :root:not([data-theme="light"]) tr.verify-missing td  { background: #2d2305; }
+        :root:not([data-theme="light"]) tr.verify-new td      { background: #0c1a2e; }
+    }
+    [data-theme="dark"] tr.verify-match td    { background: #052e16; }
+    [data-theme="dark"] tr.verify-mismatch td { background: #2d0c0c; }
+    [data-theme="dark"] tr.verify-missing td  { background: #2d2305; }
+    [data-theme="dark"] tr.verify-new td      { background: #0c1a2e; }
+
+    /* Workflow warning badge */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .workflow-badge--warn {
+            background: #2d2305;
+            color: #fcd34d;
+            border-color: #92400e;
+        }
+    }
+    [data-theme="dark"] .workflow-badge--warn {
+        background: #2d2305;
+        color: #fcd34d;
+        border-color: #92400e;
+    }
+
+    /* Path diff semantic colours (verify mismatch) */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .path-diff del {
+            color: #fca5a5;
+            background: #2d0c0c;
+        }
+        :root:not([data-theme="light"]) .path-diff ins {
+            color: #86efac;
+            background: #052e16;
+            border-bottom-color: #86efac;
+        }
+    }
+    [data-theme="dark"] .path-diff del { color: #fca5a5; background: #2d0c0c; }
+    [data-theme="dark"] .path-diff ins {
+        color: #86efac;
+        background: #052e16;
+        border-bottom-color: #86efac;
+    }
+
+    /* Owner/Project names area and inline bg-white / bg-gray-50 utility classes */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .header-names {
+            background-color: var(--bg-secondary) !important;
+            border-color: var(--border) !important;
+        }
+        :root:not([data-theme="light"]) .text-gray-700 { color: var(--text-muted) !important; }
+        :root:not([data-theme="light"]) .bg-white  { background-color: var(--bg) !important; }
+        :root:not([data-theme="light"]) .bg-gray-50 { background-color: var(--bg-secondary) !important; }
+        :root:not([data-theme="light"]) .bg-gray-100 { background-color: var(--bg-secondary) !important; }
+        :root:not([data-theme="light"]) .border-gray-100,
+        :root:not([data-theme="light"]) .border-gray-200,
+        :root:not([data-theme="light"]) .border-gray-300 { border-color: var(--border) !important; }
+        :root:not([data-theme="light"]) .text-gray-900 { color: var(--text) !important; }
+    }
+    [data-theme="dark"] .header-names {
+        background-color: var(--bg-secondary) !important;
+        border-color: var(--border) !important;
+    }
+    [data-theme="dark"] .text-gray-700 { color: var(--text-muted) !important; }
+    [data-theme="dark"] .bg-white  { background-color: var(--bg) !important; }
+    [data-theme="dark"] .bg-gray-50 { background-color: var(--bg-secondary) !important; }
+    [data-theme="dark"] .bg-gray-100 { background-color: var(--bg-secondary) !important; }
+    [data-theme="dark"] .border-gray-100,
+    [data-theme="dark"] .border-gray-200,
+    [data-theme="dark"] .border-gray-300 { border-color: var(--border) !important; }
+    [data-theme="dark"] .text-gray-900 { color: var(--text) !important; }
+
+    /* Filter inputs in table column headers */
+    @media (prefers-color-scheme: dark) {
+        :root:not([data-theme="light"]) .table-filter-input {
+            background-color: var(--bg);
+            color: var(--text);
+            border-color: var(--border);
+        }
+        :root:not([data-theme="light"]) .table-header__caption { color: var(--text-muted); }
+        :root:not([data-theme="light"]) .focus\:bg-white:focus { background-color: var(--bg) !important; }
+    }
+    [data-theme="dark"] .table-filter-input {
+        background-color: var(--bg);
+        color: var(--text);
+        border-color: var(--border);
+    }
+    [data-theme="dark"] .table-header__caption { color: var(--text-muted); }
+    [data-theme="dark"] .focus\:bg-white:focus { background-color: var(--bg) !important; }
+}
+
+/* Logo row: flex layout — logo | title | logo */
+.logo-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    width: 100%;
+}
+
+.logo-cell {
+    width: 250px;
+    height: 60px;
+    flex-shrink: 0;
+}
+
+.logo-img {
+    display: block;
+    width: 250px;
+    height: 60px;
+    object-fit: contain;
+    user-select: none;
+}
+
+#left-logo-cell .logo-img { object-position: left center; }
+#right-logo-cell .logo-img { object-position: right center; }
+
+.logo-img:not([src]),
+.logo-img[src=""] {
+    display: none;
+}
+
+.logo-placeholder {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: 100%;
+    border: 2px dashed var(--border-dark);
+    border-radius: 0.375rem;
+    color: var(--text-muted);
+    font-size: 0.75rem;
+}
+
+.logo-cell.has-logo .logo-placeholder,
+.logo-placeholder.hidden {
+    display: none;
+}
+
+.title-area {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 2px;
+    text-align: center;
+    min-width: 0;
+}
+
+/* Type combo dropdown */
+.type-combo {
+    position: relative;
+    width: 100%;
+}
+
+.type-display {
+    display: block;
+    cursor: pointer;
+    white-space: nowrap;
+    overflow: hidden;
+    outline: none;
+    min-height: 1.5em;
+}
+
+.type-display:empty::before {
+    content: attr(data-placeholder);
+    color: var(--text-muted);
+}
+
+.type-combo__menu {
+    position: absolute;
+    top: 100%;
+    left: 50%;
+    transform: translateX(-50%);
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 0.375rem;
+    box-shadow: 0 4px 6px -1px rgba(0,0,0,.1), 0 2px 4px -2px rgba(0,0,0,.1);
+    z-index: 50;
+    min-width: 160px;
+    padding: 4px 0;
+}
+
+.type-combo__option {
+    display: block;
+    width: 100%;
+    text-align: center;
+    padding: 6px 16px;
+    font-size: 0.875rem;
+    font-weight: 600;
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: var(--text);
+}
+
+.type-combo__option:hover {
+    background: var(--bg-hover);
+    color: var(--primary);
+}
+
+/* ── Targeted drop zones ─────────────────────────────────────────────────── */
+
+/* Base: relative so the label can be absolute-positioned inside */
+[data-drop-zone] {
+    position: relative;
+    border-radius: 0.375rem;
+    transition: outline 0.12s, background 0.12s, opacity 0.12s;
+}
+
+/* Label: hidden by default, centered overlay inside the zone */
+.drop-zone-label {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    position: absolute;
+    inset: 0;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.375rem;
+    font-size: 0.7rem;
+    font-weight: 600;
+    text-align: center;
+    line-height: 1.3;
+    pointer-events: none;
+    opacity: 0;
+    transition: opacity 0.12s;
+    z-index: 30;
+    white-space: pre-line;
+}
+
+/* --- Visible state: outline appears, label fades in --- */
+[data-drop-zone].dz-visible .drop-zone-label {
+    opacity: 1;
+}
+
+/* Eligible zone: blue dashed outline + subtle blue tint */
+[data-drop-zone].dz-eligible {
+    outline: 2px dashed #60a5fa;
+    outline-offset: 2px;
+    background: rgba(239, 246, 255, 0.55);
+}
+[data-drop-zone].dz-eligible .drop-zone-label {
+    color: #1e40af;
+    background: rgba(239, 246, 255, 0.9);
+}
+
+/* Ineligible zone: grey dashed outline, dimmed */
+[data-drop-zone].dz-ineligible {
+    outline: 2px dashed #d1d5db;
+    outline-offset: 2px;
+    opacity: 0.5;
+}
+[data-drop-zone].dz-ineligible .drop-zone-label {
+    color: #6b7280;
+    background: rgba(249, 250, 251, 0.85);
+}
+
+/* Hover over eligible zone: solid outline, stronger tint, white-on-blue label */
+[data-drop-zone].dz-hover {
+    outline: 2px solid #2563eb;
+    outline-offset: 2px;
+    background: rgba(219, 234, 254, 0.85);
+    opacity: 1;
+}
+[data-drop-zone].dz-hover .drop-zone-label {
+    color: #1e3a8a;
+    background: rgba(191, 219, 254, 0.95);
+    font-weight: 700;
+}
+
+/* Logo cells: label sits centered over the cell content */
+#left-logo-cell[data-drop-zone] .drop-zone-label,
+#right-logo-cell[data-drop-zone] .drop-zone-label {
+    font-size: 0.65rem;
+}
+
+/* File-table zone wrapper: display:block, no extra spacing */
+#file-table-drop-zone {
+    display: block;
+}
+
+@media screen {
+    .page-header .header-names {
+        padding: 6px 8px;
+    }
+
+    .page-header .header-names h2 {
+        margin: 0;
+        line-height: 1.2;
+    }
+
+    .page-header #project-number {
+        margin: 2px 0 6px;
+        line-height: 1.2;
+    }
+
+    .page-header .grid {
+        column-gap: 1rem;
+        row-gap: 0.5rem;
+    }
+
+    /* .action-button removed — transmittal buttons now use .btn/.btn-primary/.btn-secondary */
+
+
+    /* ── Integrity section layout ──────────────────────── */
+    .integrity-body {
+        display: flex;
+        flex-direction: column;
+        align-items: stretch;
+        gap: 0.5rem;
+        width: 100%;
+    }
+
+    /* ── Verify cards ──────────────────────────────────── */
+    .verify-card {
+        display: flex;
+        flex-direction: row;
+        flex-wrap: wrap;
+        align-items: baseline;
+        gap: 0.25rem 0.75rem;
+        padding: 0.5rem 0.75rem;
+        border-left: 4px solid;
+        border-radius: 0.25rem;
+        font-size: 0.75rem;
+        line-height: 1.5;
+    }
+    .verify-card--ok    { background: #f0fdf4; border-left-color: #22c55e; }
+    .verify-card--fail  { background: #fef2f2; border-left-color: #ef4444; }
+    .verify-card--draft { background: #fefce8; border-left-color: #f59e0b; }
+    .verify-card--info  { background: #eff6ff; border-left-color: #3b82f6; }
+
+    .verify-card__status {
+        font-weight: 700;
+        font-size: 0.8rem;
+        display: flex;
+        align-items: center;
+        gap: 0.375rem;
+    }
+    .verify-card__status--ok    { color: #166534; }
+    .verify-card__status--fail  { color: #991b1b; }
+    .verify-card__status--draft { color: #92400e; }
+    .verify-card__status--info  { color: #1e40af; }
+
+    .verify-card__detail {
+        font-size: 0.7rem;
+        color: var(--text-muted);
+    }
+    .verify-card__detail code {
+        font-family: var(--font-mono);
+        font-size: 0.65rem;
+        word-break: break-all;
+        color: var(--primary);
+    }
+
+    /* Workflow Area */
+    .workflow-area {
+        border-top: 1px solid var(--border);
+        padding-top: 0.75rem;
+        margin-top: 0.75rem;
+        display: flex;
+        flex-direction: column;
+        gap: 0.875rem;
+    }
+
+    .workflow-step {
+        display: flex;
+        flex-direction: column;
+        gap: 0.375rem;
+    }
+
+    .workflow-step__label {
+        font-size: 0.6875rem;
+        font-weight: 700;
+        color: var(--text-muted);
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+        margin: 0;
+    }
+
+    .workflow-step__body {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 0.5rem;
+    }
+
+    .workflow-dir {
+        font-family: var(--font-mono);
+        font-size: 0.625rem;
+        color: var(--text-muted);
+    }
+
+    .workflow-hint {
+        font-size: 0.625rem;
+        color: var(--text-muted);
+        font-style: italic;
+    }
+
+    .workflow-badge {
+        font-size: 0.625rem;
+        padding: 0.0625rem 0.375rem;
+        border: 1px solid;
+        border-radius: 0.25rem;
+        margin-left: 0.375rem;
+        vertical-align: middle;
+    }
+
+    .workflow-badge--warn {
+        background: #fef9c3;
+        color: #92400e;
+        border-color: #fcd34d;
+    }
+
+    /* Tools row — compact, de-emphasized */
+    .workflow-tools {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 0.375rem;
+        padding-top: 0.5rem;
+        border-top: 1px solid var(--border);
+    }
+
+    /* ── Table toolbar (above table) ───────────────────────── */
+    .table-toolbar {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: flex-end;
+        align-items: center;
+        gap: 0.25rem 0.5rem;
+        padding: 0.375rem 0;
+        border-top: 1px solid var(--border);
+        margin-top: 0.5rem;
+    }
+
+    .toolbar-btn {
+        background: none;
+        border: none;
+        font-size: 0.75rem;
+        font-weight: 500;
+        color: var(--primary);
+        cursor: pointer;
+        padding: 0.15rem 0.35rem;
+        border-radius: 0.25rem;
+    }
+
+    .toolbar-btn:hover {
+        text-decoration: underline;
+        background: var(--primary-light);
+    }
+
+    /* ── App chrome header (lives outside the transmittal) ── */
+    /* shared/base.css provides display, align-items, background, border-bottom */
+    .app-header {
+        position: sticky;
+        top: 0;
+        z-index: 1200;
+        gap: 0.5rem;
+        padding: 0.3rem 0.75rem;
+        /* Expose height for downstream sticky offsets */
+        --app-header-height: 2.1rem;
+        height: var(--app-header-height);
+        box-sizing: content-box;
+    }
+
+    .app-header__spacer {
+        flex: 1;
+    }
+
+    .app-header__icons {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+    }
+
+    .header-icon-btn {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 28px;
+        height: 28px;
+        border-radius: 0.25rem;
+        border: none;
+        background: transparent;
+        color: var(--text-muted);
+        cursor: pointer;
+        padding: 0;
+        text-decoration: none;
+        transition: color 0.15s, background 0.15s;
+    }
+
+    .header-icon-btn:hover {
+        color: var(--primary-hover);
+        background: var(--primary-light);
+    }
+
+    /* ── Fixed footer status bar at viewport bottom ───────── */
+    .page-footer {
+        position: fixed;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        z-index: 50;
+        background: var(--bg-secondary);
+        border-top: 1px solid var(--border);
+        padding: 0.2rem 0.75rem;
+    }
+
+    .page-footer__inner {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: 0.5rem;
+        max-width: 8.5in;
+        margin: 0 auto;
+    }
+
+    .page-container {
+        padding-bottom: 2rem;
+    }
+
+    /* ── Split-button ─────────────────────────────────────── */
+    .split-button {
+        position: relative;
+        display: inline-flex;
+        align-items: stretch;
+    }
+
+    .split-button > .btn:last-of-type {
+        border-top-left-radius: 0;
+        border-bottom-left-radius: 0;
+    }
+
+    .split-button__toggle {
+        border-top-right-radius: 0;
+        border-bottom-right-radius: 0;
+        border-right: 1px solid rgba(255, 255, 255, 0.3);
+        min-width: 28px;
+        padding-left: 6px;
+        padding-right: 6px;
+        font-size: 0.75rem;
+        line-height: 1;
+    }
+
+    /* ── Dropdown menu ──────────────────────────────────────── */
+    .dropdown {
+        position: relative;
+        display: inline-block;
+    }
+
+    .dropdown-toggle {
+        min-width: 28px;
+        font-size: 1rem;
+        letter-spacing: 0.1em;
+        line-height: 1;
+    }
+
+    .dropdown-menu {
+        position: absolute;
+        left: 0;
+        top: 100%;
+        margin-top: 2px;
+        min-width: 120px;
+        background: var(--bg);
+        border: 1px solid var(--border);
+        border-radius: 0.375rem;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        z-index: 1100;
+        padding: 4px 0;
+    }
+
+    .dropdown-menu.dropdown-menu--up {
+        bottom: 100%;
+        top: auto;
+        margin-top: 0;
+        margin-bottom: 2px;
+    }
+
+    /* ── Dropdown separators ─────────────────────────────────── */
+    .dropdown-separator {
+        border-top: 1px solid var(--border);
+        margin: 4px 0;
+        padding: 0;
+        font-size: 0.625rem;
+        font-weight: 600;
+        color: var(--text-muted);
+        text-transform: uppercase;
+        letter-spacing: 0.05em;
+    }
+
+    .dropdown-separator:empty {
+        padding: 0;
+    }
+
+    .dropdown-separator:not(:empty) {
+        padding: 4px 12px 2px;
+    }
+
+    /* ── Scanning blur on table ─────────────────────────────── */
+    .table-wrapper.scanning {
+        filter: blur(1px);
+        opacity: 0.7;
+        pointer-events: none;
+        transition: filter 0.3s ease, opacity 0.3s ease;
+    }
+
+    .table-wrapper {
+        transition: filter 0.3s ease, opacity 0.3s ease;
+    }
+
+    /* ── Hash validation indicators ──────────────────────────── */
+    .hash-match {
+        color: #16a34a;
+        font-weight: 700;
+    }
+
+    .hash-mismatch {
+        color: #dc2626;
+        font-weight: 700;
+    }
+
+    /* ── Inline hash progress bar ────────────────────────────── */
+    .hash-progress {
+        display: flex;
+        align-items: center;
+        gap: 4px;
+        width: 100%;
+    }
+
+    .hash-progress-bar {
+        flex: 1;
+        height: 6px;
+        background: var(--border);
+        border-radius: 3px;
+        overflow: hidden;
+    }
+
+    .hash-progress-fill {
+        height: 100%;
+        width: 0%;
+        background: var(--primary);
+        border-radius: 3px;
+        transition: width 0.15s ease;
+    }
+
+    .hash-progress-fill.done {
+        background: #22c55e;
+        width: 100%;
+    }
+
+    /* ── Per-row verify result styling ───────────────────────── */
+    tr.verify-match td { background: #dcfce7; }
+    tr.verify-mismatch td { background: #fee2e2; }
+    tr.verify-missing td { background: #fef3c7; }
+    tr.verify-new td { background: #dbeafe; }
+    tr.verify-progress td:last-child { color: #6b7280; font-style: italic; }
+
+    .dropdown-item {
+        display: block;
+        width: 100%;
+        padding: 6px 12px;
+        border: none;
+        background: none;
+        text-align: left;
+        font-size: 0.8rem;
+        color: var(--text);
+        cursor: pointer;
+        white-space: nowrap;
+    }
+
+    .dropdown-item:hover {
+        background: var(--bg-secondary);
+    }
+
+    .dropdown-item:disabled {
+        opacity: 0.4;
+        cursor: not-allowed;
+    }
+
+}
+
+@media screen {
+    #transmittal-form .page-header .relative > input[type="text"] {
+        padding-top: 0.625rem;
+        padding-bottom: 0.25rem;
+        border-top: 0 !important;
+        border-left: 0 !important;
+        border-right: 0 !important;
+        border-bottom: 1px solid var(--border) !important;
+        border-radius: 0 !important;
+        background-color: var(--bg);
+        box-shadow: none !important;
+    }
+
+    #transmittal-form .page-header .relative > input[type="text"]:focus {
+        border-bottom-color: var(--primary);
+        box-shadow: none !important;
+    }
+
+    /* Remove underlines from title area inputs (type and title) */
+    #transmittal-form .page-header .title-area input[type="text"] {
+        border-bottom: 0 !important;
+    }
+
+    #transmittal-form .page-header label[for],
+    #transmittal-form .page-header .relative > label {
+        position: absolute;
+        left: 0.5rem;
+        top: -0.5rem;
+        font-weight: 700;
+        background: var(--bg);
+        padding: 0 0.25rem;
+        font-size: 10px;
+        color: var(--text-muted);
+        pointer-events: none;
+        z-index: 1;
+    }
+
+    #transmittal-form .page-header .relative {
+        margin-top: 0.375rem;
+    }
+
+    /* Boxed inputs (full-border, floating label) inside the grid need extra top
+       margin so the absolute-positioned label (-top-2 = -0.5rem) is not clipped */
+    #transmittal-form .page-header .grid .relative {
+        margin-top: 0.75rem;
+    }
+
+    /* ── From field rendered mailto link ──────────────────────── */
+    .from-render {
+        font-size: 12px;
+        font-family: var(--font-mono);
+        line-height: 1.6;
+        padding: 0.625rem 0.5rem 0.25rem;
+        border-bottom: 1px solid var(--border);
+    }
+
+    .from-mailto {
+        color: var(--primary);
+        text-decoration: none;
+    }
+
+    .from-mailto:hover {
+        text-decoration: underline;
+    }
+
+    /* ── To field rendered mailto links ───────────────────────── */
+    .to-render {
+        font-size: 12px;
+        font-family: var(--font-mono);
+        line-height: 1.6;
+        padding: 0.625rem 0.5rem 0.25rem;
+        border-bottom: 1px solid var(--border);
+        word-break: break-word;
+    }
+
+    .to-mailto {
+        color: var(--primary);
+        text-decoration: none;
+    }
+
+    .to-mailto:hover {
+        text-decoration: underline;
+    }
+
+    .to-sep {
+        color: var(--text-muted);
+    }
+
+}
+
+@media screen {
+    .table-wrapper {
+        width: 100%;
+        max-width: 100%;
+    }
+
+    .table-wrapper table {
+        table-layout: auto;
+        width: 100%;
+        border-collapse: collapse;
+        border: 1px solid var(--border);
+    }
+
+    /* Header cells — stick below app-header (height + padding + border) */
+    .table-wrapper thead th {
+        white-space: nowrap;
+        position: sticky;
+        top: calc(2.1rem + 0.6rem + 1px);
+        z-index: 1000;
+        background-color: var(--bg-secondary);
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+        border-left: 1px solid var(--border);
+        border-right: 1px solid var(--border);
+        border-bottom: 1px solid var(--border);
+        border-top: none;
+    }
+    .table-wrapper thead th:first-child { border-left: none; }
+    .table-wrapper thead th:last-child  { border-right: none; }
+
+    /* Body cells: all gray borders */
+    .table-wrapper tbody td {
+        white-space: nowrap;
+        border-left: 1px solid var(--border);
+        border-right: 1px solid var(--border);
+        border-top: 1px solid var(--border);
+        border-bottom: 1px solid var(--border);
+    }
+    .table-wrapper tbody td:first-child { border-left: none; }
+    .table-wrapper tbody td:last-child  { border-right: none; }
+    .table-wrapper tbody tr:first-child td { border-top: none; }
+    .table-wrapper tbody tr:last-child td  { border-bottom: none; }
+
+    /* Self-entry row */
+    .table-wrapper tbody tr.self-entry td {
+        background-color: var(--bg-hover);
+    }
+
+    /* 3: Title — only column that wraps */
+    .table-wrapper thead th:nth-child(3) {
+        white-space: normal;
+    }
+
+    .table-wrapper tbody td:nth-child(3) {
+        white-space: normal;
+        overflow-wrap: anywhere;
+    }
+
+    /* 7: Size — right aligned */
+    .table-wrapper thead th:nth-child(7),
+    .table-wrapper tbody td:nth-child(7) {
+        text-align: right;
+    }
+
+    /* Row delete button */
+    .row-delete-btn {
+        display: none;
+        border: none;
+        background: none;
+        color: #dc2626;
+        font-size: 0.85rem;
+        line-height: 1;
+        padding: 0 0.2rem;
+        margin-right: 0.15rem;
+        cursor: pointer;
+        vertical-align: middle;
+        opacity: 0.5;
+    }
+    .row-delete-btn:hover {
+        opacity: 1;
+    }
+    .table-wrapper tbody tr:hover .row-delete-btn {
+        display: inline;
+    }
+
+    /* Path diff indicator (verify mismatch) */
+    .path-diff {
+        font-size: 0.65rem;
+        line-height: 1.3;
+        margin-top: 2px;
+    }
+
+    .path-diff del {
+        color: #991b1b;
+        background: #fef2f2;
+    }
+
+    .path-diff ins {
+        color: #166534;
+        background: #f0fdf4;
+        text-decoration: none;
+        border-bottom: 1px solid #166534;
+    }
+}
+
+#remarks-render-container {
+    padding: 6px;
+}
+
+/* In edit mode the rendered preview is clickable to re-enter the editor */
+#remarks-render-container.remarks-clickable {
+    cursor: text;
+    border: 1px dashed #d1d5db;
+    border-radius: 0.25rem;
+    min-height: 3.5rem;
+}
+
+#remarks-render-container.remarks-clickable:hover {
+    border-color: #93c5fd;
+    background: #f0f7ff;
+}
+
+/* Placeholder shown when remarks are empty and editable */
+#remarks-render-container .remarks-placeholder {
+    color: #9ca3af;
+    font-style: italic;
+    font-size: 12px;
+    pointer-events: none;
+}
+
+#remarks-render h1,
+#remarks-render h2,
+#remarks-render h3,
+#remarks-render h4,
+#remarks-render h5,
+#remarks-render h6 {
+    margin: 0.5rem 0 0.25rem;
+    font-weight: 600;
+}
+
+#remarks-render h1 {
+    font-size: 1.25rem;
+    font-weight: 700;
+}
+
+#remarks-render h2 {
+    font-size: 1.125rem;
+    font-weight: 700;
+}
+
+#remarks-render h3 {
+    font-size: 1rem;
+    font-weight: 700;
+}
+
+#remarks-render h4 {
+    font-size: 0.9375rem;
+}
+
+#remarks-render h5 {
+    font-size: 0.875rem;
+}
+
+#remarks-render h6 {
+    font-size: 0.8125rem;
+}
+
+#remarks-render p {
+    margin: 0.5rem 0 0.85rem;
+}
+
+#remarks-render ul {
+    list-style: disc inside;
+    padding-left: 0.75rem;
+    margin: 0.25rem 0;
+}
+
+#remarks-render ol {
+    list-style: decimal inside;
+    padding-left: 0.75rem;
+    margin: 0.25rem 0;
+}
+
+#remarks-render li {
+    margin: 0.125rem 0;
+}
+
+#remarks-render blockquote {
+    border-left: 3px solid #e5e7eb;
+    padding-left: 0.75rem;
+    color: #374151;
+    margin: 0.25rem 0;
+}
+
+#remarks-render pre {
+    background: #f9fafb;
+    border: 1px solid #e5e7eb;
+    padding: 0.5rem;
+    border-radius: 0.25rem;
+    overflow: auto;
+}
+
+#remarks-render code {
+    background: #f3f4f6;
+    border: 1px solid #e5e7eb;
+    padding: 0 0.25rem;
+    border-radius: 0.125rem;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+}
+
+#remarks-render hr {
+    border: 0;
+    border-top: 1px solid #e5e7eb;
+    margin: 0.5rem 0;
+}
+
+#remarks-render del {
+    text-decoration: line-through;
+    color: #9ca3af;
+}
+
+#remarks-render a {
+    color: #2563eb;
+    text-decoration: underline;
+}
+
+#remarks-render table {
+    border-collapse: collapse;
+    width: 100%;
+    margin: 0.25rem 0;
+}
+
+#remarks-render th,
+#remarks-render td {
+    border: 1px solid #d1d5db;
+    padding: 0.25rem 0.5rem;
+    text-align: left;
+}
+
+#remarks-render th {
+    background: #f3f4f6;
+    font-weight: 600;
+}
+
+/* ── Button bar ───────────────────────────────────────────── */
+.md-toolbar {
+    display: flex;
+    gap: 2px;
+    padding: 3px 4px;
+    background: #f3f4f6;
+    border: 1px solid #d1d5db;
+    border-bottom: none;
+    border-radius: 0.25rem 0.25rem 0 0;
+}
+
+.md-toolbar-btn {
+    min-width: 26px;
+    height: 24px;
+    padding: 0 5px;
+    border: 1px solid transparent;
+    border-radius: 3px;
+    background: transparent;
+    font-size: 12px;
+    font-weight: 600;
+    color: #374151;
+    cursor: pointer;
+    line-height: 1;
+}
+
+.md-toolbar-btn:hover {
+    background: #e5e7eb;
+    border-color: #d1d5db;
+}
+
+.md-toolbar-btn:active {
+    background: #d1d5db;
+}
+
+/* ── Edit area ────────────────────────────────────────── */
+.md-edit-area {
+    position: relative;
+    min-height: 80px;
+    border: 1px solid #d1d5db;
+    border-radius: 0 0 0.25rem 0.25rem;
+}
+
+.md-input {
+    display: block;
+    width: 100%;
+    min-height: 80px;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    font-size: 12px;
+    line-height: 1.6;
+    padding: 6px 8px;
+    margin: 0;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+    tab-size: 4;
+    border: none;
+    outline: none;
+    resize: vertical;
+    background: #fff;
+    color: #111827;
+}
+
+.md-edit-area:focus-within {
+    border-color: #93c5fd;
+    box-shadow: 0 0 0 1px #93c5fd;
+}
+
+.table-header {
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+    gap: 0.2rem;
+    width: 100%;
+    padding: 0;
+}
+
+.table-header__caption {
+    font-weight: 600;
+    font-size: 0.7rem;
+    letter-spacing: 0.04em;
+    color: var(--text-muted);
+    margin-bottom: 0;
+}
+
+.table-header-cell {
+    padding: 0;
+}
+
+/* Transmittal uses a denser table — override shared .column-filter sizing */
+.column-filter {
+    font-size: 0.65rem;
+    padding: 0.1rem 0.3rem;
+    margin-top: 0.15rem;
+    line-height: 1.2;
+}
+
+/* ── Native <dialog> base ─────────────────────────────── */
+dialog.modal {
+    border: none;
+    border-radius: 0.75rem;
+    max-width: 32rem;
+    width: min(90%, 32rem);
+    box-shadow: 0 20px 60px rgba(15, 23, 42, 0.25);
+    padding: 1.5rem;
+    gap: 1.25rem;
+    background: var(--bg);
+    color: var(--text);
+}
+
+dialog.modal[open] {
+    display: flex;
+    flex-direction: column;
+}
+
+dialog.modal::backdrop {
+    background: rgba(17, 24, 39, 0.55);
+}
+
+/* Prevent background scroll while a modal dialog is open */
+html:has(dialog.modal[open]) {
+    overflow: hidden;
+}
+
+/* ── Shared modal layout ─────────────────────────────── */
+.modal__header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.75rem;
+}
+
+.modal__title {
+    font-size: 1.25rem;
+    line-height: 1.75rem;
+    font-weight: 700;
+    color: var(--text);
+    margin: 0;
+}
+
+.modal__close {
+    background: transparent;
+    border: none;
+    font-size: 1.5rem;
+    line-height: 1;
+    cursor: pointer;
+    color: var(--text-muted);
+}
+
+.modal__body {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.modal__options {
+    display: grid;
+    gap: 0.75rem;
+}
+
+.modal__footer {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.75rem;
+}
+
+.modal__feedback {
+    min-height: 1.25rem;
+    font-size: 0.85rem;
+    color: var(--danger);
+}
+
+/* ── Narrow modal variant ────────────────────────────── */
+dialog.modal--narrow {
+    max-width: 24rem;
+    width: min(90%, 24rem);
+}
+
+/* ── Publish field styles ────────────────────────────── */
+.publish-field__label {
+    display: block;
+    font-size: 0.7rem;
+    font-weight: 600;
+    color: var(--text-muted);
+}
+
+.publish-field__row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    margin-top: 0.25rem;
+}
+
+.publish-field__input {
+    border: 1px solid var(--border);
+    border-radius: 0.375rem;
+    padding: 0.35rem 0.5rem;
+    font-size: 0.85rem;
+    width: 100%;
+    background: var(--bg);
+    color: var(--text);
+}
+
+.publish-field__warning {
+    font-size: 0.7rem;
+    color: #92400e;
+    white-space: nowrap;
+}
+
+.publish-outputs {
+    border: none;
+    margin: 0;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 0.35rem;
+}
+
+.publish-outputs legend {
+    margin-bottom: 0.25rem;
+}
+
+.publish-check {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.8rem;
+    cursor: pointer;
+}
+
+/* ── Key dialog ──────────────────────────────────────── */
+.key-dialog__desc {
+    font-size: 0.85rem;
+    color: var(--text-muted);
+    margin: 0 0 0.75rem;
+}
+
+.key-dialog__actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+/* ── Success notification ────────────────────────────── */
+@keyframes notification-slide-in {
+    from { transform: translateX(100%); opacity: 0; }
+    to { transform: translateX(0); opacity: 1; }
+}
+
+.publish-notification {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    background: #10b981;
+    color: white;
+    padding: 1rem 1.5rem;
+    border-radius: 0.5rem;
+    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
+    z-index: 10000;
+    max-width: 400px;
+    animation: notification-slide-in 0.3s ease-out;
+}
+
+.publish-notification__title {
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+}
+
+.publish-notification__file {
+    font-size: 0.875rem;
+}
+
+.publish-notification__close {
+    margin-top: 0.5rem;
+    background: rgba(255, 255, 255, 0.2);
+    border: none;
+    color: white;
+    padding: 0.25rem 0.75rem;
+    border-radius: 0.25rem;
+    cursor: pointer;
+    font-size: 0.875rem;
+}
+
+/* ── Responsive ──────────────────────────────────────── */
+@media (max-width: 480px) {
+    dialog.modal {
+        padding: 1.25rem;
+        gap: 1rem;
+    }
+
+    .modal__footer {
+        flex-direction: column-reverse;
+        align-items: stretch;
+    }
+
+    .key-dialog__actions {
+        flex-direction: column;
+        align-items: stretch;
+    }
+}
+
+/* Tailwind-inspired utility subset required by template.html */
+
+/* Typography */
+.font-sans { font-family: "Inter", "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif; }
+.font-mono { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; }
+.font-semibold { font-weight: 600; }
+.font-bold { font-weight: 700; }
+.italic { font-style: italic; }
+.text-left { text-align: left; }
+.text-center { text-align: center; }
+.text-xs { font-size: 0.75rem; line-height: 1rem; }
+.text-sm { font-size: 0.875rem; line-height: 1.25rem; }
+.text-base { font-size: 1rem; line-height: 1.5rem; }
+.text-lg { font-size: 1.125rem; line-height: 1.75rem; }
+.text-xl { font-size: 1.25rem; line-height: 1.75rem; }
+.text-2xl { font-size: 1.5rem; line-height: 2rem; }
+.text-\[12px\] { font-size: 12px; line-height: 1.4; }
+.text-\[10px\] { font-size: 10px; line-height: 1.3; }
+.text-gray-900 { color: #111827; }
+.text-gray-700 { color: #374151; }
+.text-gray-600 { color: #4b5563; }
+.text-gray-500 { color: #6b7280; }
+.text-gray-400 { color: #9ca3af; }
+.text-blue-600 { color: #2563eb; }
+.text-green-600 { color: #16a34a; }
+.text-red-600 { color: #dc2626; }
+.uppercase { text-transform: uppercase; }
+.tracking-wide { letter-spacing: 0.1em; }
+.leading-6 { line-height: 1.5rem; }
+.leading-snug { line-height: 1.375rem; }
+
+/* Backgrounds */
+.bg-white { background-color: #ffffff; }
+.bg-transparent { background-color: transparent; }
+.bg-gray-50 { background-color: #f9fafb; }
+.bg-gray-100 { background-color: #f3f4f6; }
+
+/* Borders */
+.border { border: 1px solid #d1d5db; }
+.border-0 { border: 0; }
+.border-b { border-bottom: 1px solid #d1d5db; }
+.border-t { border-top: 1px solid #d1d5db; }
+.border-gray-300 { border-color: #d1d5db; }
+.border-gray-200 { border-color: #e5e7eb; }
+.border-gray-100 { border-color: #f3f4f6; }
+.rounded-none { border-radius: 0; }
+.rounded-sm { border-radius: 0.125rem; }
+.rounded { border-radius: 0.25rem; }
+.rounded-md { border-radius: 0.375rem; }
+
+/* Effects */
+.shadow-lg { box-shadow: 0 10px 25px rgba(15, 23, 42, 0.15); }
+.transition-colors { transition: color 150ms ease, background-color 150ms ease, border-color 150ms ease, box-shadow 150ms ease; }
+
+/* Flex / Grid */
+.flex { display: flex; }
+.flex-col { flex-direction: column; }
+.flex-row { flex-direction: row; }
+.flex-1 { flex: 1 1 0%; }
+.items-center { align-items: center; }
+.items-start { align-items: flex-start; }
+.justify-between { justify-content: space-between; }
+.justify-center { justify-content: center; }
+.gap-2 { gap: 0.5rem; }
+.gap-0\.5 { gap: 0.125rem; }
+.grid { display: grid; }
+.grid-cols-12 { grid-template-columns: repeat(12, minmax(0, 1fr)); }
+.col-span-4 { grid-column: span 4 / span 4; }
+.col-span-6 { grid-column: span 6 / span 6; }
+.col-span-12 { grid-column: span 12 / span 12; }
+
+/* Positioning */
+.block { display: block; }
+.relative { position: relative; }
+.absolute { position: absolute; }
+.sticky { position: sticky; }
+.left-0 { left: 0; }
+.top-0 { top: 0; }
+.top-6 { top: 1.5rem; }
+.top-full { top: 100%; }
+.z-10 { z-index: 10; }
+.z-20 { z-index: 20; }
+.z-50 { z-index: 50; }
+
+/* Sizing */
+.w-full { width: 100%; }
+.w-auto { width: auto; }
+.w-64 { width: 16rem; }
+.w-5 { width: 1.25rem; }
+.h-5 { height: 1.25rem; }
+.h-6 { height: 1.5rem; }
+.h-auto { height: auto; }
+.min-w-0 { min-width: 0; }
+.max-w-\[1200px\] { max-width: 1200px; }
+.max-w-\[1600px\] { max-width: 1600px; }
+.max-h-96 { max-height: 24rem; }
+.min-h-\[3.5rem\] { min-height: 3.5rem; }
+.overflow-auto { overflow: auto; }
+
+/* Spacing */
+.p-2 { padding: 0.5rem; }
+.px-0 { padding-left: 0; padding-right: 0; }
+.px-1 { padding-left: 0.25rem; padding-right: 0.25rem; }
+.px-2 { padding-left: 0.5rem; padding-right: 0.5rem; }
+.px-3 { padding-left: 0.75rem; padding-right: 0.75rem; }
+.px-1\.5 { padding-left: 0.375rem; padding-right: 0.375rem; }
+.py-0 { padding-top: 0; padding-bottom: 0; }
+.py-0\.5 { padding-top: 0.125rem; padding-bottom: 0.125rem; }
+.py-1 { padding-top: 0.25rem; padding-bottom: 0.25rem; }
+.py-1\.5 { padding-top: 0.375rem; padding-bottom: 0.375rem; }
+.pt-1 { padding-top: 0.25rem; }
+.pt-5 { padding-top: 1.25rem; }
+.pb-2 { padding-bottom: 0.5rem; }
+.pb-3 { padding-bottom: 0.75rem; }
+.mt-1 { margin-top: 0.25rem; }
+.mt-2 { margin-top: 0.5rem; }
+.mb-1 { margin-bottom: 0.25rem; }
+.my-1 { margin-top: 0.25rem; margin-bottom: 0.25rem; }
+.gap-x-6 { column-gap: 1.5rem; }
+.gap-y-3 { row-gap: 0.75rem; }
+
+/* Drag-hover utilities (used by drop zone handlers) */
+.ring-2 { box-shadow: 0 0 0 2px var(--tw-ring-color, rgba(59, 130, 246, 0.5)); }
+.ring-blue-400 { --tw-ring-color: rgba(96, 165, 250, 0.7); }
+.bg-blue-50 { background-color: #eff6ff; }
+
+/* Validation error state (applied via JS in validation.js) */
+.ring-red-400 { box-shadow: 0 0 0 2px rgba(248, 113, 113, 0.5); }
+.border-red-500 { border-color: #ef4444 !important; }
+
+/* Hover & focus states */
+.hover\:bg-gray-50:hover { background-color: #f9fafb; }
+.hover\:bg-gray-100:hover { background-color: #f3f4f6; }
+.hover\:underline:hover { text-decoration: underline; }
+.focus\:outline-none:focus { outline: none; }
+.focus\:border-blue-400:focus { border-color: #60a5fa; }
+.focus\:ring-1:focus { box-shadow: 0 0 0 1px rgba(59, 130, 246, 0.35); }
+.focus\:ring-blue-400:focus { box-shadow: 0 0 0 2px rgba(96, 165, 250, 0.45); }
+.focus\:bg-white:focus { background-color: #ffffff; }
+.disabled\:pointer-events-none:disabled { pointer-events: none; }
+
+/* Table helpers */
+.table-auto { table-layout: auto; }
+.border-collapse { border-collapse: collapse; }
+
+/* Print helpers */
+@media print {
+    .print\:hidden { display: none !important; }
+}
+
+@media print {
+    body {
+        background: none;
+        padding: 0;
+    }
+
+    .page-container {
+        width: 100%;
+        margin: 0;
+        padding: 0;
+        min-height: 0;
+        box-shadow: none;
+        border: none;
+    }
+
+    @page {
+        margin: 0.375in;
+        size: 8.5in 11in;
+    }
+
+    .table-wrapper {
+        overflow: visible !important;
+        max-height: none !important;
+    }
+
+    thead th {
+        position: static !important;
+        top: auto !important;
+    }
+
+    /* Hide interactive-only elements in print */
+    .table-filter-input,
+    .logo-placeholder,
+    .drop-zone-label {
+        display: none !important;
+    }
+
+
+    /* Adjust table header caption spacing when filters are hidden */
+    .table-header__caption {
+        display: block;
+        padding: 0.25rem 0;
+    }
+
+    table {
+        width: 100% !important;
+        table-layout: fixed !important;
+        border: 1px solid #999 !important;
+        border-collapse: collapse !important;
+    }
+
+    th {
+        background-color: #e0e0e0 !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+        border-left: 1px solid #999 !important;
+        border-right: 1px solid #999 !important;
+        border-bottom: 1px solid #999 !important;
+        border-top: none !important;
+    }
+
+    td {
+        border-left: 1px solid #999 !important;
+        border-right: 1px solid #999 !important;
+        border-top: 1px solid #999 !important;
+        border-bottom: 1px solid #999 !important;
+    }
+
+    tr.self-entry td {
+        background-color: #f3f4f6 !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+    }
+
+    /* Fixed column widths for print */
+    thead th:nth-child(1),
+    tbody td:nth-child(1) {
+        width: 18% !important;
+    }
+
+    thead th:nth-child(2),
+    tbody td:nth-child(2) {
+        width: 30% !important;
+    }
+
+    thead th:nth-child(3),
+    tbody td:nth-child(3) {
+        width: 10% !important;
+    }
+
+    thead th:nth-child(4),
+    tbody td:nth-child(4) {
+        width: 8% !important;
+    }
+
+    thead th:nth-child(5),
+    tbody td:nth-child(5) {
+        width: 6% !important;
+    }
+
+    thead th:nth-child(6),
+    tbody td:nth-child(6) {
+        width: 8% !important;
+    }
+
+    thead th:nth-child(7),
+    tbody td:nth-child(7) {
+        width: 20% !important;
+    }
+
+    /* Ensure text wraps properly in print */
+    tbody td {
+        word-wrap: break-word;
+        overflow-wrap: break-word;
+    }
+
+    /* SHA256 column - allow breaking */
+    tbody td:nth-child(7) {
+        word-break: break-all;
+        font-size: 7pt !important;
+    }
+
+    /* From field: show rendered mailto link, hide input */
+    #from { display: none !important; }
+    .from-render {
+        display: block !important;
+    }
+    .from-mailto {
+        color: #2563eb !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+    }
+
+    /* To field: show rendered mailto links, hide input */
+    #to { display: none !important; }
+    .to-render {
+        display: block !important;
+    }
+    .to-mailto {
+        color: #2563eb !important;
+        -webkit-print-color-adjust: exact;
+        print-color-adjust: exact;
+    }
+}
+
+</style>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ZDDC Transmittal</title>
+</head>
+
+<body class="font-sans text-gray-900">
+    <div class="app-header print:hidden" data-no-disable="true">
+        <div class="split-button" id="bottom-menu" hidden>
+            <button id="bottom-toggle" type="button" class="btn btn-primary split-button__toggle" data-no-disable="true" aria-haspopup="true" aria-expanded="false">&#x25BE;</button>
+            <button id="bottom-primary" type="button" class="btn btn-primary" data-no-disable="true">Publish</button>
+            <div class="dropdown-menu hidden" role="menu" id="bottom-dropdown"></div>
+        </div>
+        <span id="no-js-notice" class="text-gray-400 text-xs italic">JavaScript not available</span>
+        <div class="header-title-group">
+            <span class="app-header__title">ZDDC Transmittal</span>
+            <span class="build-timestamp">v0.0.1</span>
+        </div>
+        <div class="app-header__spacer"></div>
+        <div class="app-header__icons">
+            <button type="button" id="theme-btn" class="btn btn-secondary" title="Theme: auto (follows OS)" aria-label="Theme: auto (follows OS)">◐</button>
+            <button type="button" id="help-btn" class="btn btn-secondary" aria-label="Help" title="Help">?</button>
+        </div>
+    </div>
+    <div class="page-container">
+    <form id="transmittal-form">
+    <input type="hidden" id="mode" value="edit">
+    <input type="hidden" id="published" value="false">
+    <header class="page-header flex flex-col gap-2 p-2 max-w-[1600px] relative">
+        <div class="logo-row">
+            <div class="logo-cell" id="left-logo-cell" data-drop-zone="logo-left">
+                <img id="left-logo" class="logo-img" alt="Sender Logo">
+                <span class="logo-placeholder">Drop sender logo (optional)</span>
+                <span class="drop-zone-label">Drop sender logo</span>
+            </div>
+            <div class="title-area">
+              <div class="type-combo" id="type-combo">
+                <input type="hidden" name="type" id="type" value="Transmittal">
+                <span id="type-display" role="combobox" contenteditable="true" class="type-display w-full text-2xl font-bold bg-transparent border-0 p-0 focus:outline-none text-center" data-placeholder="Type">Transmittal</span>
+                <div class="type-combo__menu hidden" id="type-menu" role="listbox">
+                  <button type="button" class="type-combo__option" role="option" data-value="Transmittal">Transmittal</button>
+                  <button type="button" class="type-combo__option" role="option" data-value="Submittal">Submittal</button>
+                </div>
+              </div>
+              <input type="text" name="title" id="title" placeholder="Title" class="w-full text-base italic bg-transparent border-0 p-0 focus:outline-none disabled:pointer-events-none text-center" value="">
+            </div>
+            <div class="logo-cell" id="right-logo-cell" data-drop-zone="logo-right">
+                <img id="right-logo" class="logo-img" alt="Receiver Logo">
+                <span class="logo-placeholder">Drop receiver logo (optional)</span>
+                <span class="drop-zone-label">Drop receiver logo</span>
+            </div>
+        </div>
+        
+        
+
+        <div id="header-info" data-drop-zone="header">
+        <div class="drop-zone-label">Drop HTML or JSON&#10;to import transmittal data</div>
+        <div class="header-names w-full bg-gray-50 border border-gray-100 rounded-md px-3 py-1.5 flex flex-col gap-0.5">
+            <h2 id="owner-name" class="text-xl font-semibold" data-placeholder="Owner Name"></h2>
+            <h2 id="project-name" class="text-lg font-semibold" data-placeholder="Project Name"></h2>
+            <div id="project-number" class="text-sm text-gray-700" data-placeholder="Project Number"></div>
+        </div>
+
+        <div class="grid grid-cols-12 gap-x-6 gap-y-3 items-start">
+          <!-- Row 1: Tracking Number (A), Date (B) -->
+          <div class="col-span-6">
+            <div class="relative">
+              <input type="text" name="tracking-number" id="tracking-number" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <label for="tracking-number" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Tracking Number</label>
+            </div>
+          </div>
+          <div class="col-span-6">
+            <div class="relative">
+              <input type="text" name="date" id="date" placeholder="YYYY-MM-DD" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <label for="date" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Date</label>
+              <input type="date" id="date-picker-hidden" style="position:absolute;width:0;height:0;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);" tabindex="-1" aria-hidden="true">
+            </div>
+          </div>
+
+          <!-- Row 2: From | Purpose (+ Response Due for Submittals) -->
+          <div class="col-span-6">
+            <div class="relative">
+              <input type="text" name="from" id="from" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <div id="from-render" class="from-render hidden"></div>
+              <label for="from" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">From</label>
+            </div>
+          </div>
+          <div class="col-span-6">
+            <div class="flex gap-x-6" id="purpose-group">
+              <div class="relative flex-1">
+                <input type="text" name="purpose" id="purpose" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+                <label for="purpose" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Purpose</label>
+              </div>
+              <div class="relative flex-1 hidden" id="response-due-wrapper">
+                <input type="text" name="response-due" id="response-due" placeholder="YYYY-MM-DD" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+                <label for="response-due" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Response Due</label>
+                <input type="date" id="response-due-picker-hidden" style="position:absolute;width:0;height:0;padding:0;border:0;overflow:hidden;clip:rect(0,0,0,0);" tabindex="-1" aria-hidden="true">
+              </div>
+            </div>
+          </div>
+
+          <!-- Row 3: To full width -->
+          <div class="col-span-12">
+            <div class="relative">
+              <input type="text" name="to" id="to" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-mono focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400">
+              <div id="to-render" class="to-render hidden"></div>
+              <label for="to" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">To</label>
+            </div>
+          </div>
+
+          <!-- Row 4: Subject full width -->
+          <div class="col-span-12">
+            <div class="relative">
+              <input type="text" name="subject" id="subject" placeholder="" class="w-full min-w-0 bg-white border border-gray-300 rounded px-2 pt-5 pb-2 text-[12px] font-bold focus:outline-none focus:ring-1 focus:ring-blue-400 focus:border-blue-400" />
+              <label for="subject" class="absolute left-2 -top-2 bg-white px-1 text-[10px] text-gray-700 font-semibold pointer-events-none">Subject</label>
+            </div>
+          </div>
+
+          <!-- Row 5: Remarks full width (Markdown) -->
+          <div class="col-span-12">
+            <div class="relative w-full">
+              <div id="remarks-wrapper" class="w-full">
+                <textarea id="remarks" name="remarks" placeholder="Remarks" aria-label="Remarks" class="px-2 pt-1 pb-3 bg-white border-0 rounded-none text-[12px] w-full min-h-[3.5rem] leading-snug resize-y"></textarea>
+                <div id="remarks-render-container" class="w-full p-2 overflow-auto">
+                  <div id="remarks-render" class="text-sm"></div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+        </div>
+    </header>
+
+    <main class="p-2 max-w-[1600px]">
+
+          <!-- Step: Integrity — "Is this verified?" -->
+          <div class="workflow-step" id="integrity-section">
+            <h3 class="workflow-step__label">
+              Integrity
+              <span id="signature-status-static" class="workflow-badge workflow-badge--warn" data-hydrate-hide="true">Not Validated (requires JavaScript)</span>
+            </h3>
+            <div id="integrity-body" class="integrity-body">
+              <div id="digest-display"></div>
+              <div id="signatures-list"></div>
+              <button id="add-signature-btn" type="button" class="btn btn-secondary btn-sm hidden print:hidden">Add Signature</button>
+            </div>
+          </div>
+
+        <!-- file table goes here (tracking number, title, revision, status) -->
+        <div id="file-table-drop-zone" data-drop-zone="file-table">
+        <div class="drop-zone-label">Drop folder to scan / verify&#10;Drop HTML or JSON to import</div>
+        <div class="table-wrapper mt-2">
+         <table class="table-auto text-[10px] w-full">
+            <thead>
+                <tr>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap"><span class="table-header__caption">#</span></th>
+                    <th class="bg-gray-100 text-left px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">TRACKING NUMBER</span>
+                            <input type="text" data-no-disable="true" data-filter-field="trackingNumber" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by tracking number">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-left px-2 py-1 sticky top-0 z-20 w-full">
+                        <label class="table-header">
+                            <span class="table-header__caption">TITLE</span>
+                            <input type="text" data-no-disable="true" data-filter-field="title" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by title">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">REVISION</span>
+                            <input type="text" data-no-disable="true" data-filter-field="revision" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by revision">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">STATUS</span>
+                            <input type="text" data-no-disable="true" data-filter-field="status" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by status">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-center px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">EXT</span>
+                            <input type="text" data-no-disable="true" data-filter-field="extension" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by extension">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-right px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">SIZE</span>
+                            <input type="text" data-no-disable="true" data-filter-field="fileSize" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by size">
+                        </label>
+                    </th>
+                    <th class="bg-gray-100 text-left px-2 py-1 sticky top-0 z-20 whitespace-nowrap">
+                        <label class="table-header">
+                            <span class="table-header__caption">SHA256</span>
+                            <input type="text" data-no-disable="true" data-filter-field="sha256" class="column-filter" placeholder="filter" inputmode="text" spellcheck="false" aria-label="Filter by SHA256">
+                        </label>
+                    </th>
+                </tr>
+            </thead>
+            <tbody>
+                <tr>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                    <td></td>
+                </tr>
+            </tbody>
+         </table>
+        </div>
+        </div>
+
+    </main>
+
+    <footer class="page-footer print:hidden">
+        <div class="page-footer__inner">
+            <span id="data-status" class="text-gray-600 text-[10px]" aria-live="polite"></span>
+            <span id="selected-directory" class="workflow-dir text-[10px]"></span>
+        </div>
+    </footer>
+    </form>
+    </div>
+
+    <dialog id="publish-modal" class="modal" data-edit-only="true" aria-labelledby="publish-modal-title">
+      <div class="modal__header">
+        <h2 id="publish-modal-title" class="modal__title">Publish Transmittal</h2>
+        <button type="button" class="modal__close" data-modal-close aria-label="Close">&times;</button>
+      </div>
+      <div class="modal__body">
+        <div id="publish-date-row" class="publish-field">
+          <label for="publish-date-input" class="publish-field__label">Date</label>
+          <div class="publish-field__row">
+            <input type="text" id="publish-date-input" class="publish-field__input" placeholder="YYYY-MM-DD" pattern="\d{4}-\d{2}-\d{2}">
+            <span id="publish-date-warning" class="publish-field__warning" hidden></span>
+          </div>
+        </div>
+        <fieldset class="publish-outputs">
+          <legend class="publish-field__label">Output</legend>
+          <label class="publish-check">
+            <input type="checkbox" id="publish-save-folder"> Save in directory
+          </label>
+          <label class="publish-check">
+            <input type="checkbox" id="publish-download-html"> Download HTML
+          </label>
+        </fieldset>
+      </div>
+      <div class="modal__feedback" id="publish-modal-feedback" role="status" aria-live="polite"></div>
+      <div class="modal__footer">
+        <button type="button" class="btn btn-secondary" data-modal-close>Cancel</button>
+        <button type="button" class="btn btn-secondary" id="publish-draft-btn">Save Draft</button>
+        <button type="button" class="btn btn-secondary" id="publish-signed-btn">Publish Signed</button>
+        <button type="button" class="btn btn-primary" id="publish-confirm">Publish</button>
+      </div>
+    </dialog>
+
+    <dialog id="key-dialog" class="modal modal--narrow" aria-labelledby="key-dialog-title">
+      <div class="modal__header">
+        <h2 id="key-dialog-title" class="modal__title">Signing Key</h2>
+        <button type="button" class="modal__close" data-modal-close aria-label="Close">&times;</button>
+      </div>
+      <div class="modal__body">
+        <p class="key-dialog__desc">Select your signing key file or generate a new key pair.</p>
+        <div class="key-dialog__actions">
+          <button type="button" class="btn btn-secondary" id="key-select-file">Select Key File</button>
+          <button type="button" class="btn btn-secondary" id="key-generate">Generate New Key</button>
+        </div>
+        <div id="key-generate-panel" hidden>
+          <label class="publish-field__label" for="key-password">Password (optional)</label>
+          <input type="password" id="key-password" class="publish-field__input" placeholder="Leave blank for no password" autocomplete="new-password">
+          <label class="publish-field__label" for="key-password-confirm" style="margin-top:0.25rem;">Confirm password</label>
+          <input type="password" id="key-password-confirm" class="publish-field__input" placeholder="Confirm password" autocomplete="new-password">
+          <div class="key-dialog__actions" style="margin-top:0.5rem;">
+            <button type="button" class="btn btn-primary" id="key-generate-confirm">Generate &amp; Download</button>
+            <button type="button" class="btn btn-secondary" id="key-generate-cancel">Back</button>
+          </div>
+        </div>
+        <div class="modal__feedback" id="key-dialog-feedback" role="status" aria-live="polite"></div>
+      </div>
+    </dialog>
+
+    <dialog id="password-dialog" class="modal modal--narrow" aria-labelledby="password-dialog-title">
+      <div class="modal__header">
+        <h2 id="password-dialog-title" class="modal__title">Enter Key Password</h2>
+        <button type="button" class="modal__close" data-modal-close aria-label="Close">&times;</button>
+      </div>
+      <div class="modal__body">
+        <p id="password-dialog-fingerprint" class="key-dialog__desc"></p>
+        <input type="password" id="password-dialog-input" class="publish-field__input" placeholder="Password" autocomplete="current-password">
+        <div class="modal__feedback" id="password-dialog-feedback" role="status" aria-live="polite"></div>
+      </div>
+      <div class="modal__footer">
+        <button type="button" class="btn btn-secondary" data-modal-close>Cancel</button>
+        <button type="button" class="btn btn-primary" id="password-dialog-ok">Unlock</button>
+      </div>
+    </dialog>
+
+    <!-- Help panel (non-modal slide-out) -->
+    <aside id="help-panel" class="help-panel" hidden aria-labelledby="help-panel-title">
+      <div class="help-panel__header">
+        <h2 id="help-panel-title" class="help-panel__title">Help</h2>
+        <button type="button" class="help-panel__close" id="help-panel-close" aria-label="Close">&times;</button>
+      </div>
+      <div class="help-panel__body">
+        <h3>What is a Transmittal?</h3>
+        <p>A transmittal is a cover sheet that travels with a set of files. It records <em>what</em> was sent, <em>to whom</em>, and <em>when</em>. This tool produces a single self-contained HTML file that serves as both the cover sheet and a cryptographic proof of what was delivered.</p>
+        <p><strong>How it works:</strong> Each file in the transmittal is fingerprinted with a SHA-256 hash &mdash; a value computed from the file&rsquo;s contents. Change even one byte and the hash changes, so a matching hash proves the file is unaltered. The transmittal then hashes the entire payload (header, file list, and all per-file hashes) into a single <em>digest</em>. Optionally, one or more people can digitally sign that digest.</p>
+
+        <h3>Typical Workflow</h3>
+        <ol>
+          <li><strong>Fill in the header</strong> &mdash; tracking number, date, recipient, project, etc.</li>
+          <li>Optionally <em>Save Draft</em> to create a reusable template.</li>
+          <li><strong>Add files</strong> &mdash; paste rows from a spreadsheet, or use <em>Scan Directory</em> to read a folder and compute hashes automatically.</li>
+          <li><strong>Review</strong> the file table and remarks.</li>
+          <li>Use <em>Verify Directory</em> to confirm every listed file is present and unchanged.</li>
+          <li><strong>Publish</strong> &mdash; click <em>Publish</em> for an unsigned digest, or use the dropdown for <em>Publish Signed</em> (with a signing key) or <em>Save Draft</em>. The output is saved to the working directory, or downloaded if no directory is selected.</li>
+          <li><strong>Distribute</strong> &mdash; send the HTML alongside the actual files.</li>
+        </ol>
+
+        <h3>Signing Keys</h3>
+        <p>Signing keys are stored in <code>.zddc-key</code> files. When generating a new key, you can optionally protect it with a password. Password-protected keys require the password each time they are used to sign.</p>
+        <p>Keys without a password work immediately, like an unprotected SSH key.</p>
+
+        <h3>Verification Levels</h3>
+        <p>A published transmittal provides up to four escalating levels of integrity protection. Higher levels guard against increasingly sophisticated threats:</p>
+        <ol>
+          <li><strong>Static HTML</strong> &mdash; A human-readable record of everything sent. Works without JavaScript (e.g.&nbsp;on a SharePoint site). No cryptographic protection.</li>
+          <li><strong>Digest check</strong> &mdash; With JavaScript, the tool recomputes the SHA-256 digest and compares it to the stored value. A match proves nothing changed since publication. Detects accidental corruption, but someone could alter both the data and the digest.</li>
+          <li><strong>Digital signatures</strong> &mdash; ECDSA signatures bind the digest to a signer&rsquo;s private key. Any change invalidates the signature, preventing undetected tampering. Add signatures after publishing via <em>Add Signature</em>.</li>
+          <li><strong>Independent verification</strong> &mdash; A tampered HTML file could ship modified JavaScript that always says &ldquo;Verified.&rdquo; To rule this out, the recipient opens the sender&rsquo;s file in their <em>own</em> trusted copy of the tool using <em>Import HTML</em>. This extracts the raw data and re-verifies it with the recipient&rsquo;s own code. Use this level for anything that matters.</li>
+        </ol>
+        <p class="text-sm text-gray-500">Level&nbsp;4 assumes the recipient&rsquo;s tool is trustworthy (downloaded from a known source or built from source). A reference instance is at <a href="https://zddc.varasys.io/releases/transmittal_latest.html" target="_blank" rel="noopener">zddc.varasys.io</a>.</p>
+
+        <h3>Menu Actions</h3>
+        <p>Actions available from the dropdown button. <span class="help-badge help-badge--draft">draft</span> items appear only while editing. <span class="help-badge help-badge--published">published</span> items appear only after publishing. Unmarked items appear in both modes.</p>
+
+        <dl>
+          <dt>Save Draft <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Downloads the current state as an HTML file. Reopen it later to continue editing, or use it as a template for new transmittals.</dd>
+
+          <dt>Revise <span class="help-badge help-badge--published">published</span></dt>
+          <dd>Unlocks a published transmittal back into an editable draft.</dd>
+
+          <dt>Add Signature <span class="help-badge help-badge--published">published</span></dt>
+          <dd>Signs the digest with a new ECDSA key and downloads the updated file. Multiple people can sign sequentially.</dd>
+
+          <dt>Acknowledge Receipt <span class="help-badge help-badge--published">published</span></dt>
+          <dd>Same as Add Signature, but labeled &ldquo;Received By&rdquo; in the signature list &mdash; used by the recipient to confirm delivery.</dd>
+        </dl>
+
+        <h4>Table Clipboard</h4>
+        <dl>
+          <dt>Paste New Rows <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Replaces the file table with tab-separated data from the clipboard (e.g.&nbsp;copied from Excel).</dd>
+          <dt>Paste Append Rows <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Appends clipboard rows to the existing file table.</dd>
+          <dt>Copy Table</dt>
+          <dd>Copies the file table as tab-separated text for pasting into spreadsheets.</dd>
+        </dl>
+
+        <h4>Data Import &amp; Export</h4>
+        <dl>
+          <dt>Import HTML</dt>
+          <dd>Opens a published transmittal HTML, extracts its data, and re-verifies it with your own code (Level&nbsp;4). You can also drag-and-drop an HTML or JSON file directly onto the <strong>Header</strong> or <strong>File table</strong> drop zones &mdash; drag anything over the page to reveal the zones.</dd>
+          <dt>Copy JSON</dt>
+          <dd>Copies the raw transmittal data as JSON for backup or transfer.</dd>
+          <dt>Paste JSON <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Loads transmittal data from JSON on the clipboard.</dd>
+        </dl>
+
+        <h4>Drag-and-Drop Zones</h4>
+        <p>Drag any file or folder over the page to reveal labelled drop zones. Zones that can accept your data are highlighted in blue; others are dimmed.</p>
+        <dl>
+          <dt>Sender / Receiver logo zones</dt>
+          <dd>Top-left and top-right areas. Accept image files. Edit mode only.</dd>
+          <dt>Header zone <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>The form header area. Accepts a transmittal HTML or JSON file to import all fields.</dd>
+          <dt>File table zone</dt>
+          <dd>The document list area. Accepts a folder (triggers Scan or Verify), or a transmittal HTML/JSON file.</dd>
+        </dl>
+
+        <h4>Directory Operations</h4>
+        <p class="text-sm text-gray-500">Requires a Chromium-based desktop browser (File System Access API).</p>
+        <dl>
+          <dt>Scan Directory <span class="help-badge help-badge--draft">draft</span></dt>
+          <dd>Picks a local folder, lists every file, and computes SHA-256 hashes to populate the file table.</dd>
+          <dt>Verify Directory</dt>
+          <dd>Picks a local folder and checks that each file on disk matches its hash in the transmittal.</dd>
+        </dl>
+
+        <h4>Other</h4>
+        <dl>
+          <dt>Create Index</dt>
+          <dd>Scans transmittal folders and builds a <code>.archive</code> directory of small HTML redirects keyed by tracking number, revision, and hash &mdash; enabling direct links between documents in a file-based archive.</dd>
+          <dt>Reset</dt>
+          <dd>Clears everything and restores the blank template.</dd>
+        </dl>
+      </div>
+    </aside>
+
+    <!-- Single source of truth for all data; replace this block to swap content -->
+    <!-- Hydration: Populate static content from JSON on publish -->
+    <script id="transmittal-data" type="application/json">
+{
+  "envelope": {
+    "version": 1,
+    "digestAlgorithm": "SHA-256",
+    "digest": "",
+    "digestedAt": "",
+    "signatureAlgorithm": "ECDSA-P256-SHA256",
+    "signatures": []
+  },
+  "payload": {
+    "version": 1,
+    "type": "Transmittal",
+    "title": "",
+    "client": "",
+    "project": "",
+    "projectNumber": "",
+    "date": "",
+    "trackingNumber": "",
+    "from": "",
+    "to": "",
+    "purpose": "",
+    "responseDue": "",
+    "subject": "",
+    "remarks": "",
+    "files": []
+  },
+  "presentation": {
+    "leftLogo": "",
+    "rightLogo": "",
+    "theme": "default",
+    "customCss": ""
+  }
+}
+    </script>
+<script>
+/**
+ * ZDDC — shared naming convention library
+ *
+ * Canonical implementation of all ZDDC filename, folder name, tracking number,
+ * revision, and status logic.  Included in every tool's build via shared/zddc.js.
+ *
+ * Exposed as window.zddc (plain global) so it works with every tool's module
+ * pattern (archive globals, classifier IIFE, transmittal IIFE, mdedit globals).
+ *
+ * Public API
+ * ----------
+ *   zddc.parseFilename(str)        → ParsedFile | null
+ *   zddc.parseFolder(str)          → ParsedFolder | null
+ *   zddc.parseRevision(str)        → ParsedRevision
+ *   zddc.formatFilename(parts)     → string
+ *   zddc.formatFolder(parts)       → string
+ *   zddc.compareRevisions(a, b)    → number  (-1 | 0 | 1)
+ *   zddc.isValidStatus(str)        → boolean
+ *   zddc.STATUSES                  → string[]
+ *
+ * ParsedFile   { trackingNumber, revision, status, title, extension }
+ * ParsedFolder { date, trackingNumber, status, title }
+ * ParsedRevision { base, modifier, modifierType, modifierNumber, isDraft, full }
+ */
+
+(function (root) {
+    'use strict';
+
+    // ── Valid status codes ───────────────────────────────────────────────────
+
+    /**
+     * Complete list of valid ZDDC document status codes.
+     * '---' denotes an unknown or not-yet-assigned status.
+     */
+    var STATUSES = [
+        '---',
+        'IFA', 'IFB', 'IFC', 'IFD', 'IFI', 'IFP', 'IFR', 'IFU',
+        'REC',
+        'RSA', 'RSB', 'RSC', 'RSD', 'RSI',
+    ];
+
+    var STATUS_SET = {};
+    for (var _i = 0; _i < STATUSES.length; _i++) {
+        STATUS_SET[STATUSES[_i]] = true;
+    }
+
+    function isValidStatus(str) {
+        return !!STATUS_SET[str];
+    }
+
+    // ── Filename parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Canonical file regex.
+     * Matches: TRACKING_REVISION (STATUS) - TITLE.EXT
+     *
+     * Tracking number: no underscores, no whitespace.
+     * Revision:        no whitespace, no parentheses.
+     * Status:          anything inside parentheses (validated separately).
+     * Title:           everything up to the last dot.
+     * Extension:       after the last dot (lowercased by parseFilename).
+     */
+    var FILE_RE = /^([^_\s]+)_([^\s()_]+)\s*\(([^)]+)\)\s*-\s*(\S.*\S|\S)\.\s*([^\s.]+)$/;
+
+    /**
+     * Parse a ZDDC filename.
+     *
+     * @param {string} filename
+     * @returns {{ trackingNumber: string, revision: string, status: string,
+     *             title: string, extension: string, valid: boolean } | null}
+     *   null only if filename is falsy.
+     *   `valid` is true when all fields matched the ZDDC pattern.
+     */
+    function parseFilename(filename) {
+        if (!filename) { return null; }
+
+        var match = filename.match(FILE_RE);
+
+        if (!match) {
+            var lastDot = filename.lastIndexOf('.');
+            return {
+                trackingNumber: '',
+                revision:       '',
+                status:         '',
+                title:          lastDot > 0 ? filename.substring(0, lastDot) : filename,
+                extension:      lastDot > 0 ? filename.substring(lastDot + 1).toLowerCase() : '',
+                valid:          false,
+            };
+        }
+
+        return {
+            trackingNumber: match[1].trim(),
+            revision:       match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            extension:      match[5].toLowerCase(),
+            valid:          true,
+        };
+    }
+
+    // ── Folder name parsing ──────────────────────────────────────────────────
+
+    /**
+     * Transmittal folder regex.
+     * Matches: YYYY-MM-DD_TRACKING (STATUS) - TITLE
+     */
+    var FOLDER_RE = /^(\d{4}-\d{2}-\d{2})_([^_\s(]+)\s*\(([^)]+)\)\s*-\s*(.+)$/;
+
+    /**
+     * Parse a ZDDC transmittal folder name.
+     *
+     * @param {string} foldername
+     * @returns {{ date: string, trackingNumber: string, status: string,
+     *             title: string, valid: boolean } | null}
+     *   null only if foldername is falsy.
+     */
+    function parseFolder(foldername) {
+        if (!foldername) { return null; }
+
+        var match = foldername.match(FOLDER_RE);
+
+        if (!match) {
+            return {
+                date:            '',
+                trackingNumber:  '',
+                status:          '',
+                title:           foldername,
+                valid:           false,
+            };
+        }
+
+        return {
+            date:           match[1],
+            trackingNumber: match[2].trim(),
+            status:         match[3].trim(),
+            title:          match[4].trim(),
+            valid:          true,
+        };
+    }
+
+    // ── Revision parsing ─────────────────────────────────────────────────────
+
+    /**
+     * Modifier sub-regex: +LETTER DIGITS  e.g. +C1, +B2, +N1, +Q1
+     * The draft prefix (~) may appear inside the modifier: A+~C1
+     */
+    var MODIFIER_RE = /^\+(~?)([A-Za-z])(\d+)$/;
+
+    /**
+     * Parse a ZDDC revision string.
+     *
+     * Revision grammar:
+     *   revision     = ['~'] base ['+' ['~'] modifier_letter modifier_number]
+     *   base         = letter(s) | digit(s) | date(YYYY-MM-DD)
+     *   modifier     = letter + digits   e.g. C1, B2, N1, Q1
+     *
+     * @param {string} revision
+     * @returns {{
+     *   base: string,
+     *   modifier: string,       full modifier string e.g. '+C1', '' if none
+     *   modifierType: string,   modifier letter e.g. 'C', '' if none
+     *   modifierNumber: number, modifier number e.g. 1, 0 if none
+     *   modifierIsDraft: boolean,
+     *   isDraft: boolean,       true if base revision starts with ~
+     *   full: string,           original input
+     * }}
+     */
+    function parseRevision(revision) {
+        var raw = (revision || '').toString();
+
+        // Split on '+' to separate base from optional modifier
+        var plusIdx = raw.indexOf('+');
+        var basePart     = plusIdx === -1 ? raw : raw.substring(0, plusIdx);
+        var modifierPart = plusIdx === -1 ? ''  : raw.substring(plusIdx);
+
+        // Draft flag on the base part
+        var isDraft = basePart.startsWith('~');
+        var base    = isDraft ? basePart.substring(1) : basePart;
+
+        // Parse modifier
+        var modifier        = '';
+        var modifierType    = '';
+        var modifierNumber  = 0;
+        var modifierIsDraft = false;
+
+        if (modifierPart) {
+            var mMatch = modifierPart.match(MODIFIER_RE);
+            if (mMatch) {
+                modifierIsDraft = mMatch[1] === '~';
+                modifierType    = mMatch[2].toUpperCase();
+                modifierNumber  = parseInt(mMatch[3], 10);
+                modifier        = modifierPart;
+            } else {
+                // Unrecognised modifier — preserve as-is
+                modifier = modifierPart;
+            }
+        }
+
+        return {
+            base:           base,
+            modifier:       modifier,
+            modifierType:   modifierType,
+            modifierNumber: modifierNumber,
+            modifierIsDraft: modifierIsDraft,
+            isDraft:        isDraft,
+            full:           raw,
+        };
+    }
+
+    // ── Revision comparison ──────────────────────────────────────────────────
+
+    /**
+     * Classify a base revision string into a sort tier:
+     *   0 = date (YYYY-MM-DD)
+     *   1 = letter(s)   A, B, AA …
+     *   2 = number(s)   0, 1, 2, 1.5 …
+     *   3 = other
+     */
+    function _baseTier(base) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(base)) { return 0; }
+        if (/^[A-Za-z]+$/.test(base))          { return 1; }
+        if (/^\d+(\.\d+)?$/.test(base))         { return 2; }
+        return 3;
+    }
+
+    /**
+     * Compare two base revision strings.
+     * Sort order: dates < letters < numbers < other.
+     */
+    function _compareBase(a, b) {
+        var ta = _baseTier(a);
+        var tb = _baseTier(b);
+        if (ta !== tb) { return ta - tb; }
+
+        if (ta === 0) { return a < b ? -1 : a > b ? 1 : 0; }       // date lexicographic = chronological
+        if (ta === 1) { return a.toUpperCase() < b.toUpperCase() ? -1 : a.toUpperCase() > b.toUpperCase() ? 1 : 0; }
+        if (ta === 2) { return parseFloat(a) - parseFloat(b); }
+        return a.localeCompare(b);
+    }
+
+    /**
+     * Compare two ZDDC revision strings for sort ordering.
+     *
+     * Canonical order (ascending = older → newer):
+     *   ~A  <  A  <  A+B1  <  A+C1  <  A+~C2  <  A+C2  <  A+N1  <  A+Q1
+     *   <  ~B  <  B  < … < 0 < 1 < 2
+     *
+     * Rules:
+     *   1. Compare base revisions first (dates < letters < numbers).
+     *   2. For equal bases, draft (isDraft=true) comes before final.
+     *   3. For equal base+draft, no-modifier < has-modifier.
+     *   4. For equal base+draft+modifier presence:
+     *      a. modifier draft comes before modifier final (modifierIsDraft).
+     *      b. Sort modifier by type letter then by number.
+     *
+     * @param {string} a
+     * @param {string} b
+     * @returns {number}  negative if a < b, 0 if equal, positive if a > b
+     */
+    function compareRevisions(a, b) {
+        var pa = parseRevision(a);
+        var pb = parseRevision(b);
+
+        // 1. Base revision
+        var baseCmp = _compareBase(pa.base, pb.base);
+        if (baseCmp !== 0) { return baseCmp; }
+
+        // 2. Draft before final (for same base)
+        if (pa.isDraft !== pb.isDraft) { return pa.isDraft ? -1 : 1; }
+
+        // 3. No modifier before any modifier
+        var aHasMod = pa.modifier !== '';
+        var bHasMod = pb.modifier !== '';
+        if (aHasMod !== bHasMod) { return aHasMod ? 1 : -1; }
+
+        if (!aHasMod) { return 0; } // both have no modifier
+
+        // 4. Compare modifiers: type → number → draft (draft is a tie-breaker only)
+        // 4a. Modifier type letter (B < C < N < Q …)
+        if (pa.modifierType !== pb.modifierType) {
+            return pa.modifierType < pb.modifierType ? -1 : 1;
+        }
+
+        // 4b. Modifier number (1 < 2 …)
+        if (pa.modifierNumber !== pb.modifierNumber) {
+            return pa.modifierNumber - pb.modifierNumber;
+        }
+
+        // 4c. Draft of a modifier comes before the final modifier (same type+number)
+        if (pa.modifierIsDraft !== pb.modifierIsDraft) {
+            return pa.modifierIsDraft ? -1 : 1;
+        }
+
+        return 0;
+    }
+
+    // ── Filename / folder formatting ─────────────────────────────────────────
+
+    /**
+     * Build a ZDDC filename from its components.
+     *
+     * @param {{ trackingNumber: string, revision: string, status: string,
+     *           title: string, extension: string }} parts
+     * @returns {string}  e.g. "123456-EL-SPC-2623_A (IFR) - Specification.pdf"
+     */
+    function formatFilename(parts) {
+        var tn  = (parts.trackingNumber || '').trim();
+        var rev = (parts.revision       || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+        var ext = (parts.extension      || '').replace(/^\./, '');
+
+        if (!tn || !rev || !st || !ttl) { return ''; }
+
+        var name = tn + '_' + rev + ' (' + st + ') - ' + ttl;
+        return ext ? name + '.' + ext : name;
+    }
+
+    /**
+     * Build a ZDDC transmittal folder name from its components.
+     *
+     * @param {{ date: string, trackingNumber: string, status: string,
+     *           title: string }} parts
+     * @returns {string}  e.g. "2025-10-31_123456-EM-SUB-0001 (IFR) - Title"
+     */
+    function formatFolder(parts) {
+        var dt  = (parts.date           || '').trim();
+        var tn  = (parts.trackingNumber || '').trim();
+        var st  = (parts.status         || '').trim();
+        var ttl = (parts.title          || '').trim();
+
+        if (!dt || !tn || !st || !ttl) { return ''; }
+
+        return dt + '_' + tn + ' (' + st + ') - ' + ttl;
+    }
+
+    // ── Filename / extension splitting ───────────────────────────────────────
+
+    /**
+     * Split a filename into its base name and extension (no leading dot).
+     * Treats leading dot ('.gitignore') as no extension.
+     *
+     * @param {string} filename
+     * @returns {{ name: string, extension: string }}
+     */
+    function splitExtension(filename) {
+        if (!filename) { return { name: '', extension: '' }; }
+        var lastDot = filename.lastIndexOf('.');
+        if (lastDot <= 0) { return { name: filename, extension: '' }; }
+        return {
+            name:      filename.substring(0, lastDot),
+            extension: filename.substring(lastDot + 1).toLowerCase(),
+        };
+    }
+
+    /**
+     * Join a base name and extension. Tolerant of either form ('pdf' or '.pdf').
+     * Returns just the name when extension is empty.
+     */
+    function joinExtension(name, extension) {
+        var ext = (extension || '').replace(/^\./, '');
+        return ext ? name + '.' + ext : name;
+    }
+
+    // ── Public API ───────────────────────────────────────────────────────────
+
+    root.zddc = {
+        STATUSES:         STATUSES,
+        isValidStatus:    isValidStatus,
+        parseFilename:    parseFilename,
+        parseFolder:      parseFolder,
+        parseRevision:    parseRevision,
+        formatFilename:   formatFilename,
+        formatFolder:     formatFolder,
+        compareRevisions: compareRevisions,
+        splitExtension:   splitExtension,
+        joinExtension:    joinExtension,
+    };
+
+}(typeof window !== 'undefined' ? window : this));
+
+/**
+ * ZDDC — shared SHA-256 helpers
+ *
+ * Attaches to window.zddc.crypto. Must load AFTER shared/zddc.js (which creates
+ * the window.zddc object).
+ *
+ * Exports:
+ *   zddc.crypto.sha256Hex(buffer)       → Promise<string>  hex digest of ArrayBuffer/Uint8Array
+ *   zddc.crypto.sha256String(str)       → Promise<string>  hex digest of UTF-8 encoded string
+ *   zddc.crypto.sha256File(file, onProgress?) → Promise<string>
+ *       chunked streaming digest for File/Blob; for files >= 4 MB, streams 2 MB chunks
+ *       and invokes onProgress(loaded, total) every ~8 MB.
+ *   zddc.crypto.bytesToHex(buffer)      → string  (hex of ArrayBuffer/Uint8Array, no digest)
+ *
+ * Throws if Web Crypto SubtleCrypto is not available.
+ */
+(function (root) {
+    'use strict';
+
+    if (!root.zddc) {
+        throw new Error('shared/hash.js: window.zddc must be loaded first');
+    }
+
+    var HASH_CHUNK_SIZE = 2 * 1024 * 1024; // 2 MB
+
+    function requireSubtle() {
+        if (!root.crypto || !root.crypto.subtle || typeof root.crypto.subtle.digest !== 'function') {
+            throw new Error('Web Crypto SubtleCrypto is required');
+        }
+    }
+
+    function bytesToHex(buffer) {
+        return Array.from(new Uint8Array(buffer), function (byte) {
+            return byte.toString(16).padStart(2, '0');
+        }).join('');
+    }
+
+    async function sha256Hex(buffer) {
+        requireSubtle();
+        var input = (buffer instanceof Uint8Array) ? buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength) : buffer;
+        var hash = await root.crypto.subtle.digest('SHA-256', input);
+        return bytesToHex(hash);
+    }
+
+    async function sha256String(str) {
+        requireSubtle();
+        var bytes = new TextEncoder().encode(str);
+        var hash = await root.crypto.subtle.digest('SHA-256', bytes);
+        return bytesToHex(hash);
+    }
+
+    async function sha256File(file, onProgress) {
+        requireSubtle();
+        // Single-shot for small files or environments without ReadableStream
+        if (file.size < HASH_CHUNK_SIZE * 2 || typeof file.stream !== 'function') {
+            if (onProgress) { onProgress(file.size, file.size); }
+            var buf = await file.arrayBuffer();
+            var hash = await root.crypto.subtle.digest('SHA-256', buf);
+            return bytesToHex(hash);
+        }
+        // Chunked streaming for large files
+        var reader = file.stream().getReader();
+        var loaded = 0;
+        var chunks = [];
+        var yieldCounter = 0;
+        while (true) {
+            var result = await reader.read();
+            if (result.done) { break; }
+            chunks.push(result.value);
+            loaded += result.value.byteLength;
+            yieldCounter++;
+            if (onProgress && yieldCounter % 4 === 0) {
+                onProgress(loaded, file.size);
+                await new Promise(function (r) { setTimeout(r, 0); });
+            }
+        }
+        var total = new Uint8Array(loaded);
+        var offset = 0;
+        for (var i = 0; i < chunks.length; i++) {
+            total.set(chunks[i], offset);
+            offset += chunks[i].byteLength;
+        }
+        var digest = await root.crypto.subtle.digest('SHA-256', total.buffer);
+        if (onProgress) { onProgress(file.size, file.size); }
+        return bytesToHex(digest);
+    }
+
+    root.zddc.crypto = {
+        sha256Hex:    sha256Hex,
+        sha256String: sha256String,
+        sha256File:   sha256File,
+        bytesToHex:   bytesToHex,
+    };
+})(typeof window !== 'undefined' ? window : globalThis);
+
+/**
+ * ZDDC shared theme toggle — light / dark / auto.
+ * Persists choice to localStorage under 'zddc-theme'.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #theme-btn in the DOM (optional — skips gracefully if absent).
+ *
+ * Theme cycle: auto → light → dark → auto …
+ * 'auto' honours the OS prefers-color-scheme media query (CSS handles it).
+ * 'light' sets data-theme="light" on <html> (overrides dark media query).
+ * 'dark'  sets data-theme="dark"  on <html>.
+ */
+(function () {
+    'use strict';
+
+    var STORAGE_KEY = 'zddc-theme';
+    var THEMES = ['auto', 'light', 'dark'];
+
+    var LABELS = {
+        auto:  '◐',
+        light: '☀',
+        dark:  '☾'
+    };
+
+    var TITLES = {
+        auto:  'Theme: auto (follows OS)',
+        light: 'Theme: light',
+        dark:  'Theme: dark'
+    };
+
+    function load() {
+        var stored = localStorage.getItem(STORAGE_KEY);
+        return THEMES.indexOf(stored) !== -1 ? stored : 'auto';
+    }
+
+    function apply(theme) {
+        if (theme === 'dark') {
+            document.documentElement.setAttribute('data-theme', 'dark');
+        } else if (theme === 'light') {
+            document.documentElement.setAttribute('data-theme', 'light');
+        } else {
+            document.documentElement.removeAttribute('data-theme');
+        }
+    }
+
+    function save(theme) {
+        try { localStorage.setItem(STORAGE_KEY, theme); } catch (e) {}
+    }
+
+    function updateButton(btn, theme) {
+        btn.textContent = LABELS[theme];
+        btn.title = TITLES[theme];
+        btn.setAttribute('aria-label', TITLES[theme]);
+    }
+
+    function next(theme) {
+        return THEMES[(THEMES.indexOf(theme) + 1) % THEMES.length];
+    }
+
+    function init() {
+        var current = load();
+        apply(current);
+
+        var btn = document.getElementById('theme-btn');
+        if (!btn) { return; }
+
+        updateButton(btn, current);
+
+        btn.addEventListener('click', function () {
+            current = next(current);
+            apply(current);
+            save(current);
+            updateButton(btn, current);
+        });
+    }
+
+    /* Apply theme immediately (before DOM ready) to avoid flash */
+    apply(load());
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+(function (global) {
+    'use strict';
+
+    if (global.transmittalApp) {
+        return;
+    }
+
+    const app = {
+        state: {
+            mode: 'edit',
+            published: false,
+            dirty: false
+        },
+        data: {
+            files: [],
+            selectedDirHandle: null,
+            selectedDirName: ''
+        },
+        constants: {
+            viewableExts: ['pdf', 'png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'txt', 'html', 'htm', 'md'],
+            digestAlgorithm: 'SHA-256',
+            signatureAlgorithm: 'ECDSA-P256-SHA256',
+            SELF_HASH: 'self:payload-digest'
+        },
+        modules: {},
+        initCallbacks: [],
+        registerInit(fn) {
+            if (typeof fn === 'function') {
+                app.initCallbacks.push(fn);
+            }
+        },
+        dirtyListeners: [],
+        onDirty(fn) {
+            if (typeof fn === 'function') {
+                app.dirtyListeners.push(fn);
+            }
+        },
+        markDirty() {
+            app.state.dirty = true;
+            app.dirtyListeners.forEach(function (fn) {
+                try { fn(); } catch (err) { console.error('[transmittal] dirtyListener error', err); }
+            });
+        },
+        ready(fn) {
+            if (typeof fn !== 'function') {
+                return;
+            }
+            if (document.readyState === 'loading') {
+                document.addEventListener('DOMContentLoaded', fn, { once: true });
+            } else {
+                fn();
+            }
+        },
+        start() {
+            if (app._started) {
+                return;
+            }
+            app._started = true;
+            const run = function () {
+                app.initCallbacks.forEach(function (fn) {
+                    try {
+                        fn();
+                    } catch (err) {
+                        console.error('[transmittal] init error', err);
+                    }
+                });
+            };
+            app.ready(run);
+        }
+    };
+
+    global.transmittalApp = app;
+})(window);
+
+(function (app) {
+    'use strict';
+
+    /**
+     * Creates a reactive state object using Proxy.
+     * When properties change, all registered subscribers are notified.
+     * 
+     * @param {Object} initialState - Initial state values
+     * @returns {Object} Reactive state proxy with subscribe/unsubscribe methods
+     */
+    function createReactiveState(initialState) {
+        const subscribers = new Set();
+        const state = { ...initialState };
+        
+        const handler = {
+            get(target, property) {
+                // Expose subscription methods
+                if (property === 'subscribe') {
+                    return function(callback) {
+                        if (typeof callback === 'function') {
+                            subscribers.add(callback);
+                        }
+                        return function unsubscribe() {
+                            subscribers.delete(callback);
+                        };
+                    };
+                }
+                
+                if (property === 'unsubscribeAll') {
+                    return function() {
+                        subscribers.clear();
+                    };
+                }
+                
+                // Return the actual property value
+                return target[property];
+            },
+            
+            set(target, property, value) {
+                const oldValue = target[property];
+                
+                // Only notify if value actually changed
+                if (oldValue !== value) {
+                    target[property] = value;
+                    
+                    // Notify all subscribers
+                    subscribers.forEach(function(callback) {
+                        try {
+                            callback(property, value, oldValue);
+                        } catch (err) {
+                            console.error('[reactive] Subscriber error:', err);
+                        }
+                    });
+                }
+                
+                return true;
+            }
+        };
+        
+        return new Proxy(state, handler);
+    }
+
+    app.createReactiveState = createReactiveState;
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom = app.dom || {};
+
+    dom.qs = function (selector) {
+        return document.querySelector(selector);
+    };
+
+    dom.qsa = function (selector) {
+        return Array.from(document.querySelectorAll(selector));
+    };
+
+    dom.show = function (element, shouldShow) {
+        if (!element) {
+            return;
+        }
+        element.hidden = !shouldShow;
+    };
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const util = app.util = app.util || {};
+
+    util.hasCrypto = function hasCrypto() {
+        return !!(window.crypto && window.crypto.subtle && typeof window.crypto.subtle.digest === 'function');
+    };
+
+    util.canonicalStringify = function canonicalStringify(input) {
+        if (input === null) {
+            return 'null';
+        }
+        const type = typeof input;
+        if (type === 'number' || type === 'boolean' || type === 'string') {
+            return JSON.stringify(input);
+        }
+        if (Array.isArray(input)) {
+            return '[' + input.map(util.canonicalStringify).join(',') + ']';
+        }
+        const keys = Object.keys(input).sort();
+        return '{' + keys.map(function (key) {
+            return JSON.stringify(key) + ':' + util.canonicalStringify(input[key]);
+        }).join(',') + '}';
+    };
+
+    util.hashString = function hashString(str) {
+        return zddc.crypto.sha256String(str);
+    };
+
+    util.arrayBufferToHex = function arrayBufferToHex(buffer) {
+        return zddc.crypto.bytesToHex(buffer);
+    };
+
+    util.base64ToArrayBuffer = function base64ToArrayBuffer(base64Value) {
+        if (!base64Value) {
+            return new ArrayBuffer(0);
+        }
+        const binaryString = atob(base64Value);
+        const length = binaryString.length;
+        const bytes = new Uint8Array(length);
+        for (let index = 0; index < length; index += 1) {
+            bytes[index] = binaryString.charCodeAt(index);
+        }
+        return bytes.buffer;
+    };
+
+    util.arrayBufferToBase64 = function arrayBufferToBase64(buffer) {
+        const bytes = new Uint8Array(buffer);
+        let output = '';
+        for (let index = 0; index < bytes.length; index += 1) {
+            output += String.fromCharCode(bytes[index]);
+        }
+        return btoa(output);
+    };
+
+    // Revision comparison delegates to shared zddc library
+    util.compareRevisionPriority = function compareRevisionPriority(aRevision, bRevision) {
+        return zddc.compareRevisions(aRevision, bRevision);
+    };
+
+    util.compareFilesByTrackingRevision = function compareFilesByTrackingRevision(a, b) {
+        const trackingA = (a && a.trackingNumber ? String(a.trackingNumber) : '').toLowerCase();
+        const trackingB = (b && b.trackingNumber ? String(b.trackingNumber) : '').toLowerCase();
+        if (trackingA < trackingB) {
+            return -1;
+        }
+        if (trackingA > trackingB) {
+            return 1;
+        }
+
+        const revisionCompare = util.compareRevisionPriority(a && a.revision, b && b.revision);
+        if (revisionCompare !== 0) {
+            return revisionCompare;
+        }
+
+        const extA = (a && a.extension ? String(a.extension) : '').toLowerCase();
+        const extB = (b && b.extension ? String(b.extension) : '').toLowerCase();
+        if (extA < extB) {
+            return -1;
+        }
+        if (extA > extB) {
+            return 1;
+        }
+
+        return 0;
+    };
+
+    util.canonicalizePublicJwk = function canonicalizePublicJwk(pk) {
+        if (!pk) {
+            return { kty: 'EC', crv: 'P-256', x: '', y: '' };
+        }
+        return {
+            kty: pk.kty || 'EC',
+            crv: pk.crv || 'P-256',
+            x: pk.x || '',
+            y: pk.y || ''
+        };
+    };
+
+    util.publicKeyFingerprint = async function publicKeyFingerprint(pk) {
+        try {
+            if (!pk) {
+                return '';
+            }
+            if (!util.hasCrypto()) {
+                return null;
+            }
+            const canonical = util.canonicalizePublicJwk(pk);
+            const canonicalStr = util.canonicalStringify(canonical);
+            const hash = await util.hashString(canonicalStr);
+            return (hash || '').slice(0, 12);
+        } catch (err) {
+            console.error('[transmittal] publicKeyFingerprint error', err);
+            return '';
+        }
+    };
+
+    util.hashFile = function hashFile(file, onProgress) {
+        return zddc.crypto.sha256File(file, onProgress);
+    };
+
+    util.escapeHtml = function escapeHtml(value) {
+        return String(value || '')
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+    };
+
+    util.escapeHtmlAttribute = function escapeHtmlAttribute(value) {
+        return String(value || '')
+            .replace(/&/g, '&amp;')
+            .replace(/"/g, '&quot;');
+    };
+
+    util.downloadBlob = function downloadBlob(filename, contents, mime) {
+        var blob = (contents instanceof Blob)
+            ? contents
+            : new Blob([contents], { type: mime || 'application/octet-stream' });
+        var anchor = document.createElement('a');
+        anchor.href = URL.createObjectURL(blob);
+        anchor.download = filename;
+        document.body.appendChild(anchor);
+        anchor.click();
+        setTimeout(function () {
+            URL.revokeObjectURL(anchor.href);
+            anchor.remove();
+        }, 0);
+    };
+
+    util.createEmptyData = function createEmptyData(date) {
+        return {
+            envelope: {
+                version: 1,
+                digestAlgorithm: app.constants.digestAlgorithm,
+                digest: '',
+                digestedAt: '',
+                signatureAlgorithm: app.constants.signatureAlgorithm,
+                signatures: []
+            },
+            payload: {
+                version: 1,
+                type: 'Transmittal',
+                title: '',
+                client: '',
+                project: '',
+                projectNumber: '',
+                date: date || '',
+                trackingNumber: '',
+                from: '',
+                to: '',
+                purpose: '',
+                responseDue: '',
+                subject: '',
+                remarks: '',
+                files: []
+            },
+            presentation: {
+                leftLogo: '',
+                rightLogo: '',
+                theme: 'default',
+                customCss: ''
+            }
+        };
+    };
+
+    util.fetchTrustedTime = function fetchTrustedTime() {
+        return new Date().toISOString();
+    };
+
+    util.formatISOWithTZ = function formatISOWithTZ(isoStr) {
+        if (!isoStr) { return 'Unknown'; }
+        var d = new Date(isoStr);
+        if (isNaN(d.getTime())) { return isoStr; }
+        try {
+            return d.toLocaleDateString('en-US', {
+                weekday: 'long',
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric',
+                hour: 'numeric',
+                minute: '2-digit',
+                timeZoneName: 'short'
+            });
+        } catch (_) {
+            return d.toLocaleString();
+        }
+    };
+
+    util.signEnvelope = async function signEnvelope(envelope, jwk) {
+        if (!jwk || jwk.kty !== 'EC') {
+            throw new Error('A valid EC private key (JWK) is required to sign.');
+        }
+        var envelopeToSign = {
+            version: envelope.version || 1,
+            digestAlgorithm: envelope.digestAlgorithm || app.constants.digestAlgorithm,
+            digest: envelope.digest,
+            digestedAt: envelope.digestedAt,
+            signatureAlgorithm: envelope.signatureAlgorithm || app.constants.signatureAlgorithm
+        };
+        var envelopeStr = util.canonicalStringify(envelopeToSign);
+        var key = await window.crypto.subtle.importKey(
+            'jwk',
+            jwk,
+            { name: 'ECDSA', namedCurve: 'P-256' },
+            false,
+            ['sign']
+        );
+        var raw = await window.crypto.subtle.sign(
+            { name: 'ECDSA', hash: { name: 'SHA-256' } },
+            key,
+            new TextEncoder().encode(envelopeStr)
+        );
+        return {
+            signature: util.arrayBufferToBase64(raw),
+            signedAt: util.fetchTrustedTime()
+        };
+    };
+
+
+    util.formatShortHash = function formatShortHash(hex) {
+        const normalized = (hex || '').trim();
+        if (!normalized) {
+            return '';
+        }
+        if (normalized.length <= 20) {
+            return normalized;
+        }
+        return normalized.slice(0, 12) + '\u2026' + normalized.slice(-8);
+    };
+
+    util.formatShortFileHash = function formatShortFileHash(hex) {
+        const normalized = (hex || '').trim();
+        if (!normalized) {
+            return '';
+        }
+        if (normalized.length <= 12) {
+            return normalized;
+        }
+        return normalized.slice(0, 6) + '\u2026' + normalized.slice(-5);
+    };
+
+    util.formatFileSize = function formatFileSize(bytes) {
+        const num = Number(bytes) || 0;
+        if (num === 0) {
+            return '0 B';
+        }
+        if (num < 1024) {
+            return num + ' B';
+        }
+        if (num < 1024 * 1024) {
+            return (num / 1024).toFixed(1) + ' KB';
+        }
+        if (num < 1024 * 1024 * 1024) {
+            return (num / (1024 * 1024)).toFixed(1) + ' MB';
+        }
+        return (num / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+    };
+
+    util.fileToImage = function fileToImage(file) {
+        return new Promise(function (resolve, reject) {
+            const url = URL.createObjectURL(file);
+            const img = new Image();
+            img.onload = function () {
+                URL.revokeObjectURL(url);
+                resolve(img);
+            };
+            img.onerror = function (err) {
+                URL.revokeObjectURL(url);
+                reject(err);
+            };
+            img.src = url;
+        });
+    };
+
+    util.imageFileToPngDataUrl = async function imageFileToPngDataUrl(file, maxWidth, maxHeight) {
+        const img = await util.fileToImage(file);
+        const scale = Math.min(1, maxWidth / img.width, maxHeight / img.height);
+        const w = Math.round(img.width * scale);
+        const h = Math.round(img.height * scale);
+        const canvas = document.createElement('canvas');
+        canvas.width = w;
+        canvas.height = h;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0, w, h);
+        return canvas.toDataURL('image/png');
+    };
+
+    // ── ZDDC Signing Key utilities ─────────────────────────
+    var KEY_FORMAT = 'zddc-signing-key-v1';
+    var KDF_ITERATIONS = 100000;
+
+    function deriveWrappingKey(password, salt) {
+        var enc = new TextEncoder();
+        return window.crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveKey'])
+            .then(function (baseKey) {
+                return window.crypto.subtle.deriveKey(
+                    { name: 'PBKDF2', salt: salt, iterations: KDF_ITERATIONS, hash: 'SHA-256' },
+                    baseKey,
+                    { name: 'AES-GCM', length: 256 },
+                    false,
+                    ['encrypt', 'decrypt']
+                );
+            });
+    }
+
+    util.encryptPrivateKey = async function encryptPrivateKey(jwk, password, publicFingerprint) {
+        var plaintext = new TextEncoder().encode(JSON.stringify(jwk));
+        var salt = window.crypto.getRandomValues(new Uint8Array(16));
+        var iv = window.crypto.getRandomValues(new Uint8Array(12));
+        var wrappingKey = await deriveWrappingKey(password, salt);
+        var ciphertext = await window.crypto.subtle.encrypt({ name: 'AES-GCM', iv: iv }, wrappingKey, plaintext);
+        return {
+            format: KEY_FORMAT,
+            publicFingerprint: publicFingerprint || '',
+            encrypted: true,
+            kdf: 'PBKDF2-SHA256',
+            iterations: KDF_ITERATIONS,
+            salt: util.arrayBufferToBase64(salt),
+            iv: util.arrayBufferToBase64(iv),
+            ciphertext: util.arrayBufferToBase64(ciphertext)
+        };
+    };
+
+    util.decryptPrivateKey = async function decryptPrivateKey(keyData, password) {
+        var salt = util.base64ToArrayBuffer(keyData.salt);
+        var iv = util.base64ToArrayBuffer(keyData.iv);
+        var ciphertext = util.base64ToArrayBuffer(keyData.ciphertext);
+        var wrappingKey = await deriveWrappingKey(password, salt);
+        var plaintext = await window.crypto.subtle.decrypt({ name: 'AES-GCM', iv: iv }, wrappingKey, ciphertext);
+        return JSON.parse(new TextDecoder().decode(plaintext));
+    };
+
+    util.wrapKeyFile = function wrapKeyFile(jwk, publicFingerprint) {
+        return {
+            format: KEY_FORMAT,
+            publicFingerprint: publicFingerprint || '',
+            encrypted: false,
+            key: jwk
+        };
+    };
+
+    util.loadKeyFile = async function loadKeyFile(text, promptForPassword) {
+        var data = JSON.parse(text);
+        // ZDDC key format
+        if (data.format === KEY_FORMAT) {
+            if (data.encrypted) {
+                if (typeof promptForPassword !== 'function') {
+                    throw new Error('Password required but no prompt available.');
+                }
+                var password = await promptForPassword(data.publicFingerprint);
+                if (!password && password !== '') { return null; } // user cancelled
+                return util.decryptPrivateKey(data, password);
+            }
+            return data.key;
+        }
+        throw new Error('Unrecognized key file format. Expected a .zddc-key file.');
+    };
+
+    util.cloneDocumentHtml = function cloneDocumentHtml() {
+        // Temporarily remove inline scripts from the LIVE DOM so that
+        // outerHTML produces a clean string with zero script bodies.
+        // We never create a clone via innerHTML because the HTML parser
+        // would corrupt the JSON block if base64 data contains a close-script tag.
+        var scripts = document.querySelectorAll('script:not([src])');
+        var saved = [];
+        for (var i = 0; i < scripts.length; i++) {
+            var el = scripts[i];
+            saved.push({
+                el: el,
+                parent: el.parentNode,
+                next: el.nextSibling,
+                body: el.textContent || '',
+                attrs: ''
+            });
+            for (var a = 0; a < el.attributes.length; a++) {
+                var attr = el.attributes[a];
+                saved[i].attrs += ' ' + attr.name + '="' +
+                    attr.value.replace(/&/g, '&amp;').replace(/"/g, '&quot;') + '"';
+            }
+            el.parentNode.removeChild(el);
+        }
+
+        var html = document.documentElement.outerHTML;
+
+        // Restore every script element to the live DOM immediately
+        for (var r = 0; r < saved.length; r++) {
+            saved[r].parent.insertBefore(saved[r].el, saved[r].next);
+        }
+
+        // Build each script tag as a safe string and insert before </body>
+        var scriptStrings = '';
+        for (var j = 0; j < saved.length; j++) {
+            var s = saved[j];
+            var safeBody = s.body;
+            var scriptType = (s.el.getAttribute('type') || '').toLowerCase();
+            if (scriptType === 'application/json') {
+                // Re-serialize from parsed data so we control the output.
+                // \u003c is valid JSON; JSON.parse converts it back to <
+                var jsonData = app.json.parse();
+                safeBody = JSON.stringify(jsonData, null, 2).replace(/</g, '\\u003c');
+            }
+            scriptStrings += '\n<script' + s.attrs + '>' + safeBody +
+                '</' + 'script>';
+        }
+
+        // Insert scripts before closing </body>
+        var bodyClose = html.lastIndexOf('</' + 'body>');
+        if (bodyClose !== -1) {
+            html = html.substring(0, bodyClose) + scriptStrings + '\n' +
+                html.substring(bodyClose);
+        } else {
+            html += scriptStrings;
+        }
+
+        return '<!DOCTYPE html>\n' + html;
+    };
+
+    /**
+     * Fetch the current page's own source HTML and replace only the
+     * transmittal-data JSON block with the supplied data object.
+     *
+     * This is the preferred save mechanism for drafts because it produces
+     * an exact copy of the source file with only the data changed, rather
+     * than a DOM snapshot that may contain stale or mutated content.
+     *
+     * @param {object} jsonData - The data object to embed as JSON.
+     * @returns {Promise<string>} The patched HTML string.
+     * @throws {Error} If the fetch fails or the JSON block is not found.
+     */
+    util.fetchAndPatchHtml = async function fetchAndPatchHtml(jsonData) {
+        var response = await fetch(location.href, { cache: 'no-cache' });
+        if (!response.ok) {
+            throw new Error('fetch failed with status ' + response.status);
+        }
+        var html = await response.text();
+        // \u003c is valid JSON; JSON.parse converts it back to <
+        var jsonStr = JSON.stringify(jsonData, null, 2).replace(/</g, '\\u003c');
+        // Replace the transmittal-data script body. The non-greedy [\s\S]*? stops
+        // at the first close-script tag, which is safe because < is escaped above.
+        var patched = html.replace(
+            new RegExp(
+                '(<script\\b[^>]*\\bid\\s*=\\s*["\']transmittal-data["\'][^>]*>)[\\s\\S]*?(<\\/' + 'script>)',
+                'i'
+            ),
+            '$1\n' + jsonStr + '\n$2'
+        );
+        if (patched === html) {
+            throw new Error('transmittal-data script block not found in fetched HTML');
+        }
+        return patched;
+    };
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const json = app.json = app.json || {};
+
+    const SCRIPT_ID = 'transmittal-data';
+
+    json.getScriptElement = function getScriptElement() {
+        return document.getElementById(SCRIPT_ID);
+    };
+
+    json.getRawText = function getRawText() {
+        const el = json.getScriptElement();
+        return el && typeof el.textContent === 'string' ? el.textContent : '';
+    };
+
+    json.setData = function setData(obj) {
+        const el = json.getScriptElement();
+        if (!el) {
+            return;
+        }
+        try {
+            el.textContent = JSON.stringify(obj, null, 2);
+        } catch (err) {
+            console.error('[transmittal] failed to serialize JSON', err);
+        }
+    };
+
+    json.parse = function parse() {
+        try {
+            const raw = json.getRawText();
+            if (raw && raw.trim().length) {
+                return JSON.parse(raw);
+            }
+        } catch (err) {
+            console.error('[transmittal] failed to parse JSON store', err);
+        }
+        return app.util.createEmptyData('');
+    };
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const json = app.json;
+    const util = app.util;
+
+    /**
+     * Hydrates static HTML content with data from JSON.
+     * Called on page load to hide static placeholders and show dynamic content.
+     */
+    function hydrate() {
+        // Hide static "Not Validated" warning (will be replaced by dynamic validation)
+        const staticWarning = dom.qs('#signature-status-static');
+        if (staticWarning) {
+            staticWarning.hidden = true;
+        }
+        
+        // Digest will be populated by security.renderSignaturesList()
+        // which is called after signature verification
+    }
+
+    /**
+     * Populates static HTML before saving/publishing.
+     * This ensures the page displays content even without JavaScript.
+     */
+    async function populateStatic() {
+        const data = json.parse();
+        const envelope = data.envelope || {};
+        const payload = data.payload || {};
+        const signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+        const files = Array.isArray(payload.files) ? payload.files : [];
+        
+        // Populate all form fields with actual values
+        const fields = {
+            '#type': payload.type || 'Transmittal',
+            '#title': payload.title || '',
+            '#owner-name': payload.client || '',
+            '#project-name': payload.project || '',
+            '#project-number': payload.projectNumber || '',
+            '#tracking-number': payload.trackingNumber || '',
+            '#date': payload.date || '',
+            '#from': payload.from || '',
+            '#to': payload.to || '',
+            '#purpose': payload.purpose || '',
+            '#response-due': payload.responseDue || '',
+            '#subject': payload.subject || '',
+            '#remarks': payload.remarks || ''
+        };
+        
+        Object.keys(fields).forEach(function(selector) {
+            const el = dom.qs(selector);
+            if (el) {
+                if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+                    el.value = fields[selector];
+                    el.setAttribute('value', fields[selector]);
+                } else {
+                    el.textContent = fields[selector];
+                }
+            }
+        });
+        var typeDisp = dom.qs('#type-display');
+        if (typeDisp) { typeDisp.textContent = fields['#type']; }
+        
+        // Render markdown for static display
+        if (app.modules.markdown && payload.remarks) {
+            const remarksRender = dom.qs('#remarks-render');
+            if (remarksRender) {
+                remarksRender.innerHTML = app.modules.markdown.render(payload.remarks);
+            }
+        }
+        
+        // Populate table with file data
+        const SELF_HASH = app.constants.SELF_HASH;
+        const tbody = dom.qs('.table-wrapper tbody');
+        if (tbody) {
+            let html = '';
+            let rowNum = 0;
+            // Separate self-entry from regular files
+            var selfFile = null;
+            var regularFiles = [];
+            files.forEach(function(file) {
+                if (file.sha256 === SELF_HASH) {
+                    selfFile = file;
+                } else {
+                    regularFiles.push(file);
+                }
+            });
+            // If no explicit self-entry in JSON, synthesize one from payload header
+            if (!selfFile) {
+                selfFile = {
+                    trackingNumber: payload.trackingNumber || '',
+                    title: payload.subject || payload.title || '',
+                    revision: payload.date || '',
+                    status: payload.purpose || '',
+                    extension: 'html',
+                    fileSize: 0,
+                    sha256: SELF_HASH
+                };
+            }
+            // Build self-link filename from payload fields
+            var selfFilename = '';
+            var dataModule = app.modules.data;
+            if (dataModule && dataModule.buildFileName) {
+                selfFilename = dataModule.buildFileName(payload, { extension: 'html' });
+            }
+            var selfHref = selfFilename ? encodeURI('./' + selfFilename) : '';
+            var selfTrackingHtml = selfHref
+                ? '<a href="' + selfHref + '" class="text-gray-500 hover:underline" target="_blank" rel="noopener">' + util.escapeHtml(selfFile.trackingNumber || '') + '</a>'
+                : util.escapeHtml(selfFile.trackingNumber || '');
+            // Row 0: self-entry
+            html += '<tr class="self-entry">' +
+                '<td class="px-2 py-1 text-center text-gray-400">0</td>' +
+                '<td class="px-2 py-1 text-gray-500 font-mono">' + selfTrackingHtml + '</td>' +
+                '<td class="px-2 py-1 text-gray-500">' + util.escapeHtml(selfFile.title || '') + '</td>' +
+                '<td class="px-2 py-1 text-center text-gray-500 font-mono">' + util.escapeHtml(selfFile.revision || '') + '</td>' +
+                '<td class="px-2 py-1 text-center text-gray-500">' + util.escapeHtml(selfFile.status || '') + '</td>' +
+                '<td class="px-2 py-1 text-center text-gray-500">html</td>' +
+                '<td class="px-2 py-1 text-right text-gray-400">\u2014</td>' +
+                '<td class="px-2 py-1 font-mono text-[9px] text-gray-400 italic">see above</td>' +
+                '</tr>';
+            // Remaining files
+            regularFiles.forEach(function(file) {
+                rowNum++;
+                var isUnmatched = !file.sha256 && !file.fileSize;
+                var formattedSize = isUnmatched ? '\u2014' : (file.fileSize ? util.formatFileSize(file.fileSize) : '');
+                var sizeClass = isUnmatched ? 'px-2 py-1 text-right text-gray-400' : 'px-2 py-1 text-right';
+                var hashContent = isUnmatched ? '<span class="italic text-gray-400">pending</span>' : (file.sha256 ? util.formatShortFileHash(file.sha256) : '');
+                html += '<tr>' +
+                    '<td class="px-2 py-1 text-center text-gray-400">' + rowNum + '</td>' +
+                    '<td class="px-2 py-1">' + (file.trackingNumber || '') + '</td>' +
+                    '<td class="px-2 py-1">' + (file.title || '') + '</td>' +
+                    '<td class="px-2 py-1 text-center">' + (file.revision || '') + '</td>' +
+                    '<td class="px-2 py-1 text-center">' + (file.status || '') + '</td>' +
+                    '<td class="px-2 py-1 text-center">' + (file.extension || '') + '</td>' +
+                    '<td class="' + sizeClass + '">' + formattedSize + '</td>' +
+                    '<td class="px-2 py-1 font-mono text-[9px]">' + hashContent + '</td>' +
+                    '</tr>';
+            });
+            tbody.innerHTML = html || '<tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr>';
+        }
+        
+        // Populate digest card (static fallback using verify-card format)
+        const digestDisplay = dom.qs('#digest-display');
+        if (digestDisplay && envelope.digest) {
+            const digestedAt = envelope.digestedAt ? new Date(envelope.digestedAt).toLocaleString() : 'Unknown';
+            digestDisplay.innerHTML =
+                '<div class="verify-card verify-card--info">' +
+                '<div class="verify-card__status verify-card__status--info">Digest (SHA-256)</div>' +
+                '<div class="verify-card__detail"><code>' + envelope.digest + '</code></div>' +
+                '<div class="verify-card__detail">' + digestedAt + '</div>' +
+                '</div>';
+        }
+
+        // Populate digest in Advanced section
+        const digestEl = dom.qs('#digest-info');
+        if (digestEl && envelope.digest) {
+            const digestedAt = envelope.digestedAt ? new Date(envelope.digestedAt).toLocaleString() : 'Unknown';
+            digestEl.innerHTML = '<div class="flex flex-col gap-0.5">' +
+                '<div><strong>Digest (SHA-256):</strong></div>' +
+                '<code class="text-[9px] break-all bg-gray-100 px-1 py-0.5 rounded">' + envelope.digest + '</code>' +
+                '<div class="text-gray-500">Created: ' + digestedAt + '</div>' +
+                '</div>';
+        }
+
+        // Populate static signature cards
+        const sigList = dom.qs('#signatures-list');
+        if (sigList && signatures.length > 0) {
+            let html = '';
+            for (let i = 0; i < signatures.length; i++) {
+                const sig = signatures[i];
+                const fingerprint = await util.publicKeyFingerprint(sig.publicKeyJwk);
+                const fpDisplay = fingerprint === null ? 'unavailable' : (fingerprint || 'Unknown');
+                const signedAt = sig.signedAt ? new Date(sig.signedAt).toLocaleString() : 'Unknown';
+                html += '<div class="verify-card verify-card--info">' +
+                    '<div class="verify-card__status verify-card__status--info">Signature ' + (i + 1) + '</div>' +
+                    '<div class="verify-card__detail">Key: <code>' + fpDisplay + '</code></div>' +
+                    '<div class="verify-card__detail">' + signedAt + '</div>' +
+                    '</div>';
+            }
+            sigList.innerHTML = html;
+        }
+
+        // Show static warning
+        const staticWarning = dom.qs('#signature-status-static');
+        if (staticWarning) {
+            staticWarning.hidden = !(envelope.digest || signatures.length > 0);
+        }
+    }
+
+    /**
+     * Populates form fields from current JSON data at runtime.
+     * Used by verification mode to hydrate the form with loaded data.
+     */
+    function hydrateForm() {
+        const data = json.parse();
+        const payload = data.payload || {};
+        const files = Array.isArray(payload.files) ? payload.files : [];
+
+        var fields = {
+            '#type': payload.type || 'Transmittal',
+            '#title': payload.title || '',
+            '#owner-name': payload.client || '',
+            '#project-name': payload.project || '',
+            '#project-number': payload.projectNumber || '',
+            '#tracking-number': payload.trackingNumber || '',
+            '#date': payload.date || '',
+            '#from': payload.from || '',
+            '#to': payload.to || '',
+            '#purpose': payload.purpose || '',
+            '#response-due': payload.responseDue || '',
+            '#subject': payload.subject || '',
+            '#remarks': payload.remarks || ''
+        };
+
+        Object.keys(fields).forEach(function (selector) {
+            var el = dom.qs(selector);
+            if (el) {
+                if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+                    el.value = fields[selector];
+                } else {
+                    el.textContent = fields[selector];
+                }
+            }
+        });
+        var typeDisp2 = dom.qs('#type-display');
+        if (typeDisp2) { typeDisp2.textContent = fields['#type']; }
+
+        // Render markdown
+        if (app.modules.markdown && payload.remarks) {
+            var remarksRender = dom.qs('#remarks-render');
+            if (remarksRender) {
+                remarksRender.innerHTML = app.modules.markdown.render(payload.remarks);
+            }
+        }
+
+        // Render email fields
+        if (app.modules.emailTags) {
+            if (app.modules.emailTags.render) { app.modules.emailTags.render(); }
+            if (app.modules.emailTags.renderFrom) { app.modules.emailTags.renderFrom(); }
+        }
+
+        // Visibility
+        if (app.modules.visibility && app.modules.visibility.applyFieldVisibility) {
+            app.modules.visibility.applyFieldVisibility();
+        }
+    }
+
+    app.modules.hydrate = {
+        hydrate: hydrate,
+        hydrateForm: hydrateForm,
+        populateStatic: populateStatic
+    };
+
+    app.registerInit(function () {
+        hydrate();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    
+    // Convert existing state to reactive state
+    if (app.createReactiveState) {
+        const oldState = app.state;
+        app.state = app.createReactiveState({
+            mode: oldState.mode || 'edit',
+            published: oldState.published || false,
+            dirty: oldState.dirty || false
+        });
+        
+        // Subscribe to state changes to automatically update UI
+        app.state.subscribe(function(property, newValue, oldValue) {
+            // Auto-apply state changes
+            if (property === 'mode' || property === 'published') {
+                state.updateHiddenFields();
+                state.apply();
+                // Sync preview checkbox to current mode
+                if (app.modules.files && app.modules.files.syncPreviewCheckbox) {
+                    app.modules.files.syncPreviewCheckbox();
+                }
+            }
+            
+            if (property === 'dirty') {
+                // Could update UI indicator here
+            }
+        });
+    }
+    
+    const state = app.state;
+
+    state.updateHiddenFields = function updateHiddenFields() {
+        const modeInput = dom.qs('#mode');
+        const publishedInput = dom.qs('#published');
+        if (modeInput) {
+            modeInput.value = state.mode;
+        }
+        if (publishedInput) {
+            publishedInput.value = state.published ? 'true' : 'false';
+        }
+    };
+
+    function toggleEditOnlyElements() {
+        const isEdit = state.mode === 'edit';
+        dom.qsa('[data-edit-only]').forEach(function (element) {
+            const value = element.getAttribute('data-edit-only');
+            if (value === 'true') {
+                dom.show(element, isEdit);
+            } else if (value === 'false') {
+                dom.show(element, !isEdit);
+            }
+        });
+    }
+
+    function updateDirectoryDependentControls() {
+        const isEdit = state.mode === 'edit';
+        const hasDirectory = !!app.data.selectedDirHandle;
+        dom.qsa('[data-requires-directory="true"]').forEach(function (element) {
+            const shouldDisable = !(isEdit && hasDirectory);
+            if ('disabled' in element) {
+                element.disabled = shouldDisable;
+            } else {
+                if (shouldDisable) {
+                    element.setAttribute('aria-disabled', 'true');
+                } else {
+                    element.removeAttribute('aria-disabled');
+                }
+            }
+        });
+    }
+
+    function updateResponseDueVisibility() {
+        var typeDisplay = dom.qs('#type-display');
+        var typeHidden = dom.qs('#type');
+        var wrapper = dom.qs('#response-due-wrapper');
+        if (!wrapper) { return; }
+        var typeVal = '';
+        if (typeDisplay) {
+            typeVal = (typeDisplay.textContent || '').trim();
+        } else if (typeHidden) {
+            typeVal = (typeHidden.value || '').trim();
+        }
+        var isSubmittal = typeVal.toLowerCase() === 'submittal';
+        if (isSubmittal) {
+            wrapper.classList.remove('hidden');
+        } else {
+            wrapper.classList.add('hidden');
+        }
+    }
+
+    state.apply = function applyState() {
+        updateResponseDueVisibility();
+        const inputs = document.querySelectorAll('input, select, textarea');
+        inputs.forEach(function (element) {
+            const noDisable = element.hasAttribute('data-no-disable') || (!!element.closest('thead') && !!element.closest('.filter-row'));
+            element.disabled = (state.mode !== 'edit') && !noDisable;
+        });
+
+        ['#owner-name', '#project-name', '#project-number', '#type-display'].forEach(function (selector) {
+            const element = dom.qs(selector);
+            if (element) {
+                element.contentEditable = (state.mode === 'edit') ? 'true' : 'false';
+            }
+        });
+
+        const remarksTextarea = dom.qs('#remarks');
+        const remarksContainer = dom.qs('#remarks-render-container');
+        var mdEditor = app.modules.markdownEditor;
+        const isEdit = (state.mode === 'edit') && !state.published;
+
+        if (remarksTextarea) { remarksTextarea.hidden = true; }
+
+        if (mdEditor) {
+            if (isEdit) {
+                // Show rendered preview with click-to-edit; editor loads on first click
+                mdEditor.bindRenderClick();
+                mdEditor.setRenderClickable(true);
+                mdEditor.showRendered();
+            } else {
+                // View mode: destroy editor, show static rendered HTML
+                mdEditor.destroy();
+                mdEditor.setRenderClickable(false);
+                mdEditor.refreshRender();
+                if (remarksContainer) { remarksContainer.hidden = false; }
+            }
+        } else if (remarksContainer) {
+            remarksContainer.hidden = false;
+        }
+
+        const titleInput = dom.qs('#title');
+        if (titleInput) {
+            const empty = !(titleInput.value || '').trim();
+            titleInput.hidden = (state.mode === 'view' && empty);
+        }
+
+        // From field: input in edit mode, rendered mailto link in view mode
+        const fromInput = dom.qs('#from');
+        const fromRender = dom.qs('#from-render');
+        if (fromInput && fromRender) {
+            if (isEdit) {
+                fromInput.hidden = false;
+                fromRender.classList.add('hidden');
+                fromRender.hidden = true;
+            } else {
+                fromInput.hidden = true;
+                fromRender.classList.remove('hidden');
+                fromRender.hidden = false;
+                if (app.modules.emailTags && app.modules.emailTags.renderFrom) {
+                    app.modules.emailTags.renderFrom();
+                }
+            }
+        }
+
+        // To field: input in edit mode, rendered mailto links in view mode
+        const toInput = dom.qs('#to');
+        const toRender = dom.qs('#to-render');
+        if (toInput && toRender) {
+            if (isEdit) {
+                toInput.hidden = false;
+                toRender.classList.add('hidden');
+                toRender.hidden = true;
+            } else {
+                toInput.hidden = true;
+                toRender.classList.remove('hidden');
+                toRender.hidden = false;
+                if (app.modules.emailTags && app.modules.emailTags.render) {
+                    app.modules.emailTags.render();
+                }
+            }
+        }
+
+        // Logo placeholders: show in edit mode when no logo loaded
+        document.querySelectorAll('.logo-cell').forEach(function (cell) {
+            var img = cell.querySelector('.logo-img');
+            var placeholder = cell.querySelector('.logo-placeholder');
+            if (!placeholder) { return; }
+            var hasLogo = img && img.getAttribute('src');
+            if (hasLogo) {
+                cell.classList.add('has-logo');
+            } else {
+                cell.classList.remove('has-logo');
+            }
+            if (state.mode === 'edit' && !hasLogo) {
+                placeholder.classList.remove('hidden');
+            } else {
+                placeholder.classList.add('hidden');
+            }
+        });
+
+        toggleEditOnlyElements();
+        updateDirectoryDependentControls();
+    };
+
+    state.detectState = function detectState() {
+        var data = app.json.parse();
+        var envelope = (data && data.envelope) || {};
+        var payload = (data && data.payload) || {};
+        var presentation = (data && data.presentation) || {};
+
+        if (envelope.digest) { return 'published'; }
+
+        var hasDate = !!(payload.date && payload.date.trim());
+        if (hasDate) { return 'draft'; }
+
+        var hasHeader = !!(payload.client || payload.project || payload.projectNumber ||
+            presentation.leftLogo || presentation.rightLogo);
+        if (hasHeader) { return 'template'; }
+
+        return 'clean';
+    };
+
+    app.registerInit(function () {
+        state.updateHiddenFields();
+        toggleEditOnlyElements();
+        updateDirectoryDependentControls();
+        var typeInput = dom.qs('#type');
+        if (typeInput) {
+            typeInput.addEventListener('input', updateResponseDueVisibility);
+        }
+        updateResponseDueVisibility();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const json = app.json;
+    const state = app.state;
+
+    function computePublishedState() {
+        const data = json.parse();
+        const digest = (data.envelope && data.envelope.digest) || '';
+        state.published = !!digest;
+        return state.published;
+    }
+
+    function setMode(mode) {
+        if (mode !== 'edit' && mode !== 'view') {
+            return;
+        }
+        if (state.published && mode === 'edit') {
+            mode = 'view';
+        }
+        state.mode = mode;
+    }
+
+    var _previousMode = state.mode;
+
+    function refresh() {
+        const wasPublished = state.published;
+        const nowPublished = computePublishedState();
+        if (nowPublished && !wasPublished) {
+            state.mode = 'view';
+        }
+        // Re-render file table only when mode actually changes (edit↔view)
+        if (state.mode !== _previousMode) {
+            _previousMode = state.mode;
+            if (app.modules.files && typeof app.modules.files.render === 'function') {
+                app.modules.files.render();
+            }
+        }
+        if (app.modules.files && app.modules.files.updateToolbars) {
+            app.modules.files.updateToolbars();
+        }
+    }
+
+    app.modules.mode = {
+        setMode,
+        refresh
+    };
+
+    app.registerInit(function () {
+        computePublishedState();
+        if (state.published) {
+            state.mode = 'view';
+        } else {
+            state.mode = 'edit';
+        }
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+
+    const visibility = app.modules.visibility = {};
+
+    // Field visibility rules based on document type
+    const FIELD_RULES = {
+        'from': ['Transmittal', 'Submittal'],
+        'to': ['Transmittal', 'Submittal']
+    };
+
+    function getDocumentType() {
+        const typeInput = dom.qs('#type');
+        return typeInput ? (typeInput.value || 'Transmittal').trim() : 'Transmittal';
+    }
+
+    function isFieldVisible(fieldId, docType) {
+        const rules = FIELD_RULES[fieldId];
+        if (!rules) {
+            return true; // No rules = always visible
+        }
+        return rules.includes(docType);
+    }
+
+    function getFieldContainer(fieldId) {
+        const input = dom.qs('#' + fieldId);
+        if (!input) {
+            return null;
+        }
+        // Find the parent container (the div with col-span-6 or col-span-12)
+        let container = input.parentElement;
+        while (container && !container.className.includes('col-span-')) {
+            container = container.parentElement;
+            if (!container || container.tagName === 'FORM') {
+                break;
+            }
+        }
+        return container || input.parentElement;
+    }
+
+    visibility.applyFieldVisibility = function applyFieldVisibility() {
+        const docType = getDocumentType();
+        Object.keys(FIELD_RULES).forEach(function(fieldId) {
+            const container = getFieldContainer(fieldId);
+            if (!container) { return; }
+            container.hidden = !isFieldVisible(fieldId, docType);
+        });
+    };
+
+    visibility.bindTypeInput = function bindTypeInput() {
+        const typeInput = dom.qs('#type');
+        if (!typeInput) {
+            return;
+        }
+
+        // Apply visibility on input change
+        typeInput.addEventListener('input', function() {
+            visibility.applyFieldVisibility();
+            if (app.markDirty) {
+                app.markDirty();
+            }
+        });
+
+        typeInput.addEventListener('change', function() {
+            visibility.applyFieldVisibility();
+        });
+    };
+
+    app.registerInit(function () {
+        visibility.bindTypeInput();
+        visibility.applyFieldVisibility();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const util = app.util;
+    const json = app.json;
+
+    let debounceTimer = null;
+    const DEBOUNCE_MS = 300; // 300ms debounce
+
+    async function updateLiveDigest() {
+        var digestDisplay = dom.qs('#digest-display');
+        if (!digestDisplay) { return; }
+
+        // Published — let renderSignaturesList handle the display
+        var data = json.parse();
+        var envelope = (data && data.envelope) || {};
+        if (envelope.digest) { return; }
+
+        // Only compute live digest in edit mode
+        if (app.state && app.state.mode !== 'edit') { return; }
+
+        try {
+            // Sync form-field values to JSON only after the app has fully
+            // initialised (i.e. loadFromJson has run and app.data.files is
+            // populated). Calling syncUiToJson before that would overwrite
+            // the saved-draft JSON with the empty in-memory state.
+            if (app._initialized && app.modules.files && app.modules.files.syncUiToJson) {
+                app.modules.files.syncUiToJson();
+                // Re-read after sync so the digest reflects the updated payload.
+                data = json.parse();
+            }
+            var payload = (data && data.payload) || {};
+            var payloadStr = util.canonicalStringify(payload);
+            var digest = await util.hashString(payloadStr);
+            var now = new Date().toLocaleString();
+
+            // Render draft verify-card
+            digestDisplay.innerHTML = '';
+            var card = document.createElement('div');
+            card.className = 'verify-card verify-card--draft';
+
+            var status = document.createElement('div');
+            status.className = 'verify-card__status verify-card__status--draft';
+            status.textContent = 'DRAFT';
+            card.appendChild(status);
+
+            var detail = document.createElement('div');
+            detail.className = 'verify-card__detail';
+            detail.innerHTML = 'Digest (SHA-256): <code>' + digest + '</code>';
+            card.appendChild(detail);
+
+            var time = document.createElement('div');
+            time.className = 'verify-card__detail';
+            time.textContent = 'Live \u2014 ' + now;
+            card.appendChild(time);
+
+            digestDisplay.appendChild(card);
+        } catch (err) {
+            console.error('[live-digest] Failed to calculate digest:', err);
+        }
+    }
+
+    function scheduleDigestUpdate() {
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(updateLiveDigest, DEBOUNCE_MS);
+    }
+
+    function bindFormChanges() {
+        const form = dom.qs('#transmittal-form');
+        if (!form) {
+            return;
+        }
+
+        // Listen to all input changes
+        form.addEventListener('input', scheduleDigestUpdate);
+        form.addEventListener('change', scheduleDigestUpdate);
+    }
+
+    function subscribeToStateChanges() {
+        // Subscribe to reactive state changes
+        if (app.state && app.state.subscribe) {
+            app.state.subscribe(function(property, newValue, oldValue) {
+                scheduleDigestUpdate();
+            });
+        }
+    }
+
+    app.onDirty(function () {
+        scheduleDigestUpdate();
+    });
+
+    app.modules.liveDigest = {
+        update: updateLiveDigest,
+        schedule: scheduleDigestUpdate
+    };
+
+    app.registerInit(function () {
+        bindFormChanges();
+        subscribeToStateChanges();
+        // Calculate initial digest
+        updateLiveDigest();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const DEBUG = false; // Set to true to enable verbose logging
+
+    const dom = app.dom;
+    const json = app.json;
+    const util = app.util;
+
+    const filesModule = app.modules.files = {};
+
+    var hasFileSystemAccess = typeof window.showDirectoryPicker === 'function';
+
+    function requireFileSystemAccess() {
+        if (hasFileSystemAccess) { return true; }
+        alert('This feature requires the File System Access API.\n\nPlease use a Chromium-based browser on desktop.');
+        return false;
+    }
+
+    function hasFiles() {
+        return Array.isArray(app.data.files) && app.data.files.length > 0;
+    }
+
+    // Three primary-button states: 'scan', 'verify', 'publish'
+    var _primaryIntent = null; // null = auto-detect, or explicit 'scan'|'verify'|'publish'
+    var _primaryHandler = null;
+
+    function setPrimary(intent) {
+        _primaryIntent = intent;
+        updateToolbars();
+    }
+
+    function setScanningState(active) {
+        var wrapper = document.querySelector('.table-wrapper');
+        if (!wrapper) { return; }
+        if (active) {
+            wrapper.classList.add('scanning');
+        } else {
+            wrapper.classList.remove('scanning');
+        }
+    }
+
+    function nowMs() {
+        if (typeof performance !== 'undefined' && typeof performance.now === 'function') {
+            return performance.now();
+        }
+        return Date.now();
+    }
+
+    function formatDuration(ms) {
+        const totalSeconds = Math.max(0, Math.round(ms / 1000));
+        const minutes = Math.floor(totalSeconds / 60);
+        const seconds = totalSeconds % 60;
+        if (minutes > 0) {
+            return minutes + 'm ' + seconds.toString().padStart(2, '0') + 's';
+        }
+        return seconds + 's';
+    }
+
+    // ── File handle permission and refresh helpers ─────────────────────
+
+    async function ensureDirHandlePermission(dirHandle) {
+        if (!dirHandle || typeof dirHandle.requestPermission !== 'function') {
+            return;
+        }
+        const permissionDescriptor = { mode: 'readwrite' };
+        const current = await dirHandle.queryPermission(permissionDescriptor);
+        if (current === 'granted') {
+            return;
+        }
+        // Request permission (requires user gesture in most browsers)
+        const result = await dirHandle.requestPermission(permissionDescriptor);
+        if (result !== 'granted') {
+            throw new Error('Read/write permission is required for the selected directory');
+        }
+    }
+
+    async function getFreshFile(fileHandle, fallbackData) {
+        if (!fileHandle || typeof fileHandle.getFile !== 'function') {
+            throw new Error('No valid file handle');
+        }
+
+        // Check permission state before attempting to get file
+        try {
+            const current = await fileHandle.queryPermission({ mode: 'read' });
+            if (current !== 'granted') {
+                // Try to request permission (will fail without user gesture)
+                try {
+                    await fileHandle.requestPermission({ mode: 'read' });
+                } catch (permErr) {
+                    // Permission request failed (likely no user gesture), skip with warning
+                    console.warn('[transmittal] Permission request failed for file:', fileHandle.name || 'unknown', permErr);
+                }
+                // Check permission again after potential request
+                const newPerm = await fileHandle.queryPermission({ mode: 'read' });
+                if (newPerm !== 'granted') {
+                    if (fallbackData) {
+                        // Use fallback data instead of throwing
+                        console.log('[transmittal] Permission not granted, using fallback for ' + (fallbackData.path || fallbackData.name || 'unknown file'));
+                        return fallbackData;
+                    }
+                    throw new Error('Permission denied for file access');
+                }
+            }
+        } catch (err) {
+            // queryPermission not supported or error
+            console.warn('[transmittal] Permission check error:', err);
+        }
+
+        try {
+            return await fileHandle.getFile();
+        } catch (err) {
+            if (err && err.name === 'NotReadableError') {
+                if (fallbackData) {
+                    console.log('[transmittal] NotReadableError, using fallback for ' + (fallbackData.path || fallbackData.name || 'unknown file'));
+                    return fallbackData;
+                }
+                throw err;
+            }
+            throw err;
+        }
+    }
+
+    function updateDirectoryIndicator(name) {
+        var indicator = dom.qs('#selected-directory');
+        if (indicator) {
+            indicator.textContent = name ? name : '';
+        }
+        updateToolbars();
+    }
+
+    function sortFilesInPlace(list) {
+        if (!Array.isArray(list)) {
+            return;
+        }
+        list.sort(util.compareFilesByTrackingRevision);
+    }
+
+    function buildFileHandleMap(files) {
+        var map = {};
+        (files || []).forEach(function (f) {
+            if (f.fileHandle) {
+                var key = (f.path || f.name || '').toLowerCase();
+                if (key) { map[key] = f.fileHandle; }
+            }
+        });
+        return map;
+    }
+
+    function restoreFileHandles(files, handleMap) {
+        (files || []).forEach(function (f) {
+            var key = (f.path || f.name || '').toLowerCase();
+            if (key && handleMap[key]) {
+                f.fileHandle = handleMap[key];
+            }
+        });
+    }
+
+    function selfEntryDate() {
+        var raw = (dom.qs('#date') || {}).value || '';
+        var trimmed = raw.trim();
+        if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) { return trimmed; }
+        var d = new Date(trimmed);
+        if (!isNaN(d.getTime())) { return d.toISOString().slice(0, 10); }
+        return trimmed;
+    }
+
+    function buildSelfEntry() {
+        var tracking = (dom.qs('#tracking-number') || {}).value || '';
+        var subject = (dom.qs('#subject') || {}).value || '';
+        var title = (dom.qs('#title') || {}).value || '';
+        var date = selfEntryDate();
+        var purpose = (dom.qs('#purpose') || {}).value || '';
+        var d = app.modules.data;
+        var filename = (d && d.buildFileName)
+            ? d.buildFileName({ trackingNumber: tracking, title: title, date: date, purpose: purpose }, { extension: 'html' })
+            : '';
+        return {
+            _isSelf: true,
+            path: filename ? ('./' + filename) : '',
+            name: filename || '',
+            trackingNumber: tracking,
+            title: subject || title,
+            revision: date,
+            status: purpose,
+            extension: 'html',
+            size: 0,
+            fileSize: 0,
+            sha256: app.constants.SELF_HASH
+        };
+    }
+
+    filesModule.buildSelfEntry = buildSelfEntry;
+
+    function canonicalFilePayload(entry) {
+        const relativePath = entry.path || entry.name || '';
+        const filename = relativePath.split('/').pop() || entry.name || '';
+        const pathOnly = relativePath.substring(0, relativePath.lastIndexOf('/')) || '';
+        return {
+            trackingNumber: entry.trackingNumber || '',
+            revision: entry.revision || '',
+            status: entry.status || '',
+            title: entry.title || '',
+            path: pathOnly,
+            filename: filename,
+            extension: entry.extension || '',
+            sha256: entry.sha256 || '',
+            fileSize: Number(entry.fileSize || entry.size || 0)
+        };
+    }
+
+    function updateFilesInJson(files) {
+        const data = json.parse();
+        const envelope = { ...(data.envelope || {}) };
+        const payload = { ...(data.payload || {}) };
+        const presentation = { ...(data.presentation || {}) };
+        
+        const sorted = (Array.isArray(files) ? files : []).slice().sort(util.compareFilesByTrackingRevision);
+        // Prepend self-entry, then regular files
+        var selfEntry = buildSelfEntry();
+        payload.files = [canonicalFilePayload(selfEntry)].concat(sorted.map(canonicalFilePayload));
+        
+        // Clear digest when files change (invalidates signatures)
+        envelope.digest = '';
+        envelope.digestedAt = '';
+        envelope.signatures = [];
+        
+        json.setData({ envelope: envelope, payload: payload, presentation: presentation });
+    }
+
+    var ARCHIVE_DIR_NAME = '.archive';
+    var MAX_DIRECTORY_DEPTH = 48;
+
+    function isHiddenName(name) {
+        return !!name && name.startsWith('.');
+    }
+
+    function shouldSkipDirectorySegment(name) {
+        if (!name) {
+            return false;
+        }
+        if (name === ARCHIVE_DIR_NAME) {
+            return true;
+        }
+        return isHiddenName(name);
+    }
+
+    async function collectFilesRecursive(handle, relPath, out, depth) {
+        const currentDepth = depth || 0;
+        if (DEBUG) console.log('[transmittal] collectFilesRecursive:', relPath, 'depth:', currentDepth, 'kind:', handle.kind);
+        
+        if (currentDepth > MAX_DIRECTORY_DEPTH) {
+            throw new Error('Directory nesting exceeds supported depth');
+        }
+        if (handle.kind === 'file') {
+            if (isHiddenName(handle.name)) {
+                if (DEBUG) console.log('[transmittal] Skipping hidden file:', relPath);
+                return;
+            }
+            if (DEBUG) console.log('[transmittal] Adding file to collection:', relPath);
+            out.push({ handle, path: relPath, name: handle.name });
+            return;
+        }
+        if (handle.kind !== 'directory') {
+            if (DEBUG) console.log('[transmittal] Unknown handle kind:', handle.kind, 'for', relPath);
+            return;
+        }
+        if (shouldSkipDirectorySegment(handle.name) && relPath) {
+            if (DEBUG) console.log('[transmittal] Skipping directory segment:', relPath);
+            return;
+        }
+        try {
+            if (DEBUG) console.log('[transmittal] Iterating directory:', relPath || 'root');
+            let childCount = 0;
+            for await (const child of handle.values()) {
+                childCount++;
+                if (DEBUG) console.log('[transmittal] Found child #' + childCount + ':', child.name, 'kind:', child.kind);
+                if (shouldSkipDirectorySegment(child.name)) {
+                    continue;
+                }
+                const childPath = relPath ? (relPath + '/' + child.name) : child.name;
+                if (DEBUG) console.log('[transmittal] Recursing into:', childPath);
+                await collectFilesRecursive(child, childPath, out, currentDepth + 1);
+            }
+            if (DEBUG) console.log('[transmittal] Finished iterating directory:', relPath || 'root', 'found', childCount, 'children');
+        } catch (err) {
+            if (err && err.name === 'NotFoundError') {
+                console.error('[transmittal] NotFoundError during directory traversal:', relPath || handle.name || '', {
+                    error: err,
+                    message: err.message,
+                    stack: err.stack,
+                    handleName: handle.name,
+                    handleKind: handle.kind
+                });
+                return;
+            }
+            console.error('[transmittal] Unexpected error during directory traversal:', relPath, err);
+            throw err;
+        }
+    }
+
+    async function collectDirectoryEntries(rootHandle) {
+        const entries = [];
+        
+        if (!rootHandle || rootHandle.kind !== 'directory') {
+            throw new Error('Invalid directory handle provided');
+        }
+        
+        try {
+            // Start directory scan
+            if (DEBUG) console.log('[transmittal] Starting directory scan for:', rootHandle.name);
+            
+            for await (const child of rootHandle.values()) {
+                if (shouldSkipDirectorySegment(child.name)) {
+                    continue;
+                }
+                const childPath = child.name;
+                try {
+                    await collectFilesRecursive(child, childPath, entries, 1);
+                } catch (err) {
+                    if (err && err.name === 'NotFoundError') {
+                        console.warn('[transmittal] directory entry missing', childPath, err);
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+        } catch (err) {
+            if (err && err.name === 'NotFoundError') {
+                console.error('[transmittal] NotFoundError during directory scan', {
+                    error: err,
+                    message: err.message,
+                    stack: err.stack,
+                    handle: rootHandle,
+                    handleName: rootHandle.name
+                });
+                // Return empty entries instead of throwing
+                return entries;
+            }
+            console.error('[transmittal] Unexpected error during directory scan', err);
+            throw err;
+        }
+        return entries;
+    }
+
+    // Promote shared helpers to filesModule for use by sub-modules
+    filesModule.nowMs = nowMs;
+    filesModule.formatDuration = formatDuration;
+    filesModule.updateDirectoryIndicator = updateDirectoryIndicator;
+    filesModule.sortFilesInPlace = sortFilesInPlace;
+    filesModule.updateFilesInJson = updateFilesInJson;
+    filesModule.collectDirectoryEntries = collectDirectoryEntries;
+
+    async function ensureDirHandle() {
+        if (typeof window.showDirectoryPicker !== 'function') {
+            throw new Error('File System Access API showDirectoryPicker is required');
+        }
+        const handle = await window.showDirectoryPicker();
+        
+        // Log the handle details for debugging
+        if (DEBUG) {
+            console.log('[transmittal] Directory selected:', {
+                name: handle.name,
+                kind: handle.kind,
+                hasQueryPermission: typeof handle.queryPermission === 'function',
+                hasRequestPermission: typeof handle.requestPermission === 'function'
+            });
+        }
+
+        async function ensureRwPermission(dirHandle) {
+            if (!dirHandle) {
+                throw new Error('Directory handle is undefined');
+            }
+            if (typeof dirHandle.requestPermission !== 'function') {
+                return;
+            }
+            const permissionDescriptor = { mode: 'readwrite' };
+            if (typeof dirHandle.queryPermission === 'function') {
+                const current = await dirHandle.queryPermission(permissionDescriptor);
+                if (current === 'granted') {
+                    return;
+                }
+            }
+            const result = await dirHandle.requestPermission(permissionDescriptor);
+            if (result !== 'granted') {
+                throw new Error('Read/write permission is required for the selected directory');
+            }
+        }
+
+        await ensureRwPermission(handle);
+        
+        // Verify the handle is still valid after permission check
+        if (!handle || handle.kind !== 'directory') {
+            throw new Error('Directory handle became invalid after permission check');
+        }
+
+        app.data.selectedDirHandle = handle;
+        updateDirectoryIndicator(handle.name);
+        app.state.apply();
+        
+        if (DEBUG) console.log('[transmittal] Directory handle ready:', handle.name);
+        return handle;
+    }
+
+    // Parse folder name: YYYY-MM-DD_TRACKING (STATUS) - TITLE
+    // Wraps zddc.parseFolder, preserving this module's null-on-invalid contract.
+    function parseFolderName(name) {
+        var parsed = zddc.parseFolder(name);
+        if (!parsed || !parsed.valid) { return null; }
+        return {
+            date:           parsed.date,
+            trackingNumber: parsed.trackingNumber,
+            status:         parsed.status,
+            title:          parsed.title
+        };
+    }
+
+    function populateFields(parsed) {
+        if (!parsed) { return; }
+        var map = {
+            'date': parsed.date,
+            'tracking-number': parsed.trackingNumber,
+            'purpose': parsed.status,
+            'subject': parsed.title
+        };
+        Object.keys(map).forEach(function (id) {
+            var el = dom.qs('#' + id);
+            if (el && map[id]) {
+                el.value = map[id];
+            }
+        });
+    }
+
+    // Shared scan pipeline: collect → populate rows → hash with progress
+    // onHash(item, hash) is called per file after hashing; return value sets cell content.
+    async function scanEntries(dirHandle, onHash) {
+        var entries = await collectDirectoryEntries(dirHandle);
+        entries.sort(function (a, b) { return a.path.localeCompare(b.path); });
+
+        // Phase 0: Ensure directory handle has permission
+        await ensureDirHandlePermission(dirHandle);
+
+        // Phase 1: merge with existing files
+        var existingIndex = filesModule.buildExistingIndex(app.data.files || []);
+        var existingPasteKeys = Object.keys(existingIndex);
+        setScanningState(true);
+        var hashCells = [];
+        for (var i = 0; i < entries.length; i++) {
+            var entry = entries[i];
+            try {
+                // Check and refresh handle permission before getFile
+                var file = await getFreshFile(entry.handle);
+                var parsed = (zddc.parseFilename(file.name) || {});
+                var fileData = {
+                    path: entry.path,
+                    name: file.name,
+                    size: file.size,
+                    fileSize: file.size,
+                    sha256: '',
+                    trackingNumber: parsed.trackingNumber,
+                    title: parsed.title,
+                    revision: parsed.revision,
+                    status: parsed.status,
+                    extension: parsed.extension || zddc.splitExtension(file.name).extension,
+                    fileHandle: entry.handle
+                };
+                var pasteKey = (fileData.trackingNumber || '').toLowerCase() + '|' + (fileData.revision || '').toLowerCase();
+                if (existingPasteKeys.indexOf(pasteKey) === -1) {
+                    app.data.files.push(fileData);
+                    var hashCell = filesModule.renderSingleRow(fileData, app.data.files.length - 1);
+                    hashCells.push({ cell: hashCell, fileData: fileData, handle: entry.handle });
+                }
+            } catch (err) {
+                console.error('[transmittal] Error reading file:', entry.path, err);
+            }
+            if (i % 20 === 0) {
+                await new Promise(function (r) { setTimeout(r, 0); });
+            }
+        }
+
+        // Phase 2: hash each file with progress bar
+        setScanningState(false);
+        for (var j = 0; j < hashCells.length; j++) {
+            var item = hashCells[j];
+            try {
+                var fill = item.cell ? item.cell.querySelector('.hash-progress-fill') : null;
+                var onProgress = fill ? function (f) {
+                    return function (loaded, total) {
+                        var pct = total > 0 ? Math.round((loaded / total) * 100) : 0;
+                        f.style.width = pct + '%';
+                    };
+                }(fill) : null;
+                var file = await getFreshFile(item.handle);
+                var hash = await util.hashFile(file, onProgress);
+                item.fileData.sha256 = hash;
+                if (onHash) {
+                    onHash(item, hash);
+                } else if (item.cell) {
+                    item.cell.textContent = util.formatShortFileHash(hash);
+                }
+            } catch (err) {
+                console.error('[transmittal] Error hashing file:', item.fileData.path, err);
+                if (item.cell) { item.cell.textContent = 'error'; }
+            }
+        }
+        return hashCells;
+    }
+
+    function finalizeAfterScan() {
+        var handleMap = buildFileHandleMap(app.data.files);
+        updateFilesInJson(app.data.files);
+        filesModule.render();
+        filesModule.loadFromJson({ filesOnly: true });
+        restoreFileHandles(app.data.files, handleMap);
+        app.state.apply();
+    }
+
+    async function selectDirectory(event) {
+        if (DEBUG) console.log('[transmittal] ========== SELECT DIRECTORY STARTED ==========');
+        const trigger = event && event.currentTarget instanceof HTMLElement ? event.currentTarget : null;
+        if (trigger) {
+            trigger.disabled = true;
+            trigger.classList.add('opacity-60');
+        }
+        try {
+            var dirHandle = app.data.selectedDirHandle;
+            if (!dirHandle) {
+                dirHandle = await ensureDirHandle();
+            }
+            populateFields(parseFolderName(dirHandle.name));
+            await scanEntries(dirHandle);
+            finalizeAfterScan();
+            app.markDirty();
+            setPrimary('publish');
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                if (DEBUG) console.log('[transmittal] User cancelled directory selection');
+            } else {
+                console.error('[transmittal] selectDirectory failed', err);
+            }
+        } finally {
+            setScanningState(false);
+            if (trigger) {
+                trigger.disabled = false;
+                trigger.classList.remove('opacity-60');
+            }
+        }
+    }
+
+    async function writeFileToSelectedDir(filename, contents, mime) {
+        if (!app.data.selectedDirHandle) {
+            throw new Error('No directory selected');
+        }
+        const fileHandle = await app.data.selectedDirHandle.getFileHandle(filename, { create: true });
+        const writable = await fileHandle.createWritable();
+        await writable.write(new Blob([contents], { type: mime || 'text/plain' }));
+        await writable.close();
+    }
+
+    filesModule.writeFileToSelectedDir = writeFileToSelectedDir;
+
+    // ── Paste helpers ─────────────────────────────────────
+    // Expected formats (tab-separated, 3-5 adjacent columns):
+    //   3 cols: Tracking \t Title \t Revision+Status   ("A (IFR)")
+    //   4 cols: Tracking \t Title \t Revision \t Status
+    //   5 cols: Tracking \t Title \t Revision \t Status \t Extension
+    var MAX_PASTE_COLS = 5;
+    var HEADER_RE = /^(#|tracking|number|title|revision|status|ext)/i;
+
+    function isHeaderLine(cols) {
+        if (!cols || !cols.length) { return false; }
+        return HEADER_RE.test((cols[0] || '').trim());
+    }
+
+    function columnsToFileRow(cols) {
+        var tracking = (cols[0] || '').trim();
+        if (!tracking) { return null; }
+        var revision = (cols[2] || '').trim();
+        var status = (cols[3] || '').trim();
+        var extension = (cols[4] || '').trim().toLowerCase();
+
+        // 3-column paste: split "A (IFR)" into revision "A" and status "IFR"
+        if (cols.length <= 3 && revision) {
+            var spaceIdx = revision.indexOf(' ');
+            if (spaceIdx > 0) {
+                status = revision.substring(spaceIdx + 1).trim().replace(/^\(+/, '').replace(/\)+$/, '');
+                revision = revision.substring(0, spaceIdx).trim();
+            }
+        }
+        return {
+            trackingNumber: tracking,
+            title: (cols[1] || '').trim(),
+            revision: revision,
+            status: status,
+            extension: extension,
+            path: '', name: '', size: 0, fileSize: 0, sha256: ''
+        };
+    }
+
+    // Parse plain-text tab-separated clipboard data.
+    // Returns { rows: [...], tooWide: false } or { rows: [], tooWide: true }.
+    function parseClipboardText(text) {
+        var lines = (text || '').split(/\r?\n/);
+        var rows = [];
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i].trim();
+            if (!line) { continue; }
+            var cols = line.split('\t');
+            if (isHeaderLine(cols)) { continue; }
+            if (cols.length > MAX_PASTE_COLS) {
+                return { rows: [], tooWide: true, colCount: cols.length };
+            }
+            var row = columnsToFileRow(cols);
+            if (row) { rows.push(row); }
+        }
+        return { rows: rows, tooWide: false };
+    }
+
+    function pasteFileKey(trackingNumber, revision) {
+        return (trackingNumber || '').toLowerCase() + '|' + (revision || '').toLowerCase();
+    }
+
+    function buildExistingIndex(files) {
+        var index = {};
+        for (var i = 0; i < files.length; i++) {
+            index[pasteFileKey(files[i].trackingNumber, files[i].revision)] = i;
+        }
+        return index;
+    }
+    filesModule.buildExistingIndex = buildExistingIndex;
+
+    async function handlePasteFiles(mode, clipText) {
+        var setStatus = app.modules.data && app.modules.data.setStatus;
+        try {
+            var text = clipText || await navigator.clipboard.readText();
+            var result = parseClipboardText(text);
+            if (result.tooWide) {
+                if (setStatus) {
+                    setStatus('Paste has ' + result.colCount + ' columns (max ' + MAX_PASTE_COLS + '). ' +
+                        'Copy only: Tracking, Title, Revision, [Status], [Extension]', 'error');
+                }
+                return;
+            }
+            var rows = result.rows;
+            if (!rows.length) {
+                if (setStatus) { setStatus('No valid rows found. Expected tab-separated: Tracking, Title, Revision, [Status], [Ext]', 'error'); }
+                return;
+            }
+
+            var added = 0, updated = 0;
+            if (mode === 'new') {
+                app.data.files = [];
+                for (var i = 0; i < rows.length; i++) {
+                    app.data.files.push(rows[i]);
+                    added++;
+                }
+            } else {
+                var index = buildExistingIndex(app.data.files || []);
+                for (var j = 0; j < rows.length; j++) {
+                    var row = rows[j];
+                    var key = pasteFileKey(row.trackingNumber, row.revision);
+                    if (index.hasOwnProperty(key)) {
+                        var existing = app.data.files[index[key]];
+                        existing.title = row.title;
+                        existing.status = row.status;
+                        if (row.extension) { existing.extension = row.extension; }
+                        updated++;
+                    } else {
+                        app.data.files.push(row);
+                        added++;
+                    }
+                }
+            }
+
+            filesModule.sortFilesInPlace(app.data.files);
+            updateFilesInJson(app.data.files);
+            filesModule.render();
+            app.state.apply();
+            app.markDirty();
+            setPrimary('verify');
+
+            var msg = mode === 'new'
+                ? 'Replaced file list: ' + added + ' rows'
+                : added + ' added, ' + updated + ' updated';
+            if (setStatus) { setStatus(msg, 'success'); }
+        } catch (err) {
+            console.error('[transmittal] paste failed', err);
+            if (setStatus) { setStatus('Paste failed: ' + (err && err.message ? err.message : err), 'error'); }
+        }
+    }
+
+    // ── Toolbar visibility per state ────────────────────
+    function updateToolbars() {
+        var docState = app.state.detectState();
+        buildBottomBar(docState);
+    }
+
+    function createMenuItem(label, handler, options) {
+        var btn = document.createElement('button');
+        btn.type = 'button';
+        btn.className = 'dropdown-item' + ((options && options.danger) ? ' text-red-600' : '');
+        btn.setAttribute('role', 'menuitem');
+        btn.textContent = label;
+        btn.addEventListener('click', handler);
+        return btn;
+    }
+
+    function createSeparator(label) {
+        var el = document.createElement('div');
+        el.className = 'dropdown-separator';
+        if (label) { el.textContent = label; }
+        return el;
+    }
+
+    function applyPrimaryButton(btn, intent) {
+        if (_primaryHandler) { btn.removeEventListener('click', _primaryHandler); }
+        btn.disabled = false;
+        btn.classList.remove('opacity-60');
+        if (intent === 'publish') {
+            btn.textContent = 'Publish';
+            _primaryHandler = function () {
+                document.dispatchEvent(new CustomEvent('transmittal:open-publish'));
+            };
+        } else if (intent === 'verify') {
+            btn.textContent = 'Verify Directory';
+            _primaryHandler = function () {
+                if (!requireFileSystemAccess()) { return; }
+                verifyFiles();
+            };
+        } else {
+            btn.textContent = 'Scan Directory';
+            _primaryHandler = function () {
+                if (!requireFileSystemAccess()) { return; }
+                selectDirectory({ currentTarget: null });
+            };
+        }
+        btn.addEventListener('click', _primaryHandler);
+    }
+
+    function buildBottomBar(docState) {
+        var primaryBtn = dom.qs('#bottom-primary');
+        var dropdown = dom.qs('#bottom-dropdown');
+        if (!primaryBtn || !dropdown) { return; }
+
+        var isPublished = docState === 'published';
+        var d = app.modules.data || {};
+
+        dropdown.innerHTML = '';
+        dropdown.classList.add('hidden');
+
+        if (isPublished) {
+            applyPrimaryButton(primaryBtn, 'verify');
+
+            dropdown.appendChild(createMenuItem('Copy Table', function () {
+                if (d.handleCopyTable) { d.handleCopyTable(); }
+            }));
+            dropdown.appendChild(createMenuItem('Copy JSON', function () {
+                if (d.handleCopyJson) { d.handleCopyJson(); }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Add Signature', function () {
+                if (app.modules.security && app.modules.security.addSignature) {
+                    app.modules.security.addSignature();
+                }
+            }));
+            dropdown.appendChild(createMenuItem('Acknowledge Receipt', function () {
+                if (app.modules.security && app.modules.security.addSignature) {
+                    app.modules.security.addSignature({ label: 'Received By' });
+                }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Revise', function () {
+                if (d.handleRevise) { d.handleRevise(); }
+            }));
+            dropdown.appendChild(createMenuItem('Import HTML', function () {
+                if (d.handleImportHtml) { d.handleImportHtml(); }
+            }));
+            dropdown.appendChild(createMenuItem('Reset', function () {
+                if (app.modules.reset && app.modules.reset.handleReset) {
+                    app.modules.reset.handleReset();
+                }
+            }, { danger: true }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Create Index', function () {
+                if (!requireFileSystemAccess()) { return; }
+                if (filesModule.generateArchiveRedirects) {
+                    filesModule.generateArchiveRedirects().catch(function (err) {
+                        console.error('[transmittal] create-index failed', err);
+                    });
+                }
+            }));
+        } else {
+            // Edit: respect explicit intent, or auto-detect
+            var intent = _primaryIntent;
+            if (!intent) {
+                intent = hasFiles() ? 'verify' : 'scan';
+            }
+            applyPrimaryButton(primaryBtn, intent);
+
+            dropdown.appendChild(createMenuItem('Scan Directory', function () {
+                if (!requireFileSystemAccess()) { return; }
+                selectDirectory({ currentTarget: null });
+            }));
+            dropdown.appendChild(createMenuItem('Verify Directory', function () {
+                if (!requireFileSystemAccess()) { return; }
+                verifyFiles();
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Publish', function () {
+                document.dispatchEvent(new CustomEvent('transmittal:open-publish'));
+            }));
+            dropdown.appendChild(createMenuItem('Save Draft', function () {
+                if (d.handleSaveHtmlDraft) { d.handleSaveHtmlDraft(); }
+            }));
+            dropdown.appendChild(createMenuItem('Create Folder', async function () {
+                var setStatus = d.setStatus;
+                try {
+                    // Sync UI so payload reflects current form values
+                    filesModule.syncUiToJson();
+                    var data = json.parse();
+                    var payload = (data && data.payload) || {};
+                    if (!payload.trackingNumber) {
+                        if (setStatus) { setStatus('Enter a tracking number first', 'error'); }
+                        return;
+                    }
+                    var folderName = d.buildFolderName(payload);
+                    // Sanitize for filesystem
+                    folderName = folderName.replace(/[<>:"/\\|?*]+/g, '_').replace(/_+/g, '_');
+
+                    // Prompt for staging directory
+                    var stagingHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
+                    var newFolderHandle = await stagingHandle.getDirectoryHandle(folderName, { create: true });
+
+                    // Set as selected directory for subsequent file operations
+                    app.data.selectedDirHandle = newFolderHandle;
+                    app.data.selectedDirName = folderName;
+                    if (filesModule.updateDirectoryIndicator) {
+                        filesModule.updateDirectoryIndicator();
+                    }
+
+                    // Save a draft into the new folder
+                    var pub = app.modules.publish;
+                    if (pub && typeof pub.syncUiToJson === 'function' && typeof pub.buildHtmlString === 'function') {
+                        await pub.syncUiToJson({ sign: false, computeDigest: false });
+                        var html = await pub.buildHtmlString();
+                        var draftName = d.buildFileName(
+                            ((json.parse() || {}).payload || {}),
+                            { extension: 'html', draft: true }
+                        );
+                        await writeFileToSelectedDir(draftName, html, 'text/html');
+                        // Verify both the folder and draft file exist
+                        var warnings = [];
+                        try {
+                            await stagingHandle.getDirectoryHandle(folderName);
+                        } catch (_) {
+                            warnings.push('folder \"' + folderName + '\" could not be verified');
+                        }
+                        try {
+                            await newFolderHandle.getFileHandle(draftName);
+                        } catch (_) {
+                            warnings.push('draft file \"' + draftName + '\" could not be verified');
+                        }
+                        if (warnings.length) {
+                            if (setStatus) { setStatus('Warning: ' + warnings.join('; ') + '. Path may be too long for Windows.', 'error'); }
+                        } else if (setStatus) {
+                            setStatus('Draft saved to ' + folderName + '. Close this file and open ' + draftName + ' from the new folder.', 'success');
+                        }
+                    } else {
+                        if (setStatus) { setStatus('Created folder: ' + folderName, 'success'); }
+                    }
+                } catch (err) {
+                    if (err && err.name === 'AbortError') { return; }
+                    console.error('[transmittal] create-folder failed', err);
+                    if (setStatus) { setStatus('Create folder failed: ' + (err.message || err), 'error'); }
+                }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Paste New Rows', async function () {
+                var text;
+                try { text = await navigator.clipboard.readText(); } catch (e) {
+                    if (d.setStatus) { d.setStatus('Clipboard access denied', 'error'); }
+                    return;
+                }
+                var result = parseClipboardText(text);
+                if (result.tooWide) {
+                    if (d.setStatus) {
+                        d.setStatus('Paste has ' + result.colCount + ' columns (max ' + MAX_PASTE_COLS + '). ' +
+                            'Copy only: Tracking, Title, Revision, [Status], [Extension]', 'error');
+                    }
+                    return;
+                }
+                if (!result.rows.length) {
+                    if (d.setStatus) { d.setStatus('No valid rows on clipboard', 'error'); }
+                    return;
+                }
+                if (confirm('Replace file list with ' + result.rows.length + ' rows from clipboard?')) {
+                    handlePasteFiles('new', text);
+                }
+            }));
+            dropdown.appendChild(createMenuItem('Paste Append Rows', function () {
+                handlePasteFiles('append');
+            }));
+            dropdown.appendChild(createMenuItem('Copy Table', function () {
+                if (d.handleCopyTable) { d.handleCopyTable(); }
+            }));
+            dropdown.appendChild(createMenuItem('Remove Files', function () {
+                if (!app.data.files.length) {
+                    if (d.setStatus) { d.setStatus('File list is already empty', 'error'); }
+                    return;
+                }
+                if (confirm('Remove all ' + app.data.files.length + ' files from the list? Header info and remarks will be kept.')) {
+                    app.data.files = [];
+                    updateFilesInJson([]);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    if (d.setStatus) { d.setStatus('File list cleared', 'success'); }
+                }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Import HTML', function () {
+                if (d.handleImportHtml) { d.handleImportHtml(); }
+            }));
+            dropdown.appendChild(createMenuItem('Copy JSON', function () {
+                if (d.handleCopyJson) { d.handleCopyJson(); }
+            }));
+            dropdown.appendChild(createMenuItem('Paste JSON', function () {
+                if (d.handleLoadFromClipboard) { d.handleLoadFromClipboard(); }
+            }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Reset', function () {
+                if (app.modules.reset && app.modules.reset.handleReset) {
+                    app.modules.reset.handleReset();
+                }
+            }, { danger: true }));
+            dropdown.appendChild(createSeparator());
+            dropdown.appendChild(createMenuItem('Create Index', function () {
+                if (!requireFileSystemAccess()) { return; }
+                if (filesModule.generateArchiveRedirects) {
+                    filesModule.generateArchiveRedirects().catch(function (err) {
+                        console.error('[transmittal] create-index failed', err);
+                    });
+                }
+            }));
+        }
+    }
+
+    // ── Bottom bar dropdown toggle ──────────────────────
+    function initBottomBarToggle() {
+        var toggle = dom.qs('#bottom-toggle');
+        var menu = dom.qs('#bottom-dropdown');
+        if (!toggle || !menu) { return; }
+
+        toggle.addEventListener('click', function (e) {
+            e.stopPropagation();
+            var open = !menu.classList.contains('hidden');
+            menu.classList.toggle('hidden', open);
+            toggle.setAttribute('aria-expanded', String(!open));
+        });
+
+        menu.addEventListener('click', function () {
+            menu.classList.add('hidden');
+            toggle.setAttribute('aria-expanded', 'false');
+        });
+
+        document.addEventListener('click', function (e) {
+            var container = dom.qs('#bottom-menu');
+            if (container && !container.contains(e.target)) {
+                menu.classList.add('hidden');
+                toggle.setAttribute('aria-expanded', 'false');
+            }
+        });
+    }
+
+
+    async function refreshDirectory() {
+        var dirHandle = app.data.selectedDirHandle;
+        if (!dirHandle) { return; }
+        try {
+            // Ensure directory handle has permission before scanning
+            await ensureDirHandlePermission(dirHandle);
+            
+            // Build expected-hash lookup from current JSON
+            var expectedHashes = {};
+            var currentData = json.parse();
+            var loadedFiles = (currentData && currentData.payload && Array.isArray(currentData.payload.files)) ? currentData.payload.files : [];
+            loadedFiles.forEach(function (f) {
+                var key = (f.path ? f.path + '/' : '') + f.filename;
+                if (f.sha256) { expectedHashes[key.toLowerCase()] = f.sha256.toLowerCase(); }
+            });
+            var hasExpected = Object.keys(expectedHashes).length > 0;
+            var matchCount = 0;
+            var mismatchCount = 0;
+
+            var hashCells = await scanEntries(dirHandle, hasExpected ? function (item, hash) {
+                if (!item.cell) { return; }
+                var display = util.formatShortFileHash(hash);
+                var fileKey = (item.fileData.path || item.fileData.name).toLowerCase();
+                var expected = expectedHashes[fileKey];
+                if (expected && expected === hash.toLowerCase()) {
+                    item.cell.innerHTML = '<span class="hash-match" title="Hash matches expected value">\u2713</span> ' + display;
+                    matchCount++;
+                } else if (expected) {
+                    item.cell.innerHTML = '<span class="hash-mismatch" title="Hash does NOT match expected value">\u2717</span> ' + display;
+                    mismatchCount++;
+                } else {
+                    item.cell.textContent = display;
+                }
+            } : null);
+
+            if (hasExpected && app.modules.data && app.modules.data.setStatus) {
+                if (mismatchCount === 0 && matchCount > 0) {
+                    app.modules.data.setStatus(matchCount + '/' + hashCells.length + ' files verified', 'success');
+                } else if (mismatchCount > 0) {
+                    app.modules.data.setStatus(mismatchCount + ' hash mismatch(es) \u2014 ' + matchCount + ' matched', 'error');
+                }
+            }
+
+            finalizeAfterScan();
+            if (!hasExpected) { app.markDirty(); }
+        } catch (err) {
+            console.error('[transmittal] Refresh failed', err);
+        } finally {
+            setScanningState(false);
+        }
+    }
+
+    // ── Verify row helpers ────────────────────────────────────
+    function findRowByFileIndex(idx) {
+        var cell = document.querySelector('td[data-index="' + idx + '"]');
+        return cell ? cell.closest('tr') : null;
+    }
+
+    function getHashCell(row) {
+        return row ? row.querySelector('td:last-child') : null;
+    }
+
+    function setRowVerifyState(row, state) {
+        if (!row) { return; }
+        row.classList.remove('verify-match', 'verify-mismatch', 'verify-missing', 'verify-new', 'verify-progress');
+        if (state) { row.classList.add('verify-' + state); }
+    }
+
+    function clearAllVerifyStates() {
+        var rows = document.querySelectorAll('tr.verify-match, tr.verify-mismatch, tr.verify-missing, tr.verify-new, tr.verify-progress');
+        rows.forEach(function (r) {
+            r.classList.remove('verify-match', 'verify-mismatch', 'verify-missing', 'verify-new', 'verify-progress');
+        });
+    }
+
+    function escapeHtml(str) {
+        var div = document.createElement('div');
+        div.textContent = str;
+        return div.innerHTML;
+    }
+
+    function showPathDiff(trackingCell, expectedPath, actualPath) {
+        var diffEl = document.createElement('div');
+        diffEl.className = 'path-diff';
+        var del = document.createElement('del');
+        del.textContent = expectedPath;
+        var ins = document.createElement('ins');
+        ins.textContent = actualPath;
+        diffEl.appendChild(del);
+        diffEl.appendChild(document.createTextNode(' \u2192 '));
+        diffEl.appendChild(ins);
+        trackingCell.appendChild(diffEl);
+    }
+
+    // Hash every directory entry upfront, before any event-loop yields.
+    // On file:// origins in Chromium, FileSystemFileHandle.getFile() fails after
+    // macrotask boundaries have elapsed since the handle was created. The fix is
+    // to call getFile() + hashFile() back-to-back for each entry in one tight
+    // sequential pass, producing a complete index before any UI yields occur.
+    // Returns { sizeIndex, nameIndex } where each entry has hash already computed.
+    async function buildVerifyIndex(entries, onProgress) {
+        var sizeIndex = {};  // fileSize → [candidate]
+        var nameIndex = {};  // "tracking\trevision" → candidate
+        var entryList = [];  // List of file metadata for later use
+        for (var i = 0; i < entries.length; i++) {
+            var entry = entries[i];
+            try {
+                var file = await entry.handle.getFile();
+                var hash = await util.hashFile(file);
+                var cand = {
+                    handle: entry.handle,
+                    path: entry.path,
+                    name: file.name,
+                    fileSize: file.size,
+                    hash: hash,
+                    matched: false
+                };
+                // Store file metadata for later use
+                entryList.push({
+                    handle: entry.handle,
+                    path: entry.path,
+                    name: file.name,
+                    fileSize: file.size,
+                    hash: hash,
+                    parsed: (zddc.parseFilename(entry.name) || {})
+                });
+                // size index
+                if (!sizeIndex[file.size]) { sizeIndex[file.size] = []; }
+                sizeIndex[file.size].push(cand);
+                // name index
+                var parsed = (zddc.parseFilename(entry.name) || {});
+                if (parsed.trackingNumber) {
+                    var nkey = parsed.trackingNumber.toLowerCase() + '\t' + (parsed.revision || '').toLowerCase();
+                    if (!nameIndex[nkey]) { nameIndex[nkey] = []; }
+                    nameIndex[nkey].push(cand);
+                }
+                if (onProgress) { onProgress(i + 1, entries.length); }
+            } catch (err) {
+                console.warn('[transmittal] verify skip entry', entry.path, err);
+            }
+        }
+        return { sizeIndex: sizeIndex, nameIndex: nameIndex, entryList: entryList };
+    }
+
+    // Find a matching directory entry by sha256 hash.
+    function findByHash(sizeIndex, fileSize, expectedHash) {
+        if (!expectedHash || fileSize == null) { return null; }
+        var candidates = sizeIndex[fileSize];
+        if (!candidates) { return null; }
+        var target = expectedHash.toLowerCase();
+        for (var c = 0; c < candidates.length; c++) {
+            var cand = candidates[c];
+            if (cand.matched) { continue; }
+            if (cand.hash && cand.hash.toLowerCase() === target) {
+                cand.matched = true;
+                return cand;
+            }
+        }
+        return null;
+    }
+
+    // Find a matching directory entry by tracking number + revision.
+    function findByTrackingRevision(nameIndex, trackingNumber, revision) {
+        var key = (trackingNumber || '').toLowerCase() + '\t' + (revision || '').toLowerCase();
+        var candidates = nameIndex[key];
+        if (!candidates || !candidates.length) { return null; }
+        for (var i = 0; i < candidates.length; i++) {
+            if (!candidates[i].matched) {
+                candidates[i].matched = true;
+                return candidates[i];
+            }
+        }
+        return null;
+    }
+
+    // Count unmatched entries in a size index
+    function countUnmatched(sizeIndex) {
+        var count = 0;
+        for (var size in sizeIndex) {
+            var group = sizeIndex[size];
+            for (var i = 0; i < group.length; i++) {
+                if (!group[i].matched) { count++; }
+            }
+        }
+        return count;
+    }
+
+    async function verifyFiles() {
+        var isPublished = !!app.state.published;
+        var setStatus = app.modules.data && app.modules.data.setStatus;
+        try {
+            var dirHandle = app.data.selectedDirHandle;
+            if (!dirHandle) {
+                dirHandle = await ensureDirHandle();
+            }
+            clearAllVerifyStates();
+            if (setStatus) { setStatus('Hashing directory\u2026', 'info'); }
+
+            var entries = await collectDirectoryEntries(dirHandle);
+            var allFiles = app.data.files || [];
+
+            // Hash every file upfront before any UI yields — on file:// origins,
+            // Chromium invalidates FileSystemFileHandle after macrotask boundaries.
+            var idx = await buildVerifyIndex(entries);
+            var sizeIndex = idx.sizeIndex;
+            var nameIndex = idx.nameIndex;
+            var entryList = idx.entryList || [];
+
+            // Build pasteKey index for existing files to avoid duplicates
+            var existingIndex = buildExistingIndex(allFiles);
+            var existingPasteKeys = Object.keys(existingIndex);
+
+            if (isPublished) {
+                // ── Published: read-only verification by hash ──
+                var verified = 0;
+                var missingCount = 0;
+
+                for (var p = 0; p < allFiles.length; p++) {
+                    var tf = allFiles[p];
+                    var row = findRowByFileIndex(p);
+                    var hCell = getHashCell(row);
+                    var trackingCell = row ? row.querySelector('td[data-field="trackingNumber"]') : null;
+
+                    setRowVerifyState(row, 'progress');
+                    await new Promise(function (r) { setTimeout(r, 0); });
+
+                    var fileSize = tf.fileSize != null ? tf.fileSize : tf.size;
+                    var found = findByHash(sizeIndex, fileSize, tf.sha256);
+
+                    if (found) {
+                        verified++;
+                        tf.fileHandle = found.handle;
+                        setRowVerifyState(row, 'match');
+                        if (hCell) {
+                            hCell.innerHTML = '<span style="color:#166534;font-weight:700;">\u2713</span> ' + escapeHtml(util.formatShortFileHash(tf.sha256));
+                        }
+                        var expectedPath = tf.path || tf.name || '';
+                        if (trackingCell && expectedPath && found.path && expectedPath !== found.path) {
+                            showPathDiff(trackingCell, expectedPath, found.path);
+                        }
+                    } else {
+                        missingCount++;
+                        setRowVerifyState(row, 'missing');
+                        if (hCell) {
+                            hCell.innerHTML = '<span style="color:#92400e;">\u26A0 not found</span>';
+                        }
+                    }
+                }
+
+                var extra = countUnmatched(sizeIndex);
+                var msg = verified + ' verified';
+                if (missingCount) { msg += ', ' + missingCount + ' missing'; }
+                if (extra) { msg += ', ' + extra + ' extra in directory'; }
+                if (setStatus) {
+                    setStatus(msg, missingCount ? 'error' : 'success');
+                }
+            } else {
+                // ── Edit: match rows against directory ──
+                // Rows WITH hash+size → match by size+hash
+                // Rows WITHOUT hash → match by tracking+revision, then populate hash/size
+                var verified = 0;
+                var populated = 0;
+                var notFound = 0;
+                var dirty = false;
+
+                for (var mi = 0; mi < allFiles.length; mi++) {
+                    var mf = allFiles[mi];
+                    var mRow = findRowByFileIndex(mi);
+                    var mhCell = getHashCell(mRow);
+
+                    setRowVerifyState(mRow, 'progress');
+                    await new Promise(function (r) { setTimeout(r, 0); });
+
+                    var hasHash = !!mf.sha256;
+                    var mFileSize = mf.fileSize != null ? mf.fileSize : mf.size;
+
+                    if (hasHash && mFileSize != null) {
+                        var foundByHash = findByHash(sizeIndex, mFileSize, mf.sha256);
+                        if (foundByHash) {
+                            mf.fileHandle = foundByHash.handle;
+                            verified++;
+                            setRowVerifyState(mRow, 'match');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#166534;font-weight:700;">\u2713</span> ' + escapeHtml(util.formatShortFileHash(mf.sha256));
+                            }
+                        } else {
+                            mf.fileHandle = null;
+                            notFound++;
+                            setRowVerifyState(mRow, 'missing');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#92400e;">\u26A0 not found</span>';
+                            }
+                        }
+                    } else {
+                        var foundByName = findByTrackingRevision(nameIndex, mf.trackingNumber, mf.revision);
+                        if (foundByName) {
+                            mf.fileHandle = foundByName.handle;
+                            mf.path = foundByName.path;
+                            mf.name = foundByName.name;
+                            mf.size = foundByName.fileSize;
+                            mf.fileSize = foundByName.fileSize;
+                            mf.sha256 = foundByName.hash;
+                            mf.extension = mf.extension || zddc.splitExtension(foundByName.name).extension;
+                            populated++;
+                            dirty = true;
+                            setRowVerifyState(mRow, 'match');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#166534;font-weight:700;">\u2713</span> ' + escapeHtml(util.formatShortFileHash(mf.sha256));
+                            }
+                        } else {
+                            notFound++;
+                            setRowVerifyState(mRow, 'missing');
+                            if (mhCell) {
+                                mhCell.innerHTML = '<span style="color:#92400e;">\u26A0 not found</span>';
+                            }
+                        }
+                    }
+                }
+
+                if (dirty) {
+                    updateFilesInJson(allFiles);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                }
+
+                var editMsg = '';
+                var parts = [];
+                if (verified) { parts.push(verified + ' verified'); }
+                if (populated) { parts.push(populated + ' matched'); }
+                if (notFound) { parts.push(notFound + ' not found'); }
+                editMsg = parts.join(', ') || 'No files to verify';
+
+                // Add new files from directory that don't match existing pasteKeys
+                var added = 0;
+                for (var ei = 0; ei < entryList.length; ei++) {
+                    var entryData = entryList[ei];
+                    if (!entryData.parsed.trackingNumber && !entryData.parsed.revision) continue; // Skip files without ZDDC pattern
+                    var pasteKey = (entryData.parsed.trackingNumber || '').toLowerCase() + '|' + (entryData.parsed.revision || '').toLowerCase();
+                    if (existingPasteKeys.indexOf(pasteKey) === -1) {
+                        // New file - use pre-hashed file data
+                        var fileData = {
+                            path: entryData.path,
+                            name: entryData.name,
+                            size: entryData.fileSize,
+                            fileSize: entryData.fileSize,
+                            sha256: '',
+                            trackingNumber: entryData.parsed.trackingNumber,
+                            title: entryData.parsed.title,
+                            revision: entryData.parsed.revision,
+                            status: entryData.parsed.status,
+                            extension: entryData.parsed.extension || zddc.splitExtension(entryData.name).extension,
+                            fileHandle: entryData.handle
+                        };
+                        app.data.files.push(fileData);
+                        added++;
+                    }
+                }
+                if (added > 0) {
+                    dirty = true;
+                    updateFilesInJson(app.data.files);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    editMsg = (editMsg ? editMsg + ', ' : '') + added + ' new file(s) added';
+                }
+
+                if (setStatus) {
+                    setStatus(editMsg, notFound && !added ? 'error' : 'success');
+                }
+            }
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                if (DEBUG) console.log('[transmittal] User cancelled verify');
+            } else {
+                console.error('[transmittal] verifyFiles failed', err);
+                if (setStatus) { setStatus('Verify failed: ' + (err.message || err), 'error'); }
+            }
+        }
+    }
+
+    document.addEventListener('transmittal:scan-directory', function () {
+        selectDirectory({ currentTarget: dom.qs('#bottom-primary') });
+    });
+
+    document.addEventListener('transmittal:verify-directory', function () {
+        verifyFiles();
+    });
+
+    filesModule.bindActionButtons = function bindActionButtons() {
+        // Reveal the menu now that JS is running
+        var bottomMenu = dom.qs('#bottom-menu');
+        if (bottomMenu) { bottomMenu.hidden = false; }
+        var noJsNotice = dom.qs('#no-js-notice');
+        if (noJsNotice) { dom.show(noJsNotice, false); }
+        initBottomBarToggle();
+        updateToolbars();
+    };
+
+    filesModule.updateToolbars = updateToolbars;
+
+    filesModule.syncUiToJson = function syncUiToJson() {
+        const val = function (selector) {
+            const el = dom.qs(selector);
+            return el ? (el.value || '') : '';
+        };
+
+        function toIsoDate(value) {
+            if (!value) {
+                return '';
+            }
+            const trimmed = String(value).trim();
+            if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+                return trimmed;
+            }
+            const match = trimmed.match(/^(?:[A-Za-z]+\s+)?([A-Za-z]{3,})\s+(\d{1,2}),\s*(\d{4})$/);
+            const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+            if (match) {
+                const monthIndex = months.indexOf(match[1].slice(0, 3));
+                if (monthIndex >= 0) {
+                    const day = String(parseInt(match[2], 10)).padStart(2, '0');
+                    const month = String(monthIndex + 1).padStart(2, '0');
+                    const year = match[3];
+                    return year + '-' + month + '-' + day;
+                }
+            }
+            const date = new Date(trimmed);
+            if (!Number.isNaN(date.getTime())) {
+                return date.toISOString().slice(0, 10);
+            }
+            return trimmed;
+        }
+
+        const data = json.parse();
+        const envelope = { ...(data.envelope || {}) };
+        const presentation = { ...(data.presentation || {}) };
+        
+        const payload = {
+            version: 1,
+            type: val('#type'),
+            title: val('#title') || '',
+            client: (dom.qs('#owner-name')?.textContent) || '',
+            project: (dom.qs('#project-name')?.textContent) || '',
+            projectNumber: (dom.qs('#project-number')?.textContent) || '',
+            date: toIsoDate(val('#date')),
+            trackingNumber: val('#tracking-number'),
+            from: val('#from'),
+            to: val('#to'),
+            purpose: val('#purpose'),
+            responseDue: val('#response-due'),
+            subject: val('#subject'),
+            remarks: val('#remarks'),
+            files: (function () {
+                var memFiles = Array.isArray(app.data.files) ? app.data.files : [];
+                var sorted = memFiles.slice().sort(util.compareFilesByTrackingRevision).map(canonicalFilePayload);
+                var self = buildSelfEntry();
+                return [canonicalFilePayload(self)].concat(sorted);
+            })()
+        };
+        
+        const leftLogoEl = dom.qs('#left-logo');
+        const rightLogoEl = dom.qs('#right-logo');
+        presentation.leftLogo = leftLogoEl && leftLogoEl.src ? leftLogoEl.src : '';
+        presentation.rightLogo = rightLogoEl && rightLogoEl.src ? rightLogoEl.src : '';
+        
+        json.setData({ envelope: envelope, payload: payload, presentation: presentation });
+    };
+
+    filesModule.loadFromJson = function loadFromJson(options) {
+        const opts = options || {};
+        const data = json.parse();
+        const payload = (data && data.payload) || {};
+        if (!opts.filesOnly) {
+            const assignValue = function (selector, value) {
+                const element = dom.qs(selector);
+                if (element) {
+                    element.value = value || '';
+                }
+            };
+            const assignText = function (selector, value) {
+                const element = dom.qs(selector);
+                if (element) {
+                    element.textContent = value || '';
+                }
+            };
+            assignValue('#type', payload.type || 'Transmittal');
+            var typeDisplay = dom.qs('#type-display');
+            if (typeDisplay) { typeDisplay.textContent = payload.type || 'Transmittal'; }
+            assignValue('#title', payload.title || '');
+            assignText('#owner-name', payload.client || '');
+            assignText('#project-name', payload.project || '');
+            assignText('#project-number', payload.projectNumber || '');
+            assignValue('#date', payload.date || '');
+            assignValue('#tracking-number', payload.trackingNumber || '');
+            assignValue('#from', payload.from || '');
+            assignValue('#to', payload.to || '');
+            assignValue('#purpose', payload.purpose || '');
+            assignValue('#response-due', payload.responseDue || '');
+            assignValue('#subject', payload.subject || '');
+            const remarks = dom.qs('#remarks');
+            if (remarks) {
+                remarks.value = payload.remarks || '';
+            }
+            
+            // Load logos from presentation data
+            const presentation = (data && data.presentation) || {};
+            const leftLogoEl = dom.qs('#left-logo');
+            const rightLogoEl = dom.qs('#right-logo');
+            if (leftLogoEl && presentation.leftLogo) {
+                leftLogoEl.src = presentation.leftLogo;
+            }
+            if (rightLogoEl && presentation.rightLogo) {
+                rightLogoEl.src = presentation.rightLogo;
+            }
+        }
+        var SELF_HASH = app.constants.SELF_HASH;
+        const files = Array.isArray(payload.files)
+            ? payload.files.filter(function (f) { return f.sha256 !== SELF_HASH; })
+            : [];
+        app.data.files = files.map(function (entry) {
+            const pathOnly = entry.path || '';
+            const filename = entry.filename || '';
+            const relativePath = pathOnly ? (pathOnly + '/' + filename) : filename;
+            
+            // When filename is empty (e.g., from pasted files), reconstruct from trackingNumber
+            let baseName = filename || relativePath.split('/').pop() || '';
+            if (!baseName && entry.trackingNumber) {
+                baseName = zddc.joinExtension(entry.trackingNumber, entry.extension || '');
+            }
+
+            const fileSize = entry.fileSize || entry.size || 0;
+            return {
+                path: relativePath,
+                name: baseName,
+                size: fileSize,
+                fileSize: fileSize,
+                sha256: entry.sha256 || '',
+                trackingNumber: entry.trackingNumber || '',
+                title: entry.title || '',
+                revision: entry.revision || '',
+                status: entry.status || '',
+                extension: zddc.splitExtension(baseName).extension
+            };
+        });
+        sortFilesInPlace(app.data.files);
+        // Don't call updateFilesInJson here - it clears digest/signatures
+        // The files are already in the JSON, we're just loading them into app.data.files
+        updateDirectoryIndicator(app.data.selectedDirHandle ? app.data.selectedDirHandle.name : '');
+        
+        // Render the table to populate it with file data
+        filesModule.render();
+        
+        if (!opts.filesOnly && app.modules.markdown && typeof app.modules.markdown.refresh === 'function') {
+            app.modules.markdown.refresh();
+        }
+        // Apply field visibility after loading data to ensure UI stays in sync
+        if (!opts.filesOnly && app.modules.visibility && typeof app.modules.visibility.applyFieldVisibility === 'function') {
+            app.modules.visibility.applyFieldVisibility();
+        }
+    };
+
+    app.registerInit(function () {
+        updateDirectoryIndicator(app.data.selectedDirHandle ? app.data.selectedDirHandle.name : '');
+        filesModule.bindActionButtons();
+        filesModule.setupTableEditing();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+    var filesModule = app.modules.files;
+
+    var ARCHIVE_DIR_NAME = '.archive';
+
+    function sanitizeUrlSegment(value, fallback) {
+        var str = (value || '').toString().trim();
+        if (!str) {
+            return fallback;
+        }
+        var cleaned = str
+            .replace(/[^A-Za-z0-9._~-]+/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-+|-+$/g, '');
+        return cleaned || fallback;
+    }
+
+    function encodeRelativePath(path) {
+        return path.split('/').map(function (segment) {
+            return encodeURIComponent(segment);
+        }).join('/');
+    }
+
+    function buildRedirectHtml(targetHref, displayName) {
+        var safeHrefAttr = util.escapeHtmlAttribute(targetHref);
+        var safeLabel = util.escapeHtml(displayName || targetHref);
+        return '<!DOCTYPE html>\n' +
+            '<html lang="en">\n' +
+            '<head>\n' +
+            '<meta charset="utf-8">\n' +
+            '<meta http-equiv="refresh" content="0; url=' + safeHrefAttr + '">\n' +
+            '<title>' + safeLabel + '</title>\n' +
+            '</head>\n' +
+            '<body>\n' +
+            '<p>Redirecting to <a href="' + safeHrefAttr + '">' + safeLabel + '</a>.</p>\n' +
+            '</body>\n' +
+            '</html>\n';
+    }
+
+    async function ensureArchiveDirectory(rootHandle) {
+        return rootHandle.getDirectoryHandle(ARCHIVE_DIR_NAME, { create: true });
+    }
+
+    async function writeRedirectFile(directoryHandle, filename, html) {
+        var fileHandle = await directoryHandle.getFileHandle(filename, { create: true });
+        var writable = await fileHandle.createWritable();
+        await writable.write(new Blob([html], { type: 'text/html' }));
+        await writable.close();
+    }
+
+    function groupFilesByTracking(files) {
+        var map = new Map();
+        files.forEach(function (file) {
+            var key = file.trackingNumber || '';
+            if (!map.has(key)) {
+                map.set(key, []);
+            }
+            map.get(key).push(file);
+        });
+        return map;
+    }
+
+    function determineLatestByTracking(grouped) {
+        var latest = new Map();
+        grouped.forEach(function (files, tracking) {
+            if (!files || !files.length) {
+                return;
+            }
+            var sorted = files.slice().sort(function (a, b) {
+                var revisionCompare = util.compareRevisionPriority(a.revision, b.revision);
+                if (revisionCompare !== 0) {
+                    return revisionCompare;
+                }
+                var pathCompare = (a.path || '').localeCompare(b.path || '');
+                if (pathCompare !== 0) {
+                    return pathCompare;
+                }
+                return (a.name || '').localeCompare(b.name || '');
+            });
+            latest.set(tracking, sorted[sorted.length - 1]);
+        });
+        return latest;
+    }
+
+    function buildRedirectFilenames(file) {
+        var trackingSegment = sanitizeUrlSegment(file.trackingNumber || '', 'tracking');
+        var rawRevision = (file.revision || '').trim();
+        var revisionSegment = rawRevision ? sanitizeUrlSegment(rawRevision, 'rev') : '';
+        var rawHash = (file.sha256 || '').trim();
+        var hashSegment = rawHash ? sanitizeUrlSegment(rawHash, 'hash') : '';
+        var htmlSuffix = '.html';
+
+        var revisionFilename = revisionSegment ? (trackingSegment + '_' + revisionSegment + htmlSuffix) : '';
+        var hashFilename = hashSegment ? (hashSegment + htmlSuffix) : '';
+        var latestFilename = trackingSegment + htmlSuffix;
+
+        return {
+            latestFilename: latestFilename,
+            revisionFilename: revisionFilename,
+            hashFilename: hashFilename
+        };
+    }
+
+    async function resolveFileMetadata(entry) {
+        var parsed = zddc.parseFilename(entry.name || entry.path || '') || {};
+        if (!parsed.trackingNumber) {
+            return null;
+        }
+        var file = await entry.handle.getFile();
+        var sha256 = await util.hashFile(file);
+        return {
+            path: entry.path,
+            name: file.name,
+            extension: parsed.extension || zddc.splitExtension(file.name).extension,
+            trackingNumber: parsed.trackingNumber,
+            revision: parsed.revision,
+            status: parsed.status,
+            title: parsed.title,
+            sha256: sha256,
+            size: file.size
+        };
+    }
+
+    function buildRelativeHref(relativePath) {
+        var encoded = encodeRelativePath(relativePath);
+        return '../' + encoded;
+    }
+
+    async function createRedirectFiles(archiveHandle, file, isLatest) {
+        var filenames = buildRedirectFilenames(file);
+        var href = buildRelativeHref(file.path);
+        var html = buildRedirectHtml(href, file.name);
+
+        var writes = [];
+        if (filenames.revisionFilename) {
+            writes.push(writeRedirectFile(archiveHandle, filenames.revisionFilename, html));
+        }
+        if (filenames.hashFilename) {
+            writes.push(writeRedirectFile(archiveHandle, filenames.hashFilename, html));
+        }
+        if (isLatest) {
+            writes.push(writeRedirectFile(archiveHandle, filenames.latestFilename, html));
+        }
+
+        await Promise.all(writes);
+        return true;
+    }
+
+    async function pickIndexDirectory() {
+        if (typeof window.showDirectoryPicker !== 'function') {
+            throw new Error('File System Access API showDirectoryPicker is required');
+        }
+        return window.showDirectoryPicker();
+    }
+
+    filesModule.generateArchiveRedirects = async function generateArchiveRedirects() {
+        var rootHandle;
+        try {
+            rootHandle = await pickIndexDirectory();
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                console.log('[transmittal] Create Index cancelled.');
+                return;
+            }
+            throw err;
+        }
+
+        var overallStart = filesModule.nowMs();
+        var entries = await filesModule.collectDirectoryEntries(rootHandle);
+        if (!entries.length) {
+            console.log('[transmittal] Create Index: No files found.');
+            return;
+        }
+
+        var archiveHandle = await ensureArchiveDirectory(rootHandle);
+        var files = [];
+        for (var i = 0; i < entries.length; i++) {
+            try {
+                var metadata = await resolveFileMetadata(entries[i]);
+                if (metadata) {
+                    files.push(metadata);
+                }
+            } catch (err) {
+                console.warn('[transmittal] create-index skip', entries[i].path, err);
+            }
+        }
+        if (!files.length) {
+            console.log('[transmittal] Create Index: No ZDDC files found.');
+            return;
+        }
+
+        var grouped = groupFilesByTracking(files);
+        var latest = determineLatestByTracking(grouped);
+
+        var writePromises = files.map(function (file) {
+            var isLatest = latest.get(file.trackingNumber) === file;
+            return createRedirectFiles(archiveHandle, file, isLatest)
+                .catch(function (err) {
+                    console.error('[transmittal] create-index write failed', file.path, err);
+                    return null;
+                });
+        });
+
+        var results = await Promise.all(writePromises);
+        var created = results.filter(function (result) { return result !== null; }).length;
+
+        var totalElapsed = filesModule.nowMs() - overallStart;
+        console.log('[transmittal] Create Index: Generated redirects for ' + created + ' files in ' + filesModule.formatDuration(totalElapsed) + '.');
+    };
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+    var filesModule = app.modules.files;
+
+    // Build ZDDC filename from file row data — delegates to shared zddc.formatFilename()
+    function buildZddcFileName(fileData, droppedExt) {
+        var ext = (fileData.extension || droppedExt || '').toLowerCase().replace(/^\.+/, '');
+        return zddc.formatFilename({
+            trackingNumber: fileData.trackingNumber || '',
+            revision:       fileData.revision || '',
+            status:         fileData.status || '',
+            title:          fileData.title || '',
+            extension:      ext,
+        });
+    }
+
+    function setupRowDropTargets() {
+        if (app.state.mode !== 'edit') { return; }
+        var rows = document.querySelectorAll('table tbody tr:not(.self-entry)');
+        rows.forEach(function (row) {
+            row.addEventListener('dragover', function (e) {
+                if (app.state.mode !== 'edit') { return; }
+                e.preventDefault();
+                e.stopPropagation();
+                row.classList.add('ring-2', 'ring-blue-400', 'bg-blue-50');
+            });
+            row.addEventListener('dragleave', function () {
+                row.classList.remove('ring-2', 'ring-blue-400', 'bg-blue-50');
+            });
+            row.addEventListener('drop', async function (e) {
+                row.classList.remove('ring-2', 'ring-blue-400', 'bg-blue-50');
+                if (app.state.mode !== 'edit') { return; }
+                var droppedFile = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+                if (!droppedFile) { return; }
+                e.preventDefault();
+                e.stopPropagation();
+
+                var setStatus = app.modules.data && app.modules.data.setStatus;
+
+                // Prompt for directory if none selected
+                if (!app.data.selectedDirHandle) {
+                    try {
+                        app.data.selectedDirHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
+                        app.data.selectedDirName = app.data.selectedDirHandle.name || '';
+                        if (filesModule.updateDirectoryIndicator) {
+                            filesModule.updateDirectoryIndicator();
+                        }
+                    } catch (pickErr) {
+                        if (setStatus) { setStatus('A directory is required to copy files', 'error'); }
+                        return;
+                    }
+                }
+
+                var indexCell = row.querySelector('td[data-index]');
+                if (!indexCell) { return; }
+                var fileIndex = Number(indexCell.dataset.index);
+                var fileData = app.data.files[fileIndex];
+                if (!fileData) { return; }
+
+                var droppedExt = zddc.splitExtension(droppedFile.name).extension;
+                var zddcName = buildZddcFileName(fileData, droppedExt);
+                if (!zddcName) { zddcName = droppedFile.name; }
+
+                var hashCell = row.querySelector('td:last-child');
+                try {
+                    if (hashCell) { hashCell.textContent = 'copying\u2026'; }
+                    var dirHandle = app.data.selectedDirHandle;
+                    var newHandle = await dirHandle.getFileHandle(zddcName, { create: true });
+                    var writable = await newHandle.createWritable();
+                    await writable.write(droppedFile);
+                    await writable.close();
+
+                    if (hashCell) { hashCell.textContent = 'hashing\u2026'; }
+                    var written = await newHandle.getFile();
+                    var hash = await util.hashFile(written);
+
+                    fileData.fileHandle = newHandle;
+                    fileData.path = zddcName;
+                    fileData.name = zddcName;
+                    fileData.size = written.size;
+                    fileData.fileSize = written.size;
+                    fileData.sha256 = hash;
+                    if (!fileData.extension) { fileData.extension = droppedExt; }
+
+                    filesModule.updateFilesInJson(app.data.files);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    if (setStatus) { setStatus('Copied \u2192 ' + zddcName, 'success'); }
+                } catch (err) {
+                    console.error('[transmittal] row file drop failed', err);
+                    if (hashCell) { hashCell.textContent = 'error'; }
+                    if (setStatus) { setStatus('Drop failed: ' + (err.message || err), 'error'); }
+                }
+            });
+        });
+    }
+
+    filesModule.clearTable = function clearTable() {
+        var tbody = document.querySelector('table tbody');
+        if (tbody) { tbody.innerHTML = ''; }
+    };
+
+    filesModule.renderSingleRow = function renderSingleRow(file, index) {
+        var tbody = document.querySelector('table tbody');
+        if (!tbody) { return null; }
+        var row = document.createElement('tr');
+
+        var numCell = document.createElement('td');
+        numCell.className = 'px-2 py-1 align-top text-center text-gray-400';
+        numCell.textContent = String(index + 1);
+        row.appendChild(numCell);
+
+        var trackingCell = document.createElement('td');
+        trackingCell.className = 'px-2 py-1 align-top whitespace-nowrap font-mono';
+        var link = document.createElement('a');
+        link.textContent = file.trackingNumber || '';
+        var relativePath = file.path || file.name || '';
+        if (relativePath) {
+            link.href = encodeURI(relativePath);
+            link.dataset.relativePath = relativePath;
+        } else {
+            link.href = '#';
+        }
+        link.title = relativePath || (file.name || '');
+        link.className = 'text-blue-600 hover:underline';
+        var ext = (file.extension || zddc.splitExtension(relativePath).extension);
+        if (app.constants.viewableExts.indexOf(ext) !== -1) {
+            link.target = '_blank';
+            link.rel = 'noopener';
+        } else {
+            var filename = (relativePath.split('/').pop() || file.name || 'download');
+            link.setAttribute('download', filename);
+        }
+        trackingCell.appendChild(link);
+        trackingCell.contentEditable = 'false';
+        trackingCell.dataset.index = String(index);
+        trackingCell.dataset.field = 'trackingNumber';
+        row.appendChild(trackingCell);
+
+        var titleCell = document.createElement('td');
+        titleCell.className = 'px-2 py-1 align-top whitespace-normal break-words w-full';
+        titleCell.textContent = file.title || '';
+        titleCell.contentEditable = (app.state.mode === 'edit').toString();
+        titleCell.setAttribute('role', 'textbox');
+        titleCell.setAttribute('aria-multiline', 'false');
+        titleCell.setAttribute('tabindex', '0');
+        titleCell.dataset.index = String(index);
+        titleCell.dataset.field = 'title';
+        row.appendChild(titleCell);
+
+        var revisionCell = document.createElement('td');
+        revisionCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+        revisionCell.textContent = file.revision || '';
+        revisionCell.contentEditable = (app.state.mode === 'edit').toString();
+        revisionCell.setAttribute('role', 'textbox');
+        revisionCell.setAttribute('aria-multiline', 'false');
+        revisionCell.setAttribute('tabindex', '0');
+        revisionCell.dataset.index = String(index);
+        revisionCell.dataset.field = 'revision';
+        row.appendChild(revisionCell);
+
+        var statusCell = document.createElement('td');
+        statusCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+        statusCell.textContent = file.status || '';
+        statusCell.contentEditable = (app.state.mode === 'edit').toString();
+        statusCell.setAttribute('role', 'textbox');
+        statusCell.setAttribute('aria-multiline', 'false');
+        statusCell.setAttribute('tabindex', '0');
+        statusCell.dataset.index = String(index);
+        statusCell.dataset.field = 'status';
+        row.appendChild(statusCell);
+
+        var extCell = document.createElement('td');
+        extCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+        extCell.textContent = (file.extension || '').toLowerCase();
+        extCell.contentEditable = 'false';
+        row.appendChild(extCell);
+
+        var sizeCell = document.createElement('td');
+        sizeCell.className = 'px-2 py-1 align-top whitespace-nowrap text-right font-mono';
+        var fileSizeValue = (file.fileSize != null ? file.fileSize : file.size);
+        sizeCell.textContent = util.formatFileSize(fileSizeValue);
+        sizeCell.contentEditable = 'false';
+        row.appendChild(sizeCell);
+
+        var hashCell = document.createElement('td');
+        hashCell.className = 'px-2 py-1 align-top font-mono text-[9px] whitespace-normal break-all leading-snug';
+        if (file.sha256) {
+            hashCell.textContent = util.formatShortFileHash(file.sha256);
+        } else {
+            var prog = document.createElement('div');
+            prog.className = 'hash-progress';
+            var bar = document.createElement('div');
+            bar.className = 'hash-progress-bar';
+            var fill = document.createElement('div');
+            fill.className = 'hash-progress-fill';
+            bar.appendChild(fill);
+            prog.appendChild(bar);
+            hashCell.appendChild(prog);
+        }
+        row.appendChild(hashCell);
+
+        tbody.appendChild(row);
+        return hashCell;
+    };
+
+    function renderSelfRow(tbody, rowNum) {
+        var self = filesModule.buildSelfEntry ? filesModule.buildSelfEntry() : null;
+        if (!self) { return; }
+        var row = document.createElement('tr');
+        row.className = 'self-entry';
+
+        var numCell = document.createElement('td');
+        numCell.className = 'px-2 py-1 align-top text-center text-gray-400';
+        numCell.textContent = String(rowNum);
+        row.appendChild(numCell);
+
+        var trackingCell = document.createElement('td');
+        trackingCell.className = 'px-2 py-1 align-top whitespace-nowrap font-mono text-gray-500';
+        var selfPath = self.path || self.name || '';
+        if (selfPath) {
+            var link = document.createElement('a');
+            link.href = encodeURI(selfPath);
+            link.textContent = self.trackingNumber || '';
+            link.className = 'text-gray-500 hover:underline';
+            link.target = '_blank';
+            link.rel = 'noopener';
+            trackingCell.appendChild(link);
+        } else {
+            trackingCell.textContent = self.trackingNumber || '';
+        }
+        row.appendChild(trackingCell);
+
+        var titleCell = document.createElement('td');
+        titleCell.className = 'px-2 py-1 align-top whitespace-normal break-words w-full text-gray-500';
+        titleCell.textContent = self.title || '';
+        row.appendChild(titleCell);
+
+        var revisionCell = document.createElement('td');
+        revisionCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono text-gray-500';
+        revisionCell.textContent = self.revision || '';
+        row.appendChild(revisionCell);
+
+        var statusCell = document.createElement('td');
+        statusCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono text-gray-500';
+        statusCell.textContent = self.status || '';
+        row.appendChild(statusCell);
+
+        var extCell = document.createElement('td');
+        extCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono text-gray-500';
+        extCell.textContent = 'html';
+        row.appendChild(extCell);
+
+        var sizeCell = document.createElement('td');
+        sizeCell.className = 'px-2 py-1 align-top whitespace-nowrap text-right font-mono text-gray-400';
+        sizeCell.textContent = '\u2014';
+        row.appendChild(sizeCell);
+
+        var hashCell = document.createElement('td');
+        hashCell.className = 'px-2 py-1 align-top font-mono text-[9px] whitespace-nowrap text-gray-400 italic';
+        hashCell.textContent = 'see above';
+        row.appendChild(hashCell);
+
+        tbody.appendChild(row);
+    }
+
+    filesModule.render = function render() {
+        var tbody = document.querySelector('table tbody');
+        if (!tbody) {
+            return;
+        }
+        tbody.innerHTML = '';
+        filesModule.sortFilesInPlace(app.data.files);
+        var filters = app.modules.filters ? app.modules.filters.getActiveFilters() : {};
+        var filtered = [];
+        (app.data.files || []).forEach(function (file, originalIndex) {
+            if (!app.modules.filters || app.modules.filters.fileMatchesFilters(file, filters)) {
+                filtered.push({ file: file, index: originalIndex });
+            }
+        });
+
+        // Row 0: transmittal self-entry (always pinned first)
+        renderSelfRow(tbody, 0);
+
+        var rowNum = 0;
+        filtered.forEach(function (entry) {
+            var file = entry.file;
+            var index = entry.index;
+            var row = document.createElement('tr');
+            rowNum++;
+
+            var numCell = document.createElement('td');
+            numCell.className = 'px-2 py-1 align-top text-center text-gray-400 whitespace-nowrap';
+            if (app.state.mode === 'edit') {
+                var delBtn = document.createElement('button');
+                delBtn.type = 'button';
+                delBtn.className = 'row-delete-btn';
+                delBtn.textContent = '\u00d7';
+                delBtn.title = 'Remove this file';
+                delBtn.dataset.fileIndex = String(index);
+                numCell.appendChild(delBtn);
+                var numSpan = document.createElement('span');
+                numSpan.textContent = String(rowNum);
+                numCell.appendChild(numSpan);
+            } else {
+                numCell.textContent = String(rowNum);
+            }
+            row.appendChild(numCell);
+
+            var trackingCell = document.createElement('td');
+            trackingCell.className = 'px-2 py-1 align-top whitespace-nowrap font-mono';
+            var link = document.createElement('a');
+            link.textContent = file.trackingNumber || '';
+            var relativePath = file.path || file.name || '';
+            if (relativePath) {
+                link.href = encodeURI(relativePath);
+                link.dataset.relativePath = relativePath;
+            } else {
+                link.href = '#';
+            }
+            link.title = relativePath || (file.name || '');
+            link.className = 'text-blue-600 hover:underline';
+            var ext = (file.extension || zddc.splitExtension(relativePath).extension);
+            if (app.constants.viewableExts.indexOf(ext) !== -1) {
+                link.target = '_blank';
+                link.rel = 'noopener';
+            } else {
+                var filename = (relativePath.split('/').pop() || file.name || 'download');
+                link.setAttribute('download', filename);
+            }
+            trackingCell.appendChild(link);
+            trackingCell.contentEditable = 'false';
+            trackingCell.dataset.index = String(index);
+            trackingCell.dataset.field = 'trackingNumber';
+            row.appendChild(trackingCell);
+
+            var titleCell = document.createElement('td');
+            titleCell.className = 'px-2 py-1 align-top whitespace-normal break-words w-full';
+            titleCell.textContent = file.title || '';
+            titleCell.contentEditable = (app.state.mode === 'edit').toString();
+            titleCell.setAttribute('role', 'textbox');
+            titleCell.setAttribute('aria-multiline', 'false');
+            titleCell.setAttribute('tabindex', '0');
+            titleCell.dataset.index = String(index);
+            titleCell.dataset.field = 'title';
+            row.appendChild(titleCell);
+
+            var revisionCell = document.createElement('td');
+            revisionCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+            revisionCell.textContent = file.revision || '';
+            revisionCell.contentEditable = (app.state.mode === 'edit').toString();
+            revisionCell.setAttribute('role', 'textbox');
+            revisionCell.setAttribute('aria-multiline', 'false');
+            revisionCell.setAttribute('tabindex', '0');
+            revisionCell.dataset.index = String(index);
+            revisionCell.dataset.field = 'revision';
+            row.appendChild(revisionCell);
+
+            var statusCell = document.createElement('td');
+            statusCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+            statusCell.textContent = file.status || '';
+            statusCell.contentEditable = (app.state.mode === 'edit').toString();
+            statusCell.setAttribute('role', 'textbox');
+            statusCell.setAttribute('aria-multiline', 'false');
+            statusCell.setAttribute('tabindex', '0');
+            statusCell.dataset.index = String(index);
+            statusCell.dataset.field = 'status';
+            row.appendChild(statusCell);
+
+            var extCell = document.createElement('td');
+            extCell.className = 'px-2 py-1 align-top whitespace-nowrap text-center font-mono';
+            extCell.textContent = (file.extension || '').toLowerCase();
+            extCell.contentEditable = 'false';
+            row.appendChild(extCell);
+
+            var sizeCell = document.createElement('td');
+            sizeCell.className = 'px-2 py-1 align-top whitespace-nowrap text-right font-mono';
+            var isUnmatched = !file.fileHandle && !file.sha256;
+            if (isUnmatched) {
+                sizeCell.textContent = '\u2014';
+                sizeCell.classList.add('text-gray-400');
+            } else {
+                var fileSizeValue = (file.fileSize != null ? file.fileSize : file.size);
+                sizeCell.textContent = util.formatFileSize(fileSizeValue);
+            }
+            sizeCell.contentEditable = 'false';
+            row.appendChild(sizeCell);
+
+            var hashCell = document.createElement('td');
+            hashCell.className = 'px-2 py-1 align-top font-mono text-[9px] whitespace-normal break-all leading-snug';
+            if (isUnmatched) {
+                hashCell.textContent = 'pending';
+                hashCell.classList.add('italic', 'text-gray-400');
+            } else {
+                hashCell.textContent = util.formatShortFileHash(file.sha256 || '');
+            }
+            row.appendChild(hashCell);
+
+            if (file._verifyResult) {
+                row.classList.add('verify-' + file._verifyResult);
+            }
+
+            tbody.appendChild(row);
+        });
+
+        if (!filtered.length) {
+            var placeholderRow = document.createElement('tr');
+            for (var i = 0; i < 8; i += 1) {
+                var cell = document.createElement('td');
+                cell.className = 'px-2 py-1 align-top';
+                placeholderRow.appendChild(cell);
+            }
+            tbody.appendChild(placeholderRow);
+        }
+
+        if (app.modules.filters && typeof app.modules.filters.refreshPlaceholders === 'function') {
+            app.modules.filters.refreshPlaceholders();
+        }
+        setupRowDropTargets();
+    };
+
+    // Undo state for row deletion
+    var _lastDeleted = null;
+    var _undoTimer = null;
+
+    function deleteFileRow(fileIndex) {
+        var file = app.data.files[fileIndex];
+        if (!file) { return; }
+        var setStatus = app.modules.data && app.modules.data.setStatus;
+        var label = (file.trackingNumber || '') + (file.title ? ' - ' + file.title : '');
+
+        // Store for undo
+        _lastDeleted = { file: file, index: fileIndex };
+        if (_undoTimer) { clearTimeout(_undoTimer); }
+        _undoTimer = setTimeout(function () { _lastDeleted = null; }, 10000);
+
+        app.data.files.splice(fileIndex, 1);
+        filesModule.updateFilesInJson(app.data.files);
+        filesModule.render();
+        app.state.apply();
+        app.markDirty();
+
+        if (setStatus) {
+            setStatus('Removed ' + (label || 'row') + '  — click here to undo', 'success');
+            // Attach one-time undo click handler to status bar
+            var statusEl = document.querySelector('#data-status');
+            if (statusEl) {
+                statusEl.style.cursor = 'pointer';
+                var cleanup = function () {
+                    statusEl.removeEventListener('click', handler);
+                    statusEl.style.cursor = '';
+                };
+                var handler = function () {
+                    cleanup();
+                    if (!_lastDeleted) { return; }
+                    var d = _lastDeleted;
+                    _lastDeleted = null;
+                    if (_undoTimer) { clearTimeout(_undoTimer); _undoTimer = null; }
+                    var idx = Math.min(d.index, app.data.files.length);
+                    app.data.files.splice(idx, 0, d.file);
+                    filesModule.updateFilesInJson(app.data.files);
+                    filesModule.render();
+                    app.state.apply();
+                    app.markDirty();
+                    if (setStatus) { setStatus('Restored ' + (label || 'row'), 'success'); }
+                };
+                // Clear cursor when undo expires
+                if (_undoTimer) { clearTimeout(_undoTimer); }
+                _undoTimer = setTimeout(function () { _lastDeleted = null; cleanup(); }, 10000);
+                statusEl.addEventListener('click', handler);
+            }
+        }
+    }
+
+    filesModule.setupTableEditing = function setupTableEditing() {
+        var tbody = document.querySelector('table tbody');
+        if (!tbody) {
+            return;
+        }
+        // Delegated handler for row delete buttons
+        tbody.addEventListener('click', function (event) {
+            var delBtn = event.target.closest('.row-delete-btn');
+            if (delBtn && delBtn.dataset.fileIndex !== undefined) {
+                event.preventDefault();
+                event.stopPropagation();
+                deleteFileRow(Number(delBtn.dataset.fileIndex));
+                return;
+            }
+        });
+        // Click delegation for file preview
+        // Edit mode: always preview (relative paths don't work until HTML is saved)
+        // View mode: preview only when checkbox is checked and file source is loaded
+        tbody.addEventListener('click', function (event) {
+            var link = event.target.closest('a');
+            if (!link) {
+                return;
+            }
+            var cell = link.closest('td');
+            if (!cell || !cell.dataset.index) {
+                return;
+            }
+            var file = app.data.files[Number(cell.dataset.index)];
+            if (!file || !filesModule.hasFileSource || !filesModule.hasFileSource(file)) {
+                return;
+            }
+            var usePreview = (app.state.mode === 'edit') ||
+                (filesModule.isPreviewEnabled && filesModule.isPreviewEnabled()) ||
+                !!(file.fileHandle);
+            if (usePreview) {
+                event.preventDefault();
+                event.stopPropagation();
+                filesModule.showFilePreview(file);
+            }
+        });
+        tbody.addEventListener('input', function (event) {
+            var target = event.target;
+            if (!(target instanceof HTMLElement)) {
+                return;
+            }
+            var index = target.dataset.index;
+            var field = target.dataset.field;
+            if (index === undefined || !field) {
+                return;
+            }
+            var entry = app.data.files[Number(index)];
+            if (!entry) {
+                return;
+            }
+            entry[field] = (target.textContent || '').replace(/\r?\n/g, ' ').trim();
+            filesModule.sortFilesInPlace(app.data.files);
+            filesModule.updateFilesInJson(app.data.files);
+            filesModule.render();
+            app.markDirty();
+            if (app.modules.liveDigest && app.modules.liveDigest.schedule) {
+                app.modules.liveDigest.schedule();
+            }
+        });
+        tbody.addEventListener('keydown', function (event) {
+            var target = event.target;
+            if (!(target instanceof HTMLElement)) {
+                return;
+            }
+            if (target.isContentEditable && event.key === 'Enter') {
+                event.preventDefault();
+            }
+        });
+        tbody.addEventListener('paste', function (event) {
+            var target = event.target;
+            if (!(target instanceof HTMLElement)) {
+                return;
+            }
+            if (!target.isContentEditable) {
+                return;
+            }
+            event.preventDefault();
+            var text = (event.clipboardData || window.clipboardData).getData('text');
+            var sanitized = (text || '').replace(/\r?\n/g, ' ');
+            try {
+                document.execCommand('insertText', false, sanitized);
+            } catch (err) {
+                target.textContent = (target.textContent || '') + sanitized;
+            }
+        });
+    };
+
+    filesModule.handleClear = function handleClear() {
+        if (app.state.mode !== 'edit') {
+            return;
+        }
+        if (filesModule.cleanupBlobUrls) {
+            filesModule.cleanupBlobUrls();
+        }
+        app.data.files = [];
+        app.data.selectedDirHandle = null;
+        filesModule.updateDirectoryIndicator('');
+        filesModule.updateFilesInJson([]);
+        filesModule.render();
+        app.state.apply();
+        app.markDirty();
+    };
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+    var filesModule = app.modules.files;
+
+    // Blob URL cache keyed by file path
+    var blobCache = new Map();
+
+    // Current preview popup window reference
+    var previewWindow = null;
+
+    // Extensions that support rich in-browser preview
+    var PREVIEW_EXTENSIONS = ['pdf', 'docx', 'xlsx', 'xls'];
+
+    // Extensions that preview as images
+    var IMAGE_EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'bmp', 'ico'];
+
+    // Cache for lazily loaded CDN libraries
+    var loadedLibraries = new Map();
+
+    var MIME_TYPES = {
+        'pdf': 'application/pdf',
+        'doc': 'application/msword',
+        'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'xls': 'application/vnd.ms-excel',
+        'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        'ppt': 'application/vnd.ms-powerpoint',
+        'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        'txt': 'text/plain',
+        'csv': 'text/csv',
+        'html': 'text/html',
+        'htm': 'text/html',
+        'xml': 'text/xml',
+        'json': 'application/json',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'png': 'image/png',
+        'gif': 'image/gif',
+        'bmp': 'image/bmp',
+        'svg': 'image/svg+xml',
+        'webp': 'image/webp',
+        'ico': 'image/x-icon',
+        'zip': 'application/zip',
+        'mp4': 'video/mp4',
+        'mp3': 'audio/mpeg',
+        'wav': 'audio/wav',
+        'md': 'text/markdown'
+    };
+
+    function getMimeType(ext) {
+        return MIME_TYPES[(ext || '').toLowerCase()] || 'application/octet-stream';
+    }
+
+    function loadLibrary(url) {
+        if (loadedLibraries.has(url)) {
+            return loadedLibraries.get(url);
+        }
+        var promise = new Promise(function (resolve, reject) {
+            var script = document.createElement('script');
+            script.src = url;
+            script.onload = resolve;
+            script.onerror = function () {
+                reject(new Error('Failed to load library: ' + url));
+            };
+            document.head.appendChild(script);
+        });
+        loadedLibraries.set(url, promise);
+        return promise;
+    }
+
+    function isPreviewable(ext) {
+        var lower = (ext || '').toLowerCase();
+        return PREVIEW_EXTENSIONS.indexOf(lower) !== -1 || IMAGE_EXTENSIONS.indexOf(lower) !== -1;
+    }
+
+    function hasFileSource(file) {
+        return !!(file.fileHandle || file.zipEntry);
+    }
+
+    async function getFileArrayBuffer(file) {
+        if (file.fileHandle) {
+            var fileData = await file.fileHandle.getFile();
+            return fileData.arrayBuffer();
+        }
+        if (file.zipEntry) {
+            return file.zipEntry.async('arraybuffer');
+        }
+        throw new Error('No file source available');
+    }
+
+    async function getFileBlobUrl(file) {
+        var cacheKey = file.path || file.name || '';
+        if (blobCache.has(cacheKey)) {
+            return blobCache.get(cacheKey);
+        }
+        var arrayBuffer = await getFileArrayBuffer(file);
+        var mimeType = getMimeType(file.extension);
+        var blob = new Blob([arrayBuffer], { type: mimeType });
+        var url = URL.createObjectURL(blob);
+        blobCache.set(cacheKey, url);
+        return url;
+    }
+
+    function cleanupBlobUrls() {
+        blobCache.forEach(function (url) {
+            URL.revokeObjectURL(url);
+        });
+        blobCache.clear();
+    }
+
+    function buildPreviewHtml(file, url) {
+        var ext = (file.extension || '').toLowerCase();
+        var safeName = util.escapeHtml(file.name || file.path || 'file');
+        var safeHref = util.escapeHtmlAttribute(url);
+
+        var contentHtml;
+        if (ext === 'pdf') {
+            contentHtml = '<iframe src="' + safeHref + '"></iframe>';
+        } else {
+            contentHtml = '<div id="previewContent"><div class="loading">Loading preview...</div></div>';
+        }
+
+        return '<!DOCTYPE html>\n' +
+            '<html>\n' +
+            '<head>\n' +
+            '<title>' + safeName + ' - Preview</title>\n' +
+            '<style>\n' +
+            '* { margin: 0; padding: 0; box-sizing: border-box; }\n' +
+            'body { display: flex; flex-direction: column; height: 100vh; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }\n' +
+            '.toolbar { display: flex; align-items: center; gap: 0.5rem; padding: 0.5rem 1rem; background: #f5f5f5; border-bottom: 1px solid #ddd; }\n' +
+            '.toolbar h1 { flex: 1; font-size: 0.95rem; font-weight: 500; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }\n' +
+            '.btn { padding: 0.4rem 0.8rem; font-size: 0.85rem; border: 1px solid #ccc; border-radius: 4px; background: white; cursor: pointer; }\n' +
+            '.btn:hover { background: #e8e8e8; }\n' +
+            'iframe { flex: 1; width: 100%; border: none; }\n' +
+            '#previewContent { flex: 1; overflow: auto; }\n' +
+            '.loading { display: flex; align-items: center; justify-content: center; height: 100%; color: #666; font-size: 1.1rem; }\n' +
+            '.docx-wrapper { padding: 1rem; }\n' +
+            '.xlsx-table { border-collapse: collapse; width: 100%; font-size: 0.85rem; }\n' +
+            '.xlsx-table th, .xlsx-table td { border: 1px solid #ddd; padding: 0.35rem 0.5rem; text-align: left; white-space: nowrap; }\n' +
+            '.xlsx-table th { background: #f0f0f0; font-weight: 600; position: sticky; top: 0; }\n' +
+            '.xlsx-table tr:nth-child(even) { background: #fafafa; }\n' +
+            '.xlsx-table tr:hover { background: #f0f7ff; }\n' +
+            '.sheet-tabs { display: flex; gap: 0; border-bottom: 1px solid #ddd; background: #f5f5f5; }\n' +
+            '.sheet-tab { padding: 0.4rem 1rem; cursor: pointer; border: 1px solid transparent; border-bottom: none; font-size: 0.85rem; background: transparent; }\n' +
+            '.sheet-tab:hover { background: #e8e8e8; }\n' +
+            '.sheet-tab.active { background: white; border-color: #ddd; border-bottom-color: white; margin-bottom: -1px; font-weight: 500; }\n' +
+            'img.preview-image { max-width: 100%; max-height: 100%; object-fit: contain; margin: auto; display: block; }\n' +
+            '</style>\n' +
+            '</head>\n' +
+            '<body>\n' +
+            '<div class="toolbar">\n' +
+            '<h1>' + safeName + '</h1>\n' +
+            '<button class="btn" onclick="downloadFile()">Download</button>\n' +
+            '</div>\n' +
+            contentHtml + '\n' +
+            '<script>\n' +
+            'var blobUrl = "' + url.replace(/"/g, '\\"') + '";\n' +
+            'var fileName = "' + safeName.replace(/"/g, '\\"') + '";\n' +
+            'function downloadFile() {\n' +
+            '  var a = document.createElement("a");\n' +
+            '  a.href = blobUrl;\n' +
+            '  a.download = fileName;\n' +
+            '  document.body.appendChild(a);\n' +
+            '  a.click();\n' +
+            '  document.body.removeChild(a);\n' +
+            '}\n' +
+            '</' + 'script>\n' +
+            '</body>\n' +
+            '</html>';
+    }
+
+    async function renderDocxInWindow(file) {
+        var container = previewWindow.document.getElementById('previewContent');
+        if (!container) {
+            return;
+        }
+        try {
+            await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+            await loadLibrary('https://cdn.jsdelivr.net/npm/docx-preview@latest/dist/docx-preview.min.js');
+            var arrayBuffer = await getFileArrayBuffer(file);
+            container.innerHTML = '';
+            await window.docx.renderAsync(arrayBuffer, container);
+        } catch (err) {
+            console.error('[transmittal] Error rendering DOCX:', err);
+            container.innerHTML = '<div class="loading">Error rendering DOCX: ' + util.escapeHtml(err.message || '') + '<br>Click Download to view in Word.</div>';
+        }
+    }
+
+    async function renderXlsxInWindow(file) {
+        var container = previewWindow.document.getElementById('previewContent');
+        if (!container) {
+            return;
+        }
+        try {
+            await loadLibrary('https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js');
+            var arrayBuffer = await getFileArrayBuffer(file);
+            var workbook = XLSX.read(arrayBuffer, { type: 'array' });
+            container.innerHTML = '';
+
+            var tableContainer = previewWindow.document.createElement('div');
+            tableContainer.style.flex = '1';
+            tableContainer.style.overflow = 'auto';
+
+            if (workbook.SheetNames.length > 1) {
+                var tabs = previewWindow.document.createElement('div');
+                tabs.className = 'sheet-tabs';
+                workbook.SheetNames.forEach(function (name, i) {
+                    var tab = previewWindow.document.createElement('button');
+                    tab.className = 'sheet-tab' + (i === 0 ? ' active' : '');
+                    tab.textContent = name;
+                    tab.addEventListener('click', function () {
+                        tabs.querySelectorAll('.sheet-tab').forEach(function (t) {
+                            t.classList.remove('active');
+                        });
+                        tab.classList.add('active');
+                        renderSheet(workbook, name, tableContainer);
+                    });
+                    tabs.appendChild(tab);
+                });
+                container.appendChild(tabs);
+            }
+
+            container.appendChild(tableContainer);
+            renderSheet(workbook, workbook.SheetNames[0], tableContainer);
+        } catch (err) {
+            console.error('[transmittal] Error rendering XLSX:', err);
+            container.innerHTML = '<div class="loading">Error rendering spreadsheet: ' + util.escapeHtml(err.message || '') + '<br>Click Download to view in Excel.</div>';
+        }
+    }
+
+    function renderSheet(workbook, sheetName, container) {
+        var sheet = workbook.Sheets[sheetName];
+        var html = XLSX.utils.sheet_to_html(sheet, { editable: false });
+        container.innerHTML = html;
+        var table = container.querySelector('table');
+        if (table) {
+            table.className = 'xlsx-table';
+        }
+    }
+
+    async function renderImageInWindow(file, url) {
+        var container = previewWindow.document.getElementById('previewContent');
+        if (!container) {
+            return;
+        }
+        container.innerHTML = '';
+        var img = previewWindow.document.createElement('img');
+        img.className = 'preview-image';
+        img.src = url;
+        img.alt = file.name || '';
+        container.appendChild(img);
+    }
+
+    async function showFilePreview(file) {
+        var ext = (file.extension || '').toLowerCase();
+        try {
+            var url = await getFileBlobUrl(file);
+            var html = buildPreviewHtml(file, url);
+
+            if (previewWindow && !previewWindow.closed) {
+                previewWindow.document.open();
+                previewWindow.document.write(html);
+                previewWindow.document.close();
+                previewWindow.focus();
+            } else {
+                var width = Math.round(screen.width * 0.6);
+                var height = Math.round(screen.height * 0.8);
+                var left = Math.round((screen.width - width) / 2);
+                var top = Math.round((screen.height - height) / 2);
+                previewWindow = window.open('', 'filePreview',
+                    'width=' + width + ',height=' + height + ',left=' + left + ',top=' + top + ',resizable=yes,scrollbars=yes');
+                if (!previewWindow) {
+                    window.open(url, '_blank');
+                    return;
+                }
+                previewWindow.document.write(html);
+                previewWindow.document.close();
+                previewWindow.focus();
+            }
+
+            if (ext === 'docx') {
+                await renderDocxInWindow(file);
+            } else if (ext === 'xlsx' || ext === 'xls') {
+                await renderXlsxInWindow(file);
+            } else if (IMAGE_EXTENSIONS.indexOf(ext) !== -1) {
+                await renderImageInWindow(file, url);
+            }
+        } catch (err) {
+            console.error('[transmittal] Error loading file preview:', err);
+            alert('Error loading preview: ' + (err && err.message ? err.message : err));
+        }
+    }
+
+    // --- Load files for preview (directory or ZIP) ---
+
+    function updatePreviewStatus(text) {
+        var el = dom.qs('#preview-status');
+        if (el) {
+            el.textContent = text;
+        }
+    }
+
+    function matchFilesToSources(sourceEntries) {
+        var files = app.data.files || [];
+        if (!files.length || !sourceEntries.length) {
+            return 0;
+        }
+
+        // Build lookup by relative path and by filename
+        var byPath = new Map();
+        var byName = new Map();
+        sourceEntries.forEach(function (entry) {
+            if (entry.path) {
+                byPath.set(entry.path, entry);
+            }
+            if (entry.name) {
+                // Only use filename match if unique
+                if (byName.has(entry.name)) {
+                    byName.set(entry.name, null); // Mark as ambiguous
+                } else {
+                    byName.set(entry.name, entry);
+                }
+            }
+        });
+
+        var matched = 0;
+        files.forEach(function (file) {
+            var source = null;
+            // Try path match first
+            if (file.path && byPath.has(file.path)) {
+                source = byPath.get(file.path);
+            }
+            // Fall back to name match
+            if (!source && file.name) {
+                var nameMatch = byName.get(file.name);
+                if (nameMatch) {
+                    source = nameMatch;
+                }
+            }
+            if (source) {
+                if (source.fileHandle) {
+                    file.fileHandle = source.fileHandle;
+                }
+                if (source.zipEntry) {
+                    file.zipEntry = source.zipEntry;
+                }
+                matched += 1;
+            }
+        });
+        return matched;
+    }
+
+    async function loadFromDirectory() {
+        if (typeof window.showDirectoryPicker !== 'function') {
+            alert('Your browser does not support directory selection. Try Chrome or Edge.');
+            return;
+        }
+        var dirHandle;
+        try {
+            dirHandle = await window.showDirectoryPicker();
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) {
+                return;
+            }
+            throw err;
+        }
+        updatePreviewStatus('Scanning directory...');
+        var entries = await filesModule.collectDirectoryEntries(dirHandle);
+        var sourceEntries = entries.map(function (entry) {
+            return { path: entry.path, name: entry.name, fileHandle: entry.handle };
+        });
+        var matched = matchFilesToSources(sourceEntries);
+        if (matched > 0) {
+            filesLoadedForPreview = true;
+            updatePreviewStatus('from "' + dirHandle.name + '" — ' + matched + ' of ' + (app.data.files || []).length + ' files matched');
+            filesModule.render();
+        } else {
+            updatePreviewStatus('No matching files found in "' + dirHandle.name + '"');
+        }
+    }
+
+    async function loadFromZip() {
+        return new Promise(function (resolve) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = '.zip';
+            input.addEventListener('change', async function () {
+                var zipFile = input.files && input.files[0];
+                if (!zipFile) {
+                    resolve();
+                    return;
+                }
+                try {
+                    updatePreviewStatus('Loading ZIP...');
+                    await loadLibrary('https://cdn.jsdelivr.net/npm/jszip@3/dist/jszip.min.js');
+                    var arrayBuffer = await zipFile.arrayBuffer();
+                    var zip = await JSZip.loadAsync(arrayBuffer);
+                    var sourceEntries = [];
+                    zip.forEach(function (relativePath, zipEntry) {
+                        if (zipEntry.dir) {
+                            return;
+                        }
+                        // Strip the outermost folder if all entries share one
+                        var name = relativePath.split('/').pop();
+                        sourceEntries.push({
+                            path: relativePath,
+                            name: name,
+                            zipEntry: zipEntry
+                        });
+                    });
+
+                    // Try stripping common prefix for better path matching
+                    if (sourceEntries.length > 0) {
+                        var firstPath = sourceEntries[0].path;
+                        var prefix = firstPath.indexOf('/') !== -1 ? firstPath.substring(0, firstPath.indexOf('/') + 1) : '';
+                        if (prefix) {
+                            var allSharePrefix = sourceEntries.every(function (e) {
+                                return e.path.indexOf(prefix) === 0;
+                            });
+                            if (allSharePrefix) {
+                                sourceEntries.forEach(function (e) {
+                                    e.path = e.path.substring(prefix.length);
+                                });
+                            }
+                        }
+                    }
+
+                    var matched = matchFilesToSources(sourceEntries);
+                    if (matched > 0) {
+                        filesLoadedForPreview = true;
+                        updatePreviewStatus('from "' + zipFile.name + '" — ' + matched + ' of ' + (app.data.files || []).length + ' files matched');
+                        filesModule.render();
+                    } else {
+                        updatePreviewStatus('No matching files found in "' + zipFile.name + '"');
+                    }
+                } catch (err) {
+                    console.error('[transmittal] Error loading ZIP:', err);
+                    updatePreviewStatus('Failed to load ZIP: ' + (err && err.message ? err.message : err));
+                }
+                resolve();
+            });
+            input.click();
+        });
+    }
+
+    // Track whether files have been loaded for preview in view mode
+    var filesLoadedForPreview = false;
+
+    function isPreviewEnabled() {
+        var checkbox = dom.qs('#preview-toggle');
+        return checkbox && checkbox.checked;
+    }
+
+    function syncCheckboxToMode() {
+        var checkbox = dom.qs('#preview-toggle');
+        if (!checkbox) {
+            return;
+        }
+        if (app.state.mode === 'edit') {
+            checkbox.checked = true;
+            checkbox.disabled = true;
+            updatePreviewStatus('');
+        } else {
+            checkbox.disabled = false;
+            if (!filesLoadedForPreview) {
+                checkbox.checked = false;
+                updatePreviewStatus('');
+            }
+        }
+    }
+
+    function showSourcePicker() {
+        var bar = dom.qs('#preview-bar');
+        var existing = dom.qs('#preview-load-menu');
+        if (existing) {
+            existing.remove();
+            return;
+        }
+        var menu = document.createElement('div');
+        menu.id = 'preview-load-menu';
+        menu.style.cssText = 'position:absolute;z-index:50;background:white;border:1px solid #ccc;border-radius:4px;box-shadow:0 2px 8px rgba(0,0,0,0.15);padding:0.25rem 0;min-width:160px;';
+
+        function addOption(label, handler) {
+            var btn = document.createElement('button');
+            btn.type = 'button';
+            btn.textContent = label;
+            btn.style.cssText = 'display:block;width:100%;text-align:left;padding:0.4rem 0.75rem;border:none;background:none;cursor:pointer;font-size:0.8rem;';
+            btn.addEventListener('mouseenter', function () { btn.style.background = '#f0f0f0'; });
+            btn.addEventListener('mouseleave', function () { btn.style.background = 'none'; });
+            btn.addEventListener('click', function () {
+                menu.remove();
+                handler();
+            });
+            menu.appendChild(btn);
+        }
+
+        addOption('Select Directory', function () {
+            loadFromDirectory().then(function () {
+                if (!filesLoadedForPreview) {
+                    uncheckPreview();
+                }
+            }).catch(function (err) {
+                console.error('[transmittal] loadFromDirectory failed', err);
+                updatePreviewStatus('Failed: ' + (err && err.message ? err.message : err));
+                uncheckPreview();
+            });
+        });
+
+        addOption('Select ZIP File', function () {
+            loadFromZip().then(function () {
+                if (!filesLoadedForPreview) {
+                    uncheckPreview();
+                }
+            }).catch(function (err) {
+                console.error('[transmittal] loadFromZip failed', err);
+                updatePreviewStatus('Failed: ' + (err && err.message ? err.message : err));
+                uncheckPreview();
+            });
+        });
+
+        if (bar) {
+            bar.style.position = 'relative';
+            menu.style.top = '1.5rem';
+            menu.style.left = '0';
+            bar.appendChild(menu);
+        }
+
+        function closeMenu(e) {
+            if (!menu.contains(e.target)) {
+                menu.remove();
+                document.removeEventListener('click', closeMenu, true);
+            }
+        }
+        setTimeout(function () {
+            document.addEventListener('click', closeMenu, true);
+        }, 0);
+    }
+
+    function uncheckPreview() {
+        var checkbox = dom.qs('#preview-toggle');
+        if (checkbox) {
+            checkbox.checked = false;
+        }
+    }
+
+    function bindPreviewBar() {
+        var checkbox = dom.qs('#preview-toggle');
+        if (!checkbox) {
+            return;
+        }
+        checkbox.addEventListener('change', function () {
+            if (app.state.mode === 'edit') {
+                checkbox.checked = true;
+                return;
+            }
+            if (checkbox.checked) {
+                if (!filesLoadedForPreview) {
+                    showSourcePicker();
+                }
+            } else {
+                updatePreviewStatus('');
+            }
+        });
+        syncCheckboxToMode();
+    }
+
+    // Expose on filesModule
+    filesModule.isPreviewable = isPreviewable;
+    filesModule.hasFileSource = hasFileSource;
+    filesModule.isPreviewEnabled = isPreviewEnabled;
+    filesModule.syncPreviewCheckbox = syncCheckboxToMode;
+    filesModule.showFilePreview = showFilePreview;
+    filesModule.cleanupBlobUrls = cleanupBlobUrls;
+    filesModule.getFileArrayBuffer = getFileArrayBuffer;
+    filesModule.getFileBlobUrl = getFileBlobUrl;
+    filesModule.loadLibrary = loadLibrary;
+    filesModule.getMimeType = getMimeType;
+
+    app.registerInit(function () {
+        bindPreviewBar();
+        window.addEventListener('beforeunload', cleanupBlobUrls);
+    });
+})(window.transmittalApp);
+
+(function() {
+    'use strict';
+
+    // Escape a string for use in a RegExp (literal match)
+    function escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+
+    // Build regex pattern at parse time based on anchors
+    function compilePattern(raw, anchorStart, anchorEnd) {
+        var src = (anchorStart ? '^' : '') + raw + (anchorEnd ? '$' : '');
+        try {
+            return new RegExp(src, 'i');
+        } catch (e) {
+            // Invalid regex — escape and retry (always succeeds)
+            var safe = (anchorStart ? '^' : '') + escapeRegex(raw) + (anchorEnd ? '$' : '');
+            return new RegExp(safe, 'i');
+        }
+    }
+
+    // Parse a single token string into a node
+    function parseToken(token) {
+        var s = token;
+        var negate = false;
+        var anchorStart = false;
+        var anchorEnd = false;
+
+        if (s.charAt(0) === '!') {
+            negate = true;
+            s = s.slice(1);
+        }
+        if (s.charAt(0) === '^') {
+            anchorStart = true;
+            s = s.slice(1);
+        }
+        if (s.length > 0 && s.charAt(s.length - 1) === '$') {
+            anchorEnd = true;
+            s = s.slice(0, -1);
+        }
+
+        if (s === '') return null;
+
+        // bare * (possibly after stripping !) → wildcard-all or wildcard-none
+        if (s === '*' && !anchorStart && !anchorEnd) {
+            return negate ? null : { type: 'wildcard-all' };
+        }
+
+        var re = compilePattern(s, anchorStart, anchorEnd);
+        return { type: negate ? 'no-match' : 'match', re: re };
+    }
+
+    // Parse expression string into AST array
+    function parse(expression) {
+        if (!expression || typeof expression !== 'string') return [];
+        var trimmed = expression.trim();
+        if (trimmed === '') return [];
+        if (trimmed === '*') return [{ type: 'wildcard-all' }];
+
+        var ast = [];
+        var i = 0;
+        var len = trimmed.length;
+
+        while (i < len) {
+            var ch = trimmed.charAt(i);
+
+            if (ch === '(') {
+                var depth = 1;
+                var j = i + 1;
+                while (j < len && depth > 0) {
+                    if (trimmed.charAt(j) === '(') depth++;
+                    else if (trimmed.charAt(j) === ')') depth--;
+                    j++;
+                }
+                var innerAst = parse(trimmed.slice(i + 1, j - 1));
+                if (innerAst.length === 1) {
+                    ast.push(innerAst[0]);
+                } else if (innerAst.length > 1) {
+                    for (var k = 0; k < innerAst.length; k++) ast.push(innerAst[k]);
+                }
+                i = j;
+            } else if (ch === '|') {
+                ast.push({ type: 'pipe' });
+                i++;
+            } else if (ch === ' ') {
+                i++;
+            } else {
+                var j = i;
+                while (j < len) {
+                    var c = trimmed.charAt(j);
+                    if (c === ' ' || c === '(' || c === '|' || c === ')') break;
+                    j++;
+                }
+                var token = trimmed.slice(i, j);
+                if (token.length > 0) {
+                    var node = parseToken(token);
+                    if (node !== null) ast.push(node);
+                }
+                i = j;
+            }
+        }
+
+        // Group pipes into OR nodes
+        var hasPipe = false;
+        var branches = [[]];
+        for (var l = 0; l < ast.length; l++) {
+            if (ast[l].type === 'pipe') {
+                hasPipe = true;
+                branches.push([]);
+            } else {
+                branches[branches.length - 1].push(ast[l]);
+            }
+        }
+        branches = branches.filter(function(b) { return b.length > 0; });
+
+        if (!hasPipe) {
+            return ast.filter(function(n) { return n.type !== 'pipe'; });
+        }
+
+        var orNodes = branches.map(function(branch) {
+            if (branch.length === 1) return branch[0];
+            return { type: 'and', nodes: branch };
+        });
+        return [{ type: 'or', nodes: orNodes }];
+    }
+
+    // Check if a single node matches the value
+    function nodeMatches(node, value) {
+        switch (node.type) {
+            case 'wildcard-all': return true;
+            case 'match':    return node.re.test(value);
+            case 'no-match': return !node.re.test(value);
+            case 'or':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (nodeMatches(node.nodes[i], value)) return true;
+                }
+                return false;
+            case 'and':
+                for (var i = 0; i < node.nodes.length; i++) {
+                    if (!nodeMatches(node.nodes[i], value)) return false;
+                }
+                return true;
+            default: return false;
+        }
+    }
+
+    // Evaluate AST against value
+    function matches(value, ast) {
+        if (!ast || ast.length === 0) return true;
+        var v = String(value); // no forced lowercase — regex has 'i' flag
+        for (var i = 0; i < ast.length; i++) {
+            if (!nodeMatches(ast[i], v)) return false;
+        }
+        return true;
+    }
+
+    if (!window.zddc) {
+        throw new Error('shared/zddc-filter.js: window.zddc must be loaded first');
+    }
+    window.zddc.filter = { parse: parse, matches: matches };
+})();
+
+(function (app) {
+    'use strict';
+
+    const filters = app.modules.filters = {};
+    const dom = app.dom;
+
+    filters.fieldString = function fieldString(file, field) {
+        let value = '';
+        switch (field) {
+            case 'trackingNumber': value = file.trackingNumber || ''; break;
+            case 'title': value = file.title || ''; break;
+            case 'revision': value = file.revision || ''; break;
+            case 'status': value = file.status || ''; break;
+            case 'extension': value = file.extension || ''; break;
+            case 'sha256': value = file.sha256 || ''; break;
+            default: value = '';
+        }
+        return String(value).toLowerCase();
+    };
+
+    filters.getActiveFilters = function getActiveFilters() {
+        const active = {};
+        const inputs = document.querySelectorAll('thead input[data-filter-field]');
+        inputs.forEach(function (input) {
+            const field = input.getAttribute('data-filter-field');
+            const query = (input.value || '').trim();
+            if (!query) return;
+            active[field] = window.zddc.filter.parse(query);
+        });
+        return active;
+    };
+
+    filters.fileMatchesFilters = function fileMatchesFilters(file, activeFilters) {
+        const fields = Object.keys(activeFilters);
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            const ast = activeFilters[field];
+            const value = filters.fieldString(file, field);
+            if (!window.zddc.filter.matches(value, ast)) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    filters.refreshPlaceholders = function refreshPlaceholders() {
+        const inputs = document.querySelectorAll('thead input[data-filter-field]');
+        inputs.forEach(function (input) {
+            const empty = !(input.value || '').trim().length;
+            input.toggleAttribute('data-empty', empty);
+        });
+    };
+
+    filters.bindFilters = function bindFilters() {
+        const head = document.querySelector('thead');
+        if (!head) return;
+
+        head.addEventListener('input', function (event) {
+            const target = event.target;
+            if (target && target.getAttribute && target.getAttribute('data-filter-field')) {
+                filters.refreshPlaceholders();
+                if (app.modules.files && typeof app.modules.files.render === 'function') {
+                    app.modules.files.render();
+                }
+            }
+        });
+
+        head.addEventListener('keydown', function (event) {
+            const target = event.target;
+            if (!(target instanceof HTMLElement)) return;
+            if (!target.getAttribute || !target.getAttribute('data-filter-field')) return;
+            if (event.key === 'Escape') {
+                target.value = '';
+                filters.refreshPlaceholders();
+                if (app.modules.files && typeof app.modules.files.render === 'function') {
+                    app.modules.files.render();
+                }
+                event.preventDefault();
+            } else if (event.key === 'Enter') {
+                event.preventDefault();
+                const inputs = Array.from(head.querySelectorAll('input[data-filter-field]'));
+                const index = inputs.indexOf(target);
+                if (index !== -1) {
+                    const next = inputs[(index + 1) % inputs.length];
+                    if (next && typeof next.focus === 'function') next.focus();
+                }
+            }
+        });
+
+        filters.refreshPlaceholders();
+    };
+
+    app.registerInit(function () {
+        filters.bindFilters();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const markdown = app.modules.markdown = {};
+    const dom = app.dom;
+
+    var escapeHtml = app.util.escapeHtml;
+
+    function renderInline(text) {
+        if (!text) {
+            return '';
+        }
+        let rendered = escapeHtml(text);
+        const codePlaceholders = [];
+        rendered = rendered.replace(/`([^`]+)`/g, function (_, code) {
+            codePlaceholders.push('<code>' + escapeHtml(code) + '</code>');
+            return '\u0000C' + (codePlaceholders.length - 1) + '\u0000';
+        });
+        rendered = rendered.replace(/\[([^\]]+)\]\(([^)]+)\)/g, function (_, label, url) {
+            const trimmedUrl = url.trim();
+            const allowed = /^(https?:\/\/|mailto:|tel:|\/|\.{1,2}\/)/i.test(trimmedUrl);
+            if (!allowed) {
+                return '[' + label + '](' + url + ')';
+            }
+            const safeUrl = trimmedUrl.replace(/\s+/g, '%20').replace(/"/g, '%22');
+            return '<a href="' + safeUrl + '" target="_blank" rel="noopener">' + escapeHtml(label) + '</a>';
+        });
+        rendered = rendered.replace(/(^|\s)((https?:\/\/)[^\s<]+)/gi, function (_, prefix, url) {
+            const safe = url.replace(/"/g, '%22');
+            return prefix + '<a href="' + safe + '" target="_blank" rel="noopener">' + url + '</a>';
+        });
+        rendered = rendered
+            .replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>')
+            .replace(/__([^_]+)__/g, '<strong>$1</strong>')
+            .replace(/(^|\W)\*([^*]+)\*(?=\W|$)/g, '$1<em>$2</em>')
+            .replace(/(^|\W)_([^_]+)_(?=\W|$)/g, '$1<em>$2</em>')
+            .replace(/~~([^~]+)~~/g, '<del>$1</del>');
+        rendered = rendered.replace(/\u0000C(\d+)\u0000/g, function (_, index) {
+            return codePlaceholders[Number(index)] || '';
+        });
+        return rendered;
+    }
+
+    function leadingIndent(text) {
+        const expanded = text.replace(/\t/g, '    ');
+        const match = expanded.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+    }
+
+    markdown.render = function renderMarkdownBasic(markdownText) {
+        const lines = (markdownText || '').replace(/\r\n?/g, '\n').split('\n');
+        const output = [];
+        let inCode = false;
+        let codeBuffer = [];
+        const listStack = [];
+        const tableSeparator = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+
+        function flushCode() {
+            if (!inCode) {
+                return;
+            }
+            output.push('<pre><code>' + escapeHtml(codeBuffer.join('\n')) + '</code></pre>');
+            inCode = false;
+            codeBuffer = [];
+        }
+
+        function closeListsTo(indent) {
+            while (listStack.length && listStack[listStack.length - 1].indent > indent) {
+                output.push('</' + listStack.pop().type + '>');
+            }
+        }
+
+        function closeAllLists() {
+            closeListsTo(-1);
+        }
+
+        function openList(type, indent) {
+            listStack.push({ type, indent });
+            output.push('<' + type + '>');
+        }
+
+        function splitCells(row) {
+            const trimmed = row.trim().replace(/^\|/, '').replace(/\|$/, '');
+            return trimmed.split('|').map(function (cell) {
+                return cell.trim();
+            });
+        }
+
+        for (let index = 0; index < lines.length; index += 1) {
+            const raw = lines[index];
+            const line = raw;
+            if (/^```/.test(line)) {
+                if (inCode) {
+                    flushCode();
+                } else {
+                    inCode = true;
+                    codeBuffer = [];
+                }
+                continue;
+            }
+            if (inCode) {
+                codeBuffer.push(raw);
+                continue;
+            }
+            if (!line.trim()) {
+                closeAllLists();
+                continue;
+            }
+            if (/\|/.test(line) && index + 1 < lines.length && tableSeparator.test(lines[index + 1])) {
+                closeAllLists();
+                const headerCells = splitCells(line);
+                index += 2;
+                const body = [];
+                while (index < lines.length && /\|/.test(lines[index]) && lines[index].trim()) {
+                    body.push(splitCells(lines[index]));
+                    index += 1;
+                }
+                index -= 1;
+                const thead = '<thead><tr>' + headerCells.map(function (cell) {
+                    return '<th>' + renderInline(cell) + '</th>';
+                }).join('') + '</tr></thead>';
+                const tbody = '<tbody>' + body.map(function (rowCells) {
+                    return '<tr>' + rowCells.map(function (cell) {
+                        return '<td>' + renderInline(cell) + '</td>';
+                    }).join('') + '</tr>';
+                }).join('') + '</tbody>';
+                output.push('<table>' + thead + tbody + '</table>');
+                continue;
+            }
+            if (/^\s*(?:---|\*\*\*|___)\s*$/.test(line)) {
+                closeAllLists();
+                output.push('<hr/>');
+                continue;
+            }
+            if (/^\s*>\s?/.test(line)) {
+                closeAllLists();
+                const quoteLines = [];
+                while (index < lines.length && /^\s*>\s?/.test(lines[index])) {
+                    quoteLines.push(lines[index].replace(/^\s*>\s?/, ''));
+                    index += 1;
+                }
+                index -= 1;
+                const html = quoteLines.map(function (text) {
+                    return '<p>' + renderInline(text) + '</p>';
+                }).join('\n');
+                output.push('<blockquote>' + html + '</blockquote>');
+                continue;
+            }
+            let match = line.match(/^(#{1,6})\s+(.*)$/);
+            if (match) {
+                closeAllLists();
+                const level = match[1].length;
+                const text = renderInline(match[2].trim());
+                output.push('<h' + level + '>' + text + '</h' + level + '>');
+                continue;
+            }
+            match = line.match(/^(\s*)[-*+]\s+(.*)$/);
+            if (match) {
+                const indent = leadingIndent(match[1]);
+                const type = 'ul';
+                if (!listStack.length || listStack[listStack.length - 1].indent < indent) {
+                    openList(type, indent);
+                } else {
+                    closeListsTo(indent);
+                    if (!listStack.length || listStack[listStack.length - 1].type !== type || listStack[listStack.length - 1].indent !== indent) {
+                        openList(type, indent);
+                    }
+                }
+                output.push('<li>' + renderInline(match[2].trim()) + '</li>');
+                continue;
+            }
+            match = line.match(/^(\s*)\d+\.\s+(.*)$/);
+            if (match) {
+                const indent = leadingIndent(match[1]);
+                const type = 'ol';
+                if (!listStack.length || listStack[listStack.length - 1].indent < indent) {
+                    openList(type, indent);
+                } else {
+                    closeListsTo(indent);
+                    if (!listStack.length || listStack[listStack.length - 1].type !== type || listStack[listStack.length - 1].indent !== indent) {
+                        openList(type, indent);
+                    }
+                }
+                output.push('<li>' + renderInline(match[2].trim()) + '</li>');
+                continue;
+            }
+            closeAllLists();
+            output.push('<p>' + renderInline(line) + '</p>');
+        }
+
+        closeAllLists();
+        flushCode();
+        return output.join('\n');
+    };
+
+    markdown.refresh = function refreshPreview() {
+        const textarea = dom.qs('#remarks');
+        const target = dom.qs('#remarks-render');
+        if (!textarea || !target) {
+            return;
+        }
+        target.innerHTML = markdown.render(textarea.value || '');
+    };
+
+    markdown.bindRemarksLivePreview = function bindRemarksLivePreview() {
+        const textarea = dom.qs('#remarks');
+        if (!textarea) {
+            return;
+        }
+        textarea.addEventListener('input', function () {
+            if (app.state.mode === 'edit') {
+                markdown.refresh();
+            }
+        });
+        markdown.refresh();
+    };
+
+    app.registerInit(function () {
+        markdown.bindRemarksLivePreview();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var markdown = app.modules.markdown;
+
+    var editor = app.modules.markdownEditor = {};
+    var inputEl = null;       // plain textarea
+    var toolbarEl = null;     // button bar
+    var wrapperEl = null;     // container for all editor elements
+    var initialized = false;
+    var renderClickBound = false;
+    var outsideClickBound = false;
+
+    // ── Textarea helpers ──────────────────────────────────────────────
+
+    function syncToHiddenTextarea() {
+        var remarks = dom.qs('#remarks');
+        if (remarks && inputEl) { remarks.value = inputEl.value; }
+    }
+
+    function insertText(before, after, placeholder) {
+        if (!inputEl) { return; }
+        inputEl.focus();
+        var start = inputEl.selectionStart;
+        var end = inputEl.selectionEnd;
+        var selected = inputEl.value.substring(start, end);
+        var insert = selected || placeholder || '';
+        var full = before + insert + (after || '');
+        // execCommand preserves undo stack in most browsers
+        document.execCommand('insertText', false, full);
+        // If we used placeholder, select it for easy replacement
+        if (!selected && insert) {
+            inputEl.selectionStart = start + before.length;
+            inputEl.selectionEnd = start + before.length + insert.length;
+        }
+    }
+
+    // ── Button bar ────────────────────────────────────────────────────
+
+    var buttons = [
+        { label: 'B',  title: 'Bold',           wrap: ['**', '**'],       placeholder: 'bold' },
+        { label: 'I',  title: 'Italic',          wrap: ['*', '*'],         placeholder: 'italic' },
+        { label: 'H',  title: 'Heading',         wrap: ['## ', ''],        placeholder: 'heading' },
+        { label: '\u2022', title: 'Bullet list',  wrap: ['- ', ''],         placeholder: 'item' },
+        { label: '1.', title: 'Numbered list',   wrap: ['1. ', ''],        placeholder: 'item' },
+        { label: '\uD83D\uDD17', title: 'Link',  wrap: ['[', '](url)'],    placeholder: 'link text' },
+        { label: '\u229E', title: 'Table',        insert: '| Col 1 | Col 2 | Col 3 |\n| --- | --- | --- |\n| | | |\n' }
+    ];
+
+    function onButtonClick(event) {
+        var btn = event.currentTarget;
+        var idx = parseInt(btn.getAttribute('data-idx'), 10);
+        var def = buttons[idx];
+        if (!def) { return; }
+        event.preventDefault();
+        if (def.wrap) {
+            insertText(def.wrap[0], def.wrap[1], def.placeholder);
+        } else if (def.insert) {
+            insertText(def.insert, '', '');
+        }
+        syncToHiddenTextarea();
+        app.markDirty();
+    }
+
+    function createToolbar() {
+        if (toolbarEl) { return toolbarEl; }
+        toolbarEl = document.createElement('div');
+        toolbarEl.className = 'md-toolbar';
+        buttons.forEach(function (def, i) {
+            var btn = document.createElement('button');
+            btn.type = 'button';
+            btn.className = 'md-toolbar-btn';
+            btn.textContent = def.label;
+            btn.title = def.title;
+            btn.setAttribute('data-idx', i);
+            btn.addEventListener('mousedown', function (e) { e.preventDefault(); });
+            btn.addEventListener('click', onButtonClick);
+            toolbarEl.appendChild(btn);
+        });
+        return toolbarEl;
+    }
+
+    // ── Visibility helpers ────────────────────────────────────────────
+
+    function refreshRender() {
+        var textarea = dom.qs('#remarks');
+        var renderEl = dom.qs('#remarks-render');
+        if (!textarea || !renderEl) { return; }
+        var value = textarea.value || '';
+        if (value.trim()) {
+            renderEl.innerHTML = markdown.render(value);
+        } else if (app.state.mode === 'edit' && !app.state.published) {
+            renderEl.innerHTML = '<span class="remarks-placeholder">Click to add remarks</span>';
+        } else {
+            renderEl.innerHTML = '';
+        }
+    }
+
+    function showRendered() {
+        if (wrapperEl) { wrapperEl.style.display = 'none'; }
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (renderContainer) { renderContainer.hidden = false; }
+        syncToHiddenTextarea();
+        refreshRender();
+    }
+
+    function showEditor() {
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (renderContainer) { renderContainer.hidden = true; }
+        if (!initialized) { editor.init(); }
+        if (wrapperEl) { wrapperEl.style.display = ''; }
+        var remarks = dom.qs('#remarks');
+        if (remarks && inputEl) {
+            inputEl.value = remarks.value || '';
+        }
+        if (inputEl) { inputEl.focus(); }
+    }
+
+    // ── Click-to-edit on rendered preview ─────────────────────────────
+
+    function onRenderClick() {
+        if (app.state.mode !== 'edit' || app.state.published) { return; }
+        showEditor();
+    }
+
+    function bindRenderClick() {
+        if (renderClickBound) { return; }
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (!renderContainer) { return; }
+        renderContainer.addEventListener('click', onRenderClick);
+        renderClickBound = true;
+    }
+
+    function setRenderClickable(clickable) {
+        var renderContainer = dom.qs('#remarks-render-container');
+        if (!renderContainer) { return; }
+        if (clickable) {
+            renderContainer.classList.add('remarks-clickable');
+        } else {
+            renderContainer.classList.remove('remarks-clickable');
+        }
+    }
+
+    // ── Outside-click collapse ────────────────────────────────────────
+
+    function onDocumentMousedown(event) {
+        if (!wrapperEl) { return; }
+        if (wrapperEl.style.display === 'none') { return; }
+        if (wrapperEl.contains(event.target)) { return; }
+        showRendered();
+    }
+
+    function bindOutsideClick() {
+        if (outsideClickBound) { return; }
+        document.addEventListener('mousedown', onDocumentMousedown, true);
+        outsideClickBound = true;
+    }
+
+    // ── Public API ────────────────────────────────────────────────────
+
+    editor.init = function initEditor() {
+        if (initialized) { return; }
+        var remarksWrapper = dom.qs('#remarks-wrapper');
+        if (!remarksWrapper) { return; }
+
+        wrapperEl = document.createElement('div');
+        wrapperEl.id = 'remarks-editor';
+        wrapperEl.style.display = 'none';
+
+        wrapperEl.appendChild(createToolbar());
+
+        // Edit area container
+        var editArea = document.createElement('div');
+        editArea.className = 'md-edit-area';
+
+        // Plain textarea
+        inputEl = document.createElement('textarea');
+        inputEl.className = 'md-input';
+        inputEl.spellcheck = true;
+        inputEl.setAttribute('aria-label', 'Remarks');
+        editArea.appendChild(inputEl);
+
+        wrapperEl.appendChild(editArea);
+        remarksWrapper.appendChild(wrapperEl);
+
+        inputEl.addEventListener('input', function () {
+            syncToHiddenTextarea();
+            app.markDirty();
+        });
+
+        inputEl.addEventListener('keydown', function (e) {
+            if (e.key === 'Tab') {
+                e.preventDefault();
+                document.execCommand('insertText', false, '    ');
+            }
+        });
+
+        bindOutsideClick();
+        initialized = true;
+    };
+
+    editor.destroy = function destroyEditor() {
+        if (wrapperEl) { wrapperEl.style.display = 'none'; }
+        syncToHiddenTextarea();
+    };
+
+    editor.showRendered = showRendered;
+    editor.showEditor = showEditor;
+    editor.refreshRender = refreshRender;
+    editor.bindRenderClick = bindRenderClick;
+    editor.setRenderClickable = setRenderClickable;
+
+    editor.isActive = function isActive() {
+        return initialized && wrapperEl && wrapperEl.style.display !== 'none';
+    };
+
+    editor.getValue = function getValue() {
+        return inputEl ? inputEl.value : '';
+    };
+
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+    function escapeHtml(str) {
+        return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+    }
+
+    function escapeAttr(str) {
+        return str.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+    }
+
+    // Split on semicolons/commas but respect quoted strings
+    function splitRecipients(raw) {
+        var parts = [];
+        var current = '';
+        var inQuote = false;
+        for (var i = 0; i < raw.length; i++) {
+            var ch = raw[i];
+            if (ch === '"') {
+                inQuote = !inQuote;
+                current += ch;
+            } else if ((ch === ';' || ch === ',') && !inQuote) {
+                var trimmed = current.trim();
+                if (trimmed) { parts.push(trimmed); }
+                current = '';
+            } else {
+                current += ch;
+            }
+        }
+        var last = current.trim();
+        if (last) { parts.push(last); }
+        return parts;
+    }
+
+    // Extract email from entries like "Display Name <email@host.com>" or bare email
+    function extractEmail(entry) {
+        var angleMatch = entry.match(/<([^>]+)>/);
+        if (angleMatch && EMAIL_RE.test(angleMatch[1])) {
+            return angleMatch[1];
+        }
+        if (EMAIL_RE.test(entry)) {
+            return entry;
+        }
+        return null;
+    }
+
+    function renderRecipient(entry) {
+        var email = extractEmail(entry);
+        if (email) {
+            return '<a href="mailto:' + escapeAttr(email) + '" class="to-mailto">' + escapeHtml(entry) + '</a>';
+        }
+        return '<span>' + escapeHtml(entry) + '</span>';
+    }
+
+    function renderToField() {
+        var input = dom.qs('#to');
+        var render = dom.qs('#to-render');
+        if (!input || !render) { return; }
+
+        var raw = input.value || '';
+        var parts = splitRecipients(raw);
+        if (!parts.length) {
+            render.innerHTML = '';
+            return;
+        }
+
+        var html = parts.map(renderRecipient).join('<span class="to-sep">; </span>');
+        render.innerHTML = html;
+    }
+
+    function renderFromField() {
+        var input = dom.qs('#from');
+        var render = dom.qs('#from-render');
+        if (!input || !render) { return; }
+
+        var raw = (input.value || '').trim();
+        if (!raw) {
+            render.innerHTML = '';
+            return;
+        }
+
+        var email = extractEmail(raw);
+        if (email) {
+            render.innerHTML = '<a href="mailto:' + escapeAttr(email) + '" class="from-mailto">' + escapeHtml(raw) + '</a>';
+        } else {
+            render.innerHTML = '<span>' + escapeHtml(raw) + '</span>';
+        }
+    }
+
+    function init() {
+        var toInput = dom.qs('#to');
+        if (toInput) {
+            toInput.addEventListener('input', renderToField);
+            toInput.addEventListener('change', renderToField);
+            renderToField();
+        }
+        var fromInput = dom.qs('#from');
+        if (fromInput) {
+            fromInput.addEventListener('input', renderFromField);
+            fromInput.addEventListener('change', renderFromField);
+            renderFromField();
+        }
+    }
+
+    app.modules.emailTags = {
+        render: renderToField,
+        renderFrom: renderFromField
+    };
+
+    app.registerInit(init);
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+
+    const validation = app.modules.validation = {};
+
+    validation.bindTrackingNumberValidation = function bindTrackingNumberValidation() {
+        const input = dom.qs('#tracking-number');
+        if (!input) {
+            return;
+        }
+        function isInvalid(value) {
+            return /\s/.test(value) || /_/.test(value);
+        }
+        function apply() {
+            const value = input.value || '';
+            const bad = isInvalid(value);
+            input.setAttribute('aria-invalid', bad ? 'true' : 'false');
+            if (bad) {
+                input.classList.add('ring-1', 'ring-red-400', 'border-red-500');
+            } else {
+                input.classList.remove('ring-1', 'ring-red-400', 'border-red-500');
+            }
+        }
+        input.addEventListener('input', apply);
+        input.addEventListener('blur', apply);
+        apply();
+    };
+
+    validation.validateBeforePublish = function validateBeforePublish() {
+        const errors = [];
+        let focusEl = null;
+        const trackingInput = dom.qs('#tracking-number');
+        if (trackingInput) {
+            const value = trackingInput.value || '';
+            if (/\s/.test(value) || /_/.test(value)) {
+                errors.push('Tracking Number must not contain spaces or underscores.');
+                if (!focusEl) {
+                    focusEl = trackingInput;
+                }
+            }
+        }
+        (app.data.files || []).forEach(function (file, index) {
+            if (file.trackingNumber && (/\s/.test(file.trackingNumber) || /_/.test(file.trackingNumber))) {
+                errors.push('Row ' + (index + 1) + ': File tracking number must not contain spaces or underscores.');
+            }
+            if (file.revision && /\s/.test(file.revision)) {
+                errors.push('Row ' + (index + 1) + ': Revision must not contain spaces.');
+            }
+        });
+        return {
+            ok: errors.length === 0,
+            focusEl: focusEl,
+            message: errors.join('\n')
+        };
+    };
+
+    app.registerInit(function () {
+        validation.bindTrackingNumberValidation();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const util = app.util;
+    const json = app.json;
+
+    const security = app.modules.security = {};
+
+    // ── Verify-card DOM helpers ────────────────────────
+    function makeCard(variant) {
+        var el = document.createElement('div');
+        el.className = 'verify-card verify-card--' + variant;
+        return el;
+    }
+    function makeStatus(text, variant) {
+        var el = document.createElement('div');
+        el.className = 'verify-card__status verify-card__status--' + variant;
+        el.textContent = text;
+        return el;
+    }
+    function makeDetail(html) {
+        var el = document.createElement('div');
+        el.className = 'verify-card__detail';
+        el.innerHTML = html;
+        return el;
+    }
+
+    security.renderSignaturesList = async function renderSignaturesList() {
+        var digestEl = dom.qs('#digest-display');
+        var container = dom.qs('#signatures-list');
+        var addButton = dom.qs('#add-signature-btn');
+        if (!container) { return; }
+
+        var data = json.parse();
+        var envelope = data.envelope || {};
+        var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+        var hasDigest = !!(envelope.digest);
+        var dv = app.data.digestVerified;
+        var results = app.data.signatureVerificationResults || [];
+
+        // ── Digest card ──
+        if (digestEl) {
+            digestEl.innerHTML = '';
+            if (hasDigest && dv) {
+                var unavailable = dv.unavailable;
+                var cardType = unavailable ? 'info' : (dv.match ? 'ok' : 'fail');
+                var dCard = makeCard(cardType);
+                if (unavailable) {
+                    dCard.appendChild(makeStatus('Digest Present \u2014 verification unavailable', 'info'));
+                } else {
+                    dCard.appendChild(makeStatus(
+                        (dv.match ? '\u2713 Digest Verified' : '\u2717 Digest Failed'),
+                        dv.match ? 'ok' : 'fail'
+                    ));
+                }
+                dCard.appendChild(makeDetail('SHA-256: <code>' + envelope.digest + '</code>'));
+                if (envelope.digestedAt) {
+                    dCard.appendChild(makeDetail(util.formatISOWithTZ(envelope.digestedAt)));
+                }
+                if (unavailable) {
+                    dCard.appendChild(makeDetail('<em>Open from file:// or https:// to verify integrity</em>'));
+                }
+                digestEl.appendChild(dCard);
+            }
+        }
+
+        // ── Signature cards ──
+        container.innerHTML = '';
+        if (!hasDigest) {
+            if (addButton) { addButton.hidden = true; }
+            return;
+        }
+
+        if (signatures.length === 0) {
+            var note = makeCard('info');
+            note.appendChild(makeStatus('No signatures \u2014 digest only', 'info'));
+            container.appendChild(note);
+        }
+
+        var cryptoUnavailable = dv && dv.unavailable;
+        for (var i = 0; i < signatures.length; i++) {
+            var sig = signatures[i];
+            var fingerprint = await util.publicKeyFingerprint(sig.publicKeyJwk);
+            var signedAt = sig.signedAt ? util.formatISOWithTZ(sig.signedAt) : 'Unknown';
+            var result = results.find(function (r) { return r.index === i; });
+            var ok = result ? result.valid : false;
+            var digestBad = dv && !dv.match && !cryptoUnavailable;
+            var pass = ok && !digestBad;
+
+            var sigLabel = sig.label || ('Signature ' + (i + 1));
+            var cardType = cryptoUnavailable ? 'info' : (pass ? 'ok' : 'fail');
+            var sCard = makeCard(cardType);
+            if (cryptoUnavailable) {
+                sCard.appendChild(makeStatus(sigLabel + ' \u2014 verification unavailable', 'info'));
+            } else {
+                sCard.appendChild(makeStatus(
+                    (pass ? '\u2713 ' + sigLabel + ' Verified' : '\u2717 ' + sigLabel + ' Failed Verification'),
+                    pass ? 'ok' : 'fail'
+                ));
+            }
+            sCard.appendChild(makeDetail('Key: <code>' + (fingerprint || 'Unknown') + '</code>'));
+            sCard.appendChild(makeDetail(signedAt));
+            container.appendChild(sCard);
+        }
+
+        if (addButton) { addButton.hidden = false; }
+    };
+
+    security.deleteSignature = async function deleteSignature(index) {
+        if (!confirm('Delete this signature?')) { return; }
+        try {
+            var data = json.parse();
+            var envelope = data.envelope || {};
+            var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+            signatures.splice(index, 1);
+            envelope.signatures = signatures;
+            json.setData({ envelope: envelope, payload: data.payload, presentation: data.presentation });
+            await security.verifySignatureIfPresent();
+            if (app.modules.data && app.modules.data.setStatus) {
+                app.modules.data.setStatus('Signature deleted', 'success');
+            }
+        } catch (err) {
+            console.error('[transmittal] failed to delete signature', err);
+            alert('Failed to delete signature: ' + (err && err.message ? err.message : err));
+        }
+    };
+
+    security.addSignature = async function addSignature(options) {
+        var opts = options || {};
+        var label = opts.label || '';
+        try {
+            var data = json.parse();
+            var envelope = data.envelope || {};
+            var payload = data.payload || {};
+
+            if (!envelope.digest) {
+                alert('Cannot add signature: document must be published first (needs digest).');
+                return;
+            }
+
+            var jwk = await security.pickSigningKey();
+            if (!jwk || jwk.kty !== 'EC') { return; }
+
+            var sigResult = await util.signEnvelope(envelope, jwk);
+            var publicJwk = security.derivePublicFromPrivate(jwk);
+
+            var sigEntry = {
+                signature: sigResult.signature,
+                signedAt: sigResult.signedAt,
+                publicKeyJwk: publicJwk
+            };
+            if (label) { sigEntry.label = label; }
+
+            var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+            signatures.push(sigEntry);
+
+            envelope.signatures = signatures;
+            json.setData({ envelope: envelope, payload: payload, presentation: data.presentation });
+            await security.verifySignatureIfPresent();
+
+            // Persist by downloading updated HTML
+            var publish = app.modules.publish;
+            if (publish && publish.buildHtmlString) {
+                var html = await publish.buildHtmlString();
+                var dataModule = app.modules.data;
+                var filename = dataModule && dataModule.buildFileName
+                    ? dataModule.buildFileName(payload, { extension: 'html' })
+                    : 'transmittal.html';
+                util.downloadBlob(filename, new Blob([html], { type: 'text/html' }), 'text/html');
+            }
+
+            var statusMsg = (label ? label : 'Signature') + ' added \u2014 download triggered';
+            if (app.modules.data && app.modules.data.setStatus) {
+                app.modules.data.setStatus(statusMsg, 'success');
+            }
+        } catch (err) {
+            console.error('[transmittal] failed to add signature', err);
+            alert('Failed to add signature: ' + (err && err.message ? err.message : err));
+        }
+    };
+
+    security.verifyPayloadSignature = async function verifyPayloadSignature(payloadStr, signatureB64, publicJwk) {
+        if (!signatureB64 || !publicJwk) {
+            return false;
+        }
+        try {
+            const key = await window.crypto.subtle.importKey(
+                'jwk',
+                publicJwk,
+                { name: 'ECDSA', namedCurve: 'P-256' },
+                false,
+                ['verify']
+            );
+            const signatureBuffer = util.base64ToArrayBuffer(signatureB64);
+            const ok = await window.crypto.subtle.verify(
+                { name: 'ECDSA', hash: { name: 'SHA-256' } },
+                key,
+                signatureBuffer,
+                new TextEncoder().encode(payloadStr)
+            );
+            return !!ok;
+        } catch (err) {
+            console.warn('[transmittal] verify error', err);
+            return false;
+        }
+    };
+
+    security.verifySignatureIfPresent = async function verifySignatureIfPresent() {
+        try {
+            var data = json.parse();
+            var envelope = data.envelope || {};
+            var payload = data.payload || {};
+            var signatures = Array.isArray(envelope.signatures) ? envelope.signatures : [];
+            var hasDigest = !!(envelope.digest);
+
+            if (!hasDigest) {
+                app.data.digestVerified = null;
+                app.data.signatureVerificationResults = [];
+                await security.renderSignaturesList();
+                return;
+            }
+
+            if (!util.hasCrypto()) {
+                app.data.digestVerified = { match: false, unavailable: true };
+                app.data.signatureVerificationResults = [];
+                await security.renderSignaturesList();
+                return;
+            }
+
+            // Verify digest matches payload
+            var payloadStr = util.canonicalStringify(payload);
+            var computedDigest = await util.hashString(payloadStr);
+            var digestMatch = envelope.digest && computedDigest &&
+                (String(envelope.digest).toLowerCase() === computedDigest.toLowerCase());
+
+            app.data.digestVerified = {
+                match: digestMatch,
+                expected: envelope.digest,
+                computed: computedDigest
+            };
+
+            if (!digestMatch || signatures.length === 0) {
+                app.data.signatureVerificationResults = [];
+                await security.renderSignaturesList();
+                return;
+            }
+
+            // Reconstruct the envelope that was signed (without signatures)
+            var envelopeToVerify = {
+                version: envelope.version || 1,
+                digestAlgorithm: envelope.digestAlgorithm || app.constants.digestAlgorithm,
+                digest: envelope.digest,
+                digestedAt: envelope.digestedAt,
+                signatureAlgorithm: envelope.signatureAlgorithm || app.constants.signatureAlgorithm
+            };
+            var envelopeStr = util.canonicalStringify(envelopeToVerify);
+
+            var results = [];
+            for (var i = 0; i < signatures.length; i++) {
+                var sig = signatures[i];
+                var signatureOk = await security.verifyPayloadSignature(envelopeStr, sig.signature, sig.publicKeyJwk);
+                results.push({
+                    index: i,
+                    valid: signatureOk,
+                    publicKey: sig.publicKeyJwk,
+                    signedAt: sig.signedAt
+                });
+            }
+
+            app.data.signatureVerificationResults = results;
+            await security.renderSignaturesList();
+        } catch (err) {
+            console.error('[transmittal] signature verification failed', err);
+            app.data.digestVerified = { match: false, error: true };
+            app.data.signatureVerificationResults = [];
+            await security.renderSignaturesList();
+        }
+    };
+
+    security.derivePublicFromPrivate = function derivePublicFromPrivate(jwk) {
+        if (!jwk) {
+            return null;
+        }
+        if (jwk.x && jwk.y) {
+            return {
+                kty: jwk.kty || 'EC',
+                crv: jwk.crv || 'P-256',
+                x: jwk.x,
+                y: jwk.y,
+                ext: true
+            };
+        }
+        return null;
+    };
+
+    security.pickSigningKey = function pickSigningKey() {
+        return new Promise(function (resolve, reject) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = '.zddc-key';
+            input.addEventListener('change', async function () {
+                try {
+                    var file = input.files && input.files[0];
+                    if (!file) { resolve(null); return; }
+                    var text = await file.text();
+                    var jwk = await util.loadKeyFile(text, security.promptForPassword);
+                    resolve(jwk);
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            input.click();
+        });
+    };
+
+    security.promptForPassword = function promptForPassword(fingerprint) {
+        return new Promise(function (resolve) {
+            var pw = window.prompt(
+                fingerprint
+                    ? 'Enter password for key ' + fingerprint + ':'
+                    : 'Enter key password:'
+            );
+            resolve(pw);
+        });
+    };
+
+    app.registerInit(function () {
+        const addSigButton = dom.qs('#add-signature-btn');
+        if (addSigButton) {
+            addSigButton.addEventListener('click', function() {
+                security.addSignature();
+            });
+        }
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var util = app.util;
+
+    var verification = app.modules.verification = {};
+
+    // ── Directory scanning for file hash verification ────
+    verification.scanDirectoryForFiles = async function scanDirectoryForFiles(dirHandle, basePath) {
+        var base = basePath || '';
+        var files = [];
+
+        for await (var entry of dirHandle.values()) {
+            if (entry.kind === 'file') {
+                var file = await entry.getFile();
+                var sha256 = await util.hashFile(file);
+                var path = base ? base + '/' + entry.name : entry.name;
+                files.push({ name: entry.name, path: path, sha256: sha256, size: file.size });
+            } else if (entry.kind === 'directory') {
+                var subPath = base ? base + '/' + entry.name : entry.name;
+                var subFiles = await verification.scanDirectoryForFiles(entry, subPath);
+                for (var j = 0; j < subFiles.length; j++) { files.push(subFiles[j]); }
+            }
+        }
+
+        return files;
+    };
+
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const json = app.json;
+
+    const dataModule = app.modules.data = {};
+
+    const STATUS_DISPLAY_MS = 6000;
+    let statusTimer = null;
+
+    function qs(selector) {
+        return dom.qs(selector);
+    }
+
+    function setStatus(message, type) {
+        const element = qs('#data-status');
+        if (!element) {
+            return;
+        }
+        element.textContent = message || '';
+        element.dataset.statusType = type || '';
+        element.classList.remove('text-red-600', 'text-green-600');
+        if (type === 'success') {
+            element.classList.add('text-green-600');
+        } else if (type === 'error') {
+            element.classList.add('text-red-600');
+        }
+        if (statusTimer) {
+            clearTimeout(statusTimer);
+        }
+        if (message) {
+            statusTimer = setTimeout(function () {
+                element.textContent = '';
+                element.classList.remove('text-red-600', 'text-green-600');
+            }, STATUS_DISPLAY_MS);
+        }
+    }
+
+    const INVALID_FILENAME_CHARS = /[\\/:*?"<>|]+/g;
+
+    function sanitizeFilenameSegment(value, fallback) {
+        const trimmed = (value || '').toString().trim();
+        if (!trimmed) {
+            return fallback || '';
+        }
+        return trimmed
+            .replace(INVALID_FILENAME_CHARS, '-')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+
+    function sanitizeTitle(value) {
+        const sanitized = sanitizeFilenameSegment(value, 'Transmittal');
+        return sanitized || 'Transmittal';
+    }
+
+    function sanitizeTracking(value) {
+        const sanitized = sanitizeFilenameSegment(value, 'TRANS');
+        return sanitized.replace(/[_\s]+/g, '-');
+    }
+
+    function sanitizeStatus(value, fallback) {
+        const sanitized = sanitizeFilenameSegment(value, fallback || '');
+        const cleaned = sanitized.replace(/[()]/g, '').trim();
+        if (cleaned) {
+            return cleaned;
+        }
+        return (fallback || 'Unspecified');
+    }
+
+    function sanitizeDate(value) {
+        const trimmed = (value || '').toString().trim();
+        if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+            return trimmed;
+        }
+        if (!trimmed) {
+            return '0000-00-00';
+        }
+        return trimmed.replace(/\s+/g, '-');
+    }
+
+    // Folder name: DATE_TRACKING (STATUS) - Title  (date first for chronological sort)
+    dataModule.buildFolderName = function buildFolderName(payload) {
+        const p = payload || {};
+        const date = sanitizeDate(p.date || '');
+        const tracking = sanitizeTracking(p.trackingNumber || '');
+        const status = sanitizeStatus(p.status || p.purpose || '', 'Unspecified');
+        const title = sanitizeTitle(p.subject || p.title || '');
+        const statusPart = status ? ' (' + status + ')' : '';
+        return date + '_' + tracking + statusPart + ' - ' + title;
+    };
+
+    // File name: TRACKING_[~]DATE (STATUS) - Subject.ext
+    // draft: true → ~DATE (tilde prefix indicates draft)
+    dataModule.buildFileName = function buildFileName(payload, options) {
+        const p = payload || {};
+        const opts = options || {};
+        const ext = opts.extension ? opts.extension.replace(/^\.+/, '') : 'json';
+        const isDraft = !!opts.draft;
+        const tracking = sanitizeTracking(p.trackingNumber || '');
+        const date = sanitizeDate(p.date || '');
+        const status = sanitizeStatus(p.status || p.purpose || '', 'Unspecified');
+        const title = sanitizeTitle(p.subject || p.title || '');
+        const statusPart = status ? ' (' + status + ')' : '';
+        const datePrefix = isDraft ? '~' : '';
+        return tracking + '_' + datePrefix + date + statusPart + ' - ' + title + '.' + ext;
+    };
+
+    async function saveFileWithPicker(filename, contents, mime) {
+        if (typeof window.showSaveFilePicker !== 'function') {
+            app.util.downloadBlob(filename, contents, mime);
+            return filename;
+        }
+        const handle = await window.showSaveFilePicker({
+            suggestedName: filename,
+            types: [
+                {
+                    description: mime || 'File',
+                    accept: { [mime || 'application/octet-stream']: ['.' + zddc.splitExtension(filename).extension] }
+                }
+            ]
+        });
+        const writable = await handle.createWritable();
+        await writable.write(new Blob([contents], { type: mime || 'application/octet-stream' }));
+        await writable.close();
+        return handle.name || filename;
+    }
+
+    async function serializeUiToJson() {
+        if (!app.modules.publish || typeof app.modules.publish.syncUiToJson !== 'function') {
+            throw new Error('Publish module not ready');
+        }
+        await app.modules.publish.syncUiToJson({ sign: false, computeDigest: false });
+        app.state.dirty = false;
+    }
+
+    // ── Extract JSON from an HTML transmittal string ────
+    function extractJsonFromHtml(htmlText) {
+        var m = htmlText.match(new RegExp('<script\\s+id\\s*=\\s*["\']transmittal-data["\'][^>]*>([\\s\\S]*?)</' + 'script>', 'i'));
+        if (!m || !m[1]) { return null; }
+        try {
+            var data = JSON.parse(m[1]);
+            if (data && typeof data === 'object' && data.payload) { return data; }
+        } catch (_) { /* not valid JSON */ }
+        return null;
+    }
+
+    function pickHtmlFile() {
+        if (typeof window.showOpenFilePicker === 'function') {
+            return window.showOpenFilePicker({
+                multiple: false,
+                types: [{ description: 'HTML Files', accept: { 'text/html': ['.html', '.htm'] } }]
+            }).then(function (handles) {
+                var handle = handles[0];
+                return handle.getFile().then(function (file) {
+                    return { file: file, name: handle.name || file.name || 'import.html' };
+                });
+            });
+        }
+        return new Promise(function (resolve, reject) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = 'text/html,.html,.htm';
+            input.addEventListener('change', function () {
+                var file = input.files && input.files[0];
+                if (!file) { reject(new Error('No file selected')); return; }
+                resolve({ file: file, name: file.name || 'import.html' });
+            });
+            input.click();
+        });
+    }
+
+    async function handleImportHtml() {
+        try {
+            var picked = await pickHtmlFile();
+            var text = await picked.file.text();
+            var data = extractJsonFromHtml(text);
+            if (!data) { throw new Error('No valid transmittal data found in this HTML file'); }
+            await applyLoadedData(data, picked.name || 'import.html');
+        } catch (err) {
+            if (err && (err.name === 'AbortError' || err.name === 'NotAllowedError')) { return; }
+            console.error('[transmittal] import-html failed', err);
+            setStatus('Failed to import HTML: ' + (err && err.message ? err.message : err), 'error');
+        }
+    }
+
+    async function applyLoadedData(data, sourceName) {
+        json.setData(data);
+        app.modules.files.loadFromJson();
+        app.state.mode = 'edit';
+        app.state.dirty = false;
+        if (app.modules.visibility && app.modules.visibility.applyFieldVisibility) {
+            app.modules.visibility.applyFieldVisibility();
+        }
+        await app.modules.security.verifySignatureIfPresent();
+        if (app.modules.security.renderSignaturesList) {
+            await app.modules.security.renderSignaturesList();
+        }
+        app.modules.mode.refresh();
+        app.state.apply();
+        if (app.modules.liveDigest && app.modules.liveDigest.schedule) {
+            app.modules.liveDigest.schedule();
+        }
+        setStatus('Loaded: ' + sourceName, 'success');
+    }
+
+    app.onDirty(function () {
+        setStatus('Unsaved changes', 'info');
+    });
+
+    async function handleLoadFromClipboard() {
+        try {
+            var text = await navigator.clipboard.readText();
+            if (!text || !text.trim()) {
+                setStatus('Clipboard is empty', 'error');
+                return;
+            }
+            var data = JSON.parse(text.trim());
+            if (!data || typeof data !== 'object' || !data.payload) {
+                throw new Error('Invalid ZDDC JSON data');
+            }
+            await applyLoadedData(data, 'clipboard');
+        } catch (err) {
+            console.error('[transmittal] load-from-clipboard failed', err);
+            if (err && err.name === 'NotAllowedError') {
+                setStatus('Clipboard access denied — please paste manually', 'error');
+            } else {
+                setStatus('Failed to load from clipboard: ' + (err && err.message ? err.message : err), 'error');
+            }
+        }
+    }
+
+    async function handleCopyJson() {
+        try {
+            await serializeUiToJson();
+            var data = json.parse();
+            var text = JSON.stringify(data, null, 2);
+            await navigator.clipboard.writeText(text);
+            setStatus('JSON copied to clipboard', 'success');
+        } catch (err) {
+            console.error('[transmittal] copy-json failed', err);
+            if (err && err.name === 'NotAllowedError') {
+                setStatus('Clipboard access denied', 'error');
+            } else {
+                setStatus('Failed to copy JSON: ' + (err && err.message ? err.message : err), 'error');
+            }
+        }
+    }
+
+    async function handleSaveHtmlDraft() {
+        try {
+            var pub = app.modules.publish;
+            if (!pub || typeof pub.syncUiToJson !== 'function' || typeof pub.buildHtmlString !== 'function') {
+                throw new Error('Publish module not ready');
+            }
+            await pub.syncUiToJson({ sign: false, computeDigest: false });
+            var html = await pub.buildHtmlString();
+            var data = json.parse();
+            var payload = (data && data.payload) || {};
+            var filename = dataModule.buildFileName(payload, { extension: 'html', draft: true });
+            await saveFileWithPicker(filename, html, 'text/html');
+            setStatus('Saved draft as ' + filename, 'success');
+        } catch (err) {
+            console.error('[transmittal] save-html-draft failed', err);
+            setStatus('Failed to save draft: ' + (err && err.message ? err.message : err), 'error');
+        }
+    }
+
+    async function handleCopyTable() {
+        try {
+            var TAB = '\t';
+            var NL = '\r\n';
+            var esc = app.util.escapeHtml;
+            var textStyle = ' style="mso-number-format:\'\\@\'"';
+            var headers = ['#', 'TRACKING NUMBER', 'TITLE', 'REVISION', 'STATUS', 'EXT', 'SIZE', 'SHA256'];
+            var headerTsv = headers.join(TAB);
+            var headerHtml = '<tr>' + headers.map(function (h) { return '<th' + textStyle + '>' + esc(h) + '</th>'; }).join('') + '</tr>';
+            var tsvLines = [headerTsv];
+            var htmlRows = [headerHtml];
+
+            function addRow(cells) {
+                tsvLines.push(cells.join(TAB));
+                htmlRows.push('<tr>' + cells.map(function (c) { return '<td' + textStyle + '>' + esc(c) + '</td>'; }).join('') + '</tr>');
+            }
+
+            // Row 0: self-entry
+            var filesModule = app.modules.files;
+            var self = filesModule && filesModule.buildSelfEntry ? filesModule.buildSelfEntry() : null;
+            if (self) {
+                addRow(['0', self.trackingNumber || '', self.title || '', self.revision || '', self.status || '', 'html', '\u2014', 'see above']);
+            }
+
+            // Regular files
+            var files = Array.isArray(app.data.files) ? app.data.files : [];
+            for (var i = 0; i < files.length; i++) {
+                var f = files[i];
+                var size = (f.fileSize != null ? f.fileSize : f.size);
+                addRow([
+                    String(i + 1),
+                    f.trackingNumber || '',
+                    f.title || '',
+                    f.revision || '',
+                    f.status || '',
+                    (f.extension || '').toLowerCase(),
+                    size ? String(size) : '',
+                    f.sha256 || ''
+                ]);
+            }
+
+            var plainText = tsvLines.join(NL);
+            var html = '<table>' + htmlRows.join('') + '</table>';
+            await navigator.clipboard.write([
+                new ClipboardItem({
+                    'text/plain': new Blob([plainText], { type: 'text/plain' }),
+                    'text/html': new Blob([html], { type: 'text/html' })
+                })
+            ]);
+            setStatus('Table copied (' + files.length + ' files)', 'success');
+        } catch (err) {
+            console.error('[transmittal] copy-table failed', err);
+            setStatus('Failed to copy table: ' + (err && err.message ? err.message : err), 'error');
+        }
+    }
+
+    async function handleRevise() {
+        if (!confirm('This will create a new draft from the published transmittal. The digest and signatures will be removed. Continue?')) {
+            return;
+        }
+        var data = json.parse();
+        if (!data) { return; }
+        // Strip digest and signatures; preserve existing date for user to update
+        data.envelope = { version: 1, digestAlgorithm: app.constants.digestAlgorithm, digest: '', digestedAt: '', signatureAlgorithm: app.constants.signatureAlgorithm, signatures: [] };
+        json.setData(data);
+        app.modules.files.loadFromJson();
+        app.state.mode = 'edit';
+        app.state.published = false;
+        app.state.dirty = true;
+        app.modules.mode.refresh();
+        setStatus('Created new draft from published transmittal', 'success');
+    }
+
+    dataModule.extractJsonFromHtml = extractJsonFromHtml;
+    dataModule.setStatus = setStatus;
+    dataModule.serializeUiToJson = serializeUiToJson;
+    dataModule.handleLoadFromClipboard = handleLoadFromClipboard;
+    dataModule.handleCopyJson = handleCopyJson;
+    dataModule.handleCopyTable = handleCopyTable;
+    dataModule.handleSaveHtmlDraft = handleSaveHtmlDraft;
+    dataModule.handleRevise = handleRevise;
+    dataModule.handleImportHtml = handleImportHtml;
+    dataModule.applyLoadedData = applyLoadedData;
+    dataModule.buildFileName = dataModule.buildFileName || buildFileName;
+
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const util = app.util;
+    const json = app.json;
+    const security = app.modules.security;
+    const validation = app.modules.validation;
+    const filesModule = app.modules.files;
+    const dataModule = app.modules.data;
+    const mode = app.modules.mode;
+
+    async function syncUiToJson(options) {
+        const sign = !!(options && options.sign);
+        const computeDigest = !!(options && options.computeDigest);
+        
+        // First, sync UI to JSON to ensure JSON is up-to-date
+        filesModule.syncUiToJson();
+        
+        // Now use JSON as single source of truth
+        const data = json.parse();
+        const previousEnvelope = (data && data.envelope) || {};
+        const payload = (data && data.payload) || {};
+        const previousPresentation = (data && data.presentation) || {};
+        const payloadStr = util.canonicalStringify(payload);
+        const previousPayloadStr = util.canonicalStringify(payload);
+        const payloadChanged = false; // Always false since we just synced
+
+        let digest = previousEnvelope.digest || '';
+        let digestedAt = previousEnvelope.digestedAt || '';
+        let signatures = Array.isArray(previousEnvelope.signatures) ? previousEnvelope.signatures.slice() : [];
+
+        let computedDigest = '';
+        if (sign || computeDigest || payloadChanged || !digest) {
+            try {
+                computedDigest = await util.hashString(payloadStr);
+            } catch (err) {
+                computedDigest = '';
+            }
+        }
+
+        if (sign || computeDigest) {
+            if (!computedDigest) {
+                throw new Error('Unable to compute digest.');
+            }
+            digest = computedDigest;
+            digestedAt = util.fetchTrustedTime();
+        }
+        
+        if (sign) {
+            const jwk = options && options.signingKey;
+            if (!jwk || jwk.kty !== 'EC') {
+                throw new Error('A valid EC private key (JWK) is required to sign this transmittal.');
+            }
+            const envelopeForSigning = {
+                version: 1,
+                digestAlgorithm: app.constants.digestAlgorithm,
+                digest: digest,
+                digestedAt: digestedAt,
+                signatureAlgorithm: app.constants.signatureAlgorithm
+            };
+            const sigResult = await util.signEnvelope(envelopeForSigning, jwk);
+            const publicJwk = security.derivePublicFromPrivate(jwk);
+            signatures.push({
+                signature: sigResult.signature,
+                signedAt: sigResult.signedAt,
+                publicKeyJwk: publicJwk
+            });
+        }
+
+        const envelope = {
+            version: 1,
+            digestAlgorithm: app.constants.digestAlgorithm,
+            digest: digest,
+            digestedAt: digestedAt,
+            signatureAlgorithm: app.constants.signatureAlgorithm,
+            signatures: signatures
+        };
+        const presentation = previousPresentation;
+        json.setData({ envelope: envelope, payload: payload, presentation: presentation });
+        if (computeDigest || sign) {
+            try {
+                await security.verifySignatureIfPresent();
+            } catch (_) {
+                // ignore
+            }
+            app.state.apply();
+        }
+        app.state.dirty = false;
+    }
+
+    async function buildHtmlString() {
+        // Hide editor before cloning so its markup is not in the output
+        var mdEditor = app.modules.markdownEditor;
+        var editorWasActive = mdEditor && mdEditor.isActive();
+        if (editorWasActive) { mdEditor.destroy(); }
+
+        // ── Preferred path: fetch the page's own source and patch the JSON ──
+        // This produces an exact copy of the original file with only the data
+        // changed, avoiding DOM-snapshot drift. Falls back to the DOM-snapshot
+        // approach when the page cannot fetch itself (e.g. opaque origins).
+        try {
+            var jsonData = app.json.parse();
+            var html = await util.fetchAndPatchHtml(jsonData);
+            if (editorWasActive && mdEditor && typeof mdEditor.showRendered === 'function') {
+                mdEditor.showRendered();
+            }
+            return html;
+        } catch (fetchErr) {
+            console.warn('[transmittal] fetch-based save unavailable, falling back to DOM snapshot:', fetchErr.message);
+        }
+
+        // ── Fallback path: DOM snapshot ─────────────────────────────────────
+        // Populate static content before cloning for progressive enhancement
+        if (app.modules.hydrate && app.modules.hydrate.populateStatic) {
+            await app.modules.hydrate.populateStatic();
+        }
+
+        // Remove any existing success notifications
+        var notifications = document.querySelectorAll('[data-publish-notification]');
+        notifications.forEach(function (notif) { notif.remove(); });
+
+        // Hide workflow edit-only steps before cloning (viewers shouldn't see them)
+        var workflowEditSteps = dom.qsa('.workflow-step[data-edit-only], .workflow-tools');
+        var wasVisible = [];
+        workflowEditSteps.forEach(function (el) {
+            wasVisible.push(!el.hidden);
+            el.hidden = true;
+        });
+
+        // Re-hide bottom menu and restore no-js notice before cloning
+        var bottomMenu = dom.qs('#bottom-menu');
+        var bottomMenuWasVisible = bottomMenu && !bottomMenu.hidden;
+        if (bottomMenu) { bottomMenu.hidden = true; }
+        var noJsNotice = dom.qs('#no-js-notice');
+        var addedNotice = false;
+        if (!noJsNotice && bottomMenu && bottomMenu.parentNode) {
+            noJsNotice = document.createElement('span');
+            noJsNotice.id = 'no-js-notice';
+            noJsNotice.className = 'text-gray-400 text-xs italic';
+            noJsNotice.textContent = 'JavaScript not available';
+            bottomMenu.parentNode.insertBefore(noJsNotice, bottomMenu.nextSibling);
+            addedNotice = true;
+        }
+
+        // Close any open dialogs before cloning (they get reopened after)
+        var openDialogs = Array.from(document.querySelectorAll('dialog[open]'));
+        openDialogs.forEach(function (dlg) { dlg.close(); });
+
+        var snapshotHtml = util.cloneDocumentHtml();
+
+        // Restore bottom menu visibility
+        if (bottomMenu && bottomMenuWasVisible) { bottomMenu.hidden = false; }
+        if (noJsNotice) { dom.show(noJsNotice, false); }
+
+        // Reopen dialogs that were open
+        openDialogs.forEach(function (dlg) { dlg.showModal(); });
+
+        // Restore workflow elements
+        workflowEditSteps.forEach(function (el, i) {
+            if (wasVisible[i]) { el.hidden = false; }
+        });
+
+        // Re-hydrate to restore dynamic state after cloning
+        if (app.modules.hydrate && app.modules.hydrate.hydrate) {
+            app.modules.hydrate.hydrate();
+        }
+
+        // Show rendered preview again (editor loads on next click)
+        if (mdEditor) { mdEditor.showRendered(); }
+
+        return snapshotHtml;
+    }
+
+    function requireDirectoryHandle() {
+        if (!app.data.selectedDirHandle) {
+            throw new Error('Select a directory before saving.');
+        }
+        return app.data.selectedDirHandle;
+    }
+
+    async function writeHtmlToDirectory(filename, html) {
+        requireDirectoryHandle();
+        await filesModule.writeFileToSelectedDir(filename, html, 'text/html');
+    }
+
+    function loadSigningKey(providedKey) {
+        if (providedKey) { return providedKey; }
+        throw new Error('A signing key is required. Select or generate one first.');
+    }
+
+    async function executePublish(config) {
+        const modeSelection = (config && config.mode) || 'digest';
+        const wantDownload = !!(config && config.download);
+        const wantSaveToFolder = !!(config && config.saveToFolder);
+
+        const validationResult = validation.validateBeforePublish();
+        if (!validationResult.ok) {
+            const error = new Error(validationResult.message || 'Validation failed before publishing.');
+            error.focusEl = validationResult.focusEl || null;
+            throw error;
+        }
+
+        if (wantSaveToFolder) {
+            requireDirectoryHandle();
+        }
+
+        const shouldSign = modeSelection === 'signed';
+        const shouldComputeDigest = modeSelection === 'signed' || modeSelection === 'digest';
+        const isDraft = modeSelection === 'draft';
+
+        let signingKey = null;
+        if (shouldSign) {
+            signingKey = await loadSigningKey(config && config.signingKey);
+        }
+
+        await syncUiToJson({
+            sign: shouldSign,
+            computeDigest: shouldComputeDigest,
+            signingKey: signingKey
+        });
+
+        mode.refresh();
+        const html = await buildHtmlString();
+        const data = json.parse();
+        const payload = (data && data.payload) || {};
+        const filename = dataModule.buildFileName(payload, { extension: 'html', draft: isDraft });
+
+        if (wantSaveToFolder) {
+            await writeHtmlToDirectory(filename, html);
+            // If publishing (not draft), delete the draft file from the directory
+            if (!isDraft) {
+                var draftName = dataModule.buildFileName(payload, { extension: 'html', draft: true });
+                if (draftName !== filename) {
+                    try {
+                        await app.data.selectedDirHandle.removeEntry(draftName);
+                    } catch (_) {
+                        // Draft file may not exist — that's fine
+                    }
+                }
+            }
+        }
+        if (wantDownload) {
+            util.downloadBlob(filename, new Blob([html], { type: 'text/html' }), 'text/html');
+        }
+        mode.refresh();
+        dataModule.setStatus('Published HTML as ' + filename, 'success');
+
+        return {
+            filename: filename,
+            mode: modeSelection
+        };
+    }
+
+    app.modules.publish = {
+        syncUiToJson,
+        buildHtmlString,
+        executePublish
+    };
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    var dom = app.dom;
+    var json = app.json;
+    var filesModule = app.modules.files;
+    var security = app.modules.security;
+
+    function originalEmptyData() {
+        return {
+            envelope: {
+                version: 1,
+                digestAlgorithm: app.constants.digestAlgorithm,
+                digest: '',
+                digestedAt: '',
+                signatureAlgorithm: app.constants.signatureAlgorithm,
+                signatures: []
+            },
+            payload: {
+                version: 1,
+                type: 'Transmittal',
+                title: '',
+                client: '',
+                project: '',
+                projectNumber: '',
+                date: '',
+                trackingNumber: '',
+                from: '',
+                to: '',
+                purpose: '',
+                responseDue: '',
+                subject: '',
+                remarks: '',
+                files: []
+            },
+            presentation: {
+                leftLogo: '',
+                rightLogo: '',
+                theme: 'default',
+                customCss: ''
+            }
+        };
+    }
+
+    async function handleReset() {
+        if (!confirm('Reset will clear all data. Continue?')) {
+            return;
+        }
+        json.setData(originalEmptyData());
+
+        // Clear logos in DOM
+        var leftLogo = dom.qs('#left-logo');
+        var rightLogo = dom.qs('#right-logo');
+        if (leftLogo) { leftLogo.src = ''; }
+        if (rightLogo) { rightLogo.src = ''; }
+
+        // Clear runtime state
+        app.data.files = [];
+        app.data.selectedDirHandle = null;
+        app.data.selectedDirName = '';
+
+        filesModule.loadFromJson();
+        app.state.mode = 'edit';
+        app.state.published = false;
+        app.state.dirty = false;
+        if (security.renderSignaturesList) {
+            security.renderSignaturesList();
+        }
+        if (app.modules.mode && app.modules.mode.refresh) {
+            app.modules.mode.refresh();
+        }
+        app.state.apply();
+        if (app.modules.liveDigest && app.modules.liveDigest.schedule) {
+            app.modules.liveDigest.schedule();
+        }
+    }
+
+    app.modules.reset = {
+        handleReset: handleReset
+    };
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    if (!app || !app.dom || !app.modules) {
+        console.error('[publish-modal] App not properly initialized');
+        return;
+    }
+
+    var dom = app.dom;
+    var util = app.util;
+
+    function qs(sel) { return dom.qs(sel); }
+
+    // ── Date helpers ────────────────────────────────────
+    function getTodayIso() {
+        var d = new Date();
+        return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
+    }
+
+    function toIsoDate(str) {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(str)) { return str; }
+        var d = new Date(str);
+        if (isNaN(d.getTime())) { return str; }
+        return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
+    }
+
+    function syncDateWarning() {
+        var dateInput = qs('#publish-date-input');
+        var warning = qs('#publish-date-warning');
+        if (!dateInput || !warning) { return; }
+        var val = (dateInput.value || '').trim();
+        var today = getTodayIso();
+        if (!val || val === today) {
+            warning.textContent = '';
+            warning.hidden = true;
+        } else {
+            warning.textContent = '\u26A0 Date differs from today (' + today + ')';
+            warning.hidden = false;
+        }
+    }
+
+    // ── Feedback helpers ────────────────────────────────
+    function showFeedback(feedbackEl, message, type) {
+        if (!feedbackEl) { return; }
+        feedbackEl.textContent = message || '';
+        feedbackEl.style.color = type === 'error' ? '#dc2626' : type === 'success' ? '#16a34a' : '';
+    }
+
+    // ── Success notification ────────────────────────────
+    function showSuccessNotification(filename) {
+        var notification = document.createElement('div');
+        notification.className = 'publish-notification';
+        notification.setAttribute('data-publish-notification', 'true');
+
+        var title = document.createElement('div');
+        title.className = 'publish-notification__title';
+        title.textContent = '\u2713 Transmittal Published Successfully';
+
+        var file = document.createElement('div');
+        file.className = 'publish-notification__file';
+        file.textContent = 'Saved as: ' + filename;
+
+        var closeBtn = document.createElement('button');
+        closeBtn.className = 'publish-notification__close';
+        closeBtn.textContent = 'Close';
+        closeBtn.addEventListener('click', function () { notification.remove(); });
+
+        notification.appendChild(title);
+        notification.appendChild(file);
+        notification.appendChild(closeBtn);
+        document.body.appendChild(notification);
+        setTimeout(function () { if (notification.parentElement) { notification.remove(); } }, 10000);
+    }
+
+    // ── Password dialog ─────────────────────────────────
+    function promptForPassword(fingerprint) {
+        return new Promise(function (resolve) {
+            var dialog = qs('#password-dialog');
+            var input = qs('#password-dialog-input');
+            var okBtn = qs('#password-dialog-ok');
+            var feedback = qs('#password-dialog-feedback');
+            var fpEl = qs('#password-dialog-fingerprint');
+            if (!dialog || !input || !okBtn) { resolve(null); return; }
+
+            input.value = '';
+            showFeedback(feedback, '', '');
+            if (fpEl) {
+                fpEl.textContent = fingerprint ? 'Key fingerprint: ' + fingerprint : 'This key is password-protected.';
+            }
+            dialog.showModal();
+            input.focus();
+
+            function cleanup() {
+                okBtn.removeEventListener('click', onOk);
+                dialog.removeEventListener('close', onClose);
+            }
+            function onOk() {
+                var pw = input.value;
+                cleanup();
+                dialog.close();
+                resolve(pw);
+            }
+            function onClose() {
+                cleanup();
+                resolve(null);
+            }
+            okBtn.addEventListener('click', onOk);
+            dialog.addEventListener('close', onClose);
+
+            // Enter key submits
+            input.addEventListener('keydown', function handler(e) {
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    input.removeEventListener('keydown', handler);
+                    onOk();
+                }
+            });
+        });
+    }
+
+    // ── Key dialog ──────────────────────────────────────
+    function openKeyDialog() {
+        return new Promise(function (resolve) {
+            var dialog = qs('#key-dialog');
+            var selectBtn = qs('#key-select-file');
+            var generateBtn = qs('#key-generate');
+            var generatePanel = qs('#key-generate-panel');
+            var genConfirmBtn = qs('#key-generate-confirm');
+            var genCancelBtn = qs('#key-generate-cancel');
+            var pwInput = qs('#key-password');
+            var pwConfirm = qs('#key-password-confirm');
+            var feedback = qs('#key-dialog-feedback');
+            if (!dialog) { resolve(null); return; }
+
+            // Reset state
+            if (generatePanel) { generatePanel.hidden = true; }
+            if (pwInput) { pwInput.value = ''; }
+            if (pwConfirm) { pwConfirm.value = ''; }
+            showFeedback(feedback, '', '');
+            dialog.showModal();
+
+            var resolved = false;
+            function done(jwk) {
+                if (resolved) { return; }
+                resolved = true;
+                cleanup();
+                if (dialog.open) { dialog.close(); }
+                resolve(jwk);
+            }
+            function cleanup() {
+                if (selectBtn) { selectBtn.removeEventListener('click', onSelect); }
+                if (generateBtn) { generateBtn.removeEventListener('click', onGenerate); }
+                if (genConfirmBtn) { genConfirmBtn.removeEventListener('click', onGenConfirm); }
+                if (genCancelBtn) { genCancelBtn.removeEventListener('click', onGenCancel); }
+                dialog.removeEventListener('close', onDialogClose);
+            }
+
+            function onDialogClose() { done(null); }
+
+            async function onSelect() {
+                try {
+                    var security = app.modules.security;
+                    var jwk = await pickKeyFileWithPassword();
+                    if (jwk) { done(jwk); }
+                } catch (err) {
+                    showFeedback(feedback, 'Failed to load key: ' + (err.message || err), 'error');
+                }
+            }
+
+            function onGenerate() {
+                if (generatePanel) { generatePanel.hidden = false; }
+                if (generateBtn) { generateBtn.hidden = true; }
+                if (selectBtn) { selectBtn.hidden = true; }
+            }
+
+            function onGenCancel() {
+                if (generatePanel) { generatePanel.hidden = true; }
+                if (generateBtn) { generateBtn.hidden = false; }
+                if (selectBtn) { selectBtn.hidden = false; }
+                if (pwInput) { pwInput.value = ''; }
+                if (pwConfirm) { pwConfirm.value = ''; }
+            }
+
+            async function onGenConfirm() {
+                var pw = pwInput ? pwInput.value : '';
+                var pwc = pwConfirm ? pwConfirm.value : '';
+                if (pw && pw !== pwc) {
+                    showFeedback(feedback, 'Passwords do not match.', 'error');
+                    return;
+                }
+                try {
+                    showFeedback(feedback, 'Generating key\u2026', '');
+                    var security = app.modules.security;
+                    var keys = await window.crypto.subtle.generateKey(
+                        { name: 'ECDSA', namedCurve: 'P-256' }, true, ['sign', 'verify']
+                    );
+                    var privateJwk = await window.crypto.subtle.exportKey('jwk', keys.privateKey);
+                    var publicJwk = security.derivePublicFromPrivate(privateJwk);
+                    var fingerprint = await util.publicKeyFingerprint(publicJwk);
+
+                    var keyFileData;
+                    if (pw) {
+                        keyFileData = await util.encryptPrivateKey(privateJwk, pw, fingerprint);
+                    } else {
+                        keyFileData = util.wrapKeyFile(privateJwk, fingerprint);
+                    }
+                    util.downloadBlob('signing-key.zddc-key', JSON.stringify(keyFileData, null, 2), 'application/json');
+                    showFeedback(feedback, 'Key downloaded. Fingerprint: ' + (fingerprint || '(unknown)'), 'success');
+                    done(privateJwk);
+                } catch (err) {
+                    showFeedback(feedback, 'Failed to generate key: ' + (err.message || err), 'error');
+                }
+            }
+
+            if (selectBtn) { selectBtn.addEventListener('click', onSelect); }
+            if (generateBtn) { generateBtn.addEventListener('click', onGenerate); }
+            if (genConfirmBtn) { genConfirmBtn.addEventListener('click', onGenConfirm); }
+            if (genCancelBtn) { genCancelBtn.addEventListener('click', onGenCancel); }
+            dialog.addEventListener('close', onDialogClose);
+        });
+    }
+
+    // ── Pick key file with automatic password prompt ────
+    function pickKeyFileWithPassword() {
+        return new Promise(function (resolve, reject) {
+            var input = document.createElement('input');
+            input.type = 'file';
+            input.accept = '.zddc-key';
+            input.addEventListener('change', async function () {
+                try {
+                    var file = input.files && input.files[0];
+                    if (!file) { resolve(null); return; }
+                    var text = await file.text();
+                    var jwk = await util.loadKeyFile(text, promptForPassword);
+                    resolve(jwk);
+                } catch (err) {
+                    reject(err);
+                }
+            });
+            input.click();
+        });
+    }
+
+    // ── Output checkbox helpers ───────────────────────────
+    function readOutputOptions() {
+        var saveCb = qs('#publish-save-folder');
+        var dlCb = qs('#publish-download-html');
+        return {
+            saveToFolder: saveCb && saveCb.checked,
+            download: dlCb && dlCb.checked
+        };
+    }
+
+    function syncOutputCheckboxes() {
+        var saveCb = qs('#publish-save-folder');
+        var dlCb = qs('#publish-download-html');
+        var hasDir = !!app.data.selectedDirHandle;
+        if (saveCb) { saveCb.checked = hasDir; }
+        if (dlCb) { dlCb.checked = !hasDir; }
+    }
+
+    function restoreOutputOptions(opts) {
+        var saveCb = qs('#publish-save-folder');
+        var dlCb = qs('#publish-download-html');
+        if (saveCb) { saveCb.checked = !!opts.saveToFolder; }
+        if (dlCb) { dlCb.checked = !!opts.download; }
+    }
+
+    function feedbackLabel(mode) {
+        if (mode === 'draft') { return 'Saving draft'; }
+        if (mode === 'signed') { return 'Signing and publishing'; }
+        return 'Publishing';
+    }
+
+    function setPublishBusy(busy) {
+        var btns = [qs('#publish-confirm'), qs('#publish-signed-btn'), qs('#publish-draft-btn')];
+        for (var i = 0; i < btns.length; i++) {
+            if (!btns[i]) { continue; }
+            btns[i].disabled = busy;
+            if (busy) { btns[i].classList.add('opacity-60'); }
+            else { btns[i].classList.remove('opacity-60'); }
+        }
+    }
+
+    // ── Core publish execution ──────────────────────────
+    async function executePublishFlow(mode, signingKey) {
+        var feedback = qs('#publish-modal-feedback');
+        var opts = readOutputOptions();
+
+        if (!opts.saveToFolder && !opts.download) {
+            throw new Error('Select at least one output option.');
+        }
+
+        // Prompt for directory if Save in directory is checked but none selected
+        if (opts.saveToFolder && !app.data.selectedDirHandle) {
+            try {
+                var dirHandle = await window.showDirectoryPicker({ mode: 'readwrite' });
+                app.data.selectedDirHandle = dirHandle;
+                if (app.modules.files && app.modules.files.updateDirectoryIndicator) {
+                    app.modules.files.updateDirectoryIndicator();
+                }
+            } catch (dirErr) {
+                throw new Error('A directory is required to save. Please select a directory.');
+            }
+        }
+
+        // Sync date from modal back to form
+        var dateInput = qs('#publish-date-input');
+        var formDate = qs('#date');
+        if (dateInput && formDate && dateInput.value) {
+            formDate.value = dateInput.value;
+        }
+
+        var publishModule = app.modules.publish;
+        if (!publishModule || typeof publishModule.executePublish !== 'function') {
+            throw new Error('Publish module not ready');
+        }
+
+        showFeedback(feedback, feedbackLabel(mode) + '\u2026', '');
+
+        var result = await publishModule.executePublish({
+            mode: mode,
+            saveToFolder: opts.saveToFolder,
+            download: opts.download,
+            signingKey: signingKey || null
+        });
+
+        return result;
+    }
+
+    // ── Publish modal ───────────────────────────────────
+    function initPublishModal() {
+        var modal = qs('#publish-modal');
+        if (!modal) { return; }
+
+        var feedback = qs('#publish-modal-feedback');
+        var confirmBtn = qs('#publish-confirm');
+        var signedBtn = qs('#publish-signed-btn');
+        var draftBtn = qs('#publish-draft-btn');
+        var dateInput = qs('#publish-date-input');
+
+        // Close buttons
+        modal.querySelectorAll('[data-modal-close]').forEach(function (btn) {
+            btn.addEventListener('click', function () {
+                if (modal.open) { modal.close(); }
+            });
+        });
+
+        // Backdrop click
+        modal.addEventListener('click', function (e) {
+            if (e.target === modal) { modal.close(); }
+        });
+
+        // Date warning
+        if (dateInput) { dateInput.addEventListener('input', syncDateWarning); }
+
+        function openModal() {
+            showFeedback(feedback, '', '');
+            syncOutputCheckboxes();
+            // Populate date
+            var formDate = qs('#date');
+            if (formDate && dateInput) {
+                var val = (formDate.value || '').trim();
+                dateInput.value = val ? toIsoDate(val) : getTodayIso();
+            }
+            syncDateWarning();
+            // Warn about missing hashes before user commits
+            var missingHash = 0;
+            (app.data.files || []).forEach(function (f) {
+                if (!f.sha256) { missingHash++; }
+            });
+            if (missingHash > 0) {
+                showFeedback(feedback, missingHash + ' file(s) have no SHA-256 hash.', 'error');
+            }
+            if (!modal.open) { modal.showModal(); }
+        }
+
+        function closeAndNotify(result) {
+            if (modal.open) { modal.close(); }
+            var msg = result.zipFilename ? result.filename + ' + ' + result.zipFilename : result.filename;
+            setTimeout(function () { showSuccessNotification(msg); }, 100);
+        }
+
+        function handleError(err) {
+            showFeedback(feedback, err && err.message ? err.message : 'Publish failed.', 'error');
+            if (err && err.focusEl && typeof err.focusEl.focus === 'function') {
+                if (modal.open) { modal.close(); }
+                err.focusEl.focus();
+                if (err.focusEl.scrollIntoView) { err.focusEl.scrollIntoView({ behavior: 'smooth', block: 'center' }); }
+            }
+        }
+
+        // Publish (unsigned with digest) — primary action
+        if (confirmBtn) {
+            confirmBtn.addEventListener('click', async function () {
+                setPublishBusy(true);
+                try {
+                    var result = await executePublishFlow('digest');
+                    setPublishBusy(false);
+                    closeAndNotify(result);
+                } catch (err) {
+                    setPublishBusy(false);
+                    handleError(err);
+                }
+            });
+        }
+
+        // Publish Signed — opens key dialog first
+        if (signedBtn) {
+            signedBtn.addEventListener('click', async function () {
+                // Save user's checkbox selections before closing
+                var savedOpts = readOutputOptions();
+                if (modal.open) { modal.close(); }
+
+                try {
+                    var jwk = await openKeyDialog();
+                    if (!jwk) { openModal(); restoreOutputOptions(savedOpts); return; }
+
+                    openModal();
+                    restoreOutputOptions(savedOpts);
+                    setPublishBusy(true);
+                    var result = await executePublishFlow('signed', jwk);
+                    setPublishBusy(false);
+                    closeAndNotify(result);
+                } catch (err) {
+                    setPublishBusy(false);
+                    openModal();
+                    restoreOutputOptions(savedOpts);
+                    handleError(err);
+                }
+            });
+        }
+
+        // Save Draft
+        if (draftBtn) {
+            draftBtn.addEventListener('click', async function () {
+                setPublishBusy(true);
+                try {
+                    var result = await executePublishFlow('draft');
+                    setPublishBusy(false);
+                    closeAndNotify(result);
+                } catch (err) {
+                    setPublishBusy(false);
+                    handleError(err);
+                }
+            });
+        }
+
+        // Listen for publish requests from the primary action button
+        document.addEventListener('transmittal:open-publish', function () {
+            openModal();
+        });
+    }
+
+    // ── Password dialog close buttons ───────────────────
+    function initPasswordDialog() {
+        var dialog = qs('#password-dialog');
+        if (!dialog) { return; }
+        dialog.querySelectorAll('[data-modal-close]').forEach(function (btn) {
+            btn.addEventListener('click', function () {
+                if (dialog.open) { dialog.close(); }
+            });
+        });
+        dialog.addEventListener('click', function (e) {
+            if (e.target === dialog) { dialog.close(); }
+        });
+    }
+
+    // ── Key dialog close buttons ────────────────────────
+    function initKeyDialog() {
+        var dialog = qs('#key-dialog');
+        if (!dialog) { return; }
+        dialog.querySelectorAll('[data-modal-close]').forEach(function (btn) {
+            btn.addEventListener('click', function () {
+                if (dialog.open) { dialog.close(); }
+            });
+        });
+        dialog.addEventListener('click', function (e) {
+            if (e.target === dialog) { dialog.close(); }
+        });
+    }
+
+    app.registerInit(function () {
+        initPublishModal();
+        initPasswordDialog();
+        initKeyDialog();
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    const dom = app.dom;
+    const logosModule = app.modules.logos = {};
+
+    // Read an image file and apply it as a logo.
+    // imgId: 'left-logo' or 'right-logo'
+    async function applyLogoFile(imgId, file) {
+        if (!file) { return; }
+        var img = dom.qs('#' + imgId);
+        if (!img) { return; }
+        try {
+            var dataUrl = await new Promise(function (resolve, reject) {
+                var reader = new FileReader();
+                reader.onload = function () { resolve(reader.result); };
+                reader.onerror = function () { reject(reader.error); };
+                reader.readAsDataURL(file);
+            });
+            img.src = dataUrl;
+            // Mark logo-cell as having a logo so placeholder is hidden
+            var cell = img.closest('[data-drop-zone]');
+            if (cell) { cell.classList.add('has-logo'); }
+            app.state.apply();
+        } catch (err) {
+            console.error('[transmittal] logo apply failed', err);
+            alert('Failed to load logo: ' + (err && err.message ? err.message : err));
+        }
+    }
+
+    logosModule.applyLogoFile = applyLogoFile;
+
+    app.registerInit(function () {
+        // Nothing to wire here — drag-and-drop is handled by drop-zones.js.
+        // Keep the has-logo class in sync with existing logo src on load.
+        ['left-logo', 'right-logo'].forEach(function (imgId) {
+            var img = dom.qs('#' + imgId);
+            if (!img) { return; }
+            var cell = img.closest('[data-drop-zone]');
+            if (cell && img.src && img.src !== window.location.href) {
+                cell.classList.add('has-logo');
+            }
+        });
+    });
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    // ── Targeted drop zones ─────────────────────────────────────────────────
+    // Shows contextual zone outlines when anything is dragged over the window.
+    // Emphasises zones that can accept the dragged data type.
+    // Hands off actual processing to existing module helpers.
+
+    var dropZonesModule = app.modules.dropZones = {};
+
+    // ── Data-transfer classification ────────────────────────────────────────
+    // Returns { hasImage, hasHtmlJson, hasPossibleDir }
+    // NOTE: MIME types ARE accessible on items during dragenter/dragover,
+    // but filenames are not. Directories have kind === 'file' and type === ''.
+    function classifyTransfer(dt) {
+        var hasImage = false;
+        var hasHtmlJson = false;
+        var hasPossibleDir = false;
+
+        if (!dt || !dt.items) {
+            return { hasImage: hasImage, hasHtmlJson: hasHtmlJson, hasPossibleDir: hasPossibleDir };
+        }
+
+        var items = dt.items;
+        for (var i = 0; i < items.length; i++) {
+            var item = items[i];
+            if (item.kind !== 'file') { continue; }
+            var t = (item.type || '').toLowerCase();
+            if (t.indexOf('image/') === 0) {
+                hasImage = true;
+            } else if (t === 'text/html' || t === 'application/json') {
+                hasHtmlJson = true;
+            } else if (t === '') {
+                // Could be a directory or a file with no MIME (e.g. .json on some OSes)
+                hasPossibleDir = true;
+            }
+        }
+        return { hasImage: hasImage, hasHtmlJson: hasHtmlJson, hasPossibleDir: hasPossibleDir };
+    }
+
+    // ── Eligibility per zone type ───────────────────────────────────────────
+    function zoneIsEligible(zoneType, cls) {
+        var inEditMode = (app.state && app.state.mode === 'edit');
+        switch (zoneType) {
+            case 'logo-left':
+            case 'logo-right':
+                return cls.hasImage && inEditMode;
+            case 'header':
+                // Accept HTML/JSON imports; also allow unknown-type files (hasPossibleDir)
+                // so that dragging a JSON with no MIME still lights up the header zone.
+                return (cls.hasHtmlJson || cls.hasPossibleDir) && inEditMode;
+            case 'file-table':
+                // Directories and HTML/JSON imports are always eligible here.
+                // (Verify works in both edit and published mode.)
+                // Pure image-only drops are not accepted here.
+                return cls.hasHtmlJson || cls.hasPossibleDir;
+            default:
+                return false;
+        }
+    }
+
+    // ── Zone visibility helpers ─────────────────────────────────────────────
+    function getAllZones() {
+        return document.querySelectorAll('[data-drop-zone]');
+    }
+
+    function showZones(cls) {
+        getAllZones().forEach(function (el) {
+            var zoneType = el.getAttribute('data-drop-zone');
+            var eligible = zoneIsEligible(zoneType, cls);
+            el.classList.add('dz-visible');
+            el.classList.toggle('dz-eligible', eligible);
+            el.classList.toggle('dz-ineligible', !eligible);
+        });
+    }
+
+    function hideZones() {
+        getAllZones().forEach(function (el) {
+            el.classList.remove('dz-visible', 'dz-eligible', 'dz-ineligible', 'dz-hover');
+        });
+    }
+
+    // ── Window-level drag tracking ──────────────────────────────────────────
+    // Use relatedTarget to distinguish real enter/leave from child-element noise.
+    // relatedTarget is null when the drag crosses the window boundary.
+    // Note: this approach is reliable in Chromium-based browsers. Firefox has
+    // a known quirk where relatedTarget may not be null at true window boundary
+    // in all cases; zones may not appear in Firefox. Acceptable given the app's
+    // primary target is Chromium.
+
+    document.addEventListener('dragenter', function (e) {
+        e.preventDefault();
+        if (e.relatedTarget === null) {
+            showZones(classifyTransfer(e.dataTransfer));
+        }
+    });
+
+    document.addEventListener('dragleave', function (e) {
+        if (e.relatedTarget === null) {
+            hideZones();
+        }
+    });
+
+    document.addEventListener('dragover', function (e) { e.preventDefault(); });
+
+    document.addEventListener('drop', function (e) {
+        // Default handler: prevent browser navigation. Specific zones handle drops.
+        e.preventDefault();
+        hideZones();
+    });
+
+    // ── Per-zone drop handler: HTML / JSON import ───────────────────────────
+    async function handleDataFileDrop(file, sourceName) {
+        var dataModule = app.modules.data;
+        if (!dataModule) { return; }
+        var name = (sourceName || '').toLowerCase();
+        try {
+            var text = await file.text();
+            var data = null;
+            if (name.endsWith('.json')) {
+                data = JSON.parse(text);
+            } else {
+                // HTML: extract embedded JSON using the shared helper from data.js
+                if (dataModule.extractJsonFromHtml) {
+                    data = dataModule.extractJsonFromHtml(text);
+                }
+            }
+            if (!data) {
+                if (dataModule.setStatus) { dataModule.setStatus('Dropped file does not contain transmittal data', 'error'); }
+                return;
+            }
+            await dataModule.applyLoadedData(data, sourceName || 'dropped');
+        } catch (err) {
+            console.error('[transmittal] drop-zones: file drop failed', err);
+            if (dataModule.setStatus) {
+                dataModule.setStatus('Failed to import: ' + (err && err.message ? err.message : err), 'error');
+            }
+        }
+    }
+
+    // ── Per-zone drop handler: directory ────────────────────────────────────
+    async function handleDirectoryDrop(item) {
+        var dataModule = app.modules.data;
+        var filesModule = app.modules.files;
+        if (!item || typeof item.getAsFileSystemHandle !== 'function') { return false; }
+        try {
+            var handle = await item.getAsFileSystemHandle();
+            if (!handle || handle.kind !== 'directory') { return false; }
+            if (typeof handle.requestPermission === 'function') {
+                await handle.requestPermission({ mode: 'readwrite' });
+            }
+            app.data.selectedDirHandle = handle;
+            if (filesModule && filesModule.updateDirectoryIndicator) {
+                filesModule.updateDirectoryIndicator();
+            }
+            if (dataModule && dataModule.setStatus) {
+                dataModule.setStatus('Directory: ' + handle.name, 'info');
+            }
+            var isPublished = !!app.state.published;
+            var hasFiles = app.data.files && app.data.files.length > 0;
+            if (isPublished || hasFiles) {
+                document.dispatchEvent(new CustomEvent('transmittal:verify-directory'));
+            } else {
+                document.dispatchEvent(new CustomEvent('transmittal:scan-directory'));
+            }
+            return true;
+        } catch (err) {
+            console.warn('[transmittal] drop-zones: getAsFileSystemHandle failed', err);
+            return false;
+        }
+    }
+
+    // ── Wire a single zone element ──────────────────────────────────────────
+    function wireZone(el) {
+        var zoneType = el.getAttribute('data-drop-zone');
+
+        el.addEventListener('dragover', function (e) {
+            var cls = classifyTransfer(e.dataTransfer);
+            if (zoneIsEligible(zoneType, cls)) {
+                e.preventDefault();
+                e.stopPropagation();
+                el.classList.add('dz-hover');
+            }
+        });
+
+        el.addEventListener('dragleave', function (e) {
+            // Only remove hover if we're actually leaving this element
+            // (not just moving to a child element within it)
+            if (!el.contains(e.relatedTarget)) {
+                el.classList.remove('dz-hover');
+            }
+        });
+
+        el.addEventListener('drop', async function (e) {
+            var cls = classifyTransfer(e.dataTransfer);
+            if (!zoneIsEligible(zoneType, cls)) { return; }
+            e.preventDefault();
+            e.stopPropagation();
+            hideZones();
+
+            // ── Logo zones ──────────────────────────────────────────
+            if (zoneType === 'logo-left' || zoneType === 'logo-right') {
+                var file = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+                if (!file) { return; }
+                var imgId = zoneType === 'logo-left' ? 'left-logo' : 'right-logo';
+                if (app.modules.logos && app.modules.logos.applyLogoFile) {
+                    await app.modules.logos.applyLogoFile(imgId, file);
+                }
+                return;
+            }
+
+            // ── Header zone: HTML or JSON import only ───────────────
+            if (zoneType === 'header') {
+                var file = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+                if (!file) { return; }
+                var name = (file.name || '').toLowerCase();
+                if (!name.endsWith('.html') && !name.endsWith('.htm') && !name.endsWith('.json')) {
+                    if (app.modules.data && app.modules.data.setStatus) {
+                        app.modules.data.setStatus('Drop an HTML or JSON transmittal file here', 'error');
+                    }
+                    return;
+                }
+                await handleDataFileDrop(file, file.name);
+                return;
+            }
+
+            // ── File-table zone: directory or HTML/JSON ─────────────
+            if (zoneType === 'file-table') {
+                var ftItems = e.dataTransfer && e.dataTransfer.items;
+                var ftFirstItem = ftItems && ftItems.length > 0 ? ftItems[0] : null;
+                // Grab file synchronously before async work
+                var ftFile = e.dataTransfer && e.dataTransfer.files && e.dataTransfer.files[0];
+
+                // Try directory first
+                if (ftFirstItem) {
+                    var wasDir = await handleDirectoryDrop(ftFirstItem);
+                    if (wasDir) { return; }
+                }
+
+                // Fall back to file-based import
+                if (!ftFile) { return; }
+                var ftName = (ftFile.name || '').toLowerCase();
+                if (!ftName.endsWith('.html') && !ftName.endsWith('.htm') && !ftName.endsWith('.json')) {
+                    if (app.modules.data && app.modules.data.setStatus) {
+                        app.modules.data.setStatus('Drop a folder, HTML, or JSON file here', 'error');
+                    }
+                    return;
+                }
+                await handleDataFileDrop(ftFile, ftFile.name);
+            }
+        });
+    }
+
+    // ── Initialization ──────────────────────────────────────────────────────
+    app.registerInit(function () {
+        document.querySelectorAll('[data-drop-zone]').forEach(wireZone);
+    });
+
+    dropZonesModule.classifyTransfer = classifyTransfer;
+    dropZonesModule.zoneIsEligible = zoneIsEligible;
+
+})(window.transmittalApp);
+
+(function (app) {
+    'use strict';
+
+    app.registerInit(function () {
+        let tabbing = false;
+
+        document.addEventListener('keydown', function (event) {
+            if (event.key === 'Tab') {
+                tabbing = true;
+            }
+        }, true);
+
+        document.addEventListener('mousedown', function () {
+            tabbing = false;
+        }, true);
+
+        document.addEventListener('focusin', function (event) {
+            if (!tabbing) {
+                return;
+            }
+            tabbing = false;
+            const target = event.target;
+            if (!target) {
+                return;
+            }
+            if (target.id === 'remarks') {
+                return;
+            }
+            if (target instanceof HTMLInputElement) {
+                try {
+                    target.select();
+                } catch (_) {
+                    // ignore selection issues
+                }
+                return;
+            }
+            if (target instanceof HTMLTextAreaElement) {
+                return;
+            }
+            if (target.isContentEditable) {
+                try {
+                    const selection = window.getSelection && window.getSelection();
+                    if (selection && document.createRange) {
+                        const range = document.createRange();
+                        range.selectNodeContents(target);
+                        selection.removeAllRanges();
+                        selection.addRange(range);
+                    }
+                } catch (_) {
+                    // ignore
+                }
+            }
+        }, true);
+    });
+})(window.transmittalApp);
+
+/**
+ * ZDDC shared help panel — open/close logic.
+ * Works with all four tools regardless of their module pattern.
+ * Expects: #help-btn, #help-panel, #help-panel-close in the DOM.
+ */
+(function () {
+    'use strict';
+
+    function init() {
+        var helpBtn   = document.getElementById('help-btn');
+        var panel     = document.getElementById('help-panel');
+        var closeBtn  = document.getElementById('help-panel-close');
+
+        if (!helpBtn || !panel) { return; }
+
+        function isOpen() { return !panel.hidden; }
+
+        function openPanel() {
+            panel.hidden = false;
+            document.body.classList.add('help-open');
+        }
+
+        function closePanel() {
+            panel.hidden = true;
+            document.body.classList.remove('help-open');
+        }
+
+        helpBtn.addEventListener('click', function () {
+            if (isOpen()) { closePanel(); } else { openPanel(); }
+        });
+
+        if (closeBtn) {
+            closeBtn.addEventListener('click', closePanel);
+        }
+
+        document.addEventListener('keydown', function (e) {
+            if (e.key === 'Escape' && isOpen()) { closePanel(); }
+        });
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', init);
+    } else {
+        init();
+    }
+}());
+
+(function (app) {
+    'use strict';
+
+    const filesModule = app.modules.files;
+    const security = app.modules.security;
+    const mode = app.modules.mode;
+
+    // Global handler: close parent <dialog> when any [data-modal-close] button is clicked
+    document.addEventListener('click', function (e) {
+        var btn = e.target.closest('[data-modal-close]');
+        if (!btn) { return; }
+        var dlg = btn.closest('dialog');
+        if (dlg && dlg.open) { dlg.close(); }
+    });
+
+    // ── Date field + calendar picker wiring ────────────
+    function toIso(str) {
+        if (!str || !str.trim()) { return ''; }
+        var t = str.trim();
+        if (/^\d{4}-\d{2}-\d{2}$/.test(t)) { return t; }
+        var d = new Date(t);
+        if (!isNaN(d.getTime())) {
+            var y = d.getFullYear();
+            var m = String(d.getMonth() + 1).padStart(2, '0');
+            var day = String(d.getDate()).padStart(2, '0');
+            return y + '-' + m + '-' + day;
+        }
+        return t;
+    }
+
+    function wireDatePicker(textId, pickerId) {
+        var dateText = app.dom.qs(textId);
+        var datePicker = app.dom.qs(pickerId);
+        if (!dateText || !datePicker) { return; }
+
+        dateText.addEventListener('click', function () {
+            var iso = toIso(dateText.value);
+            datePicker.value = (iso && /^\d{4}-\d{2}-\d{2}$/.test(iso)) ? iso : '';
+            datePicker.showPicker();
+        });
+
+        datePicker.addEventListener('change', function () {
+            if (datePicker.value) {
+                dateText.value = datePicker.value;
+                dateText.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        });
+
+        dateText.addEventListener('blur', function () {
+            var iso = toIso(dateText.value);
+            if (iso !== dateText.value) {
+                dateText.value = iso;
+                dateText.dispatchEvent(new Event('input', { bubbles: true }));
+            }
+        });
+    }
+
+    wireDatePicker('#date', '#date-picker-hidden');
+    wireDatePicker('#response-due', '#response-due-picker-hidden');
+
+    app.registerInit(async function () {
+        // ── Type combo dropdown wiring ───────────────────────
+        (function () {
+            var typeHidden = app.dom.qs('#type');
+            var typeDisplay = app.dom.qs('#type-display');
+            var menu = app.dom.qs('#type-menu');
+            if (!typeHidden || !typeDisplay || !menu) { return; }
+
+            function syncToHidden() {
+                var text = (typeDisplay.textContent || '').trim();
+                typeHidden.value = text;
+                typeHidden.dispatchEvent(new Event('input', { bubbles: true }));
+                if (app.state && app.state.apply) { app.state.apply(); }
+            }
+
+            function isOpen() { return !menu.classList.contains('hidden'); }
+            function closeMenu() { menu.classList.add('hidden'); }
+
+            typeDisplay.addEventListener('input', syncToHidden);
+
+            typeDisplay.addEventListener('blur', syncToHidden);
+
+            typeDisplay.addEventListener('keydown', function (e) {
+                if (e.key === 'Enter') {
+                    e.preventDefault();
+                    typeDisplay.blur();
+                }
+            });
+
+            typeDisplay.addEventListener('paste', function (e) {
+                e.preventDefault();
+                var text = (e.clipboardData || window.clipboardData).getData('text/plain');
+                document.execCommand('insertText', false, text.replace(/\n/g, ' '));
+            });
+
+            typeDisplay.addEventListener('click', function () {
+                if (app.state.mode !== 'edit') { return; }
+                if (isOpen()) { closeMenu(); } else { menu.classList.remove('hidden'); }
+            });
+
+            menu.addEventListener('click', function (e) {
+                var opt = e.target.closest('[data-value]');
+                if (!opt) { return; }
+                var val = opt.getAttribute('data-value');
+                typeDisplay.textContent = val;
+                typeHidden.value = val;
+                typeHidden.dispatchEvent(new Event('input', { bubbles: true }));
+                closeMenu();
+                if (app.state && app.state.apply) { app.state.apply(); }
+            });
+
+            document.addEventListener('click', function (e) {
+                if (isOpen() && !menu.contains(e.target) && e.target !== typeDisplay) {
+                    closeMenu();
+                }
+            });
+        })();
+        filesModule.loadFromJson();
+        app._initialized = true;
+        app.state.updateHiddenFields();
+        app.state.apply();
+        await security.verifySignatureIfPresent();
+        mode.refresh();
+    });
+
+    app.ready(function () {
+        app.start();
+    });
+})(window.transmittalApp);
+
+</script>
+<script id="help-markdown" type="application/markdown">
+# Transmittal Creator
+
+[← Back to ZDDC](../README.md)
+
+Create professional document transmittals that are impossible to forge or tamper with. Each transmittal is a self-contained HTML file with built-in integrity checking and optional digital signatures. Email it, archive it, trust it.
+
+**[🔗 Open Transmittal Creator](dist/transmittal.html)** - Click to use online, or right-click → "Save Link As" to keep your own copy.
+
+## The "Record Player with the Record" Concept
+
+This tool embodies true data portability - each transmittal contains both the data AND the viewer. Recipients don't need special software, accounts, or training. They just open the HTML file in any browser to see a professional transmittal with full verification capabilities. In 20 years, it will still work exactly the same.
+
+## What Makes Transmittals Special?
+
+✅ **Tamper-Proof**  
+Every file gets a SHA-256 fingerprint. If even one character changes, it's detected instantly.
+
+🔒 **Digitally Signable**  
+Optionally sign with cryptographic keys. Proves WHO sent it and WHEN, forever.
+
+📧 **Self-Contained**  
+The entire transmittal is one HTML file. Email it, archive it, open it anywhere.
+
+📊 **Machine-Readable**  
+Embedded JSON data means your systems can parse and process automatically.
+
+🔍 **Independently Verifiable**  
+Anyone can verify signatures and checksums - but verification MUST be done using a trusted copy of this tool, not the transmittal itself. See [Verification Security](#verification-security) below.
+
+## Quick Start
+
+### Workflow A: Paste file list first (typical for new transmittals)
+
+1. **Fill in the header** — Tracking Number, Date, To, From, Subject, Purpose, Remarks
+2. **Create Folder** — Menu → Create Folder → select staging directory → folder is created and selected
+3. **Paste file list** — Copy 3-5 adjacent columns from Excel (Tracking, Title, Revision, [Status], [Extension]) → Menu → Paste New Rows
+4. **Drop files onto rows** — Drag individual files from your OS onto matching rows to copy with ZDDC names and compute hashes
+5. **Save Draft** — Menu → Save Draft → save into the created folder
+6. **Publish** — When ready, Menu → Publish → choose Unsigned or Signed
+
+### Workflow B: Scan an existing directory
+
+1. **Click "Select Directory"** — Choose folder with files to transmit
+2. **Files auto-populate** — With tracking numbers, revisions, and checksums parsed from ZDDC filenames
+3. **Fill in the form** — To, From, Subject, and any remarks
+4. **Click Publish** — Choose Draft, Unsigned, or Signed
+5. **Send the HTML file** — Email it or save to your archive
+
+## Verification Security
+
+⚠️ **CRITICAL: Self-Verification is NOT Secure**
+
+When you open a transmittal, it may display "✓ Signature Valid" - but **this display can be faked**. A malicious actor could create a transmittal that shows valid signatures while containing altered data.
+
+### How to Verify Securely
+
+**For Document Controllers / Official Verification:**
+
+1. **Use a trusted tool instance** - Download the official transmittal tool from a trusted source (e.g., your organization's approved version or https://zddc.varasys.io/releases/transmittal_latest.html)
+2. **Export JSON from the transmittal** - Open the transmittal → Click "Download Data"
+3. **Import JSON into trusted tool** - Open your trusted tool → Click "Load JSON" → Paste the exported data
+4. **Verify file hashes** - Click "Select Directory" and point to the actual files
+5. **Check the verification display** - Only trust the verification shown in YOUR trusted tool, not the transmittal itself
+
+**Why This Works:**
+- The trusted tool's code is verified (by you or your organization)
+- The JSON data is extracted and re-verified independently
+- File hashes are computed fresh from the actual files
+- The verification logic cannot be tampered with
+
+**For Casual Review:**
+- The self-verification display is fine for informal checks
+- Useful for catching accidental modifications
+- NOT sufficient for legal/contractual verification
+
+### Verification Workflow
+
+```
+Received Transmittal (untrusted)
+    ↓
+Export JSON Data
+    ↓
+Trusted Tool Instance (verified by your organization)
+    ↓
+Import JSON → Verify Signatures → Verify File Hashes
+    ↓
+Official Verification Result
+```
+
+**Best Practice:** Organizations should maintain a verified copy of the transmittal tool at a known URL or network location for all document controllers to use for official verification.
+
+## Technical Architecture
+
+### Data-First Design
+- **Single source of truth**: `<script id="transmittal-data" type="application/json">` block
+- All UI state derived from this embedded JSON
+- No duplicate data storage in the HTML
+
+### Build System
+- **Build script** that:
+  - Concatenates modular CSS and JavaScript files
+  - Inlines everything into template.html
+  - Embeds this README as help documentation
+  - Outputs single `dist/transmittal.html` file
+
+### Security Model
+- All cryptographic operations happen **client-side** (Web Crypto API)
+- Private keys never stored or uploaded
+- **Self-verification is informational only** - a malicious transmittal can fake verification displays
+- **Secure verification requires external validation** - see [Verification Security](#verification-security)
+- Organizations should maintain a trusted tool instance for official verification
+
+## Key Features
+
+✅ **Portable**: Single HTML file works offline  
+✅ **Cryptographic**: SHA-256 hashing + ECDSA signatures  
+✅ **Parseable**: Embedded JSON for machine automation  
+✅ **Human-readable**: Clean UI with print optimization  
+✅ **Filterable**: Boolean logic filtering on all columns  
+✅ **Verifiable**: Independent signature verification  
+✅ **Standards-based**: ZDDC filename convention compliance  
+
+## Use Case
+
+This tool is designed for **engineering/construction document transmittals** where:
+- Multiple files need to be transmitted with metadata
+- Cryptographic integrity verification is required
+- Non-repudiation via digital signatures is valuable
+- Recipients need human-readable + machine-parseable format
+- Offline/portable distribution is essential
+
+The project achieves a **self-contained, verifiable document package** that bridges human workflow needs with automation requirements.
+
+## How It Works
+
+The transmittal operates on a simple principle: all data lives in a single JSON block inside the HTML. When you save or publish, it updates this JSON and downloads a new HTML file. This ensures:
+
+- Complete data portability
+- No hidden state or complexity  
+- Easy integration with other systems
+- Full transparency of what's stored
+
+
+## Field reference (canonical payload)
+
+Form values map to a stable canonical payload used for hashing/signing and JSON export. This payload lives inside the `<script type="application/json" id="transmittal-data">` block.
+
+**JSON Schema**: See [`transmittal.schema.json`](./transmittal/transmittal.schema.json) for the complete, machine-readable schema definition.
+
+### Key Fields
+
+**Payload** (core document data):
+- `version` — Payload schema version (currently 1)
+- `type` — Document type: "Transmittal", "Submittal", or custom text (e.g., "Contract Attachment 1")
+- `title` — Optional descriptive title
+- `client` — The Owner Name
+- `project` — The Project Name
+- `projectNumber` — The Project Number
+- `date` — Date in YYYY-MM-DD format (canonicalized from friendly text)
+- `trackingNumber` — Must not contain spaces or underscores
+- `from` — Who issued the document (hidden when type is not Transmittal or Submittal)
+- `to` — Recipient (hidden when type is not Transmittal or Submittal)
+- `purpose` — Purpose of document (hidden when type is not Transmittal or Submittal)
+- `responseDue` — Response deadline (shown only when type is Submittal)
+- `subject` — Subject line
+- `remarks` — Free-form Markdown content
+- `files[]` — Array of file objects, each containing:
+  - `trackingNumber`, `revision`, `status`, `title` (parsed from ZDDC filename)
+  - `path` — Directory path relative to transmittal root (empty string for root-level files)
+  - `filename` — Filename only (without path)
+  - `sha256` — SHA-256 hash of file contents (hex)
+  - `fileSize` — File size in bytes
+
+**Envelope** (cryptographic metadata):
+- `version` — Envelope schema version (currently 1)
+- `digestAlgorithm` — Always "SHA-256"
+- `digest` — SHA-256 hash of canonical payload string (hex)
+- `digestedAt` — ISO 8601 timestamp when digest was computed
+- `signatureAlgorithm` — "ECDSA-P256-SHA256"
+- `signatures[]` — Array of signature objects, each containing:
+  - `signature` — ECDSA signature over canonical envelope (base64)
+  - `signedAt` — ISO 8601 timestamp when this signature was created
+  - `publicKeyJwk` — EC P-256 public key (JWK) for verification
+
+**Security Model**: Signatures sign the envelope (which contains the digest), not the payload directly. This prevents tampering with the digest field while maintaining a two-layer verification:
+1. **Digest verification**: Confirms payload hasn't been modified (fast, no crypto)
+2. **Signature verification**: Confirms envelope (including digest) is authentic (cryptographic proof)
+
+**Presentation** (optional display assets - not signed):
+- `leftLogo` — Left logo as data URL
+- `rightLogo` — Right logo as data URL
+- `theme` — Visual theme identifier
+- `customCss` — Optional custom CSS for styling
+
+
+## Files table
+
+**Columns**: Tracking Number, Title, Revision, Status, EXT, Size, SHA256
+
+**Column visibility**:
+- **Default view**: Shows Tracking Number, Title, Revision, Status (essential columns)
+- **Show Details**: Toggle to reveal EXT, Size, SHA256 (technical details)
+- **Fullscreen**: Expand table to full browser window for better viewing of large file lists
+
+**Pasting file lists**:
+- Copy 3-5 **adjacent** tab-separated columns from Excel or any spreadsheet
+- Expected column order: Tracking, Title, Revision, [Status], [Extension]
+- 3-column paste: third column can be combined "A (IFR)" → splits into Revision "A" and Status "IFR"
+- Pastes with more than 5 columns are rejected with an error — condition your data into adjacent columns first
+- **Paste New Rows**: Replaces entire file list (confirms first)
+- **Paste Append Rows**: Adds to existing list, updates matching rows by tracking+revision key
+
+**Drop file onto row**:
+- Drag a file from your OS onto any table row in edit mode
+- The file is copied to the selected directory with the proper ZDDC filename
+- SHA-256 hash is computed and stored
+- If no directory is selected, you will be prompted to pick one
+
+**File scanning**:
+- "Select Directory" / "Scan Directory" scans recursively using the File System Access API, hashing files locally and parsing names
+- Filename parser expects: `trackingNumber_revision (status) - title.ext`
+  - Example: `A101-203_revA (Issued) - Site Plan.pdf`
+  - If a filename doesn't match, it still appears; parsed fields default to empty and `title` becomes the base name
+- Imports are merged on key `(trackingNumber|revision)`; newer scans update/replace matching rows
+- For known viewable types (`pdf,png,jpg,jpeg,gif,svg,webp,txt,html,htm,md`), links open in a new tab; others download
+
+
+## Filtering
+
+Each column has a filter input. Supported expression syntax:
+
+| Expression | Meaning |
+|---|---|
+| `term` | Contains "term" (case-insensitive) |
+| `!term` | Does not contain "term" |
+| `^term` | Starts with "term" |
+| `term$` | Ends with "term" |
+| `a b` | Matches both (AND) |
+| `a \| b` | Matches either (OR) |
+| `^IFA \| ^IFB` | Starts with IFA or IFB |
+| `pdf !draft` | Contains "pdf" and not "draft" |
+| `!^~` | Does not start with ~ (excludes drafts) |
+| `el.*spc` | Regex: "el" followed by "spc" |
+| `[ei]fa` | Regex character class: "efa" or "ifa" |
+
+Examples:
+
+- Only PDFs: in EXT filter, type `pdf$`.
+- Exclude drafts: in Revision, type `!^~`.
+- Status IFA or IFB: type `^IFA | ^IFB`.
+- Title contains both "floor" and "plan": type `floor plan`.
+- Tracking contains "el" then "spc": type `el.*spc`.
+
+
+## Form validation
+
+The transmittal provides real-time validation to catch errors early:
+
+**Inline validation** (as you type):
+- **Tracking Number**: Highlights if contains spaces or underscores (invalid characters)
+- **Date fields**: Auto-formats to YYYY-MM-DD, shows format hint on focus
+- **File table**: Shows parsing warnings for filenames that don't match ZDDC convention
+
+**Publish-time validation**:
+- All required fields must be filled
+- Tracking numbers must not contain spaces or underscores
+- File revisions must not contain spaces
+- At least one file must be included
+
+**Smart defaults**:
+- **Date**: Pre-filled with today's date in YYYY-MM-DD format
+
+
+## Signature verification
+
+⚠️ **WARNING: For official verification, see [Verification Security](#verification-security) above. The verification display shown here can be faked by a malicious transmittal.**
+
+When viewing a published transmittal, signature status is displayed above the files table:
+
+**For each signature**:
+- ✓ **Valid** — Signature verified successfully (in this document's context)
+- ⚠ **Warning** — Signature valid but transmittal has been edited
+- ✗ **Invalid** — Signature verification failed
+
+**Verification Actions**:
+- **Verify Externally** — Opens a trusted tool instance for independent verification
+  - Copies JSON data to clipboard
+  - Opens https://zddc.varasys.io/releases/transmittal_latest.html in validation mode
+  - Paste JSON and select directory to verify file hashes independently
+  - Only trust verification results from the trusted tool, not this document
+
+**Signature details** (expandable):
+- Public key fingerprint (click to copy)
+- Signature timestamp (from `signedAt` field)
+- Signature index (e.g., "Signature 1 of 3")
+
+**Other Actions**:
+- **Delete signature** — Remove invalid or outdated signatures
+- **Add signature** — Co-sign the document with your key
+  - Opens signing dialog (select existing key or generate new key)
+  - New signature appended to `signatures[]` array with current timestamp
+  - Downloads updated document (cannot save in place)
+
+
+## Saving and loading transmittals
+
+**Save Draft** (Menu → Save Draft):
+- Saves current state as an HTML file via the system file picker
+- All header info, file list, and remarks are preserved
+- Open the saved HTML in a browser to resume editing
+- Drafts have no digest or signature
+
+**Create Folder** (Menu → Create Folder):
+- Builds a folder name from the form: `YYYY-MM-DD_TRACKING (PURPOSE) - SUBJECT`
+- Prompts you to select a staging directory, then creates the subfolder
+- The new folder becomes the selected directory for file drops and Save Draft
+- Requires at least a tracking number
+
+**Remove Files** (Menu → Remove Files):
+- Clears the file list while keeping all header info and remarks
+- Useful when reusing a transmittal template with a new set of files
+
+**Save as JSON**:
+- Click **Download Data** to export the current transmittal as JSON
+- This file can be reloaded later as either:
+  - A finished transmittal (view/verify)
+  - A starting point for a new transmittal (edit/modify)
+
+**Load from JSON**:
+- Click **Load JSON** to import a previously saved transmittal
+- All form fields, files, and presentation assets (logos) are restored
+
+**Import HTML** (Menu → Import HTML):
+- Load a previously saved draft or published transmittal HTML file
+- Extracts the embedded JSON and restores all fields
+- You can also drag-and-drop an HTML or JSON file directly onto the page — see **Drag-and-Drop Zones** below
+
+## Drag-and-Drop Zones
+
+Whenever you drag any file or folder over the browser window, labelled drop zones appear on the transmittal to show you exactly where data can land:
+
+| Zone | Location | Accepts | Notes |
+|------|----------|---------|-------|
+| **Sender logo** | Top-left logo area | Image files (png, jpg, svg, …) | Edit mode only |
+| **Receiver logo** | Top-right logo area | Image files | Edit mode only |
+| **Header** | Header info block | Transmittal HTML or JSON file | Imports all header fields and file list; edit mode only |
+| **File table** | Document table area | Folder (scan or verify) · Transmittal HTML or JSON | Works in both edit and published mode |
+
+**Visual feedback during drag:**
+- Zones that can accept the dragged data are highlighted with a blue dashed outline and a descriptive label.
+- Zones that cannot accept the data are shown with a grey outline and dimmed.
+- When you hover over an eligible zone, it brightens further to confirm where the drop will land.
+
+**Logos and presentation assets**:
+- Logos ARE included in JSON exports (in the optional `presentation` object)
+- Logos are NOT part of the signed `payload` (separate top-level object)
+- When you drag-drop logos, they're converted to data URLs
+- The `presentation` object includes:
+  - `leftLogo` and `rightLogo` (data URLs)
+  - `theme` (visual theme identifier)
+  - `customCss` (optional custom styling)
+- This keeps the cryptographic signature focused on document data, not visual styling
+
+
+## JSON export format
+
+Download Data exports the exact contents of the embedded JSON block.
+
+**Format**: See [`transmittal.schema.json`](./transmittal/transmittal.schema.json) for the complete structure.
+
+**Key Points**:
+- The `payload` contains all transmittal data (metadata + files)
+- The `envelope` contains cryptographic metadata (digest, timestamp, signatures)
+- The `presentation` (optional) contains display assets (logos, styling) - **not signed**
+- The digest is computed over the canonical JSON string of `payload` only (sorted keys, stable formatting)
+- Each signature in the `signatures[]` array signs the same canonical payload string
+- If unsigned, the `signatures` array is empty `[]`
+- Presentation assets travel with the JSON but are excluded from cryptographic operations
+
+
+## Browser compatibility and printing
+
+- Directory selection requires the File System Access API (Chromium‑based browsers). On unsupported browsers, file scanning will not work.
+- Print styles are optimized for US Letter (8.5in×11in). Table header "sticky" behavior is disabled in print.
+
+
+## Publishing & Signing
+
+When you click **Publish**, a modal opens with these options:
+
+1. **Save Draft** — Saves HTML with current data (no digest, no signature)
+   - Also available directly from Menu → Save Draft (without opening the publish modal)
+   - Use for work-in-progress transmittals
+   - Can be reopened and edited later
+
+2. **Publish Unsigned** — Creates transmittal with digest only (no signature)
+   - Provides integrity verification via SHA-256 digest
+   - Proves content hasn't been modified
+   - No identity authentication
+
+3. **Publish Signed** — Creates transmittal with digest + signature(s)
+   - Choose one of:
+     - **Sign with Existing Key** — Select your saved private key JWK file
+     - **Sign with New Key** — Generate new EC P-256 key pair (downloads private key for you to save)
+   - Provides both integrity and authentication
+   - Supports multiple signatures (co-signing)
+
+**Security notes**:
+- All cryptographic operations happen locally in the browser (Web Crypto API)
+- Private keys are never stored or uploaded
+- Only public keys are embedded in the published transmittal for verification
+- If you generate a new key, **save the downloaded private key file** — you'll need it to sign future transmittals with the same identity
+- Editing a published transmittal invalidates existing signatures (they can be deleted)
+
+## Workflow
+
+The transmittal operates in different modes that control what actions are available:
+
+### Edit Mode (Default)
+
+**When active**: New transmittals or when explicitly toggled to Edit mode.
+
+**Document type selector**:
+
+The `type` field is a text input with autocomplete suggestions. Type to select or enter custom text.
+
+| Field | Transmittal | Submittal | File List (custom text) |
+|-------|-------------|-----------|-------------------------|
+| From | ✓ | ✓ | — |
+| To | ✓ | ✓ | — |
+| Purpose | ✓ | ✓ | — |
+| Response Due | — | ✓ | — |
+| Subject | ✓ | ✓ | ✓ |
+| Remarks | ✓ | ✓ | ✓ |
+
+**Usage**:
+- **Transmittal** — General document transmittals (no response required)
+- **Submittal** — Submittals requiring response (shop drawings, product data, samples)
+- **Custom text** — Type any text (e.g., "Contract Attachment 1", "Document Register") for file lists without workflow fields
+
+**Primary actions** (toolbar buttons):
+- **Select Directory** / **Scan Directory** — Scan filesystem to populate files table
+- **Verify Directory** — Re-hash files and compare against stored hashes
+- **Publish** — Opens publish modal (Draft / Unsigned / Signed)
+
+**Menu actions** (☰ dropdown):
+- **Scan Directory** / **Verify Directory** — Same as toolbar buttons
+- **Publish** / **Save Draft** / **Create Folder** — Publishing and folder management
+- **Paste New Rows** / **Paste Append Rows** — Paste file lists from clipboard
+- **Copy Table** — Copy file table to clipboard as tab-separated text
+- **Remove Files** — Clear file list, keep header and remarks
+- **Import HTML** — Load a saved draft or published transmittal
+- **Copy JSON** / **Paste JSON** — JSON clipboard operations
+- **Reset** — Clear all form data and files (start over)
+- **Create Index** — Generate archive redirect index in selected directory
+
+**Header bar actions** (always available):
+- **View/Edit toggle** — Switch between edit and read-only mode
+- **Load JSON** — Import a previously saved document
+- **Download Data** — Export JSON for signature verification or system integration
+- **Help** — View this documentation
+
+**UI behavior**: All form fields and table cells are editable. Filter inputs remain active for searching.
+
+### View Mode
+
+**When active**: Toggle from Edit mode or when opening a published transmittal.
+
+**Available actions**:
+- **View/Edit** — Switch to Edit mode (allows modifications)
+- **Download Data** — Export JSON for signature verification or system integration
+- **Help** — View this documentation
+
+**UI behavior**: Form fields and table cells are read-only. Filter inputs remain active for searching. All editing controls hidden (Select Directory, Publish, Reset).
+
+### Published State
+
+**When active**: Automatically detected when transmittal contains a valid digest.
+
+**Additional display**: Signature verification status shown above files table with public key fingerprint(s).
+
+**Behavior**: Defaults to View mode on load. Can toggle to Edit mode, but signature status indicates the transmittal has been published.
+
+### Mode Transitions
+
+```
+New Transmittal → Edit Mode
+                    ↓
+              Save Draft → Edit Mode (unsigned)
+                    ↓
+           Sign & Publish → Published State (View Mode)
+                    ↓
+              Toggle Edit → Published State (Edit Mode)
+```
+
+
+---
+
+Authoring notes:
+
+- UI copy uses “Tracking Number” consistently. The underlying key remains `trackingNumber`.
+- This README documents only the transmittal folder assets and does not change any code outside this directory.
+</script>
+</body>
+
+</html>
diff --git a/website/track-alpha.zip b/website/track-alpha.zip
new file mode 100644
index 0000000..543437b
Binary files /dev/null and b/website/track-alpha.zip differ
diff --git a/website/track-beta.zip b/website/track-beta.zip
new file mode 100644
index 0000000..07ac269
Binary files /dev/null and b/website/track-beta.zip differ
diff --git a/website/track-latest.zip b/website/track-latest.zip
new file mode 100644
index 0000000..aa43e1b
Binary files /dev/null and b/website/track-latest.zip differ
diff --git a/zddc/Containerfile b/zddc/Containerfile
new file mode 100644
index 0000000..e96fb7f
--- /dev/null
+++ b/zddc/Containerfile
@@ -0,0 +1,50 @@
+# syntax=docker/dockerfile:1
+
+# ─── Stage 1: build ──────────────────────────────────────────────────────────
+FROM docker.io/library/golang:1.24-alpine AS builder
+
+WORKDIR /src
+
+# git is required by go mod for VCS dependencies
+RUN apk add --no-cache git
+
+# Skip sum DB checks (allows building with empty/partial go.sum)
+ENV GONOSUMDB=* GOPRIVATE=* GOPROXY=direct
+
+# Copy source
+COPY . .
+
+# Build linux/amd64 (used by the runtime image and Linux hosts)
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags="-s -w" \
+    -o /out/zddc-server-linux-amd64 ./cmd/zddc-server
+
+# Cross-compile for macOS (Intel and Apple Silicon)
+RUN CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -trimpath -ldflags="-s -w" \
+    -o /out/zddc-server-darwin-amd64 ./cmd/zddc-server
+
+RUN CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -trimpath -ldflags="-s -w" \
+    -o /out/zddc-server-darwin-arm64 ./cmd/zddc-server
+
+# Cross-compile for Windows
+RUN CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -trimpath -ldflags="-s -w" \
+    -o /out/zddc-server-windows-amd64.exe ./cmd/zddc-server
+
+# ─── Stage 2: export binaries ─────────────────────────────────────────────────
+# Use `podman build --target binaries -o dist/ .` to extract binaries to the host.
+# No base image needed — this stage only exists to hold the output files.
+FROM scratch AS binaries
+COPY --from=builder /out/ /
+
+# ─── Stage 3: runtime ────────────────────────────────────────────────────────
+FROM docker.io/library/alpine:3.20
+
+# Non-root user
+RUN addgroup -S zddc && adduser -S -G zddc zddc
+
+COPY --from=builder /out/zddc-server-linux-amd64 /usr/local/bin/zddc-server
+
+USER zddc
+
+EXPOSE 8443
+
+ENTRYPOINT ["/usr/local/bin/zddc-server"]
diff --git a/zddc/README.md b/zddc/README.md
new file mode 100644
index 0000000..669b918
--- /dev/null
+++ b/zddc/README.md
@@ -0,0 +1,355 @@
+# zddc-server
+
+A purpose-built HTTPS file server for ZDDC document archives. Designed to replace
+`caddy file-server --browse` with features specific to ZDDC workflows.
+
+## Features
+
+- **High-performance static file serving** — ETag, conditional GET, Cache-Control
+- **Cascading `.zddc` ACL** — email-based allow/deny lists evaluated bottom-up from requested directory to root
+- **Caddy-compatible JSON listings** — the Archive Browser works without modification
+- **Virtual `.archive` index** — resolve the earliest revision of any tracked document by URL
+- **Filesystem watcher** — archive index updates automatically when files change
+- **Flexible TLS modes** — self-signed, real certificates, or plain HTTP
+- **Podman-native** — multi-stage build, non-root runtime, SELinux-compatible volumes
+
+## Quick Start
+
+```sh
+# Build the container image
+podman build -t zddc-server .
+
+# Run against your archive root
+podman run --rm \
+  -v /srv/archive:/data:z \
+  -e ZDDC_ROOT=/data \
+  -p 8443:8443 \
+  zddc-server
+```
+
+Or with podman-compose:
+
+```sh
+ZDDC_DATA_DIR=/srv/archive podman-compose up --build
+```
+
+> **Docker users:** Replace `podman` with `docker` and `podman-compose` with `docker-compose`. Remove the `:z` volume suffix (that is a SELinux/podman convention).
+
+## Environment Variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `ZDDC_ROOT` | *(required)* | Absolute path to the served file tree |
+| `ZDDC_ADDR` | `:8443` | Bind address (host:port) |
+| `ZDDC_TLS_CERT` | *(empty)* | Path to PEM certificate file. `none` = plain HTTP (no TLS); empty = generate self-signed |
+| `ZDDC_TLS_KEY` | *(empty)* | Path to PEM private key file. Required when `ZDDC_TLS_CERT` is a file path; ignored otherwise |
+| `ZDDC_LOG_LEVEL` | `info` | Log level: `debug`, `info`, `warn`, `error` |
+| `ZDDC_INDEX_PATH` | `.archive` | URL path segment name for the virtual archive index |
+| `ZDDC_EMAIL_HEADER` | `X-Email` | HTTP request header containing the authenticated user's email |
+| `ZDDC_CORS_ORIGIN` | `https://zddc.varasys.io` | Comma-separated allowlist of origins permitted to make cross-origin requests. Empty value disables CORS entirely. Default lets ZDDC tools served from `zddc.varasys.io` (e.g. via the bootstrap pattern) call back into your deployed server. |
+
+`ZDDC_TLS_CERT=none` disables TLS entirely (plain HTTP). Both cert and key must be set together when using real certificates.
+
+### CORS
+
+The default `ZDDC_CORS_ORIGIN=https://zddc.varasys.io` exists so the canonical
+ZDDC tool builds (hosted at `zddc.varasys.io`) can call back into your
+deployed `zddc-server` without extra configuration. If you self-host the
+tools on your own domain (e.g. `tools.acme.com`), set:
+
+```sh
+ZDDC_CORS_ORIGIN=https://tools.acme.com
+```
+
+Multiple origins are comma-separated. To disable CORS entirely (e.g. when
+all clients are same-origin), set `ZDDC_CORS_ORIGIN=` (empty value). The
+middleware echoes the matched origin back per-request and sets
+`Access-Control-Allow-Credentials: true` so the upstream-set `X-Email`
+header crosses the boundary.
+
+## TLS
+
+### Plain HTTP (no TLS)
+
+Set `ZDDC_TLS_CERT=none` to run without TLS. Recommended when an upstream reverse proxy
+(nginx, Caddy, Traefik) terminates external TLS and talks to zddc-server over plain HTTP
+on a private network:
+
+```sh
+podman run --rm \
+  -v /srv/archive:/data:z \
+  -e ZDDC_ROOT=/data \
+  -e ZDDC_TLS_CERT=none \
+  -e ZDDC_ADDR=:8080 \
+  -p 8080:8080 \
+  zddc-server
+```
+
+When `ZDDC_TLS_CERT` / `ZDDC_TLS_KEY` are empty (or when using real certificates), zddc-server generates an ECDSA P-256
+self-signed certificate in memory at startup. The certificate changes on every restart —
+this is intentional and acceptable when an upstream reverse proxy terminates external TLS
+and uses this server only for encrypted in-datacenter transport.
+
+To use a real certificate (e.g. from Let's Encrypt or an internal CA):
+
+```sh
+podman run --rm \
+  -v /etc/ssl/zddc:/certs:z,ro \
+  -e ZDDC_TLS_CERT=/certs/server.crt \
+  -e ZDDC_TLS_KEY=/certs/server.key \
+  ...
+```
+
+## Authentication
+
+zddc-server does **not** perform authentication itself. It reads the user's email address
+from a request header (default: `X-Email`) that must be set by an upstream reverse proxy
+(nginx, Caddy, Traefik, Azure Application Gateway, etc.) after authenticating the user.
+
+If the header is absent, the user is treated as anonymous (empty email). A directory with
+no `.zddc` rules is publicly accessible; a directory with an allowlist requires a matching
+email.
+
+## `.zddc` Access Control Files
+
+Place a `.zddc` YAML file in any directory to control access. Rules cascade from parent
+directories — child rules are appended to (not replaced by) parent rules.
+
+```yaml
+# Example .zddc file
+acl:
+  allow:
+    - "*@mycompany.com"       # all users at mycompany.com
+    - "contractor@partner.com" # specific external user
+  deny:
+    - "intern@mycompany.com"  # override: block this specific user
+```
+
+### ACL evaluation order
+
+Rules are evaluated **bottom-up**: starting at the requested directory and walking
+toward the root. The first explicit match (allow or deny) at any level wins.
+
+1. Check deny patterns at the current level — if email matches → **403 Forbidden**
+2. Check allow patterns at the current level — if email matches → **allow**
+3. No match at this level → walk up to parent directory and repeat
+4. If no `.zddc` files were found anywhere in the chain → **allow** (public, no rules)
+5. If `.zddc` files exist but email matched nothing → **403 Forbidden** (not on any list)
+
+This model supports three user tiers in a single tree:
+
+| Level | Rule | Effect |
+|---|---|---|
+| Root | `allow: ["*@company.com"]` | All company users see everything |
+| Project dir | `allow: ["team@company.com"]` | Restricts to the project team |
+| Vendor subdir | `allow: ["vendor@ext.com"]` | Grants a third-party access to their folder only |
+
+A vendor navigating to their subdirectory is allowed by the deepest matching rule,
+even if a higher-level rule would deny them.
+
+### Glob patterns
+
+`*` matches any sequence of characters within one side of the `@` boundary:
+
+| Pattern | Matches |
+|---|---|
+| `*@mycompany.com` | Any user at mycompany.com |
+| `alice@*` | alice at any domain |
+| `*` | Any non-empty email |
+| `alice@example.com` | Exact match only |
+
+### Directory visibility
+
+Directories for which the user lacks access are **omitted** from JSON listings entirely —
+they are neither listed nor queryable. A direct request to a denied path returns `403`.
+
+## Landing Page and Tool Install
+
+The recommended install drops `install.zip` (downloaded from
+`https://zddc.varasys.io/install.zip`) into `ZDDC_ROOT/`:
+
+```
+ZDDC_ROOT/
+  index.html          ← landing page (current stable)
+  archive.html        ← archive browser
+  transmittal.html
+  classifier.html
+  mdedit.html
+  _template/          ← template directory of level-1 bootstrap stubs;
+                        rename a copy to <project-name>/ for each project
+  Project-001/
+    archive.html      ← level-1 stub: fetches ../archive.html
+    transmittal.html
+    classifier.html
+    mdedit.html
+  Project-002/
+  …
+```
+
+This is fully self-contained — no external dependencies. To make the
+deployment auto-track a published channel from `zddc.varasys.io`, drop
+`track-alpha.zip` / `track-beta.zip` / `track-latest.zip` (also at
+`https://zddc.varasys.io/`) over `ZDDC_ROOT/`: those replace the root
+`<tool>.html` files with level-2 bootstrap stubs that fetch the named
+channel from `zddc.varasys.io` on each page load. See
+[`bootstrap/README.md`](../bootstrap/README.md) for the full install
+guide, the `?v=…` URL parameter for per-request version selection, and
+the `ZDDC_CORS_ORIGIN` env var that lets `zddc-server` accept
+cross-origin calls from the level-2 source.
+
+The landing page fetches `GET /` (with `Accept: application/json`) to retrieve the list
+of top-level project directories the requesting user has access to. It renders checkboxes
+for each project and opens `archive.html?projects=Proj-A,Proj-B` when the user clicks
+"Open Archive".
+
+**Presets** (named project selections) are stored in the browser's `localStorage` — no
+server-side state required.
+
+**Shared URLs**: the `?projects=` parameter is preserved in the archive browser URL so
+users can email direct links to a pre-filtered view. If the recipient does not have
+access to a project listed in the URL, a warning banner is shown.
+
+## Access Logging
+
+Every HTTP request is logged as a structured `slog` entry at `INFO` level:
+
+| Field | Description |
+|---|---|
+| `ts` | Request arrival timestamp (RFC3339) |
+| `email` | User email from the configured header, or `anonymous` |
+| `method` | HTTP method |
+| `path` | URL path |
+| `status` | HTTP response status code |
+| `bytes` | Response body bytes written |
+| `duration_ms` | Request duration in milliseconds |
+
+Log output goes to `stderr`. Use `ZDDC_LOG_LEVEL=warn` to suppress access logs if needed,
+or pipe `stderr` to a log aggregator.
+
+## Virtual Archive Index (`.archive`)
+
+Any URL path segment named `.archive` (configurable via `ZDDC_INDEX_PATH`) is intercepted
+by the server and treated as a virtual document index.
+
+The index is built at startup by scanning all transmittal folders under `ZDDC_ROOT`. It
+maps each `(trackingNumber, revision, modifier)` tuple to the file from the
+**chronologically earliest** transmittal folder that contains it.
+
+### URL patterns
+
+| URL | Resolves to |
+|---|---|
+| `GET /Project/.archive/TRK-001.html` | Latest base revision of TRK-001 |
+| `GET /Project/.archive/TRK-001_A.html` | Base revision A of TRK-001 |
+| `GET /Project/.archive/TRK-001_A+C1.html` | Modifier C1 of revision A of TRK-001 |
+| `GET /Project/.archive/` | JSON listing of all resolvable trackingNumber.html entries |
+
+All responses are `302 Found` redirects to the actual file URL. ACL is enforced on both
+the `.archive` context directory and the resolved target file.
+
+### Why "earliest" transmittal?
+
+Any file claiming to be `TRK-001_A (IFC)` should be identical across transmittals
+(same content, same SHA-256). If the same tracking number and revision appears in multiple
+transmittals, the first one received chronologically is treated as the authoritative copy.
+A later arrival with a different hash is an error condition (to be detected separately).
+
+### Index refresh
+
+The index refreshes automatically via an `fsnotify` filesystem watcher. Changes are
+debounced by 2 seconds before the relevant transmittal folder is re-indexed.
+
+> **Note for Azure Files**: Azure SMB mounts do not support `inotify`/`fsnotify` reliably.
+> The watcher will log a warning and the index will only be updated by restarting the server.
+
+## ZDDC Filename Convention
+
+The server parses filenames following the ZDDC convention:
+
+```
+trackingNumber_revision (status) - title.extension
+```
+
+| Part | Format | Example |
+|---|---|---|
+| `trackingNumber` | No spaces or underscores | `123456-EL-SPC-2623` |
+| `revision` | `~?[A-Z0-9]+(\+[CBNQ][0-9]+)?` | `A`, `~B`, `C+C1` |
+| `status` | One of the valid status codes | `IFC`, `REC`, `---` |
+| `title` | Free text | `Electrical Specification` |
+
+Valid status codes: `IFA IFB IFC IFD IFI IFP IFR IFU REC RSA RSB RSC RSD RSI ---`
+
+Transmittal folder format: `YYYY-MM-DD_trackingNumber (STATUS) - title`
+
+## Integration with Archive Browser
+
+The Archive Browser (`archive.html`) can connect to zddc-server in HTTP mode. The server
+returns JSON directory listings in exactly the same format as Caddy's `file-server --browse`
+— no changes to `archive/js/source.js` are needed.
+
+To use: install `archive.html` at `ZDDC_ROOT/archive.html` (or any subdirectory) — either
+the actual built tool from `install.zip`, or a level-1/level-2 bootstrap stub that fetches
+it. Then open it via the zddc-server URL; the app will auto-connect and scan the directory
+tree.
+
+## Building
+
+### Run as a container
+
+```sh
+podman build -t zddc-server .
+```
+
+### Compile native binaries (no Go installation required)
+
+Use the `binaries` build target to cross-compile for all platforms using podman
+as the build environment. Binaries are extracted directly to a local `dist/`
+directory — no container runs on your host.
+
+```sh
+# From the zddc/ directory
+mkdir -p dist
+podman build --target binaries -o dist/ .
+```
+
+This produces:
+
+| File | Platform |
+|---|---|
+| `dist/zddc-server-linux-amd64` | Linux (x86-64) |
+| `dist/zddc-server-darwin-amd64` | macOS (Intel) |
+| `dist/zddc-server-darwin-arm64` | macOS (Apple Silicon) |
+| `dist/zddc-server-windows-amd64.exe` | Windows (x86-64) |
+
+All binaries are statically linked (CGO disabled) — no runtime dependencies.
+
+Run the binary directly:
+
+```sh
+# Linux / macOS
+ZDDC_ROOT=/srv/archive ZDDC_TLS_CERT=none ZDDC_ADDR=:8080 ./dist/zddc-server-linux-amd64
+
+# Windows (PowerShell)
+$env:ZDDC_ROOT="C:\archive"; $env:ZDDC_TLS_CERT="none"; $env:ZDDC_ADDR=":8080"
+.\dist\zddc-server-windows-amd64.exe
+```
+
+> **Docker users:** Replace `podman build` with `docker build`. The `--target` and
+> `-o` flags work identically in Docker BuildKit (enabled by default in Docker 23+).
+
+## Release Tagging
+
+Follow the repository convention: `zddc-server-vX.Y.Z`
+
+```sh
+git tag zddc-server-v1.0.0
+git push --tags
+```
+
+---
+
+**Notes:**
+
+- The container uses a multi-stage build
+- The `.archive` virtual path resolves ZDDC tracking numbers to their earliest-received revision
+- ACL is enforced via bottom-up `.zddc` file evaluation
diff --git a/zddc/cmd/zddc-server/main.go b/zddc/cmd/zddc-server/main.go
new file mode 100644
index 0000000..355775d
--- /dev/null
+++ b/zddc/cmd/zddc-server/main.go
@@ -0,0 +1,197 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/archive"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/handler"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/tlsutil"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/zddc"
+)
+
+func main() {
+	cfg, err := config.Load()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "configuration error: %v\n", err)
+		os.Exit(1)
+	}
+
+	setupLogger(cfg.LogLevel)
+
+	slog.Info("zddc-server starting", "root", cfg.Root, "addr", cfg.Addr)
+
+	// Build archive index
+	slog.Info("building archive index...")
+	start := time.Now()
+	idx, err := archive.BuildIndex(cfg.Root)
+	if err != nil {
+		slog.Error("failed to build archive index", "err", err)
+		os.Exit(1)
+	}
+	slog.Info("archive index built", "duration", time.Since(start))
+
+	// TLS config
+	tlsCfg, useTLS, err := tlsutil.TLSConfig(cfg)
+	if err != nil {
+		slog.Error("failed to configure TLS", "err", err)
+		os.Exit(1)
+	}
+
+	// Context for graceful shutdown
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
+	defer cancel()
+
+	// Start file-system watcher
+	watcher, err := archive.NewWatcher(cfg.Root, idx)
+	if err != nil {
+		slog.Warn("failed to start filesystem watcher (index will not auto-update)", "err", err)
+	} else {
+		go func() {
+			if err := watcher.Start(ctx); err != nil && ctx.Err() == nil {
+				slog.Error("watcher error", "err", err)
+			}
+		}()
+	}
+
+	// HTTP handler
+	mux := http.NewServeMux()
+	mux.Handle("/", handler.AccessLogMiddleware(handler.CORSMiddleware(cfg, handler.ACLMiddleware(cfg, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		dispatch(cfg, idx, w, r)
+	})))))
+
+	srv := &http.Server{
+		Addr:      cfg.Addr,
+		Handler:   mux,
+		TLSConfig: tlsCfg,
+	}
+
+	// Serve in goroutine
+	if useTLS {
+		go func() {
+			slog.Info("listening", "addr", cfg.Addr, "tls", true)
+			if err := srv.ListenAndServeTLS("", ""); err != nil && err != http.ErrServerClosed {
+				slog.Error("server error", "err", err)
+				cancel()
+			}
+		}()
+	} else {
+		go func() {
+			slog.Info("listening", "addr", cfg.Addr, "tls", false)
+			if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+				slog.Error("server error", "err", err)
+				cancel()
+			}
+		}()
+	}
+
+	<-ctx.Done()
+	slog.Info("shutting down...")
+
+	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer shutdownCancel()
+	if err := srv.Shutdown(shutdownCtx); err != nil {
+		slog.Error("shutdown error", "err", err)
+	}
+	slog.Info("stopped")
+}
+
+// dispatch routes a request to the appropriate handler.
+func dispatch(cfg config.Config, idx *archive.Index, w http.ResponseWriter, r *http.Request) {
+	urlPath := r.URL.Path
+	email := handler.EmailFromContext(r)
+
+	// Project list API: GET / with Accept: application/json
+	if urlPath == "/" {
+		accept := r.Header.Get("Accept")
+		if strings.Contains(accept, "application/json") {
+			handler.ServeProjectList(cfg, w, r)
+			return
+		}
+	}
+
+	// Split path into segments
+	segments := strings.Split(strings.Trim(urlPath, "/"), "/")
+
+	// Check for .archive segment in the path
+	for i, seg := range segments {
+		if seg == cfg.IndexPath {
+			// contextPath is everything before .archive
+			contextPath := "/" + strings.Join(segments[:i], "/")
+			var filename string
+			if i+1 < len(segments) {
+				filename = strings.Join(segments[i+1:], "/")
+			}
+			handler.ServeArchive(cfg, idx, w, r, contextPath, filename)
+			return
+		}
+	}
+
+	// Resolve the physical path
+	cleanPath := filepath.FromSlash(strings.TrimPrefix(urlPath, "/"))
+	absPath := filepath.Join(cfg.Root, cleanPath)
+
+	// Guard against path traversal
+	if !strings.HasPrefix(absPath, cfg.Root+string(filepath.Separator)) && absPath != cfg.Root {
+		http.Error(w, "Not Found", http.StatusNotFound)
+		return
+	}
+
+	// Check filesystem
+	info, err := os.Stat(absPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			http.Error(w, "Not Found", http.StatusNotFound)
+		} else {
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	if info.IsDir() {
+		// ACL check
+		chain, _ := zddc.EffectivePolicy(cfg.Root, absPath)
+		if !zddc.AllowedWithChain(chain, email) {
+			http.Error(w, "Forbidden", http.StatusForbidden)
+			return
+		}
+		if !strings.HasSuffix(urlPath, "/") {
+			http.Redirect(w, r, urlPath+"/", http.StatusMovedPermanently)
+			return
+		}
+		handler.ServeDirectory(cfg, w, r)
+		return
+	}
+
+	// Regular file: ACL on parent directory
+	chain, _ := zddc.EffectivePolicy(cfg.Root, filepath.Dir(absPath))
+	if !zddc.AllowedWithChain(chain, email) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+	handler.ServeFile(w, r, absPath)
+}
+
+func setupLogger(level string) {
+	var l slog.Level
+	switch strings.ToLower(level) {
+	case "debug":
+		l = slog.LevelDebug
+	case "warn":
+		l = slog.LevelWarn
+	case "error":
+		l = slog.LevelError
+	default:
+		l = slog.LevelInfo
+	}
+	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: l})))
+}
diff --git a/zddc/go.mod b/zddc/go.mod
new file mode 100644
index 0000000..6d203b4
--- /dev/null
+++ b/zddc/go.mod
@@ -0,0 +1,10 @@
+module codeberg.org/VARASYS/ZDDC/zddc
+
+go 1.24
+
+require (
+	github.com/fsnotify/fsnotify v1.9.0
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require golang.org/x/sys v0.26.0 // indirect
diff --git a/zddc/go.sum b/zddc/go.sum
new file mode 100644
index 0000000..07a230d
--- /dev/null
+++ b/zddc/go.sum
@@ -0,0 +1,8 @@
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
+golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/zddc/internal/archive/index.go b/zddc/internal/archive/index.go
new file mode 100644
index 0000000..8ac7500
--- /dev/null
+++ b/zddc/internal/archive/index.go
@@ -0,0 +1,297 @@
+package archive
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+)
+
+// RevisionEntry holds the resolved file paths for one base revision.
+type RevisionEntry struct {
+	BasePath  string            // server-relative path for trackingNumber_rev.html
+	Modifiers map[string]string // modifier key (e.g. "C1") → server-relative path
+	Date      string            // transmittal date (YYYY-MM-DD) for first-seen logic
+}
+
+// TrackingEntry holds all revision data for one tracking number.
+type TrackingEntry struct {
+	HighestBaseRev string                     // highest base revision (for trackingNumber.html)
+	ByRevision     map[string]*RevisionEntry  // base revision → entry
+}
+
+// Index is the in-memory archive index.
+type Index struct {
+	mu         sync.RWMutex
+	ByTracking map[string]*TrackingEntry
+}
+
+// NewIndex returns an empty Index.
+func NewIndex() *Index {
+	return &Index{
+		ByTracking: make(map[string]*TrackingEntry),
+	}
+}
+
+// transmittalFolderRE matches: YYYY-MM-DD_anything (anything) - anything
+var transmittalFolderRE = regexp.MustCompile(`^(\d{4}-\d{2}-\d{2})_[^_\s]+\s*\([^)]+\)\s*-\s*.+$`)
+
+// zddc filename: trackingNumber_revision (status) - title.ext
+// trackingNumber: no spaces or underscores
+// revision: ~?[A-Z0-9]+(+[CBNQ][0-9]+)?
+var zddcFilenameRE = regexp.MustCompile(
+	`^([^_\s]+(?:-[^_\s]+)*)_(~?[A-Z0-9]+)(\+[CBNQ][0-9]+)?\s+\([^)]+\)\s*-\s*.+\.([^.]+)$`,
+)
+
+type parsedFile struct {
+	trackingNumber string
+	baseRev        string
+	modifier       string // empty or e.g. "C1"
+	date           string // transmittal folder date
+	serverPath     string // server-relative path (slash-separated, no leading slash)
+}
+
+// BuildIndex walks fsRoot, finds all transmittal folders, and builds the index.
+func BuildIndex(fsRoot string) (*Index, error) {
+	idx := NewIndex()
+	if err := walkAndIndex(idx, fsRoot, fsRoot, ""); err != nil {
+		return nil, err
+	}
+	return idx, nil
+}
+
+// walkAndIndex recursively walks dirAbs looking for transmittal folders.
+// serverDir is the server-relative path of dirAbs (slash-separated, no leading slash).
+func walkAndIndex(idx *Index, fsRoot, dirAbs, serverDir string) error {
+	entries, err := os.ReadDir(dirAbs)
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range entries {
+		name := entry.Name()
+		if strings.HasPrefix(name, ".") {
+			continue
+		}
+		if !entry.IsDir() {
+			continue
+		}
+
+		var childServerDir string
+		if serverDir == "" {
+			childServerDir = name
+		} else {
+			childServerDir = serverDir + "/" + name
+		}
+		childAbs := filepath.Join(dirAbs, name)
+
+		if m := transmittalFolderRE.FindStringSubmatch(name); m != nil {
+			// This is a transmittal folder — index its files
+			date := m[1]
+			if err := indexTransmittalFolder(idx, fsRoot, childAbs, childServerDir, date); err != nil {
+				// Non-fatal: log and continue
+				continue
+			}
+		} else {
+			// Recurse into grouping/portfolio/project folders
+			if err := walkAndIndex(idx, fsRoot, childAbs, childServerDir); err != nil {
+				continue
+			}
+		}
+	}
+	return nil
+}
+
+// indexTransmittalFolder indexes all ZDDC files in a transmittal folder.
+func indexTransmittalFolder(idx *Index, fsRoot, folderAbs, folderServerPath, date string) error {
+	return filepath.WalkDir(folderAbs, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			// Log the error but continue indexing other files
+			_ = err // would log here: slog.Warn("walkdir error", "path", path, "err", err)
+			return nil
+		}
+		if d.IsDir() {
+			return nil
+		}
+		name := d.Name()
+		if strings.HasPrefix(name, ".") {
+			return nil
+		}
+
+		m := zddcFilenameRE.FindStringSubmatch(name)
+		if m == nil {
+			return nil
+		}
+
+		tracking := m[1]
+		baseRev := m[2]
+		modifierFull := m[3] // e.g. "+C1" or ""
+		modifier := ""
+		if modifierFull != "" {
+			modifier = modifierFull[1:] // strip leading "+"
+		}
+
+		// Build server-relative path
+		relPath, err := filepath.Rel(fsRoot, path)
+		if err != nil {
+			return nil
+		}
+		serverPath := filepath.ToSlash(relPath)
+
+		pf := parsedFile{
+			trackingNumber: tracking,
+			baseRev:        baseRev,
+			modifier:       modifier,
+			date:           date,
+			serverPath:     serverPath,
+		}
+
+		idx.recordFile(pf)
+		return nil
+	})
+}
+
+// recordFile adds a parsed file to the index using first-seen (oldest date) logic.
+func (idx *Index) recordFile(pf parsedFile) {
+	idx.mu.Lock()
+	defer idx.mu.Unlock()
+
+	te, ok := idx.ByTracking[pf.trackingNumber]
+	if !ok {
+		te = &TrackingEntry{
+			ByRevision: make(map[string]*RevisionEntry),
+		}
+		idx.ByTracking[pf.trackingNumber] = te
+	}
+
+	re, ok := te.ByRevision[pf.baseRev]
+	if !ok {
+		re = &RevisionEntry{
+			Modifiers: make(map[string]string),
+		}
+		te.ByRevision[pf.baseRev] = re
+	}
+
+	if pf.modifier == "" {
+		// Base revision file — record if this transmittal is older than current
+		if re.BasePath == "" || pf.date < re.Date {
+			re.BasePath = pf.serverPath
+			re.Date = pf.date
+		}
+	} else {
+		// Modifier file — record if no entry yet or this transmittal is older
+		if existing, exists := re.Modifiers[pf.modifier]; !exists || pf.date < re.Date {
+			_ = existing
+			re.Modifiers[pf.modifier] = pf.serverPath
+		}
+	}
+
+	// Update highest base revision
+	te.HighestBaseRev = highestRevision(te)
+}
+
+// highestRevision returns the highest base revision among all revisions in te.
+// Revision ordering: numeric revisions (0,1,2…) are lower than alphabetic (A,B,C…).
+// Draft prefix ~ means lower than base.
+func highestRevision(te *TrackingEntry) string {
+	if len(te.ByRevision) == 0 {
+		return ""
+	}
+	revs := make([]string, 0, len(te.ByRevision))
+	for r := range te.ByRevision {
+		revs = append(revs, r)
+	}
+	sort.Slice(revs, func(i, j int) bool {
+		return compareRevisions(revs[i], revs[j]) < 0
+	})
+	return revs[len(revs)-1]
+}
+
+// compareRevisions returns negative if a < b, 0 if equal, positive if a > b.
+// Order: ~rev < numeric < alpha (A < B < C ...)
+func compareRevisions(a, b string) int {
+	isDraftA := strings.HasPrefix(a, "~")
+	isDraftB := strings.HasPrefix(b, "~")
+	baseA := strings.TrimPrefix(a, "~")
+	baseB := strings.TrimPrefix(b, "~")
+
+	// Draft < non-draft of same base
+	if baseA == baseB {
+		if isDraftA && !isDraftB {
+			return -1
+		}
+		if !isDraftA && isDraftB {
+			return 1
+		}
+		return 0
+	}
+
+	// Numeric vs alpha: numeric comes first
+	aIsNum := len(baseA) > 0 && baseA[0] >= '0' && baseA[0] <= '9'
+	bIsNum := len(baseB) > 0 && baseB[0] >= '0' && baseB[0] <= '9'
+	if aIsNum && !bIsNum {
+		return -1
+	}
+	if !aIsNum && bIsNum {
+		return 1
+	}
+
+	// Both numeric or both alpha: string comparison (works for single-char alpha)
+	if baseA < baseB {
+		return -1
+	}
+	if baseA > baseB {
+		return 1
+	}
+	return 0
+}
+
+// UpdateFromDir re-indexes a single transmittal folder (called by the watcher).
+func (idx *Index) UpdateFromDir(fsRoot, transmittalDirPath string) error {
+	// Determine the date from the folder name
+	folderName := filepath.Base(transmittalDirPath)
+	m := transmittalFolderRE.FindStringSubmatch(folderName)
+	if m == nil {
+		return nil // not a transmittal folder
+	}
+	date := m[1]
+
+	// Compute server-relative path for this folder
+	rel, err := filepath.Rel(fsRoot, transmittalDirPath)
+	if err != nil {
+		return err
+	}
+	serverDir := filepath.ToSlash(rel)
+
+	return indexTransmittalFolder(idx, fsRoot, transmittalDirPath, serverDir, date)
+}
+
+// TrackingEntrySummary is a minimal summary for archive directory listings.
+type TrackingEntrySummary struct {
+	TrackingNumber string
+	HighestPath    string // server-relative path for the highest base revision
+}
+
+// AllTrackingEntries returns a snapshot of all tracking entries.
+// Safe for concurrent use.
+func (idx *Index) AllTrackingEntries() []TrackingEntrySummary {
+	idx.mu.RLock()
+	defer idx.mu.RUnlock()
+
+	result := make([]TrackingEntrySummary, 0, len(idx.ByTracking))
+	for tn, te := range idx.ByTracking {
+		var highPath string
+		if te.HighestBaseRev != "" {
+			if re, ok := te.ByRevision[te.HighestBaseRev]; ok {
+				highPath = re.BasePath
+			}
+		}
+		result = append(result, TrackingEntrySummary{
+			TrackingNumber: tn,
+			HighestPath:    highPath,
+		})
+	}
+	return result
+}
diff --git a/zddc/internal/archive/resolver.go b/zddc/internal/archive/resolver.go
new file mode 100644
index 0000000..5c2cc8d
--- /dev/null
+++ b/zddc/internal/archive/resolver.go
@@ -0,0 +1,80 @@
+package archive
+
+import (
+	"strings"
+)
+
+// Resolve parses the .archive request filename and returns the server-relative
+// redirect target URL (no leading slash).
+//
+// Supported URL filename patterns (after stripping .html suffix):
+//   - trackingNumber              → highest base revision of trackingNumber
+//   - trackingNumber_rev          → base revision file for rev
+//   - trackingNumber_rev+C1       → modifier file (C1, B1, N1, Q1)
+//
+// Returns ("", false) if the filename cannot be parsed or no match exists.
+func Resolve(idx *Index, filename string) (string, bool) {
+	// Strip .html suffix
+	stem := strings.TrimSuffix(filename, ".html")
+	if stem == filename {
+		// No .html suffix — not a valid archive request
+		return "", false
+	}
+
+	idx.mu.RLock()
+	defer idx.mu.RUnlock()
+
+	// Try to split off revision part (last _ segment)
+	lastUnderscore := strings.LastIndex(stem, "_")
+	if lastUnderscore < 0 {
+		// No underscore — treat entire stem as tracking number
+		tracking := stem
+		te, ok := idx.ByTracking[tracking]
+		if !ok || te.HighestBaseRev == "" {
+			return "", false
+		}
+		re, ok := te.ByRevision[te.HighestBaseRev]
+		if !ok || re.BasePath == "" {
+			return "", false
+		}
+		return re.BasePath, true
+	}
+
+	tracking := stem[:lastUnderscore]
+	revPart := stem[lastUnderscore+1:]
+
+	// Split revPart on "+" to separate baseRev from modifier
+	plusIdx := strings.Index(revPart, "+")
+	var baseRev, modifier string
+	if plusIdx < 0 {
+		baseRev = revPart
+		modifier = ""
+	} else {
+		baseRev = revPart[:plusIdx]
+		modifier = revPart[plusIdx+1:]
+	}
+
+	te, ok := idx.ByTracking[tracking]
+	if !ok {
+		return "", false
+	}
+
+	re, ok := te.ByRevision[baseRev]
+	if !ok {
+		return "", false
+	}
+
+	if modifier == "" {
+		if re.BasePath == "" {
+			return "", false
+		}
+		return re.BasePath, true
+	}
+
+	// Modifier lookup
+	path, ok := re.Modifiers[modifier]
+	if !ok {
+		return "", false
+	}
+	return path, true
+}
diff --git a/zddc/internal/archive/watcher.go b/zddc/internal/archive/watcher.go
new file mode 100644
index 0000000..fd649e4
--- /dev/null
+++ b/zddc/internal/archive/watcher.go
@@ -0,0 +1,131 @@
+package archive
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/zddc"
+)
+
+// Watcher watches fsRoot for filesystem changes and updates the archive index
+// and the zddc ACL policy cache.
+type Watcher struct {
+	fsRoot  string
+	idx     *Index
+	watcher *fsnotify.Watcher
+
+	// Debounce: pending dir → timer
+	mu      sync.Mutex
+	pending map[string]*time.Timer
+}
+
+// NewWatcher creates a new Watcher. Call Start to begin watching.
+func NewWatcher(fsRoot string, idx *Index) (*Watcher, error) {
+	w, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+	return &Watcher{
+		fsRoot:  fsRoot,
+		idx:     idx,
+		watcher: w,
+		pending: make(map[string]*time.Timer),
+	}, nil
+}
+
+// Start begins watching and blocks until ctx is cancelled.
+// It registers the entire directory tree under fsRoot.
+func (w *Watcher) Start(ctx context.Context) error {
+	// Walk and register all directories
+	if err := filepath.WalkDir(w.fsRoot, func(path string, d os.DirEntry, err error) error {
+		if err != nil || !d.IsDir() {
+			return nil
+		}
+		return w.watcher.Add(path)
+	}); err != nil {
+		return err
+	}
+
+	go func() {
+		defer w.watcher.Close()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+
+			case event, ok := <-w.watcher.Events:
+				if !ok {
+					return
+				}
+				w.handleEvent(event)
+
+			case err, ok := <-w.watcher.Errors:
+				if !ok {
+					return
+				}
+				slog.Warn("fsnotify error", "err", err)
+			}
+		}
+	}()
+
+	<-ctx.Done()
+	return nil
+}
+
+func (w *Watcher) handleEvent(event fsnotify.Event) {
+	path := event.Name
+	base := filepath.Base(path)
+
+	// New directory created — register it
+	if event.Has(fsnotify.Create) {
+		if info, err := os.Stat(path); err == nil && info.IsDir() {
+			_ = w.watcher.Add(path)
+		}
+	}
+
+	// .zddc file changed — invalidate ACL policy cache
+	if base == ".zddc" {
+		dir := filepath.Dir(path)
+		zddc.InvalidateCache(dir)
+		return
+	}
+
+	// Skip dot-files
+	if strings.HasPrefix(base, ".") {
+		return
+	}
+
+	// For transmittal folder events, schedule a debounced index update
+	dirPath := filepath.Dir(path)
+	dirName := filepath.Base(dirPath)
+	if transmittalFolderRE.MatchString(dirName) {
+		w.scheduleIndexUpdate(dirPath)
+	}
+}
+
+// scheduleIndexUpdate debounces an index update for dirPath (2-second delay).
+func (w *Watcher) scheduleIndexUpdate(dirPath string) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	if t, ok := w.pending[dirPath]; ok {
+		t.Reset(2 * time.Second)
+		return
+	}
+
+	w.pending[dirPath] = time.AfterFunc(2*time.Second, func() {
+		w.mu.Lock()
+		delete(w.pending, dirPath)
+		w.mu.Unlock()
+
+		if err := w.idx.UpdateFromDir(w.fsRoot, dirPath); err != nil {
+			slog.Warn("archive index update failed", "dir", dirPath, "err", err)
+		}
+	})
+}
diff --git a/zddc/internal/config/config.go b/zddc/internal/config/config.go
new file mode 100644
index 0000000..ce11acc
--- /dev/null
+++ b/zddc/internal/config/config.go
@@ -0,0 +1,126 @@
+package config
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+)
+
+// Config holds all runtime configuration loaded from environment variables.
+type Config struct {
+	Root        string   // ZDDC_ROOT — absolute path to the served file tree
+	Addr        string   // ZDDC_ADDR — bind address (default :8443)
+	TLSCert     string   // ZDDC_TLS_CERT — path to PEM cert; empty = self-signed
+	TLSKey      string   // ZDDC_TLS_KEY — path to PEM key; empty = self-signed
+	TLSMode     string   // computed from TLSCert/TLSKey: none/selfsigned/provided
+	LogLevel    string   // ZDDC_LOG_LEVEL — debug/info/warn/error (default info)
+	IndexPath   string   // ZDDC_INDEX_PATH — virtual segment name (default .archive)
+	EmailHeader string   // ZDDC_EMAIL_HEADER — header name for user email (default X-Email)
+	CORSOrigins []string // ZDDC_CORS_ORIGIN — comma-separated CORS allowlist; default https://zddc.varasys.io; empty disables
+}
+
+// Load reads configuration from environment variables and validates required fields.
+func Load() (Config, error) {
+	cfg := Config{
+		Addr:        getEnv("ZDDC_ADDR", ":8443"),
+		Root:        os.Getenv("ZDDC_ROOT"),
+		TLSCert:     os.Getenv("ZDDC_TLS_CERT"),
+		TLSKey:      os.Getenv("ZDDC_TLS_KEY"),
+		LogLevel:    getEnv("ZDDC_LOG_LEVEL", "info"),
+		IndexPath:   getEnv("ZDDC_INDEX_PATH", ".archive"),
+		EmailHeader: getEnv("ZDDC_EMAIL_HEADER", "X-Email"),
+		CORSOrigins: parseCORSOrigins(),
+	}
+
+	if cfg.Root == "" {
+		return Config{}, errors.New("ZDDC_ROOT environment variable is required")
+	}
+
+	info, err := os.Stat(cfg.Root)
+	if err != nil {
+		return Config{}, fmt.Errorf("ZDDC_ROOT %q is not accessible: %w", cfg.Root, err)
+	}
+	if !info.IsDir() {
+		return Config{}, fmt.Errorf("ZDDC_ROOT %q is not a directory", cfg.Root)
+	}
+
+	// Determine TLS mode
+	if cfg.TLSCert == "none" {
+		cfg.TLSMode = "none"
+	} else if cfg.TLSCert == "" && cfg.TLSKey == "" {
+		cfg.TLSMode = "selfsigned"
+	} else {
+		cfg.TLSMode = "provided"
+	}
+
+	// Cert and key must both be set or both be empty only when TLSMode == "provided"
+	if cfg.TLSMode == "provided" && (cfg.TLSCert == "") != (cfg.TLSKey == "") {
+		return Config{}, errors.New("ZDDC_TLS_CERT and ZDDC_TLS_KEY must both be set or both be empty")
+	}
+
+	// Plain HTTP mode trusts the X-Email header from any client. That is only
+	// safe behind an authenticating reverse proxy, so refuse to start when
+	// binding plain HTTP to a non-loopback interface unless the operator has
+	// explicitly acknowledged the deployment shape via ZDDC_INSECURE_DIRECT=1.
+	if cfg.TLSMode == "none" && !isLoopbackAddr(cfg.Addr) && os.Getenv("ZDDC_INSECURE_DIRECT") != "1" {
+		return Config{}, fmt.Errorf(
+			"ZDDC_TLS_CERT=none binds plain HTTP to %q which trusts %s headers from any client; "+
+				"either use TLS (unset ZDDC_TLS_CERT or supply a cert), bind to loopback (127.0.0.1: or [::1]:), "+
+				"or set ZDDC_INSECURE_DIRECT=1 to confirm an authenticating reverse proxy is in front",
+			cfg.Addr, cfg.EmailHeader)
+	}
+
+	return cfg, nil
+}
+
+// isLoopbackAddr reports whether addr binds only to a loopback interface.
+// addr is in net.Listen form: "host:port", ":port", or "[ipv6]:port".
+// ":port" means all interfaces, so it is NOT loopback.
+func isLoopbackAddr(addr string) bool {
+	host, _, err := net.SplitHostPort(addr)
+	if err != nil {
+		return false
+	}
+	if host == "" {
+		return false
+	}
+	if host == "localhost" {
+		return true
+	}
+	ip := net.ParseIP(host)
+	if ip == nil {
+		return false
+	}
+	return ip.IsLoopback()
+}
+
+func getEnv(key, fallback string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return fallback
+}
+
+// parseCORSOrigins reads ZDDC_CORS_ORIGIN as a comma-separated allowlist.
+// Unset → default to https://zddc.varasys.io. Empty string → CORS disabled.
+// Origins are not validated as URLs here; the middleware does an exact-match
+// comparison against the request's Origin header.
+func parseCORSOrigins() []string {
+	v, ok := os.LookupEnv("ZDDC_CORS_ORIGIN")
+	if !ok {
+		return []string{"https://zddc.varasys.io"}
+	}
+	if v == "" {
+		return nil
+	}
+	parts := strings.Split(v, ",")
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if s := strings.TrimSpace(p); s != "" {
+			out = append(out, s)
+		}
+	}
+	return out
+}
diff --git a/zddc/internal/config/config_test.go b/zddc/internal/config/config_test.go
new file mode 100644
index 0000000..7769669
--- /dev/null
+++ b/zddc/internal/config/config_test.go
@@ -0,0 +1,229 @@
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestIsLoopbackAddr(t *testing.T) {
+	cases := []struct {
+		addr string
+		want bool
+	}{
+		{"127.0.0.1:8080", true},
+		{"localhost:8080", true},
+		{"[::1]:8080", true},
+		{"127.0.0.5:80", true}, // any 127/8 is loopback
+		{"0.0.0.0:8080", false},
+		{":8443", false}, // bare port = all interfaces
+		{"10.0.0.1:80", false},
+		{"example.com:443", false},
+		{"[2001:db8::1]:80", false},
+		{"", false},
+		{"not-an-addr", false}, // SplitHostPort fails
+	}
+	for _, tc := range cases {
+		t.Run(tc.addr, func(t *testing.T) {
+			if got := isLoopbackAddr(tc.addr); got != tc.want {
+				t.Errorf("isLoopbackAddr(%q) = %v, want %v", tc.addr, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestLoad(t *testing.T) {
+	root := t.TempDir()
+
+	// Pre-set the env so each subtest can override what it needs.
+	type envSet map[string]string
+	clearAll := func() {
+		for _, k := range []string{"ZDDC_ROOT", "ZDDC_ADDR", "ZDDC_TLS_CERT", "ZDDC_TLS_KEY", "ZDDC_INSECURE_DIRECT", "ZDDC_LOG_LEVEL", "ZDDC_INDEX_PATH", "ZDDC_EMAIL_HEADER", "ZDDC_CORS_ORIGIN"} {
+			os.Unsetenv(k)
+		}
+	}
+	apply := func(env envSet) {
+		clearAll()
+		for k, v := range env {
+			os.Setenv(k, v)
+		}
+	}
+
+	cases := []struct {
+		name        string
+		env         envSet
+		wantErr     bool
+		errContains string
+		check       func(*testing.T, Config)
+	}{
+		{
+			name: "missing root",
+			env:  envSet{},
+			// ZDDC_ROOT not set
+			wantErr:     true,
+			errContains: "ZDDC_ROOT",
+		},
+		{
+			name:        "root not a directory",
+			env:         envSet{"ZDDC_ROOT": filepath.Join(root, "does-not-exist")},
+			wantErr:     true,
+			errContains: "not accessible",
+		},
+		{
+			name: "defaults applied with TLS self-signed",
+			env:  envSet{"ZDDC_ROOT": root},
+			check: func(t *testing.T, cfg Config) {
+				if cfg.Addr != ":8443" {
+					t.Errorf("Addr = %q, want :8443", cfg.Addr)
+				}
+				if cfg.TLSMode != "selfsigned" {
+					t.Errorf("TLSMode = %q, want selfsigned", cfg.TLSMode)
+				}
+				if cfg.IndexPath != ".archive" {
+					t.Errorf("IndexPath = %q, want .archive", cfg.IndexPath)
+				}
+				if cfg.EmailHeader != "X-Email" {
+					t.Errorf("EmailHeader = %q, want X-Email", cfg.EmailHeader)
+				}
+				if len(cfg.CORSOrigins) != 1 || cfg.CORSOrigins[0] != "https://zddc.varasys.io" {
+					t.Errorf("CORSOrigins = %v, want [https://zddc.varasys.io]", cfg.CORSOrigins)
+				}
+			},
+		},
+		{
+			name: "CORS single origin override",
+			env: envSet{
+				"ZDDC_ROOT":        root,
+				"ZDDC_CORS_ORIGIN": "https://tools.acme.com",
+			},
+			check: func(t *testing.T, cfg Config) {
+				if len(cfg.CORSOrigins) != 1 || cfg.CORSOrigins[0] != "https://tools.acme.com" {
+					t.Errorf("CORSOrigins = %v, want [https://tools.acme.com]", cfg.CORSOrigins)
+				}
+			},
+		},
+		{
+			name: "CORS multi-origin allowlist",
+			env: envSet{
+				"ZDDC_ROOT":        root,
+				"ZDDC_CORS_ORIGIN": "https://a.example, https://b.example ,https://c.example",
+			},
+			check: func(t *testing.T, cfg Config) {
+				want := []string{"https://a.example", "https://b.example", "https://c.example"}
+				if len(cfg.CORSOrigins) != len(want) {
+					t.Fatalf("CORSOrigins = %v, want %v", cfg.CORSOrigins, want)
+				}
+				for i, w := range want {
+					if cfg.CORSOrigins[i] != w {
+						t.Errorf("CORSOrigins[%d] = %q, want %q", i, cfg.CORSOrigins[i], w)
+					}
+				}
+			},
+		},
+		{
+			name: "CORS disabled with empty value",
+			env: envSet{
+				"ZDDC_ROOT":        root,
+				"ZDDC_CORS_ORIGIN": "",
+			},
+			check: func(t *testing.T, cfg Config) {
+				if len(cfg.CORSOrigins) != 0 {
+					t.Errorf("CORSOrigins = %v, want empty (CORS disabled)", cfg.CORSOrigins)
+				}
+			},
+		},
+		{
+			name: "TLS provided requires both cert and key",
+			env: envSet{
+				"ZDDC_ROOT":     root,
+				"ZDDC_TLS_CERT": "/some/cert.pem",
+				// missing key
+			},
+			wantErr:     true,
+			errContains: "both be set or both be empty",
+		},
+		{
+			name: "plain HTTP on all interfaces without insecure flag is rejected",
+			env: envSet{
+				"ZDDC_ROOT":     root,
+				"ZDDC_TLS_CERT": "none",
+				"ZDDC_ADDR":     ":8080",
+			},
+			wantErr:     true,
+			errContains: "ZDDC_INSECURE_DIRECT",
+		},
+		{
+			name: "plain HTTP on 0.0.0.0 without insecure flag is rejected",
+			env: envSet{
+				"ZDDC_ROOT":     root,
+				"ZDDC_TLS_CERT": "none",
+				"ZDDC_ADDR":     "0.0.0.0:8080",
+			},
+			wantErr:     true,
+			errContains: "ZDDC_INSECURE_DIRECT",
+		},
+		{
+			name: "plain HTTP on loopback is allowed",
+			env: envSet{
+				"ZDDC_ROOT":     root,
+				"ZDDC_TLS_CERT": "none",
+				"ZDDC_ADDR":     "127.0.0.1:8080",
+			},
+			check: func(t *testing.T, cfg Config) {
+				if cfg.TLSMode != "none" {
+					t.Errorf("TLSMode = %q, want none", cfg.TLSMode)
+				}
+			},
+		},
+		{
+			name: "plain HTTP on non-loopback with explicit opt-in is allowed",
+			env: envSet{
+				"ZDDC_ROOT":            root,
+				"ZDDC_TLS_CERT":        "none",
+				"ZDDC_ADDR":            ":8080",
+				"ZDDC_INSECURE_DIRECT": "1",
+			},
+			check: func(t *testing.T, cfg Config) {
+				if cfg.TLSMode != "none" {
+					t.Errorf("TLSMode = %q, want none", cfg.TLSMode)
+				}
+			},
+		},
+		{
+			name: "ZDDC_INSECURE_DIRECT set to non-1 is not opt-in",
+			env: envSet{
+				"ZDDC_ROOT":            root,
+				"ZDDC_TLS_CERT":        "none",
+				"ZDDC_ADDR":            ":8080",
+				"ZDDC_INSECURE_DIRECT": "true", // must be exactly "1"
+			},
+			wantErr:     true,
+			errContains: "ZDDC_INSECURE_DIRECT",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			apply(tc.env)
+			defer clearAll()
+
+			cfg, err := Load()
+			if tc.wantErr {
+				if err == nil {
+					t.Fatalf("Load() = nil error, want error containing %q", tc.errContains)
+				}
+				if tc.errContains != "" && !strings.Contains(err.Error(), tc.errContains) {
+					t.Errorf("Load() error = %v, want substring %q", err, tc.errContains)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("Load() unexpected error: %v", err)
+			}
+			if tc.check != nil {
+				tc.check(t, cfg)
+			}
+		})
+	}
+}
diff --git a/zddc/internal/fs/tree.go b/zddc/internal/fs/tree.go
new file mode 100644
index 0000000..a0b5f4f
--- /dev/null
+++ b/zddc/internal/fs/tree.go
@@ -0,0 +1,93 @@
+package fs
+
+import (
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/listing"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/zddc"
+)
+
+// safeJoin joins fsRoot and relPath, then verifies the result is under fsRoot.
+// Returns ("", false) if relPath would escape fsRoot.
+func safeJoin(fsRoot, relPath string) (string, bool) {
+	abs := filepath.Join(fsRoot, filepath.FromSlash(relPath))
+	if !strings.HasPrefix(abs, fsRoot+string(filepath.Separator)) && abs != fsRoot {
+		return "", false
+	}
+	return abs, true
+}
+
+// ListDirectory returns a Caddy-compatible JSON listing for the directory at
+// filepath.Join(fsRoot, dirPath), filtered by ACL for userEmail.
+//
+// Rules:
+//   - Hidden files and .zddc files are excluded
+//   - *.portfolio files appear as virtual directories (stem + "/")
+//   - Subdirectories for which the user lacks access are omitted (not 403'd inline)
+//   - dirPath="" means the root of the served tree
+//
+// baseURL should end with "/" and is the URL prefix for this directory.
+func ListDirectory(fsRoot, dirPath, userEmail, baseURL string) ([]listing.FileInfo, error) {
+	absDir, ok := safeJoin(fsRoot, dirPath)
+	if !ok {
+		return nil, os.ErrNotExist
+	}
+
+	entries, err := os.ReadDir(absDir)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []listing.FileInfo
+
+	for _, entry := range entries {
+		name := entry.Name()
+
+		// Skip hidden files and dotfiles (including .zddc)
+		if strings.HasPrefix(name, ".") {
+			continue
+		}
+
+		info, err := entry.Info()
+		if err != nil {
+			continue
+		}
+
+		isDir := entry.IsDir()
+
+		if isDir {
+			// ACL check for subdirectory
+			subAbs := filepath.Join(absDir, name)
+			chain, err := zddc.EffectivePolicy(fsRoot, subAbs)
+			if err != nil || !zddc.AllowedWithChain(chain, userEmail) {
+				continue // omit denied directories silently
+			}
+			fi := listing.FileInfo{
+				Name:    name + "/",
+				Size:    info.Size(),
+				URL:     baseURL + url.PathEscape(name) + "/",
+				ModTime: info.ModTime(),
+				Mode:    uint32(info.Mode()),
+				IsDir:   true,
+			}
+			result = append(result, fi)
+			continue
+		}
+
+		// Regular file
+		fi := listing.FileInfo{
+			Name:    name,
+			Size:    info.Size(),
+			URL:     baseURL + url.PathEscape(name),
+			ModTime: info.ModTime(),
+			Mode:    uint32(info.Mode()),
+			IsDir:   false,
+		}
+		result = append(result, fi)
+	}
+
+	return result, nil
+}
diff --git a/zddc/internal/handler/archivehandler.go b/zddc/internal/handler/archivehandler.go
new file mode 100644
index 0000000..7e33054
--- /dev/null
+++ b/zddc/internal/handler/archivehandler.go
@@ -0,0 +1,92 @@
+package handler
+
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"path/filepath"
+	"strings"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/archive"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/listing"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/zddc"
+)
+
+// ServeArchive handles requests under a .archive virtual path segment.
+//
+// contextPath: the URL path leading up to (but not including) .archive (e.g. "/Project-123")
+// filename:    the part after .archive/ (empty for directory listing)
+func ServeArchive(cfg config.Config, idx *archive.Index, w http.ResponseWriter, r *http.Request, contextPath, filename string) {
+	email := EmailFromContext(r)
+
+	// ACL check on the context directory
+	dirPath := strings.TrimPrefix(contextPath, "/")
+	dirPath = strings.TrimSuffix(dirPath, "/")
+	absDir := filepath.Join(cfg.Root, filepath.FromSlash(dirPath))
+	chain, err := zddc.EffectivePolicy(cfg.Root, absDir)
+	if err != nil {
+		slog.Warn("ACL policy error", "path", absDir, "err", err)
+	}
+	if !zddc.AllowedWithChain(chain, email) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	if filename == "" {
+		// Directory listing: return all trackingNumber.html entries this user can access
+		serveArchiveListing(cfg, idx, w, r, contextPath, email)
+		return
+	}
+
+	// Single file resolve
+	target, ok := archive.Resolve(idx, filename)
+	if !ok {
+		http.Error(w, "Not Found", http.StatusNotFound)
+		return
+	}
+
+	// ACL check on the resolved file's directory (prevents info leakage)
+	fileDir := filepath.Dir(filepath.Join(cfg.Root, filepath.FromSlash(target)))
+	chain, err = zddc.EffectivePolicy(cfg.Root, fileDir)
+	if err != nil {
+		slog.Warn("ACL policy error on resolved file", "path", fileDir, "err", err)
+	}
+	if !zddc.AllowedWithChain(chain, email) {
+		http.Error(w, "Not Found", http.StatusNotFound)
+		return
+	}
+
+	// 302 redirect to the real file path
+	http.Redirect(w, r, "/"+target, http.StatusFound)
+}
+
+func serveArchiveListing(cfg config.Config, idx *archive.Index, w http.ResponseWriter, r *http.Request, contextPath, email string) {
+	allEntries := idx.AllTrackingEntries()
+	archiveBase := contextPath + "/" + cfg.IndexPath + "/"
+
+	var result []listing.FileInfo
+	for _, item := range allEntries {
+		if item.HighestPath == "" {
+			continue
+		}
+		// ACL check on the resolved file's directory
+		fileDir := filepath.Dir(filepath.Join(cfg.Root, filepath.FromSlash(item.HighestPath)))
+		chain, err := zddc.EffectivePolicy(cfg.Root, fileDir)
+		if err != nil || !zddc.AllowedWithChain(chain, email) {
+			continue
+		}
+		entryName := item.TrackingNumber + ".html"
+		result = append(result, listing.FileInfo{
+			Name:  entryName,
+			URL:   archiveBase + entryName,
+			IsDir: false,
+		})
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Cache-Control", "no-cache")
+	if err := json.NewEncoder(w).Encode(result); err != nil {
+		slog.Error("encoding archive listing", "err", err)
+	}
+}
diff --git a/zddc/internal/handler/cors.go b/zddc/internal/handler/cors.go
new file mode 100644
index 0000000..823e641
--- /dev/null
+++ b/zddc/internal/handler/cors.go
@@ -0,0 +1,54 @@
+package handler
+
+import (
+	"net/http"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+)
+
+// CORSMiddleware applies a per-origin CORS policy keyed off cfg.CORSOrigins.
+//
+// On any request whose Origin header exactly matches an entry in the
+// allowlist, the middleware echoes that origin in Access-Control-Allow-Origin
+// and sets Access-Control-Allow-Credentials: true (we use credentials so the
+// reverse-proxy-set X-Email header / cookies cross the boundary). Vary: Origin
+// is always set when the allowlist is non-empty so caches do not collapse
+// per-origin responses.
+//
+// OPTIONS preflight requests are answered directly with 204 + the appropriate
+// allow-methods/headers, bypassing later middleware (so preflight does not
+// require auth). Non-OPTIONS requests pass through to the next handler.
+//
+// Requests with no Origin header, or an Origin that does not match the
+// allowlist, get no CORS response headers — the browser blocks them
+// naturally. An empty allowlist disables CORS entirely.
+func CORSMiddleware(cfg config.Config, next http.Handler) http.Handler {
+	if len(cfg.CORSOrigins) == 0 {
+		return next
+	}
+	allow := make(map[string]struct{}, len(cfg.CORSOrigins))
+	for _, o := range cfg.CORSOrigins {
+		allow[o] = struct{}{}
+	}
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		origin := r.Header.Get("Origin")
+		if origin != "" {
+			if _, ok := allow[origin]; ok {
+				h := w.Header()
+				h.Set("Access-Control-Allow-Origin", origin)
+				h.Set("Access-Control-Allow-Credentials", "true")
+				h.Add("Vary", "Origin")
+				if r.Method == http.MethodOptions {
+					if reqHeaders := r.Header.Get("Access-Control-Request-Headers"); reqHeaders != "" {
+						h.Set("Access-Control-Allow-Headers", reqHeaders)
+					}
+					h.Set("Access-Control-Allow-Methods", "GET, OPTIONS")
+					h.Set("Access-Control-Max-Age", "600")
+					w.WriteHeader(http.StatusNoContent)
+					return
+				}
+			}
+		}
+		next.ServeHTTP(w, r)
+	})
+}
diff --git a/zddc/internal/handler/cors_test.go b/zddc/internal/handler/cors_test.go
new file mode 100644
index 0000000..90b0512
--- /dev/null
+++ b/zddc/internal/handler/cors_test.go
@@ -0,0 +1,140 @@
+package handler
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+)
+
+func TestCORSMiddleware(t *testing.T) {
+	allowed := config.Config{CORSOrigins: []string{"https://zddc.varasys.io", "https://other.example"}}
+	disabled := config.Config{CORSOrigins: nil}
+
+	pass := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte("ok"))
+	})
+
+	cases := []struct {
+		name           string
+		cfg            config.Config
+		method         string
+		origin         string
+		acrHeaders     string
+		wantStatus     int
+		wantAllowOrig  string
+		wantAllowCreds string
+		wantVary       string
+		wantAllowHdrs  string
+		wantNextCalled bool
+	}{
+		{
+			name:           "allowed origin, GET",
+			cfg:            allowed,
+			method:         http.MethodGet,
+			origin:         "https://zddc.varasys.io",
+			wantStatus:     http.StatusOK,
+			wantAllowOrig:  "https://zddc.varasys.io",
+			wantAllowCreds: "true",
+			wantVary:       "Origin",
+			wantNextCalled: true,
+		},
+		{
+			name:           "second allowed origin, GET",
+			cfg:            allowed,
+			method:         http.MethodGet,
+			origin:         "https://other.example",
+			wantStatus:     http.StatusOK,
+			wantAllowOrig:  "https://other.example",
+			wantAllowCreds: "true",
+			wantVary:       "Origin",
+			wantNextCalled: true,
+		},
+		{
+			name:           "disallowed origin, GET",
+			cfg:            allowed,
+			method:         http.MethodGet,
+			origin:         "https://evil.example",
+			wantStatus:     http.StatusOK,
+			wantNextCalled: true,
+		},
+		{
+			name:           "no Origin header, GET",
+			cfg:            allowed,
+			method:         http.MethodGet,
+			wantStatus:     http.StatusOK,
+			wantNextCalled: true,
+		},
+		{
+			name:           "OPTIONS preflight, allowed origin",
+			cfg:            allowed,
+			method:         http.MethodOptions,
+			origin:         "https://zddc.varasys.io",
+			acrHeaders:     "X-Email, Content-Type",
+			wantStatus:     http.StatusNoContent,
+			wantAllowOrig:  "https://zddc.varasys.io",
+			wantAllowCreds: "true",
+			wantVary:       "Origin",
+			wantAllowHdrs:  "X-Email, Content-Type",
+			wantNextCalled: false,
+		},
+		{
+			name:           "OPTIONS preflight, disallowed origin falls through",
+			cfg:            allowed,
+			method:         http.MethodOptions,
+			origin:         "https://evil.example",
+			wantStatus:     http.StatusOK,
+			wantNextCalled: true,
+		},
+		{
+			name:           "CORS disabled passes through",
+			cfg:            disabled,
+			method:         http.MethodGet,
+			origin:         "https://zddc.varasys.io",
+			wantStatus:     http.StatusOK,
+			wantNextCalled: true,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			called := false
+			next := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				called = true
+				pass.ServeHTTP(w, r)
+			})
+			h := CORSMiddleware(tc.cfg, next)
+
+			req := httptest.NewRequest(tc.method, "/", nil)
+			if tc.origin != "" {
+				req.Header.Set("Origin", tc.origin)
+			}
+			if tc.acrHeaders != "" {
+				req.Header.Set("Access-Control-Request-Headers", tc.acrHeaders)
+			}
+			rec := httptest.NewRecorder()
+			h.ServeHTTP(rec, req)
+
+			if rec.Code != tc.wantStatus {
+				t.Errorf("status = %d, want %d", rec.Code, tc.wantStatus)
+			}
+			if got := rec.Header().Get("Access-Control-Allow-Origin"); got != tc.wantAllowOrig {
+				t.Errorf("Access-Control-Allow-Origin = %q, want %q", got, tc.wantAllowOrig)
+			}
+			if got := rec.Header().Get("Access-Control-Allow-Credentials"); got != tc.wantAllowCreds {
+				t.Errorf("Access-Control-Allow-Credentials = %q, want %q", got, tc.wantAllowCreds)
+			}
+			if got := rec.Header().Get("Vary"); got != tc.wantVary {
+				t.Errorf("Vary = %q, want %q", got, tc.wantVary)
+			}
+			if got := rec.Header().Get("Access-Control-Allow-Headers"); got != tc.wantAllowHdrs {
+				t.Errorf("Access-Control-Allow-Headers = %q, want %q", got, tc.wantAllowHdrs)
+			}
+			if called != tc.wantNextCalled {
+				t.Errorf("next called = %v, want %v", called, tc.wantNextCalled)
+			}
+		})
+	}
+}
diff --git a/zddc/internal/handler/directory.go b/zddc/internal/handler/directory.go
new file mode 100644
index 0000000..57393a5
--- /dev/null
+++ b/zddc/internal/handler/directory.go
@@ -0,0 +1,102 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+	appfs "codeberg.org/VARASYS/ZDDC/zddc/internal/fs"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/zddc"
+)
+
+// safeJoin joins fsRoot and relPath, then verifies the result is under fsRoot.
+// Returns ("", false) if relPath would escape fsRoot.
+func safeJoin(fsRoot, relPath string) (string, bool) {
+	abs := filepath.Join(fsRoot, filepath.FromSlash(relPath))
+	if !strings.HasPrefix(abs, fsRoot+string(filepath.Separator)) && abs != fsRoot {
+		return "", false
+	}
+	return abs, true
+}
+
+// ServeDirectory handles a request for a directory path.
+// If Accept: application/json → return Caddy-compatible JSON listing.
+// Otherwise → return minimal HTML.
+func ServeDirectory(cfg config.Config, w http.ResponseWriter, r *http.Request) {
+	urlPath := r.URL.Path
+	if !strings.HasSuffix(urlPath, "/") {
+		http.Redirect(w, r, urlPath+"/", http.StatusMovedPermanently)
+		return
+	}
+
+	email := EmailFromContext(r)
+
+	// Compute relative dir path (no leading or trailing slash)
+	dirPath := strings.TrimPrefix(urlPath, "/")
+	dirPath = strings.TrimSuffix(dirPath, "/")
+
+	// ACL check on this directory itself
+	absDir, ok := safeJoin(cfg.Root, dirPath)
+	if !ok {
+		http.Error(w, "Not Found", http.StatusNotFound)
+		return
+	}
+	chain, err := zddc.EffectivePolicy(cfg.Root, absDir)
+	if err != nil {
+		slog.Warn("ACL policy error", "path", absDir, "err", err)
+	}
+	if !zddc.AllowedWithChain(chain, email) {
+		http.Error(w, "Forbidden", http.StatusForbidden)
+		return
+	}
+
+	accept := r.Header.Get("Accept")
+
+	// For HTML requests, serve index.html if present (landing page convention)
+	if !strings.Contains(accept, "application/json") {
+		indexPath := filepath.Join(absDir, "index.html")
+		if info, err := os.Stat(indexPath); err == nil && !info.IsDir() {
+			ServeFile(w, r, indexPath)
+			return
+		}
+	}
+
+	// Build base URL for listing entries
+	baseURL := urlPath // relative URLs suffice for JSON listings
+
+	entries, err := appfs.ListDirectory(cfg.Root, dirPath, email, baseURL)
+	if err != nil {
+		if os.IsNotExist(err) {
+			http.Error(w, "Not Found", http.StatusNotFound)
+		} else {
+			slog.Error("listing directory", "path", dirPath, "err", err)
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	if strings.Contains(accept, "application/json") {
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Cache-Control", "no-cache")
+		if err := json.NewEncoder(w).Encode(entries); err != nil {
+			slog.Error("encoding directory listing", "err", err)
+		}
+		return
+	}
+
+	// Minimal HTML for accidental browser navigation
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	fmt.Fprintf(w,
+		`<!DOCTYPE html><html><head><meta charset="utf-8"><title>Index of %s</title></head>`+
+			`<body><h1>Index of %s</h1>`+
+			`<p>This server is designed to be used with the ZDDC Archive Browser. `+
+			`Directory listings are available as JSON (Accept: application/json).</p>`+
+			`</body></html>`,
+		urlPath, urlPath,
+	)
+}
diff --git a/zddc/internal/handler/middleware.go b/zddc/internal/handler/middleware.go
new file mode 100644
index 0000000..88a2e91
--- /dev/null
+++ b/zddc/internal/handler/middleware.go
@@ -0,0 +1,90 @@
+package handler
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+	"log/slog"
+)
+
+type contextKey string
+
+// EmailKey is the context key for the authenticated user's email.
+const EmailKey contextKey = "email"
+
+// ACLMiddleware extracts the user email from the configured header and stores
+// it in the request context. It does NOT enforce ACL itself — each handler
+// performs its own ACL check via zddc.EffectivePolicy / zddc.AllowedWithChain.
+func ACLMiddleware(cfg config.Config, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		email := r.Header.Get(cfg.EmailHeader)
+		ctx := context.WithValue(r.Context(), EmailKey, email)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+// EmailFromContext extracts the user email from the request context.
+func EmailFromContext(r *http.Request) string {
+	if v, ok := r.Context().Value(EmailKey).(string); ok {
+		return v
+	}
+	return ""
+}
+
+// responseWriter wraps http.ResponseWriter to capture status code and bytes written.
+type responseWriter struct {
+	http.ResponseWriter
+	status int
+	bytes  int
+	wrote  bool
+}
+
+// WriteHeader records the status code and writes it to the underlying ResponseWriter.
+func (rw *responseWriter) WriteHeader(code int) {
+	rw.status = code
+	rw.wrote = true
+	rw.ResponseWriter.WriteHeader(code)
+}
+
+// Write records the bytes written and writes to the underlying ResponseWriter.
+func (rw *responseWriter) Write(b []byte) (int, error) {
+	n, err := rw.ResponseWriter.Write(b)
+	rw.bytes += n
+	return n, err
+}
+
+// AccessLogMiddleware logs a structured line per HTTP request after the response is written.
+func AccessLogMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Capture request start time
+		start := time.Now()
+
+		// Wrap the ResponseWriter
+		wrapped := &responseWriter{ResponseWriter: w, status: 200}
+
+		// Serve the request
+		next.ServeHTTP(wrapped, r)
+
+		// Calculate duration
+		durationMs := int(time.Since(start).Milliseconds())
+
+		// Get email from context
+		email := EmailFromContext(r)
+		if email == "" {
+			email = "anonymous"
+		}
+
+		// Log access
+		slog.Info("access",
+			"ts", start.Format(time.RFC3339),
+			"email", email,
+			"method", r.Method,
+			"path", r.URL.Path,
+			"status", wrapped.status,
+			"bytes", wrapped.bytes,
+			"duration_ms", durationMs,
+		)
+	})
+}
diff --git a/zddc/internal/handler/projectshandler.go b/zddc/internal/handler/projectshandler.go
new file mode 100644
index 0000000..3343c7e
--- /dev/null
+++ b/zddc/internal/handler/projectshandler.go
@@ -0,0 +1,63 @@
+package handler
+
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/zddc"
+)
+
+// ProjectInfo is a single entry in the project list response.
+type ProjectInfo struct {
+	Name string `json:"name"`
+	URL  string `json:"url"`
+}
+
+// ServeProjectList handles GET / with Accept: application/json.
+// It returns all top-level directories under cfg.Root that the requesting
+// user has access to, as a JSON array of ProjectInfo.
+func ServeProjectList(cfg config.Config, w http.ResponseWriter, r *http.Request) {
+	email := EmailFromContext(r)
+
+	entries, err := os.ReadDir(cfg.Root)
+	if err != nil {
+		slog.Error("reading root directory", "err", err)
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+
+	var projects []ProjectInfo
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		name := entry.Name()
+		// Skip hidden directories
+		if strings.HasPrefix(name, ".") {
+			continue
+		}
+		absPath := filepath.Join(cfg.Root, name)
+		chain, err := zddc.EffectivePolicy(cfg.Root, absPath)
+		if err != nil {
+			slog.Warn("ACL policy error", "path", absPath, "err", err)
+		}
+		if !zddc.AllowedWithChain(chain, email) {
+			continue
+		}
+		projects = append(projects, ProjectInfo{
+			Name: name,
+			URL:  "/" + name + "/",
+		})
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Header().Set("Cache-Control", "no-cache")
+	if err := json.NewEncoder(w).Encode(projects); err != nil {
+		slog.Error("encoding project list", "err", err)
+	}
+}
diff --git a/zddc/internal/handler/static.go b/zddc/internal/handler/static.go
new file mode 100644
index 0000000..654dad2
--- /dev/null
+++ b/zddc/internal/handler/static.go
@@ -0,0 +1,98 @@
+package handler
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"mime"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+// etagCache caches (etag, modtime) keyed by absolute file path.
+// Key: path, Value: etagCacheEntry
+var etagCacheM sync.Map
+
+type etagCacheEntry struct {
+	modTime time.Time
+	etag    string
+}
+
+// ServeFile serves a single file with ETag, conditional GET (If-None-Match,
+// If-Modified-Since), and Cache-Control headers.
+// fsPath is the absolute filesystem path to the file.
+func ServeFile(w http.ResponseWriter, r *http.Request, fsPath string) {
+	f, err := os.Open(fsPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			http.Error(w, "Not Found", http.StatusNotFound)
+		} else {
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		}
+		return
+	}
+	defer f.Close()
+
+	info, err := f.Stat()
+	if err != nil {
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+	if info.IsDir() {
+		http.Error(w, "Not a file", http.StatusBadRequest)
+		return
+	}
+
+	etag := computeETag(fsPath, info.ModTime(), f)
+
+	// Set headers
+	w.Header().Set("ETag", fmt.Sprintf(`"%s"`, etag))
+	w.Header().Set("Cache-Control", "public, max-age=3600, must-revalidate")
+
+	// Conditional GET: If-None-Match
+	if match := r.Header.Get("If-None-Match"); match != "" {
+		if match == fmt.Sprintf(`"%s"`, etag) {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
+	}
+
+	// Content-Type
+	ext := filepath.Ext(fsPath)
+	ct := mime.TypeByExtension(ext)
+	if ct == "" {
+		ct = "application/octet-stream"
+	}
+	w.Header().Set("Content-Type", ct)
+
+	// Seek back to start after ETag computation
+	if _, err := f.Seek(0, io.SeekStart); err != nil {
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+
+	http.ServeContent(w, r, info.Name(), info.ModTime(), f)
+}
+
+// computeETag returns the SHA-256 ETag for a file, using a modtime-keyed cache.
+func computeETag(path string, modTime time.Time, f *os.File) string {
+	if entry, ok := etagCacheM.Load(path); ok {
+		cached := entry.(etagCacheEntry)
+		if cached.modTime.Equal(modTime) {
+			return cached.etag
+		}
+	}
+
+	h := sha256.New()
+	if _, err := f.Seek(0, io.SeekStart); err == nil {
+		io.Copy(h, f)
+	}
+	etag := hex.EncodeToString(h.Sum(nil))[:32] // first 32 hex chars (128 bits) is sufficient
+
+	etagCacheM.Store(path, etagCacheEntry{modTime: modTime, etag: etag})
+	return etag
+}
diff --git a/zddc/internal/listing/listing.go b/zddc/internal/listing/listing.go
new file mode 100644
index 0000000..c435ff8
--- /dev/null
+++ b/zddc/internal/listing/listing.go
@@ -0,0 +1,46 @@
+package listing
+
+import (
+	"net/url"
+	"os"
+)
+
+// FromDirEntries converts os.DirEntry slice to []FileInfo.
+// baseURL is the URL prefix for this directory (must end with "/").
+// Hidden files (starting with ".") are excluded.
+func FromDirEntries(entries []os.DirEntry, baseURL string) ([]FileInfo, error) {
+	var result []FileInfo
+	for _, entry := range entries {
+		name := entry.Name()
+
+		// Skip hidden files and dotfiles
+		if len(name) == 0 || name[0] == '.' {
+			continue
+		}
+
+		info, err := entry.Info()
+		if err != nil {
+			continue
+		}
+
+		isDir := entry.IsDir()
+		entryName := name
+		entryURL := baseURL + url.PathEscape(name)
+		if isDir {
+			entryName = name + "/"
+			entryURL = baseURL + url.PathEscape(name) + "/"
+		}
+
+		fi := FileInfo{
+			Name:      entryName,
+			Size:      info.Size(),
+			URL:       entryURL,
+			ModTime:   info.ModTime(),
+			Mode:      uint32(info.Mode()),
+			IsDir:     isDir,
+			IsSymlink: false,
+		}
+		result = append(result, fi)
+	}
+	return result, nil
+}
diff --git a/zddc/internal/listing/types.go b/zddc/internal/listing/types.go
new file mode 100644
index 0000000..6934a6f
--- /dev/null
+++ b/zddc/internal/listing/types.go
@@ -0,0 +1,15 @@
+package listing
+
+import "time"
+
+// FileInfo matches Caddy's browse JSON output exactly.
+// The archive browser (source.js) expects this exact shape.
+type FileInfo struct {
+	Name      string    `json:"name"`       // filename; directories have a trailing "/"
+	Size      int64     `json:"size"`
+	URL       string    `json:"url"`        // relative URL to the item
+	ModTime   time.Time `json:"mod_time"`
+	Mode      uint32    `json:"mode"`
+	IsDir     bool      `json:"is_dir"`
+	IsSymlink bool      `json:"is_symlink"` // always false — no real symlinks served
+}
diff --git a/zddc/internal/tlsutil/selfsigned.go b/zddc/internal/tlsutil/selfsigned.go
new file mode 100644
index 0000000..1c8caab
--- /dev/null
+++ b/zddc/internal/tlsutil/selfsigned.go
@@ -0,0 +1,86 @@
+package tlsutil
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"math/big"
+	"net"
+	"time"
+
+	"codeberg.org/VARASYS/ZDDC/zddc/internal/config"
+)
+
+// TLSConfig returns a *tls.Config and a flag indicating whether to use TLS.
+// If cfg.TLSMode is "none", returns (nil, false, nil) for plain HTTP.
+// If cfg.TLSMode is "selfsigned" or "provided", returns a TLS config and true.
+func TLSConfig(cfg config.Config) (*tls.Config, bool, error) {
+	if cfg.TLSMode == "none" {
+		return nil, false, nil
+	}
+
+	var cert tls.Certificate
+	var err error
+
+	if cfg.TLSCert != "" && cfg.TLSKey != "" {
+		cert, err = tls.LoadX509KeyPair(cfg.TLSCert, cfg.TLSKey)
+	} else {
+		cert, err = selfSigned()
+	}
+	if err != nil {
+		return nil, false, err
+	}
+
+	return &tls.Config{
+		Certificates: []tls.Certificate{cert},
+		MinVersion:   tls.VersionTLS12,
+	}, true, nil
+}
+
+// selfSigned generates an in-memory ECDSA P-256 self-signed certificate
+// valid for 10 years. The certificate is never written to disk.
+func selfSigned() (tls.Certificate, error) {
+	priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		return tls.Certificate{}, err
+	}
+
+	serial, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
+	if err != nil {
+		return tls.Certificate{}, err
+	}
+
+	template := &x509.Certificate{
+		SerialNumber: serial,
+		Subject: pkix.Name{
+			CommonName:   "zddc-server",
+			Organization: []string{"ZDDC"},
+		},
+		NotBefore:             time.Now().Add(-time.Minute),
+		NotAfter:              time.Now().Add(10 * 365 * 24 * time.Hour),
+		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		BasicConstraintsValid: true,
+		IPAddresses:           []net.IP{net.ParseIP("127.0.0.1"), net.IPv6loopback},
+		DNSNames:              []string{"localhost"},
+	}
+
+	certDER, err := x509.CreateCertificate(rand.Reader, template, template, &priv.PublicKey, priv)
+	if err != nil {
+		return tls.Certificate{}, err
+	}
+
+	privDER, err := x509.MarshalECPrivateKey(priv)
+	if err != nil {
+		return tls.Certificate{}, err
+	}
+
+	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
+	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: privDER})
+
+	return tls.X509KeyPair(certPEM, keyPEM)
+}
diff --git a/zddc/internal/zddc/acl.go b/zddc/internal/zddc/acl.go
new file mode 100644
index 0000000..1b1223a
--- /dev/null
+++ b/zddc/internal/zddc/acl.go
@@ -0,0 +1,119 @@
+package zddc
+
+import "strings"
+
+// AllowedAtLevel checks whether email is explicitly allowed or denied by a single
+// .zddc level. Returns (decision, matched):
+//   - (false, true)  — email matched a deny pattern → deny
+//   - (true,  true)  — email matched an allow pattern → allow
+//   - (false, false) — no match in this level → keep walking up
+func AllowedAtLevel(level ZddcFile, email string) (decision bool, matched bool) {
+	// deny checked first
+	for _, pattern := range level.ACL.Deny {
+		if matchesPattern(pattern, email) {
+			return false, true
+		}
+	}
+	for _, pattern := range level.ACL.Allow {
+		if matchesPattern(pattern, email) {
+			return true, true
+		}
+	}
+	return false, false
+}
+
+// AllowedWithChain evaluates a PolicyChain bottom-up (deepest level first).
+// First explicit match (allow or deny) wins.
+// If no level matches and HasAnyFile is false → allow (no rules = public).
+// If no level matches and HasAnyFile is true  → deny (user not on any list).
+func AllowedWithChain(chain PolicyChain, email string) bool {
+	for i := len(chain.Levels) - 1; i >= 0; i-- {
+		decision, matched := AllowedAtLevel(chain.Levels[i], email)
+		if matched {
+			return decision
+		}
+	}
+	return !chain.HasAnyFile
+}
+
+// matchesPattern checks if email matches a glob pattern.
+//
+// The pattern may use * as a wildcard within the local part or domain part,
+// but * does not cross the @ boundary. Examples:
+//   - "*@mycompany.com" matches any user at mycompany.com
+//   - "alice@*" matches alice at any domain
+//   - "alice@example.com" matches exactly
+//   - "*" matches any non-empty email (the @ boundary rule means * must stay in one segment)
+func matchesPattern(pattern, email string) bool {
+	// Exact match (fast path)
+	if pattern == email {
+		return true
+	}
+
+	// Wildcard-free check already handled above; split on @
+	patternParts := strings.SplitN(pattern, "@", 2)
+	emailParts := strings.SplitN(email, "@", 2)
+
+	if len(patternParts) == 2 && len(emailParts) == 2 {
+		// Both have @: match local and domain separately
+		return globMatch(patternParts[0], emailParts[0]) &&
+			globMatch(patternParts[1], emailParts[1])
+	}
+
+	if len(patternParts) == 1 {
+		// Pattern has no @ — match against the full email string
+		return globMatch(pattern, email)
+	}
+
+	return false
+}
+
+// globMatch performs simple glob matching where * matches any sequence of chars.
+func globMatch(pattern, s string) bool {
+	// Two-pointer approach: handle multiple * segments
+	if pattern == "*" {
+		return true
+	}
+	if !strings.Contains(pattern, "*") {
+		return pattern == s
+	}
+
+	// Split pattern on * and match segments in order
+	parts := strings.Split(pattern, "*")
+	remaining := s
+	for i, part := range parts {
+		if part == "" {
+			continue
+		}
+		idx := strings.Index(remaining, part)
+		if idx < 0 {
+			return false
+		}
+		// First segment must match at start
+		if i == 0 && idx != 0 {
+			return false
+		}
+		remaining = remaining[idx+len(part):]
+	}
+	// Last segment must match at end (no trailing *)
+	if parts[len(parts)-1] != "" {
+		// The remaining string must be empty because the last part already consumed it
+		// Actually we need to check: if the last part is non-empty, remaining must be empty
+		// because we consumed up through that part above. If there's a trailing *, remaining
+		// can be anything.
+		// Re-check: split("a*b", "*") → ["a", "b"]. After matching "a" at start and "b"
+		// somewhere after, remaining should be "" if "b" is last segment.
+		// The loop above leaves remaining = s[after last part matched]. If last part is
+		// non-empty and pattern doesn't end with *, remaining must be "".
+		// Actually, the last segment check needs to verify that remaining is empty after
+		// the last part was matched. If there's a trailing *, remaining can be anything.
+		// The last part in parts is what remains after the last *. If it's non-empty,
+		// we need remaining to be empty (pattern didn't end with *).
+		// Since we're processing left-to-right and the last part must match at the end,
+		// remaining must be empty after consuming the last part.
+		if !strings.HasSuffix(pattern, "*") && remaining != "" {
+			return false
+		}
+	}
+	return true
+}
diff --git a/zddc/internal/zddc/acl_test.go b/zddc/internal/zddc/acl_test.go
new file mode 100644
index 0000000..ac0cb7b
--- /dev/null
+++ b/zddc/internal/zddc/acl_test.go
@@ -0,0 +1,250 @@
+package zddc
+
+import "testing"
+
+func TestGlobMatch(t *testing.T) {
+	cases := []struct {
+		pattern string
+		s       string
+		want    bool
+	}{
+		// Literal (no wildcard)
+		{"alice", "alice", true},
+		{"alice", "bob", false},
+		{"", "", true},
+		{"", "x", false},
+
+		// Lone wildcard
+		{"*", "anything", true},
+		{"*", "", true},
+
+		// Prefix wildcard
+		{"*@example.com", "@example.com", true},
+		{"*.com", "example.com", true},
+		{"*.com", "example.org", false},
+
+		// Suffix wildcard
+		{"alice*", "alice", true},
+		{"alice*", "alice@example.com", true},
+		{"alice*", "bob", false},
+
+		// Middle wildcard
+		{"a*b", "ab", true},
+		{"a*b", "axxxb", true},
+		{"a*b", "axxx", false},
+		{"a*b", "xxxb", false},
+
+		// Multiple wildcards
+		{"*-*-*", "a-b-c", true},
+		{"*-*-*", "ab-c", false},
+
+		// Anchored: no implicit leading wildcard
+		{"alice@*", "bob@example.com", false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.pattern+"|"+tc.s, func(t *testing.T) {
+			if got := globMatch(tc.pattern, tc.s); got != tc.want {
+				t.Errorf("globMatch(%q, %q) = %v, want %v", tc.pattern, tc.s, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestMatchesPattern(t *testing.T) {
+	cases := []struct {
+		pattern string
+		email   string
+		want    bool
+	}{
+		// Exact match
+		{"alice@example.com", "alice@example.com", true},
+		{"alice@example.com", "bob@example.com", false},
+
+		// Wildcard local part, fixed domain
+		{"*@example.com", "alice@example.com", true},
+		{"*@example.com", "anyone@example.com", true},
+		{"*@example.com", "alice@evil.com", false},
+
+		// Fixed local part, wildcard domain
+		{"alice@*", "alice@example.com", true},
+		{"alice@*", "alice@evil.com", true},
+		{"alice@*", "bob@example.com", false},
+
+		// @-boundary respected: * in local part does not eat the @
+		{"alice*", "alice@example.com", true}, // pattern has no @, matches against full email
+		// But splitting on @ for both sides:
+		{"*", "alice@example.com", true}, // lone * matches anything
+		{"*@*", "alice@example.com", true},
+		{"*@*", "no-at-sign", false}, // pattern has @, email doesn't
+
+		// Pattern with @, email without
+		{"alice@example.com", "alice", false},
+
+		// Empty email: lone "*" should still match per docstring? Actually globMatch("*", "") = true
+		// But matchesPattern("*", "") splits "*" on @ → ["*"]. Then globMatch("*", "") = true.
+		// The docstring says "matches any non-empty email" but the implementation matches empty too.
+		// Document the actual behavior in the test.
+		{"*", "", true},
+	}
+	for _, tc := range cases {
+		t.Run(tc.pattern+"|"+tc.email, func(t *testing.T) {
+			if got := matchesPattern(tc.pattern, tc.email); got != tc.want {
+				t.Errorf("matchesPattern(%q, %q) = %v, want %v", tc.pattern, tc.email, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestAllowedAtLevel(t *testing.T) {
+	cases := []struct {
+		name        string
+		level       ZddcFile
+		email       string
+		wantAllowed bool
+		wantMatched bool
+	}{
+		{
+			name:        "no rules: not matched",
+			level:       ZddcFile{},
+			email:       "alice@example.com",
+			wantAllowed: false,
+			wantMatched: false,
+		},
+		{
+			name: "allow matched",
+			level: ZddcFile{ACL: ACLRules{
+				Allow: []string{"*@example.com"},
+			}},
+			email:       "alice@example.com",
+			wantAllowed: true,
+			wantMatched: true,
+		},
+		{
+			name: "deny matched",
+			level: ZddcFile{ACL: ACLRules{
+				Deny: []string{"alice@example.com"},
+			}},
+			email:       "alice@example.com",
+			wantAllowed: false,
+			wantMatched: true,
+		},
+		{
+			name: "deny wins over allow at the same level",
+			level: ZddcFile{ACL: ACLRules{
+				Allow: []string{"*@example.com"},
+				Deny:  []string{"alice@example.com"},
+			}},
+			email:       "alice@example.com",
+			wantAllowed: false,
+			wantMatched: true,
+		},
+		{
+			name: "neither rule matches",
+			level: ZddcFile{ACL: ACLRules{
+				Allow: []string{"*@example.com"},
+				Deny:  []string{"*@evil.com"},
+			}},
+			email:       "carol@other.org",
+			wantAllowed: false,
+			wantMatched: false,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			gotAllowed, gotMatched := AllowedAtLevel(tc.level, tc.email)
+			if gotAllowed != tc.wantAllowed || gotMatched != tc.wantMatched {
+				t.Errorf("AllowedAtLevel(%v, %q) = (%v, %v), want (%v, %v)",
+					tc.level, tc.email, gotAllowed, gotMatched, tc.wantAllowed, tc.wantMatched)
+			}
+		})
+	}
+}
+
+func TestAllowedWithChain(t *testing.T) {
+	allow := func(p ...string) ZddcFile { return ZddcFile{ACL: ACLRules{Allow: p}} }
+	deny := func(p ...string) ZddcFile { return ZddcFile{ACL: ACLRules{Deny: p}} }
+	allowDeny := func(a, d []string) ZddcFile { return ZddcFile{ACL: ACLRules{Allow: a, Deny: d}} }
+	empty := ZddcFile{}
+
+	cases := []struct {
+		name  string
+		chain PolicyChain
+		email string
+		want  bool
+	}{
+		{
+			name:  "empty chain, no files: default allow",
+			chain: PolicyChain{HasAnyFile: false},
+			email: "alice@example.com",
+			want:  true,
+		},
+		{
+			name:  "files exist but no rule matches: default deny",
+			chain: PolicyChain{Levels: []ZddcFile{allow("*@trusted.com")}, HasAnyFile: true},
+			email: "alice@example.com",
+			want:  false,
+		},
+		{
+			name:  "leaf allow wins",
+			chain: PolicyChain{Levels: []ZddcFile{empty, allow("*@example.com")}, HasAnyFile: true},
+			email: "alice@example.com",
+			want:  true,
+		},
+		{
+			name: "leaf deny beats parent allow (bottom-up first match)",
+			chain: PolicyChain{Levels: []ZddcFile{
+				allow("*@example.com"),
+				deny("alice@example.com"),
+			}, HasAnyFile: true},
+			email: "alice@example.com",
+			want:  false,
+		},
+		{
+			name: "leaf has no rule for user, falls back to parent allow",
+			chain: PolicyChain{Levels: []ZddcFile{
+				allow("*@example.com"),
+				allow("bob@example.com"), // doesn't match alice
+			}, HasAnyFile: true},
+			email: "alice@example.com",
+			want:  true,
+		},
+		{
+			name: "leaf allows user that parent denies",
+			chain: PolicyChain{Levels: []ZddcFile{
+				deny("alice@example.com"),
+				allow("alice@example.com"),
+			}, HasAnyFile: true},
+			email: "alice@example.com",
+			want:  true, // leaf wins
+		},
+		{
+			name: "multi-level: deepest match wins",
+			chain: PolicyChain{Levels: []ZddcFile{
+				allow("*@example.com"),
+				allowDeny([]string{"*@example.com"}, []string{"alice@example.com"}),
+				allow("alice@example.com"), // deepest re-allows alice
+			}, HasAnyFile: true},
+			email: "alice@example.com",
+			want:  true,
+		},
+		{
+			name:  "no match anywhere with files present: deny",
+			chain: PolicyChain{Levels: []ZddcFile{empty, empty, empty}, HasAnyFile: true},
+			email: "alice@example.com",
+			want:  false,
+		},
+		{
+			name:  "no match anywhere without files: allow",
+			chain: PolicyChain{Levels: []ZddcFile{empty, empty, empty}, HasAnyFile: false},
+			email: "alice@example.com",
+			want:  true,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := AllowedWithChain(tc.chain, tc.email); got != tc.want {
+				t.Errorf("AllowedWithChain = %v, want %v", got, tc.want)
+			}
+		})
+	}
+}
diff --git a/zddc/internal/zddc/cascade.go b/zddc/internal/zddc/cascade.go
new file mode 100644
index 0000000..081fcf2
--- /dev/null
+++ b/zddc/internal/zddc/cascade.go
@@ -0,0 +1,98 @@
+package zddc
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+// PolicyChain represents a chain of .zddc files from root to leaf.
+type PolicyChain struct {
+	Levels     []ZddcFile // ordered root (index 0) → leaf (last index)
+	HasAnyFile bool       // true if at least one .zddc file exists in the chain
+}
+
+// policyCache caches effective policies keyed by dirPath.
+// Values are PolicyChain.
+var policyCache sync.Map
+
+// EffectivePolicy returns the ACL policy chain for dirPath by reading
+// all .zddc files from fsRoot down to dirPath.
+//
+// Child directory rules take precedence over parent rules.
+// A deny at any level cannot be overridden by a parent allow.
+func EffectivePolicy(fsRoot, dirPath string) (PolicyChain, error) {
+	// Normalize: ensure fsRoot and dirPath use the same separator
+	fsRoot = filepath.Clean(fsRoot)
+	dirPath = filepath.Clean(dirPath)
+
+	// Build list of directories from root to dirPath (inclusive)
+	var dirs []string
+	if !strings.HasPrefix(dirPath, fsRoot) {
+		// dirPath must be under fsRoot; if not, treat it as an empty chain
+		return PolicyChain{}, nil
+	}
+
+	rel, err := filepath.Rel(fsRoot, dirPath)
+	if err != nil {
+		return PolicyChain{}, err
+	}
+
+	// Walk from root down: root, root/a, root/a/b, ...
+	dirs = append(dirs, fsRoot)
+	if rel != "." {
+		parts := strings.Split(rel, string(filepath.Separator))
+		current := fsRoot
+		for _, part := range parts {
+			current = filepath.Join(current, part)
+			dirs = append(dirs, current)
+		}
+	}
+
+	// Check cache for the most specific (deepest) cached entry we can reuse
+	cacheKey := dirPath
+	if cached, ok := policyCache.Load(cacheKey); ok {
+		return cached.(PolicyChain), nil
+	}
+
+	// Build policy chain: read each .zddc file
+	var chain PolicyChain
+	for _, dir := range dirs {
+		zddcPath := filepath.Join(dir, ".zddc")
+		// Check if .zddc file exists
+		_, err := os.Stat(zddcPath)
+		if err == nil {
+			// File exists
+			chain.HasAnyFile = true
+			parsed, err := ParseFile(zddcPath)
+			if err != nil {
+				// Parse error — append empty file but continue
+				chain.Levels = append(chain.Levels, ZddcFile{})
+			} else {
+				chain.Levels = append(chain.Levels, parsed)
+			}
+		} else if os.IsNotExist(err) {
+			// File doesn't exist
+			chain.Levels = append(chain.Levels, ZddcFile{})
+		} else {
+			// Other error (permission, etc.)
+			chain.Levels = append(chain.Levels, ZddcFile{})
+		}
+	}
+
+	policyCache.Store(cacheKey, chain)
+	return chain, nil
+}
+
+// InvalidateCache removes the cached policy for dirPath and all descendants.
+func InvalidateCache(dirPath string) {
+	dirPath = filepath.Clean(dirPath)
+	policyCache.Range(func(key, _ any) bool {
+		k := key.(string)
+		if k == dirPath || strings.HasPrefix(k, dirPath+string(filepath.Separator)) {
+			policyCache.Delete(key)
+		}
+		return true
+	})
+}
diff --git a/zddc/internal/zddc/cascade_test.go b/zddc/internal/zddc/cascade_test.go
new file mode 100644
index 0000000..4bd4cfd
--- /dev/null
+++ b/zddc/internal/zddc/cascade_test.go
@@ -0,0 +1,245 @@
+package zddc
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// resetCache empties the package-level policyCache so each test starts clean.
+func resetCache() {
+	policyCache.Range(func(k, _ any) bool {
+		policyCache.Delete(k)
+		return true
+	})
+}
+
+func writeZddc(t *testing.T, dir, body string) {
+	t.Helper()
+	if err := os.WriteFile(filepath.Join(dir, ".zddc"), []byte(body), 0o644); err != nil {
+		t.Fatalf("write .zddc in %s: %v", dir, err)
+	}
+}
+
+func TestEffectivePolicy(t *testing.T) {
+	t.Run("no .zddc files anywhere: chain has no files", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		leaf := filepath.Join(root, "a", "b")
+		if err := os.MkdirAll(leaf, 0o755); err != nil {
+			t.Fatal(err)
+		}
+
+		chain, err := EffectivePolicy(root, leaf)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if chain.HasAnyFile {
+			t.Errorf("HasAnyFile = true, want false")
+		}
+		// One level per directory (root, root/a, root/a/b) = 3
+		if got, want := len(chain.Levels), 3; got != want {
+			t.Errorf("len(Levels) = %d, want %d", got, want)
+		}
+	})
+
+	t.Run("cascade order is root → leaf", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		mid := filepath.Join(root, "a")
+		leaf := filepath.Join(mid, "b")
+		if err := os.MkdirAll(leaf, 0o755); err != nil {
+			t.Fatal(err)
+		}
+		writeZddc(t, root, "acl:\n  allow:\n    - root@example.com\n")
+		writeZddc(t, leaf, "acl:\n  allow:\n    - leaf@example.com\n")
+
+		chain, err := EffectivePolicy(root, leaf)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !chain.HasAnyFile {
+			t.Error("HasAnyFile = false, want true")
+		}
+		if len(chain.Levels) != 3 {
+			t.Fatalf("len(Levels) = %d, want 3", len(chain.Levels))
+		}
+		if got := chain.Levels[0].ACL.Allow; len(got) != 1 || got[0] != "root@example.com" {
+			t.Errorf("root level Allow = %v, want [root@example.com]", got)
+		}
+		if got := chain.Levels[1].ACL.Allow; len(got) != 0 {
+			t.Errorf("middle level Allow = %v, want empty", got)
+		}
+		if got := chain.Levels[2].ACL.Allow; len(got) != 1 || got[0] != "leaf@example.com" {
+			t.Errorf("leaf level Allow = %v, want [leaf@example.com]", got)
+		}
+	})
+
+	t.Run("dirPath outside fsRoot returns empty chain", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		other := t.TempDir() // unrelated tree
+
+		chain, err := EffectivePolicy(root, other)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if chain.HasAnyFile {
+			t.Error("HasAnyFile = true, want false for out-of-root path")
+		}
+		if len(chain.Levels) != 0 {
+			t.Errorf("len(Levels) = %d, want 0", len(chain.Levels))
+		}
+	})
+
+	t.Run("malformed .zddc yields empty level but does not abort the chain", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		leaf := filepath.Join(root, "a")
+		if err := os.MkdirAll(leaf, 0o755); err != nil {
+			t.Fatal(err)
+		}
+		// Garbage YAML
+		writeZddc(t, root, "::: not yaml :::")
+		writeZddc(t, leaf, "acl:\n  allow:\n    - leaf@example.com\n")
+
+		chain, err := EffectivePolicy(root, leaf)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !chain.HasAnyFile {
+			t.Error("HasAnyFile = false, want true (malformed file still counts as present)")
+		}
+		// Root level parsed empty (parse error path), leaf level has the rule
+		if got := chain.Levels[0].ACL.Allow; len(got) != 0 {
+			t.Errorf("root level Allow = %v, want empty (parse error)", got)
+		}
+		if got := chain.Levels[1].ACL.Allow; len(got) != 1 || got[0] != "leaf@example.com" {
+			t.Errorf("leaf level Allow = %v, want [leaf@example.com]", got)
+		}
+	})
+
+	t.Run("dirPath equal to fsRoot has single level", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		writeZddc(t, root, "acl:\n  allow:\n    - root@example.com\n")
+
+		chain, err := EffectivePolicy(root, root)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(chain.Levels) != 1 {
+			t.Errorf("len(Levels) = %d, want 1", len(chain.Levels))
+		}
+	})
+}
+
+func TestEffectivePolicyEndToEnd(t *testing.T) {
+	resetCache()
+	root := t.TempDir()
+	pub := filepath.Join(root, "public")
+	priv := filepath.Join(root, "private")
+	for _, d := range []string{pub, priv} {
+		if err := os.MkdirAll(d, 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	writeZddc(t, priv, "acl:\n  allow:\n    - alice@example.com\n  deny:\n    - bob@example.com\n")
+
+	// public/: no .zddc on the chain → default allow for everyone
+	chainPub, _ := EffectivePolicy(root, pub)
+	if !AllowedWithChain(chainPub, "anyone@anywhere.com") {
+		t.Error("public/ should be open when no .zddc files exist on the chain")
+	}
+
+	// private/: has rules → only alice gets in
+	chainPriv, _ := EffectivePolicy(root, priv)
+	if !AllowedWithChain(chainPriv, "alice@example.com") {
+		t.Error("alice should be allowed in private/")
+	}
+	if AllowedWithChain(chainPriv, "bob@example.com") {
+		t.Error("bob should be denied in private/")
+	}
+	if AllowedWithChain(chainPriv, "carol@example.com") {
+		t.Error("carol (unlisted) should be denied in private/ when files exist")
+	}
+}
+
+func TestInvalidateCache(t *testing.T) {
+	t.Run("invalidates exact path", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		dir := filepath.Join(root, "a")
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			t.Fatal(err)
+		}
+
+		_, _ = EffectivePolicy(root, dir)
+		if _, ok := policyCache.Load(dir); !ok {
+			t.Fatal("cache should contain entry after EffectivePolicy")
+		}
+		InvalidateCache(dir)
+		if _, ok := policyCache.Load(dir); ok {
+			t.Error("cache should not contain entry after InvalidateCache")
+		}
+	})
+
+	t.Run("invalidates descendants when parent changes", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		mid := filepath.Join(root, "a")
+		leaf := filepath.Join(mid, "b")
+		sibling := filepath.Join(root, "c")
+		for _, d := range []string{leaf, sibling} {
+			if err := os.MkdirAll(d, 0o755); err != nil {
+				t.Fatal(err)
+			}
+		}
+
+		// Populate cache for mid, leaf, sibling
+		_, _ = EffectivePolicy(root, mid)
+		_, _ = EffectivePolicy(root, leaf)
+		_, _ = EffectivePolicy(root, sibling)
+		for _, p := range []string{mid, leaf, sibling} {
+			if _, ok := policyCache.Load(p); !ok {
+				t.Fatalf("cache missing %s", p)
+			}
+		}
+
+		// Change a .zddc in mid → InvalidateCache(mid) drops mid and leaf, keeps sibling
+		InvalidateCache(mid)
+		if _, ok := policyCache.Load(mid); ok {
+			t.Error("mid should be invalidated")
+		}
+		if _, ok := policyCache.Load(leaf); ok {
+			t.Error("leaf (descendant of mid) should be invalidated")
+		}
+		if _, ok := policyCache.Load(sibling); !ok {
+			t.Error("sibling should remain cached")
+		}
+	})
+
+	t.Run("invalidating a path does not invalidate string-prefix-but-not-path-prefix", func(t *testing.T) {
+		resetCache()
+		root := t.TempDir()
+		// "/tmp/foo" should not invalidate "/tmp/foobar" — the implementation guards
+		// this by appending the separator before HasPrefix.
+		foo := filepath.Join(root, "foo")
+		foobar := filepath.Join(root, "foobar")
+		for _, d := range []string{foo, foobar} {
+			if err := os.MkdirAll(d, 0o755); err != nil {
+				t.Fatal(err)
+			}
+		}
+		_, _ = EffectivePolicy(root, foo)
+		_, _ = EffectivePolicy(root, foobar)
+
+		InvalidateCache(foo)
+		if _, ok := policyCache.Load(foo); ok {
+			t.Error("foo should be invalidated")
+		}
+		if _, ok := policyCache.Load(foobar); !ok {
+			t.Error("foobar should NOT be invalidated by InvalidateCache(foo)")
+		}
+	})
+}
diff --git a/zddc/internal/zddc/file.go b/zddc/internal/zddc/file.go
new file mode 100644
index 0000000..7f62c2f
--- /dev/null
+++ b/zddc/internal/zddc/file.go
@@ -0,0 +1,36 @@
+package zddc
+
+import (
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+// ACLRules holds email allow/deny lists.
+type ACLRules struct {
+	Allow []string `yaml:"allow"`
+	Deny  []string `yaml:"deny"`
+}
+
+// ZddcFile represents the parsed contents of a .zddc configuration file.
+type ZddcFile struct {
+	ACL ACLRules `yaml:"acl"`
+}
+
+// ParseFile reads and parses a .zddc YAML file.
+// Returns an empty ZddcFile (no rules) if the file does not exist.
+func ParseFile(path string) (ZddcFile, error) {
+	data, err := os.ReadFile(path)
+	if os.IsNotExist(err) {
+		return ZddcFile{}, nil
+	}
+	if err != nil {
+		return ZddcFile{}, err
+	}
+
+	var zf ZddcFile
+	if err := yaml.Unmarshal(data, &zf); err != nil {
+		return ZddcFile{}, err
+	}
+	return zf, nil
+}
diff --git a/zddc/podman-compose.yaml b/zddc/podman-compose.yaml
new file mode 100644
index 0000000..643d576
--- /dev/null
+++ b/zddc/podman-compose.yaml
@@ -0,0 +1,32 @@
+# podman-compose.yaml — local development environment
+# Usage: podman-compose up --build
+#
+# Requires a directory to serve. Set ZDDC_DATA_DIR to the path of your
+# archive root, or mount it manually.
+#
+# Note: Use :z volume suffix for SELinux-enabled hosts (RHEL, Fedora, CentOS).
+
+services:
+  zddc-server:
+    build:
+      context: .
+      dockerfile: Containerfile
+    image: zddc-server:dev
+    ports:
+      - "8443:8443"
+    # TLS modes (set via ZDDC_TLS_CERT):
+    #   empty (default)      — self-signed cert generated in memory at startup
+    #   ZDDC_TLS_CERT=none   — plain HTTP, no TLS (use when reverse proxy handles TLS)
+    #   ZDDC_TLS_CERT=/path  — load cert from file (also set ZDDC_TLS_KEY)
+    environment:
+      ZDDC_ROOT: /data
+      ZDDC_ADDR: ":8443"
+      ZDDC_LOG_LEVEL: debug
+      ZDDC_INDEX_PATH: .archive
+      ZDDC_EMAIL_HEADER: X-Email
+    volumes:
+      - type: bind
+        source: ${ZDDC_DATA_DIR:-./testdata}
+        target: /data
+        options: z
+    restart: unless-stopped