diff --git a/.github/workflows/deploy-to-gh.yml b/.github/workflows/deploy-to-gh.yml
index 7ce60a5..f8961c6 100644
--- a/.github/workflows/deploy-to-gh.yml
+++ b/.github/workflows/deploy-to-gh.yml
@@ -4,29 +4,35 @@ on:
   push:
     branches:
       - master
+      - refactor-vanilla-es-modules
+      - vpat_fixes
+  workflow_dispatch:
+
+# NB the fork's Actions default is read-only: the deploy step needs
+# write access to push the gh-pages branch
+permissions:
+  contents: write
 
 jobs:
   build-then-deploy:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - name: Setup JAVA
-        uses: actions/setup-java@v3
+      - name: Setup Python
+        uses: actions/setup-python@v5
         with:
-          distribution: 'zulu'
-          java-version: '17'
-          check-latest: true
+          python-version: '3.x'
 
       - name: Run per se
-        run: bash deploy/build_js.sh
+        run: python3 deploy/build_js.py
         shell: bash
 
       - name: Save files
         run: |
           mkdir dist
-          cp ermac.min.js src_js/third_party/jquery.min.js dist
+          cp ermac.min.js dist
           cp -r webassets oauth crystvis labs dist
           cp example_prod.html dist/index.html
 
diff --git a/.github/workflows/parity.yml b/.github/workflows/parity.yml
new file mode 100644
index 0000000..82a978a
--- /dev/null
+++ b/.github/workflows/parity.yml
@@ -0,0 +1,66 @@
+name: Parity with the deployed GUI
+
+# The refactored GUI must behave exactly like the pinned deployed bundle
+# (see parity/README.md). Pull requests run the scenarios of the components
+# most at risk; the full battery runs on demand. Recorded MPDS API responses
+# are cached between runs to keep the load on api.mpds.io minimal.
+
+on:
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      only:
+        description: 'scenario names or globs (empty = all)'
+        required: false
+        default: ''
+
+jobs:
+  parity:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install Playwright and Chromium
+        run: |
+          # NB pinned: the browser build affects rendering and lazy loading;
+          # 1.50 = Chromium 133, the build the suite is validated with
+          pip install playwright==1.50.0 pillow
+          python -m playwright install --with-deps chromium
+
+      - name: Restore recorded API responses
+        uses: actions/cache@v4
+        with:
+          path: parity/out
+          key: parity-api-${{ hashFiles('parity/scenarios.json', 'parity/config.json') }}-${{ github.run_id }}
+          restore-keys: |
+            parity-api-${{ hashFiles('parity/scenarios.json', 'parity/config.json') }}-
+            parity-api-
+
+      - name: Run the parity suite
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            if [ -n "${{ github.event.inputs.only }}" ]; then
+              python3 parity/run_parity.py --only '${{ github.event.inputs.only }}'
+            else
+              python3 parity/run_parity.py
+            fi
+          else
+            python3 parity/run_parity.py --tag legacy,multiselect,sort,controls,mock,keyboard
+          fi
+
+      - name: Upload the evidence
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: parity-out
+          path: |
+            parity/out/report.json
+            parity/out/*/diff.txt
+            parity/out/*/*-capture.json
+            parity/out/*/*.png
+          if-no-files-found: ignore
diff --git a/.gitignore b/.gitignore
index 552af80..5953367 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,16 @@ labs/pd3d/data
 package.json
 package-lock.json
 /node_modules
+
+# parity testing
+parity/reference/
+parity/out/
+__pycache__/
+# created at runtime by the chrome-cli driver (app_folder is /parity)
+parity/webassets
+parity/labs
+parity/oauth
+parity/crystvis
+parity/ermac.min.js
+
+.venv
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..dfc3aba
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,280 @@
+# AGENTS.md
+
+Guidance for coding agents working on Ermac. The README explains what Ermac is
+and how to serve it; this file is about **changing it without breaking users**.
+Ermac is embedded in third-party sites and its URLs are shared in papers and
+emails, so "it still works on my page" is not the bar: the bar is **parity
+with the deployed version**, checked by `parity/`.
+
+## Rules that are easy to break
+
+1. **No Node, npm, Java or any new toolchain.** Python 3 stdlib only for build
+   and tooling; Playwright and Pillow are allowed for `parity/` only. Do not add
+   `package.json`, lockfiles, transpilers or minifiers (they are gitignored on
+   purpose).
+2. **No new runtime dependencies.** Vendored, framework-free libraries in
+   `src_js/third_party/` only; jQuery and its plugins were removed and must
+   stay out.
+3. **`window.wmgui` is a public API.** Host pages read and call it
+   (`wmgui.search`, `wmgui.notify`, `wmgui.aug_search_cmd`, endpoints, ...).
+   Do not rename or remove its members; add new ones only deliberately.
+4. **Hash routes are public URLs.** `#search/...`, `#inquiry/...`,
+   `#phase_id/...`, `#entry/...` etc. live in bookmarks and publications. Never
+   change their syntax or parameter encoding; only add routes.
+5. **Never edit `ermac.min.js`.** It is a build product
+   (`python3 deploy/build_js.py`), gitignored, and deployed by CI from `master`.
+6. **Do not "fix" a parity failure by editing its scenario.** The OLD deployed
+   bundle is the specification. Change a scenario only for an *intentional*,
+   maintainer-approved behavior change, and say why: `"xfail": "<reason>"`
+   plus an `"expect_new"` object pinning the new behavior (an xfail
+   scenario without it would pass whatever the new code does), or, when the
+   change is confined to a few probes (typically `focus`),
+   `"approved": "<reason>"` plus `"expect_new"`: those probes are pinned on
+   NEW instead of compared, and every other layer still is. `ignore` is for
+   a layer that is irrelevant to the scenario.
+
+## Where a change goes
+
+| you want to... | edit | also |
+|---|---|---|
+| add or change a route | `src_js/app/router.js` (`url__<name>` + the `routes` registry) | add a route scenario |
+| add an API call | endpoint URL in `src_js/core/settings.js` (`wmgui.<x>_endpoint`), call via `ajax()` from `core/ajax.js` | check the request encoding (see below) |
+| change rendered HTML | `src_js/app/markup.js` (static shell) or the render functions in `src_js/app/search.js` | ids/classes are CSS and embedding contracts |
+| change a click/key behavior | `src_js/app/events.js` (`register_events()`) | add a narrow interaction scenario |
+| add a clickable control, tab set or dialog | the markup/render site, plus an entry in `A11Y_CONTROLS` (and `A11Y_ROVING` for a group) in `src_js/core/a11y.js` | `parity --tag a11y` (the audits count mouse-only controls) |
+| change search-box behavior | `src_js/components/multiselect.js` (selectize stand-in) | `parity --tag multiselect` |
+| change table sorting | `src_js/components/tablesort.js` (tablesorter stand-in) | `parity --tag sort` |
+| change styling | `webassets/ermac.css` | pixels layer; keep class names |
+| change per-site behavior | `wmgui.editions` in `core/settings.js` (edition picked from the hostname by `assign_edition()`) | |
+
+## The bundler is not a real module system
+
+`deploy/build_js.py` concatenates every module into **one classic script with
+one shared top-level scope** under a single `"use strict"`, after the vendored
+libraries in the fixed `VENDORED` order. Consequences:
+
+- **Top-level names must be unique across all modules**, exported or not. Two
+  private `function helper()` in different files collide in the bundle while
+  working fine in dev mode (real ES modules). Prefix or nest private helpers.
+- Imports must be relative (`./x.js`), and use the exporter's own names:
+  `import { a as b }` is not supported, and a default import must be named
+  exactly like the exporter's local default name. `export { a, b }` blocks are
+  rejected; use `export function` / `export const`.
+- Module top-level code runs in topological order (DFS post-order from
+  `app/run.js`, cycles tolerated). Do not rely on a module's side effects
+  having run unless you import it.
+- Dev mode (`example_dev.html`, native ES modules) and the bundle can differ.
+  **The parity suite tests the bundle only**; for scope-sensitive changes, also
+  load `example_dev.html` once.
+- The build fails loudly on unresolved names in imports. It does **not** catch
+  a missing import of a name that happens to exist globally in the bundle
+  (it works bundled, throws in dev). Import everything you use.
+
+## Compatibility contracts
+
+- **The DOM and CSS contracts of the replaced plugins** are relied on by
+  `webassets/ermac.css` and by host-page CSS and scripts. The vanilla
+  components are ports of the *vendored* selectize 0.12 and jquery.tablesorter
+  2.0 (read them in git history: `git show master:src_js/third_party/...`),
+  not of their documentation. Search box: `.selectize-control.multi.plugin-*`,
+  `.selectize-input` (+ `items`, `full`/`not-full`, `has-items`,
+  `has-options`, `focus`, `input-active`, `dropdown-active`),
+  `.selectize-dropdown(-content)` positioned with explicit
+  `width`/`top`/`left`, chips with `data-facet`/`data-term`/`data-value`,
+  options with `data-selectable`/`data-value`, the hidden original
+  `<select multiple class="selectized">` mirroring the chips as
+  `<option selected>`, the `<select id>-selectized` input of
+  `type="select-multiple"` auto-sized to its text. Table: `tablesorter`,
+  `th.header`, `headerSortUp`/`headerSortDown` (NB ascending is marked
+  `headerSortDown`). Keep the names **and** the moments they are toggled.
+- **Request encoding is part of the server contract.** The server was written
+  against jQuery `$.param` and jQuery `.data()`: values that were numbers must
+  stay numbers (`data-rankfilter="5"` read via `getAttribute` is the string
+  `"5"`: convert it, as `events.js` now does), nested objects/arrays serialize the jQuery way
+  (`param()` in `core/ajax.js` is a faithful port of jQuery 3.7.1 `$.param`),
+  form posts stay `application/x-www-form-urlencoded`. The parity API layer
+  compares method, path, sorted query and POST body.
+- **Numeric searches in hashes** use the router's own `prop,sign,value;...`
+  form (`#inquiry/numeric=band%20gap%2C%3E%2C3`). Build every `#inquiry...`
+  hash with `inquiry_param()` (`components/sliders.js`), which serializes a
+  numeric array that way, never with `param()` directly. Approved fix: the old
+  GUI passed the arrays to `$.param` in the typed-text search and the VIEW
+  buttons, giving `numeric[0][]=...` keys the router cannot read ("Unrecognized
+  input"); see the `search_numeric_text*` and `numeric_view_phases_button`
+  scenarios. The route syntax itself is unchanged (rule 4).
+- **localStorage keys** (`wm_search_log_v5`, `wm`, `bid_history`,
+  `absolidix_v1`, `wm_u_email`, `wm_reload_v1`, `wm_redir_v1`, `darkmode`) hold
+  users' history and session: never rename or reshape them without a migration.
+- **The "hash-hack"**: re-submitting the current inquiry toggles a trailing `=`
+  on the hash to force a `hashchange`. It looks like a bug; it is load-bearing.
+- **`String.prototype.startswith`** (lowercase) and friends are deliberate
+  base-type extensions in `core/utils.js`; `startswith` is not a typo of
+  `startsWith`.
+
+## Accessibility contracts
+
+The keyboard and zoom support (VPAT findings WCAG 2.1.1 Keyboard, 1.4.4
+Resize Text) lives in `src_js/core/a11y.js`, installed by `app/run.js`, and
+the ACCESSIBILITY section at the end of `webassets/ermac.css`.
+
+- **Declarative, not per render site.** The app renders much of its UI as
+  HTML strings. `A11Y_CONTROLS` maps selectors to a role, label, state
+  (`aria-pressed`/`-selected`/`-checked`/`-expanded`/`-sort` derived from the
+  existing classes such as `active`, `working`, `selected_a`) and
+  `tabindex`; a MutationObserver re-applies it after every content or class
+  change. A new mouse-only `div`/`span`/`li` control needs an entry, or the
+  a11y audits report it. Native `<button>`/`<a href>`/inputs need none.
+- **One activation path.** Enter/Space on a `role=button|tab|radio|link`
+  (or `data-a11y-activate`) element calls its `click()`, so the existing
+  click handlers in `events.js` serve the keyboard too. Do not add parallel
+  key handlers; keep the click handlers delegated and idempotent.
+- **Roving groups** (`A11Y_ROVING`): the periodic table (an 18-column grid),
+  the results rows, the gallery and polyhedra items, the tab lists and the
+  VIEW switches have one Tab stop and arrow keys inside.
+- **Dialogs** (`div.modal.user_dialogue`): when one becomes visible, the rest
+  of `<body>` is made `inert`, except `A11Y_NOT_INERT` (the overlay,
+  notifications, `#numericbox` next to the advanced search, `#userbox` which
+  stays above the overlay and toggles the account dialogs, the `<body>`-level
+  autocomplete suggestions, tooltips, the preloader). The dialog takes the
+  focus (or keeps a field the code already focused), and on close the focus
+  returns to the opener. Anything appended to `<body>` that a dialog needs
+  goes into `A11Y_NOT_INERT`, or it becomes unclickable. Host pages can drive
+  the same logic: `wmgui.open_dialog(box, initial_selector)` /
+  `wmgui.release_dialog()` (public API, rule 3).
+- **Skip control:** routing uses the hash, so the skip control is a
+  `<button id="a11y_skip">` moving the focus, never an `href="#..."` link
+  (that would navigate).
+- **Focus rings** use `:focus-visible` (keyboard only); mouse users see no
+  change. Text inputs keep their old look. Chips keep the multiselect's
+  keyboard model (Backspace removes the last one).
+- **Zoom (1.4.4):** at 150% and 200% zoom of a 1280×800 screen (853×533 and
+  640×400 CSS px viewports) all controls must stay reachable: the periodic
+  table and the hierarchy dialog are clamped instead of a negative
+  `margin-left`, the fixed side columns and the fixed dialogs scroll
+  vertically instead of clipping, and the hierarchy's `vh` line heights have
+  an `em` floor. `a11y_zoom150_*` / `a11y_zoom200_*` audit this. Sizes in
+  `vh`/`vw` inside `overflow:hidden` are the usual culprit.
+- **Parity:** the comparison strips `role`, `tabindex`, `aria-*`, `inert`
+  and `data-a11y-*` (`ignore_attributes` in `parity/config.json`), so the
+  attributes alone do not diverge from the deployed GUI, while focus and
+  pixels still do. The OLD side uses the CSS **pinned** with the bundle
+  (`OLD_CSS_URL`/`OLD_CSS_SHA1`), so a CSS change shows up as a pixel diff.
+
+## jQuery-migration traps (each has bitten this codebase)
+
+- `return false` from a handler: `on()` in `core/dom.js` honors it like
+  jQuery (`preventDefault()` + `stopPropagation()`), plain
+  `addEventListener` handlers do **not**. Several handlers in `events.js`
+  still end with `return false` from the jQuery era; where one is a direct
+  listener, call `event.preventDefault()` / `stopPropagation()` explicitly.
+- Delegation order: jQuery ran the delegated handlers of one root deepest
+  element first, and a `stopPropagation()` in an inner handler skipped the
+  outer ones (the row "Show" button must not also open the row). `on()`
+  reproduces this; separate `addEventListener` calls on one root do not.
+- Event order with a real mouse is `mousedown → (blur of the focused input) →
+  mouseup → click`. A widget that closes on blur loses the click unless its
+  `mousedown` calls `preventDefault()`: selectize options and chips, and
+  tablesorter headers (`cancelSelection`), all do; keep it that way.
+- Selectize deferred `onFocus` to the next tick and blurred on any document
+  mousedown outside the control; app code that writes chips while the box is
+  focused relies on that timing (the dropdown opened by the write is closed
+  again by the deferred refresh).
+- **Enter is not handled by the multiselect**: the vendored selectize has its
+  Enter handler commented out, so Enter bubbles to the `#search_holder` and
+  document handlers, which run the search with the chips **and the raw
+  typed text** (a highlighted suggestion is not picked). Never consume Enter
+  in the component.
+- `show()`/`hide()`/`toggle_display()` in `core/dom.js` implement jQuery 3:
+  `hide()` remembers the inline display, `show()` restores it or falls back
+  to the tag's default display (`list-item` for `<li>`...), and only the
+  element itself is considered, not its ancestors. Do not replace them with
+  `style.display = 'block'`.
+- jQuery `.data('x')` coerced `"5"` to `5`, `"true"` to `true`, JSON to
+  objects; `getAttribute` / `dataset` return strings.
+- `ajax()` rejects with `{aborted: true}` only for `.abort()`; a network
+  failure is `{aborted: false, status: 0}` and must reach the "Connection to
+  server is lost" notification, like jQuery's `'error'` vs `'abort'`.
+- `Math.random` drives visible content (legend, examples, tooltips' random
+  picks, `control_e` plot type). Code that consumes random values in a
+  different order shifts all of them; parity seeds the sequence but cannot
+  realign it.
+- `wmgui.clean()` is the only sanitizer for server text shown in
+  notifications: keep it stripping scripts, embedded documents, `on*`
+  attributes and `javascript:` URLs (bar the app's own `location.reload()`).
+- jQuery is null-safe, the DOM is not: `$('x').text()` on no match is `''`,
+  `$('x').textContent` throws. Inside an `async` function the throw becomes
+  an unhandled rejection and the UI silently stays half-built (the "See
+  also" column once stayed empty because a ported selector was scoped to
+  `#sim_col`, where the selected `busy_entry` row never is). Keep the
+  original selector's scope, and guard reads that may not match.
+- jQuery acts on the whole set: `$('div.cross:visible').trigger('click')`
+  clicks every visible cross (ESC closes all panels); `.find(isVisible)`
+  picks only the first. Port set operations with `filter` + `forEach`.
+- A "simplified" `$.param` that just `encodeURIComponent`s each value turns
+  an array into `a,b,c` instead of `key[]=a&key[]=b&key[]=c`. This once
+  silently changed (and half-fixed) the numeric search URLs; `param()` is
+  tested against the vendored jQuery for nested arrays, objects, `null`,
+  functions and top-level `{name, value}` arrays.
+
+## Verifying a change: the parity loop
+
+```
+python3 parity/run_parity.py --lint                 # after editing scenarios.json / config.json
+python3 parity/run_parity.py --only 'ms_*'          # the area you touched
+python3 parity/run_parity.py                        # everything: 7-25 min, host-dependent
+```
+
+- Before changing code, run the scenarios of the area and **record which
+  already fail**. A failing scenario is a divergence from the deployed
+  version, not flakiness: runs are deterministic (seeded random, virtual
+  time, replayed API responses), so reruns give the same set.
+- For every behavior you touch, **add a narrow scenario** (one route, the
+  fewest steps, probes that pin exactly that behavior) — see
+  `parity/README.md` for the step and probe vocabulary. Prefer a specific
+  probe (`classes:`, `focus`, `texts:`, `attr:`) over relying on pixels.
+- Read failures from `out/<scenario>/diff.txt` and `old|new-capture.json`;
+  `pixel-diff.png` shows *where*. The default probes (focus, search box
+  state, notification, `wmgui.search`) catch many collateral changes.
+- Parity is relative (new matches old). For a fact that must hold on its
+  own, add `expect` (see `parity/README.md`); an `expect` failure on the OLD
+  side means the data or the specification moved, not your change.
+- A `WARN the OLD side itself failed step N` means the scenario is wrong
+  (selector, hidden element, onboarding tooltip covering the target — use
+  `"tooltips": false`), not the code.
+- A scenario reported `ERROR SideFrozen` hung the browser (an endless loop,
+  a promise that never settles, a request that never completes): the
+  watchdog killed it after `--stall-timeout` s; its last activity says where.
+  Never "fix" it by raising the timeout before you know what it waits for.
+- Use native input (the default). `--input synthetic` (and the chrome-cli
+  driver) dispatch synthetic events and **miss focus/blur regressions**.
+- The specification is the bundle **pinned** in `run_parity.py` (`OLD_URL`
+  at a fixed gh-pages commit, `OLD_SHA1`, and its stylesheet `OLD_CSS_URL`,
+  `OLD_CSS_SHA1`), not the live demo, which serves the new code once it is
+  deployed. Move it only deliberately (`--reference-url` /
+  `--reference-sha1`, `--reference-css-url` / `--reference-css-sha1`), after
+  a release.
+- CI (`.github/workflows/parity.yml`) runs the component scenarios on every
+  pull request with a pinned Playwright/Chromium build; a red run is a
+  divergence to explain, not to re-run.
+- Sandboxed or macOS hosts without Chrome:
+  `PARITY_BROWSER=<chromium or headless_shell> PARITY_BROWSER_ARGS=--single-process`
+  with the Playwright driver; it needs no listening sockets.
+
+## The MPDS API: be a good citizen
+
+- The data are live at `api.mpds.io`; automated usage beyond the public API
+  violates the MPDS ToS (see the console warning in `app/run.js`). Keep test
+  traffic small: parity replays recorded responses (`out/*/api-cache/`), and
+  `--fresh-cache` should be the exception.
+- **Never exercise account endpoints against production** (`/users/login`,
+  `factor`, `access`, `ratify`, `lost_password`, `new_password`, `api_key`):
+  use `"mock": [...]` in the scenario. Never put real credentials or API keys in
+  scenarios, fixtures, caches or commits.
+- Do not commit `parity/out/`, `parity/reference/` or recorded responses.
+
+## Style
+
+Match the surrounding code: 2-space indent, single quotes, semicolons,
+`snake_case` functions, the `$`/`$$`/`on` helpers from `core/dom.js`, comments
+starting with `NB` for non-obvious decisions. Keep diffs local; do not
+reformat files you are not changing.
diff --git a/README.md b/README.md
index 18a73c5..5e9c04d 100755
--- a/README.md
+++ b/README.md
@@ -20,26 +20,26 @@ cd ermac
 # then run your static web-server and open it in a web-browser
 ```
 
+**NB local development.** When served from a "localhost" origin, the GUI switches to development mode and expects the MPDS API at `http://localhost:7070` (see `src_js/core/settings.js`). There is no local backend in this repository — the data stays at the MPDS server — so run the bundled reverse proxy to the real API in a second terminal:
 
-## Technical details
+```
+python3 deploy/dev_api_proxy.py     # 127.0.0.1:7070 -> https://api.mpds.io/v0
+```
 
-Ermac is just a thin browser client (with a little fat). From whatever physical location, it talks to the MPDS platform servers at the `api.mpds.io` domain. Beware, Ermac employs the old-style JQuery-fashioned ES5 JavaScript (see `src_js` folder). The `Node` and `npm` are intentionally **NOT** used. Several external dependencies are supplied simply along with the codebase in `third_party` and `src_js/third_party` folders. For future, we consider re-implementation of this codebase in the modular TypeScript framework. Please [contact us](mailto:hello@tilde.pro) if you'd like to know more or help.
+Without it, the client data request fails and the GUI won't finish initializing (`Failed to load GUI`). Alternatively, serve the GUI from any non-"localhost" origin (e.g. `http://127.0.0.1:5555` or a LAN address): the GUI then talks to `https://api.mpds.io/v0` directly, no proxy needed.
 
 
-## Compilation
+## Technical details
 
-Compilation into the production bundle `ermac.min.js` from `src_js` is done via the Google Closure Compiler supplied in `third_party/jscomp` folder, see `deploy/build_js.sh` script. For that you need a Java Runtime Environment (JRE), i.e. a command `java -version` should _not_ produce an error in your terminal. On a typical Unix, such as Debian, JRE is installed e.g. like this:
+Ermac is just a thin browser client (with a little fat). From whatever physical location, it talks to the MPDS platform servers at the `api.mpds.io` domain. Ermac is written in modular **pure vanilla JavaScript (ES modules)**, without any framework. The `Node` and `npm` are intentionally **NOT** used. The few remaining external dependencies are supplied simply along with the codebase in `src_js/third_party` (noUiSlider, wNumb, the MPDS NLP parser, and darkmode.js — all framework-free), with the jQuery era of this codebase being over. Please [contact us](mailto:hello@tilde.pro) if you'd like to know more or help.
 
-```
-apt-get -y update && apt-get -y upgrade
-apt-get install default-jre
-java -version
-```
 
-Given your JRE works, compilation is done as follows:
+## Compilation
+
+Compilation into the production bundle `ermac.min.js` from the ES modules in `src_js` is done via the dependency-aware script `deploy/build_js.py`, which requires only a Python 3 interpreter (still no Node). It concatenates the vendored libraries and the application modules in topological order, stripping the `import`/`export` statements:
 
 ```
-bash deploy/build_js.sh
+python3 deploy/build_js.py
 ```
 
 The resulted file `ermac.min.js` is to be included into your webpage (see `example_prod.html`). Alternatively, see [Ermac demo](https://mpds-io.github.io/ermac) which is just a repository branch `gh-pages` compiled by GitHub action.
@@ -47,30 +47,37 @@ The resulted file `ermac.min.js` is to be included into your webpage (see `examp
 
 ## Code architecture
 
-The entire app lives in a global namespace object `window.wmgui`. There is no module system, and the code is intentionally ES5 jQuery-style (some files use ES6+ features and are compiled with `ECMASCRIPT_NEXT`).
+The entire app lives in the global state object `window.wmgui` (kept for embeddability) while being structured as ES modules with explicit dependencies. In the **development mode**, the code is served directly from the `src_js/app/run.js` ES module entry (see `example_dev.html`). In the **production mode**, the code is compiled into a single static bundle `ermac.min.js` (see `example_prod.html`).
 
-**Script load order** (defined in `example_dev.html` and mirrored in `deploy/build_js.sh`):
+**Module map** (entry: `src_js/app/run.js`):
 
-| File | Role |
+| Module | Role |
 |---|---|
-| `wmsettings.js` | All global state, constants, API endpoint URLs, edition configs, facet definitions |
-| `wmcore.js` | Utility functions, DOM helpers, AJAX wrappers, selectize read/write helpers |
-| `sliders.js` | Numeric range slider UI (noUiSlider-based) |
-| `ptable.js` | Interactive periodic table widget |
-| `router.js` | Hash-based routing — `url__<route>()` functions handle `#search/`, `#inquiry/`, `#phase/`, `#polyhedra/`, etc. |
-| `events.js` | DOM event listeners and `register_events()` |
-| `markup.js` | HTML generation and `register_html()` (injects the full UI into `<body>`) |
-| `main_logic.js` | Core search logic: `request_search()`, display/render functions, `wmgui.notify()`, `wmgui.aug_search_cmd()` |
-| `startup.js` | `satisfy_requirements()` — initializes selectize instances, loads `wmdata.json`, wires autocomplete, triggers initial route |
-| `run.js` | Entry point — calls `assign_edition()`, `register_html()`, `satisfy_requirements()`, and `register_events()` |
+| `core/dom.js` | Vanilla DOM helpers (`$`, `$$`, show/hide, delegated events, offsets) |
+| `core/ajax.js` | Abortable promise-based XHR wrapper, URL serialization (`param`), `is_empty` |
+| `core/settings.js` | All global state (`window.wmgui`), constants, API endpoint URLs, edition configs |
+| `core/utils.js` | Base-type extensions, `wmgui.clean`, `loadCSS`, domain data, interpretation HTML, random query generators |
+| `core/a11y.js` | Keyboard accessibility: a declarative registry giving the clickable `div`/`span`/`li` controls roles, labels, states and Tab stops, Enter/Space activation, arrow keys in grouped widgets, focus management of dialogs (`wmgui.open_dialog()` / `wmgui.release_dialog()`) |
+| `components/multiselect.js` | Vanilla multi-select input (replaces selectize.js, same CSS classes) |
+| `components/tablesort.js` | Vanilla table sorting (replaces jquery.tablesorter, same CSS classes) |
+| `components/autocomplete.js` | Simple autocompletion (converted from the vendored spin-off) |
+| `components/sliders.js` | Numeric range slider UI (noUiSlider-based) |
+| `app/ptable.js` | Interactive periodic table widget |
+| `app/router.js` | Hash-based routing — an explicit registry of `url__<route>()` handlers for `#search/`, `#inquiry/`, `#phase/`, `#polyhedra/`, etc. |
+| `app/events.js` | DOM event listeners and `register_events()` |
+| `app/markup.js` | HTML generation and `register_html()` (injects the full UI into `<body>`) |
+| `app/search.js` | Core search logic: `request_search()`, display/render functions, `wmgui.notify()`, `wmgui.aug_search_cmd()`, user session |
+| `app/startup.js` | `satisfy_requirements()` — initializes multiselects, loads client data, wires autocomplete, triggers initial route |
+| `app/run.js` | Entry point — calls `assign_edition()`, `register_html()`, `satisfy_requirements()`, `register_events()` and `install_a11y()` |
 
 **Key concepts:**
 
 - `wmgui.search` — the live search state object, synced with URL hash parameters
 - `wmgui.search_type` — `0` = entries, `1` = phases, `2` = articles
 - `wmgui.facets` — the 15 search categories (formulae, props, elements, classes, lattices, sgs, protos, authors, years, codens, doi, aeatoms, aetypes, geos, orgs)
-- `wmdata.json` — client-side data (properties list, journal CODENs, property hierarchy) fetched at startup from `wmgui.client_data_addr`
+- `wmdata` — client-side data (properties list, journal CODENs, property hierarchy) fetched at startup from `wmgui.wmdata_endpoint`
 - `wmgui.editions` — multi-tenant config keyed by edition ID (0 = MPDS, 1 = ASM, 10/15/16 = Ermac variants); the active edition is detected from the current hostname
+- Accessibility — every control is reachable and operable with the keyboard (Tab, Enter/Space, arrow keys in the periodic table, the results, the tabs and the VIEW switches; ESC closes panels), dialogs keep the focus inside and return it on close, and the layout stays usable at 200% zoom. A host page that adds its own dialog can use `wmgui.open_dialog(box, initial_selector)` / `wmgui.release_dialog()`
 
 **Embedded sub-apps** (loaded in iframes):
 
@@ -79,14 +86,22 @@ The entire app lives in a global namespace object `window.wmgui`. There is no mo
 - `labs/pd3d/` — 3D phase diagram viewer (Three.js-based)
 - `labs/view-phonons/` — phonon visualiser
 
-**Third-party libraries** (vendored in `src_js/third_party/` and `third_party/`):
+**Third-party libraries** (all framework-free, vendored in `src_js/third_party/`):
 
-- jQuery, selectize.js, noUiSlider, wNumb, autocomplete.js, darkmode.js, jquery.tablesorter
+- noUiSlider, wNumb, darkmode.js
 - `optimade_mpds_nlp.js` — NLP parser that converts free-text queries to structured facet objects
 
-### No test suite
+### Parity tests
+
+The `parity/` suite checks that the GUI behaves exactly like the deployed version at [mpds-io.github.io/ermac](https://mpds-io.github.io/ermac): every scenario (a route, optional clicks and keystrokes, and the observations to compare) runs against the old and the new bundle in a headless browser, comparing API requests, DOM state, focus, JS errors and screenshots. Scenarios are declared in `parity/scenarios.json` (a list of scenario objects; defaults and fixtures in `parity/config.json`); see [`parity/README.md`](parity/README.md) for running them and adding new ones.
+
+```
+# NB one interpreter throughout: install with the python3 that runs the suite
+python3 -m pip install playwright==1.50.0 pillow && python3 -m playwright install chromium
+python3 parity/run_parity.py
+```
 
-There are no automated tests. Verify changes by loading `example_dev.html` in a browser and exercising the search and visualisation features manually.
+Contributors and coding agents: see [`AGENTS.md`](AGENTS.md) for the compatibility contracts and pitfalls of changing this codebase.
 
 
 ## License
diff --git a/deploy/build_js.py b/deploy/build_js.py
new file mode 100644
index 0000000..ba04562
--- /dev/null
+++ b/deploy/build_js.py
@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""
+Ermac ES-module bundler: builds ermac.min.js from src_js/ without Node.js.
+
+The application is authored as ES modules (native import/export). This script
+concatenates them into a single classic script:
+
+  1. vendored vanilla libraries are prepended as-is (they define window globals);
+  2. modules are appended in dependency order (topological sort, entry: src_js/app/run.js);
+  3. `import ... from ...` statements are stripped (names resolve at script scope);
+  4. `export function`/`export const` keep their declarations, `export default <name>` is dropped.
+
+Supported import syntax (single- or multi-line, trailing commas allowed):
+  import { a, b } from './x.js';
+  import name from './x.js';        (default export)
+"""
+
+import os
+import re
+import sys
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+ENTRY = os.path.join(ROOT, "src_js", "app", "run.js")
+TARGET = os.path.join(ROOT, "ermac.min.js")
+
+# NB order matters, these define window globals used by the app modules
+VENDORED = [
+    "src_js/third_party/wNumb.js",
+    "src_js/third_party/nouislider.js",
+    "src_js/third_party/optimade_mpds_nlp.js",
+    "src_js/third_party/darkmode.js",
+]
+
+IMPORT_RE = re.compile(
+    r"""^[ \t]*import\s+(?:([\w$]+)\s*,?\s*)?(?:\{([^}]*)\})?\s*from\s+['"]([^'"]+)['"]\s*;[ \t]*\n?""",
+    re.M,
+)
+EXPORT_DEFAULT_RE = re.compile(
+    r"""^[ \t]*export\s+default\s+([\w$]+)\s*;[ \t]*\n?""", re.M
+)
+EXPORT_DECL_RE = re.compile(
+    r"""^[ \t]*export\s+(?=(?:async\s+)?function\b|const\b|let\b|var\b|class\b)""",
+    re.M,
+)
+EXPORT_BLOCK_RE = re.compile(r"""^[ \t]*export\s*\{""", re.M)
+
+
+class Module(object):
+    def __init__(self, path):
+        self.path = path
+        with open(path, "r", encoding="utf-8") as f:
+            source = f.read()
+        self.imports = []  # (default_alias, [named], resolved_path)
+        self.default_export = None  # local name of `export default`
+        self.exports = set()
+
+        for match in IMPORT_RE.finditer(source):
+            default_alias, named, target = match.groups()
+            named = [n.strip() for n in (named or "").split(",") if n.strip()]
+            self.imports.append((default_alias, named, self.resolve(target)))
+
+        body = IMPORT_RE.sub("", source)
+
+        if EXPORT_BLOCK_RE.search(body):
+            raise SyntaxError(
+                "Named export blocks are not supported in %s" % path
+            )
+
+        default_match = EXPORT_DEFAULT_RE.search(body)
+        if default_match:
+            self.default_export = default_match.group(1)
+            body = EXPORT_DEFAULT_RE.sub("", body, count=1)
+
+        for match in EXPORT_DECL_RE.finditer(body):
+            self.exports.add(declare_name(body, match.start()))
+
+        body = EXPORT_DECL_RE.sub("", body)
+        self.body = body
+
+    def resolve(self, target):
+        if not target.startswith("."):
+            raise ImportError(
+                "Only relative imports are supported: %s in %s" % (target, self.path)
+            )
+        resolved = os.path.normpath(os.path.join(os.path.dirname(self.path), target))
+        if not os.path.exists(resolved):
+            raise ImportError("Unresolved import: %s in %s" % (target, self.path))
+        return resolved
+
+
+def declare_name(source, offset):
+    """Determine the identifier declared by an export statement at `offset`."""
+    rest = source[offset:]
+    m = (
+        re.match(r"\s*export\s+(?:async\s+)?function\s+([\w$]+)", rest)
+        or re.match(r"\s*export\s+(?:const|let|var)\s+([\w$]+)", rest)
+        or re.match(r"\s*export\s+class\s+([\w$]+)", rest)
+    )
+    if not m:
+        raise SyntaxError("Cannot determine the exported name at: %r" % rest[:60])
+    return m.group(1)
+
+
+def bundle():
+    modules = {}
+
+    def load(path):
+        path = os.path.abspath(path)
+        if path not in modules:
+            modules[path] = Module(path)
+            for default_alias, named, target in modules[path].imports:
+                load(target)
+        return modules[path]
+
+    entry = load(ENTRY)
+
+    # topological order, DFS post-order, cycle-tolerant
+    order = []
+    visited = set()
+
+    def visit(path):
+        if path in visited:
+            return
+        visited.add(path)
+        for default_alias, named, target in modules[path].imports:
+            visit(target)
+        order.append(path)
+
+    visit(os.path.abspath(ENTRY))
+
+    # validate the import graph
+    for path, module in modules.items():
+        for default_alias, named, target in module.imports:
+            target_module = modules[target]
+            if default_alias:
+                if not target_module.default_export:
+                    raise ImportError(
+                        "%s imports a default export, but %s has none" % (path, target)
+                    )
+                if default_alias != target_module.default_export:
+                    raise ImportError(
+                        "Default import %r in %s must be aliased as %r in the bundle"
+                        % (default_alias, path, target_module.default_export)
+                    )
+            for name in named:
+                if name not in target_module.exports:
+                    raise ImportError(
+                        "%s imports %r, but %s does not export it"
+                        % (path, name, target)
+                    )
+
+    parts = [
+        "/* Ermac, the embeddable MPDS GUI: https://github.com/mpds-io/ermac */",
+        "/* NB built by deploy/build_js.py, do not edit */",
+        '"use strict";',
+        "",
+    ]
+
+    for vendor in VENDORED:
+        vendor_path = os.path.join(ROOT, vendor)
+        with open(vendor_path, "r", encoding="utf-8") as f:
+            parts.append("/* %s */" % vendor)
+            parts.append(f.read())
+            parts.append("")
+
+    for path in order:
+        module = modules[path]
+        parts.append("/* module: %s */" % os.path.relpath(path, ROOT))
+        parts.append(module.body)
+        parts.append("")
+
+    result = "\n".join(parts) + "\n"
+
+    # NB guard: no ES module syntax may survive the stripping
+    leftover = re.search(r"^[ \t]*(?:import|export)\b", result, re.M)
+    if leftover:
+        context = result[leftover.start():leftover.start() + 120]
+        raise SyntaxError(
+            "unstripped ES module syntax survived in the bundle:\n%r" % context
+        )
+
+    with open(TARGET, "w", encoding="utf-8") as f:
+        f.write(result)
+
+    print(
+        "Bundled %d app modules + %d vendored libs -> %s (%d KB)"
+        % (
+            len(order),
+            len(VENDORED),
+            os.path.relpath(TARGET, ROOT),
+            len(result) // 1024,
+        )
+    )
+    print("Module order:")
+    for path in order:
+        print("  - %s" % os.path.relpath(path, ROOT))
+    print("NB check absence of errors in the output above")
+
+
+if __name__ == "__main__":
+    try:
+        bundle()
+    except (ImportError, SyntaxError) as e:
+        sys.exit("BUILD ERROR: %s" % e)
diff --git a/deploy/build_js.sh b/deploy/build_js.sh
deleted file mode 100755
index ec86f59..0000000
--- a/deploy/build_js.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/bin/bash
-
-ROOT=$(dirname $0)/../
-JSCOMP=$ROOT/third_party/jscomp/compiler.jar
-JSTARGET=$ROOT/ermac.min.js
-
-cat $ROOT/src_js/third_party/jquery.min.js > $JSTARGET
-
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/third_party/jquery.tablesorter.js --compilation_level WHITESPACE_ONLY >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/third_party/wNumb.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/third_party/nouislider.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/third_party/selectize.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/third_party/selectize_preserve_on_blur.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT_NEXT    --js $ROOT/src_js/third_party/optimade_mpds_nlp.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/third_party/darkmode.js >> $JSTARGET
-
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/wmsettings.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT_NEXT    --js $ROOT/src_js/wmcore.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/sliders.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT_NEXT    --js $ROOT/src_js/ptable.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/third_party/autocomplete.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/router.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/events.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT_NEXT    --js $ROOT/src_js/markup.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/main_logic.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/startup.js >> $JSTARGET
-java -jar $JSCOMP --jscomp_off checkTypes --language_in ECMASCRIPT5_STRICT --js $ROOT/src_js/run.js >> $JSTARGET
-
-echo "NB check absense of errors in the compiler output"
diff --git a/deploy/dev_api_proxy.py b/deploy/dev_api_proxy.py
new file mode 100644
index 0000000..f5ce24d
--- /dev/null
+++ b/deploy/dev_api_proxy.py
@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+"""
+Ermac local development API proxy.
+
+The Ermac GUI talks to the MPDS platform API at https://api.mpds.io/v0.
+When the GUI is served from a "localhost" origin, it switches to development
+mode and expects the API at http://localhost:7070 (see src_js/core/settings.js).
+
+There is no local backend in this repository (the data stays at the MPDS server),
+so for local development this script reverse-proxies localhost:7070 to the real
+MPDS API, adding the CORS headers needed for the cross-origin XHR calls.
+Pure Python standard library, no dependencies:
+
+    python3 deploy/dev_api_proxy.py            # 127.0.0.1:7070 -> https://api.mpds.io/v0
+
+Then serve the GUI from any port, e.g.:
+
+    python3 -m http.server 5555
+
+and open http://localhost:5555/example_dev.html
+
+NB anonymous browsing (searches, wmdata, refinements) works without any key.
+NB logging in through the proxy may not keep the session cookie, depending on
+the MPDS cookie flags: for full account testing prefer a non-"localhost" origin
+(e.g. http://127.0.0.1:5555), which makes the GUI talk to the MPDS API directly.
+"""
+
+import argparse
+import hashlib
+import http.server
+import os
+import sys
+import threading
+import urllib.error
+import urllib.parse
+import urllib.request
+
+HOST = "127.0.0.1"
+PORT = 7070
+REMOTE = "https://api.mpds.io/v0"
+TIMEOUT = 20
+
+# NB parity testing mode: with --cache DIR, responses are stored on disk and
+# replayed on subsequent identical requests, making comparative test runs
+# deterministic regardless of the live data changes at the MPDS server
+CACHE_DIR = None
+_log_lock = threading.Lock()
+
+
+def cache_lookup(method, path):
+    """(status, content_type, payload, location) or None. NB a redirect
+    record carries its Location on a third header line."""
+    if not CACHE_DIR:
+        return None
+    key = hashlib.sha1(("%s %s" % (method, path)).encode()).hexdigest()
+    cache_path = os.path.join(CACHE_DIR, key)
+    if not os.path.exists(cache_path):
+        return None
+    with open(cache_path, "rb") as f:
+        status = int(f.readline().strip())
+        content_type = f.readline().strip().decode()
+        location = f.readline().strip().decode() if is_redirect(status) else ""
+        payload = f.read()
+    return status, content_type, payload, location
+
+
+def cacheable(status):
+    """Transient failures (rate limits, server errors, this proxy's own 502)
+    must not be replayed forever."""
+    return status < 500 and status != 429
+
+
+def cache_key_path(method, path, body):
+    """POSTs to the same URL with different bodies are different requests.
+    NB shared with parity/run_parity.py, so both drivers read one cache."""
+    if method == "POST":
+        return path + "\n" + hashlib.sha1(body or b"").hexdigest()
+    return path
+
+
+def cache_store(method, path, status, content_type, payload, location=""):
+    if not CACHE_DIR:
+        return
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    key = hashlib.sha1(("%s %s" % (method, path)).encode()).hexdigest()
+    with open(os.path.join(CACHE_DIR, key), "wb") as f:
+        f.write(("%d\n%s\n" % (status, content_type)).encode())
+        if is_redirect(status):
+            f.write(("%s\n" % location).encode())
+        f.write(payload)
+
+
+def is_redirect(status):
+    return 300 <= status < 400
+
+
+class _KeepRedirects(urllib.request.HTTPRedirectHandler):
+    """Hand 3xx responses back instead of following them: the browser must
+    see the redirect itself. E.g. an anonymous /download/p?...&fmt=pdf is a
+    302 to https://mpds.io/#junction (sign-in); followed here, the proxy
+    served the mpds.io page (its fragment lost) as if it were the API
+    response, with its relative assets resolving to the proxy: broken HTML."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+_OPENER = urllib.request.build_opener(_KeepRedirects)
+
+
+def fetch_remote(method, path, body=None, headers=None):
+    """(status, response_headers, payload) of REMOTE + path, redirects NOT
+    followed; transport errors give a 502 with a JSON error payload.
+    NB shared with parity/run_parity.py."""
+    request = urllib.request.Request(REMOTE + path, data=body, method=method, headers=headers or {})
+    last_error = None
+    # NB the CDN may occasionally cut a response short, so retry once
+    for attempt in (1, 2):
+        try:
+            with _OPENER.open(request, timeout=TIMEOUT) as response:
+                return response.status, response.headers, response.read()
+        except urllib.error.HTTPError as error:  # NB includes the 3xx
+            return error.code, error.headers, error.read()
+        except Exception as error:
+            last_error = error
+    return 502, {}, ('{"error": "dev proxy: %s"}' % last_error).encode()
+
+
+def local_location(location, path, local_origin):
+    """A redirect back into the API stays on this proxy; others (mpds.io)
+    are passed as absolute URLs, fragment included."""
+    if not location:
+        return location
+    absolute = urllib.parse.urljoin(REMOTE + path, location)
+    if absolute.startswith(REMOTE + "/") or absolute == REMOTE:
+        return local_origin + absolute[len(REMOTE):]
+    return absolute
+
+HOP_BY_HOP = {
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade",
+    "content-encoding",
+    "content-length",
+}
+
+
+class ProxyHandler(http.server.BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def _cors(self):
+        origin = self.headers.get("Origin")
+        if origin:
+            self.send_header("Access-Control-Allow-Origin", origin)
+            self.send_header("Access-Control-Allow-Credentials", "true")
+
+    def do_OPTIONS(self):
+        self.send_response(200)
+        self._cors()
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.send_header("Access-Control-Max-Age", "21600")
+        self.send_header("Content-Length", "0")
+        self.end_headers()
+
+    def _forward(self, method, send_body=True):
+        body = None
+
+        if method == "POST":
+            try:
+                length = int(self.headers.get("Content-Length") or 0)
+            except ValueError:
+                self.send_error(400, "malformed Content-Length")
+                return
+            body = self.rfile.read(length) if length > 0 else b""
+
+        key = cache_key_path(method, self.path, body)
+        cached = cache_lookup(method, key)
+        local_origin = "http://%s" % (self.headers.get("Host") or "%s:%d" % (HOST, PORT))
+        if cached is not None:
+            status, content_type, payload, location = cached
+            try:
+                self.send_response(status)
+                self._cors()
+                if content_type:
+                    self.send_header("Content-Type", content_type)
+                if location:
+                    self.send_header("Location", local_location(location, self.path, local_origin))
+                self.send_header("Content-Length", str(len(payload)))
+                self.end_headers()
+                if send_body:
+                    self.wfile.write(payload)
+            except (BrokenPipeError, ConnectionResetError):
+                pass
+            return
+
+        headers = {}
+        for header in ("Content-Type", "Origin", "Key", "Accept-Language"):
+            value = self.headers.get(header)
+            if value:
+                headers[header] = value
+
+        status, response_headers, payload = fetch_remote(method, self.path, body, headers)
+        location = (response_headers or {}).get("Location", "")
+
+        if cacheable(status):
+            cache_store(method, key, status,
+                        (response_headers or {}).get("Content-Type", ""),
+                        payload, location)
+
+        try:
+            self.send_response(status)
+            self._cors()
+            for name, value in (response_headers or {}).items():
+                # NB the proxy handles CORS itself (the origin it sees is localhost,
+                # not the real browser origin), so drop the remote CORS headers
+                if name.lower() == "location":
+                    value = local_location(value, self.path, local_origin)
+                if name.lower() not in HOP_BY_HOP and not name.lower().startswith(
+                    "access-control-"
+                ):
+                    self.send_header(name, value)
+            self.send_header("Content-Length", str(len(payload)))
+            self.end_headers()
+            if send_body:
+                self.wfile.write(payload)
+        except (BrokenPipeError, ConnectionResetError):
+            pass  # NB the browser aborted the request, e.g. on page reload
+
+    def do_GET(self):
+        self._forward("GET")
+
+    def do_POST(self):
+        self._forward("POST")
+
+    def do_HEAD(self):
+        # NB answered from the GET response (and its cache entry), headers only
+        self._forward("GET", send_body=False)
+
+    def log_message(self, fmt, *args):
+        # NB a single write() must carry the whole line: concurrent request
+        # threads otherwise interleave and corrupt the log (which the parity
+        # suite relies on), especially with unbuffered stdout
+        with _log_lock:
+            sys.stdout.write("proxy: %s - %s\n" % (self.address_string(), fmt % args))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=PORT)
+    parser.add_argument(
+        "--cache",
+        default=None,
+        help="cache API responses on disk and replay them, see parity/run_parity.py",
+    )
+    args = parser.parse_args()
+    if args.cache:
+        CACHE_DIR = args.cache
+    server = http.server.ThreadingHTTPServer((HOST, args.port), ProxyHandler)
+    print(
+        "dev API proxy: http://%s:%d -> %s%s"
+        % (HOST, args.port, REMOTE, " (cached: %s)" % CACHE_DIR if CACHE_DIR else "")
+    )
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        server.shutdown()
diff --git a/example_dev.html b/example_dev.html
index 92d3bef..1e45fc5 100755
--- a/example_dev.html
+++ b/example_dev.html
@@ -1,42 +1,25 @@
-<!DOCTYPE html>
+<!doctype html>
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta charset="utf-8" />
-<link rel="stylesheet" type="text/css" href="webassets/ermac.css" />
-</head>
-<body>
-<script type="text/javascript">
-// a very simple env loader
-var to_load = [
-    'src_js/third_party/jquery.min.js',
-    'src_js/third_party/jquery.tablesorter.js',
-    'src_js/third_party/wNumb.js',
-    'src_js/third_party/nouislider.js',
-    'src_js/third_party/selectize.js',
-    'src_js/third_party/selectize_preserve_on_blur.js',
-    'src_js/third_party/optimade_mpds_nlp.js',
-    'src_js/third_party/darkmode.js',
-    'src_js/wmsettings.js',
-    'src_js/wmcore.js',
-    'src_js/sliders.js',
-    'src_js/ptable.js',
-    'src_js/third_party/autocomplete.js',
-    'src_js/router.js',
-    'src_js/events.js',
-    'src_js/markup.js',
-    'src_js/main_logic.js',
-    'src_js/startup.js',
-    'src_js/run.js'
-];
-
-var head = document.getElementsByTagName('head')[0];
-for (var i = 0; i < to_load.length; i++){
-    var script = document.createElement('script');
-    script.type = 'text/javascript';
-    script.src = to_load[i];
-    script.async = false;
-    head.appendChild(script);
-}
-</script>
-</body>
+  <head>
+    <meta charset="utf-8" />
+    <link rel="stylesheet" type="text/css" href="webassets/ermac.css" />
+  </head>
+  <body>
+    <!-- NB vendored vanilla libraries, they must be loaded before the app -->
+    <script type="text/javascript" src="src_js/third_party/wNumb.js"></script>
+    <script
+      type="text/javascript"
+      src="src_js/third_party/nouislider.js"
+    ></script>
+    <script
+      type="text/javascript"
+      src="src_js/third_party/optimade_mpds_nlp.js"
+    ></script>
+    <script
+      type="text/javascript"
+      src="src_js/third_party/darkmode.js"
+    ></script>
+    <!-- NB the app itself is pure vanilla ES modules -->
+    <script type="module" src="src_js/app/run.js"></script>
+  </body>
 </html>
diff --git a/parity/README.md b/parity/README.md
new file mode 100644
index 0000000..cf0283f
--- /dev/null
+++ b/parity/README.md
@@ -0,0 +1,369 @@
+# Ermac parity test
+
+Automated comparative testing of the refactored GUI against the previously
+deployed version at <https://mpds-io.github.io/ermac>: every scenario runs on
+the OLD bundle and on the NEW one under identical, deterministic conditions,
+and the two sides must agree. No manual inspection needed.
+
+```
+# NB one interpreter throughout: install with the python3 that runs the suite
+python3 -m pip install playwright==1.50.0 pillow && python3 -m playwright install chromium
+
+python3 parity/run_parity.py                      # everything
+python3 parity/run_parity.py --only 'ms_*,start'  # names or glob patterns
+python3 parity/run_parity.py --tag multiselect    # by tag
+python3 parity/run_parity.py --list               # what is there
+python3 parity/run_parity.py --lint               # validate scenarios.json + config.json only
+python3 parity/run_parity.py --no-pixels          # skip the screenshot layer
+```
+
+The tests live in **[`scenarios.json`](scenarios.json)**, a list of scenario
+objects; the defaults applied to every scenario and the fixtures are in
+**[`config.json`](config.json)**. The runner (`run_parity.py`) and the
+in-page harness (`harness.js`) contain no test-specific code.
+
+JSON has no comments: any object (a scenario, a step, the defaults, a
+fixture) may carry a `"comment"` (a string or a list of strings), which is
+ignored. Scenarios that open a group of related tests carry
+`"comment": "section: ..."`. The linter reports syntax errors with their line
+and column, duplicate keys (which JSON parsers otherwise silently resolve to
+the last one) and unknown keys.
+
+## Adding a parity test
+
+Add an object to the list in `scenarios.json`. A route alone is a valid test:
+
+```json
+{
+  "name": "route_inquiry_entries",
+  "route": "#inquiry_entries/elements=Ag-O&classes=oxide"
+}
+```
+
+A narrow interaction test is a route, a few **steps**, and the **probes** that
+pin the behavior down:
+
+```json
+{
+  "name": "ms_backspace_removes_last_item",
+  "desc": "Backspace in the empty input removes the last item",
+  "route": "#search/Ag-O",
+  "steps": [
+    {"focus": "#search_field-selectized"},
+    {"key": "Backspace", "after": 1200}
+  ],
+  "probe": ["texts:#search_holder .selectize-input > div[data-term]"],
+  "tags": ["multiselect", "keyboard"]
+}
+```
+
+Then `python3 parity/run_parity.py --lint` and
+`python3 parity/run_parity.py --only ms_backspace_removes_last_item`.
+
+You normally never write expected values: the OLD side **is** the
+expectation. You only say what to do and what to look at. When a fact must
+hold regardless of the old GUI (e.g. "this search shows the 'similar data'
+notice"), add an [`expect`](#absolute-expectations) object.
+
+### Steps
+
+Each step is an object with exactly one action. `"nth": N` picks the
+N-th match of a selector (default 0). `"after": ms` overrides the virtual time
+allowed after the step (default `step_after`, 400 ms).
+
+| step | meaning |
+|---|---|
+| `{"click": "sel"}` / `dblclick` / `hover` | mouse on the element |
+| `{"mousedown": "sel"}` | a bare `mousedown` event (e.g. reference links) |
+| `{"focus": "sel"}` / `{"blur": "sel"}` / `{"blur": true}` | focus management (`true` = the active element) |
+| `{"type": "sel", "text": "Ag O", "clear": true}` | key-by-key typing (fires keydown/keypress/input/keyup) |
+| `{"key": "Enter", "on": "sel"}` | a single key press, on `sel` or the focused element: `Enter`, `Escape`, `Backspace`, `ArrowDown`, `ArrowUp`, `Tab`, `ControlOrMeta+a`, ... The key is held 30 ms, like a person: what keydown triggers (e.g. a route change) runs before keyup instead of racing it |
+| `{"fill": "sel", "text": "..."}` | set an input value at once (input + change events) |
+| `{"check": "sel"}` / `uncheck` | checkboxes and radios |
+| `{"hash": "#route"}` / `{"back": true}` | in-app navigation, browser Back |
+| `{"scroll": "sel"}` / `{"scroll_y": 600}` | scroll an element into view / the window to y |
+| `{"wait": 2000}` | let 2000 ms of virtual time pass |
+| `{"wait_for": "sel", "timeout": 10000}` / `wait_gone` | until an element appears / disappears |
+| `{"eval": "js"}` | escape hatch: run JS in the page |
+
+A step whose selector matches nothing is recorded as `missing`, a wait that
+expires as `timeout`; the remaining steps are `skipped`. The step outcomes are
+compared too, and a scenario whose steps fail on the OLD side is flagged with
+a warning (it does not test what it claims).
+
+### Probes
+
+A probe is a string `kind:selector` (or `kind:selector@argument`) evaluated in
+the page after the last step; its value must be identical on both sides.
+
+| probe | value |
+|---|---|
+| `text:sel` / `texts:sel` | normalized textContent of the first / all matches |
+| `html:sel` | normalized innerHTML |
+| `value:sel` / `values:sel` | form values |
+| `checked:sel`, `disabled:sel`, `readonly:sel` | booleans |
+| `count:sel` | number of matches |
+| `visible:sel` / `visibles:sel` / `nvisible:sel` | rendered visibility (first / list / how many) |
+| `class:sel` / `classes:sel` | sorted class list |
+| `attr:sel@name` / `attrs:sel@name` | attribute value(s) |
+| `style:sel@property` | computed style |
+| `rect:sel` / `rects:sel` | `[x, y, width, height]` (layout) |
+| `focus` | which element has the keyboard focus |
+| `hash`, `title`, `scroll`, `history`, `selection` | location hash, document title, scroll offsets, history length, selected text |
+| `storage:key` | a localStorage value |
+| `js:expression` | any JSON-able JS expression, e.g. `js:wmgui.search` |
+
+`defaults.probe` in `config.json` lists the probes evaluated in **every** scenario (focus,
+notification text and visibility, search box items/text/dropdown, open
+modals, `wmgui.search`, localStorage keys, ...). A probe that is `null` on
+both sides (selector matching nothing) is reported as a *vacuous* warning.
+
+### Absolute expectations
+
+Parity is relative: if the old and the new GUI both show 8 hits, a "no hits"
+scenario still passes. `expect` adds absolute assertions on probes, checked
+on **each** side independently:
+
+```json
+{
+  "comment": "settle: NB the notification hides 4 s after it appears",
+  "name": "search_am_ru_binary_similar",
+  "route": "#start",
+  "steps": [
+    {"type": "#search_field-selectized", "text": "Am Ru binary", "after": 300},
+    {"key": "Enter", "after": 1500}
+  ],
+  "settle": 1000,
+  "expect": {
+    "text:#notifybox": {"contains": "similar data shown"},
+    "visible:#notifybox": true,
+    "hash": "#inquiry/elements=Am-Ru&classes=binary"
+  }
+}
+```
+
+E.g. `"expect": {"count:#databrowser tr.tcell, #databrowser div.gallery_item": {"gt": 0}}`
+asserts that there are results. A plain value means equality; operators: `equals`, `not`, `contains`,
+`not_contains` (strings, lists), `matches` (regex search), `gt`, `ge`,
+`lt`, `le` (numbers). The probes of `expect` are also compared old vs new
+like any other. Failures are reported per side in the `expect` layer, e.g.
+`OLD count:... is 8, expected equals 0`: a failing OLD side means the data or
+the specification changed, not the refactoring. NB in JSON a backslash in a
+probe must be doubled, e.g. `"js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1"`.
+
+The `qa` scenarios (`--tag qa`) are result-count checks for 78 facet
+searches from a QA list: route `#inquiry/<facets>`, expecting the number the
+GUI reports in the page title (`[At least ]N result(s)`, i.e. the API's
+`estimated_count`). The counts were re-recorded from the live API (the QA
+list's own numbers were outdated; each `desc` keeps them) and are checked
+loosely so that growing data keeps them green: nonzero cases expect at least
+the recorded count (`ge`), cases hitting the server's fuzzy fallback also
+expect its "similar data shown" notice, and zero cases expect 0 plus their
+notice ("No hits" / "Unrecognized property"), so a page that failed to load
+cannot pass as 0. Runs replay the recorded responses, so the counts only
+move with `--fresh-cache` or `--live`, e.g. a periodic
+`--tag qa --fresh-cache` to watch the data. Their parity comparison counts
+like any other scenario; the tag is not part of the PR CI set.
+
+### Approved behaviour changes
+
+When the new GUI deliberately differs from the old one (a fix the maintainer
+approved), the scenario keeps comparing both sides, is marked `xfail` with the
+reason, and pins the **new** behaviour with `expect_new`, checked on the NEW
+side only. A violated `expect_new` makes the scenario FAIL even though it is
+xfail; without it an xfail scenario would pass whatever NEW does.
+
+```json
+{
+  "name": "search_numeric_text",
+  "route": "#start",
+  "steps": [
+    {"type": "#search_field-selectized", "text": "band gap > 3", "after": 100},
+    {"key": "Enter", "after": 1500}
+  ],
+  "xfail": "APPROVED CHANGE: the old GUI wrote numeric[0][]=... keys the router cannot read",
+  "expect_new": {
+    "hash": "#inquiry/numeric=band%20gap%2C%3E%2C3",
+    "js:JSON.stringify(wmgui.search.numeric)": "[[\"band gap\",\">\",\"3\"]]"
+  }
+}
+```
+
+When the change is confined to a few probes (an a11y change moving the
+`focus`, say) a whole-scenario `xfail` would be too wide: it tolerates every
+layer, so an unrelated regression in the same scenario would go unnoticed.
+Use `"approved": "<reason>"` instead: the probes named in `expect_new` are
+pinned on NEW and left out of the OLD-vs-NEW comparison, everything else is
+compared as usual and the scenario PASSes or FAILs normally (the summary
+counts these PASSes, `report.json` carries the reason).
+
+```json
+{
+  "name": "control_phases",
+  "route": "#inquiry/elements=Ag-O&classes=oxide",
+  "steps": [{"wait_for": "#control_b"}, {"click": "#control_b", "after": 1500}],
+  "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+  "expect_new": {"focus": "#control_b"}
+}
+```
+
+The linter rejects `expect_new` without `xfail` or `approved`, `approved`
+without `expect_new`, and both `approved` and `xfail` on one scenario.
+
+### Accessibility audit (`--tag a11y`)
+
+`harness.js` defines `window.__a11y()`, usable in any `js:` probe, e.g.
+`"js:window.__a11y().mouse_only_total"`. It returns:
+
+| key | meaning |
+|---|---|
+| `mouse_only_total`, `mouse_only` | visible `cursor:pointer` elements (outermost of a pointer subtree) that are neither focusable nor inside a focusable element or a `<label>`, by region, with examples; members of a roving group (`tabindex="-1"` under a `tabindex="0"` sibling) and `[data-a11y-keyboard]` elements (documented other keyboard model) count as reachable |
+| `tab_count`, `tab_order` | the Tab sequence (the first 40, with their region) |
+| `modal`, `focusable_outside_modal`, `outside_modal` | the visible dialog and the Tab stops outside it (`#userbox` is exempt: it stays above the overlay by design) |
+| `unreachable_total`, `unreachable` | controls cut off by the viewport or by an `overflow:hidden` ancestor (4 px tolerance in scrollable columns), i.e. that zooming makes unusable |
+| `viewport`, `scroll_width`, `overflow_x`, `focus_after_open` | context |
+
+The `a11y_audit_*` scenarios pin 0 mouse-only controls on the main screens and
+0 Tab stops outside each dialog; `a11y_zoom150_*` / `a11y_zoom200_*` pin 0
+unreachable controls at 853×533 / 640×400 (150% / 200% of 1280×800); the others pin single keyboard contracts (arrows in
+the periodic table, Enter on a VIEW switch, focus into and back out of
+dialogs, the skip control). They are `xfail` against the deployed GUI, which
+has none of this, and `expect_new` pins the result.
+
+### Other scenario keys
+
+| key | meaning |
+|---|---|
+| `desc`, `tags` | free text; `--tag` selects by tag |
+| `"storage": {"key": "value"}` | localStorage preset, set before the app boots |
+| `"mock": [{"path": "/users/login", "json": {...}}]` | stub an API path (prefix): `json`/`body`, `status`, `method`, or `"abort": true` for a network failure. Mocked scenarios never reach the MPDS server (playwright driver only) |
+| `boot`, `settle`, `step_after`, `wait_for_timeout` | virtual-time budget (ms) around the steps |
+| `"pixels": "strict" \| "loose" \| "off"`, `pixel_threshold` | screenshot comparison; `loose` reports but never fails |
+| `"api": "ordered" \| "unordered" \| "off"` | API request log comparison |
+| `"viewport": [w, h]` | default `[1280, 2400]` |
+| `"expect": {"<probe>": value}` | absolute assertions, see above |
+| `"ignore": ["pixels", "probe:focus", "dom:header_th"]` | accept an intentional difference (say why in `desc`); `expect` can be ignored too |
+| `"ignore_attributes": ["role", "aria-*"]` | attributes stripped from the DOM and the probe values before the comparison (`aria-*` is a prefix); the default in `config.json` strips the accessibility markup (`role`, `tabindex`, `aria-*`, `inert`, `data-a11y-*`). `expect`/`expect_new` see the raw values |
+| `"xfail": "reason"` | known or approved divergence: reported XFAIL, and XPASS (failing) once the sides agree; pair it with `expect_new` |
+| `"approved": "reason"` | an approved change confined to the `expect_new` probes, see above |
+| `"skip": "reason"` | not run |
+
+Route placeholders such as `#phase_id/{phid}` are filled from the `fixtures`
+of `config.json`, harvested from the OLD side before the run (`probe` or regex
+`pattern`).
+
+## How it works
+
+1. The OLD reference bundle is **pinned**: fetched once from a fixed gh-pages
+   commit (`OLD_URL`, the deployment of master `a71cabb`) and verified
+   against `OLD_SHA1` on every run (cached in `reference/`). The live demo
+   is deliberately not used: once the refactoring is deployed it serves the
+   NEW bundle. `--reference-url` / `--reference-sha1` move the specification
+   deliberately. The NEW bundle is rebuilt from the current sources.
+   The OLD **stylesheet** is pinned the same way (`OLD_CSS_URL`,
+   `OLD_CSS_SHA1`, `--reference-css-url` / `--reference-css-sha1`): `old.html`
+   loads `reference/ermac_old.css` (its `url()`s rewritten to `webassets/`),
+   `new.html` the working tree's `webassets/ermac.css`, so a CSS change is a
+   pixel diff like any other.
+2. Both are loaded by `old.html` / `new.html` on a `localhost` origin, so
+   both run in development mode and talk to the API at `localhost:7070`.
+3. `harness.js` runs before either bundle: seeded `Math.random`, frozen
+   rotating legend, identical masking of random-content ink, capture of
+   uncaught errors / unhandled rejections / `console.error`, the probe
+   engine, and a synthetic step executor (for the chrome-cli driver).
+4. Time is virtual on both drivers: it only advances while no API fetch is
+   pending, so app timers (tooltips after 4 s, notifications hiding after
+   4 s, autocomplete throttles) fire at the same logical moment on both sides.
+5. API responses: the OLD side records them in `out/<scenario>/api-cache/`,
+   the NEW side replays them, so both see identical data regardless of live
+   index changes. External hosts (thumbnails etc.) are blocked on both sides.
+6. Eight comparison layers per scenario:
+   - **api** — MPDS API requests: method, path, sorted query, and (playwright
+     driver) the POST content type and body;
+   - **ext** — requests to external hosts except images (playwright driver;
+     `<img loading="lazy">` fetches depend on the browser build's lazy-load
+     distance, the image URLs are compared through the DOM instead);
+   - **dom** — the legacy semantic keys (title, tables and row order,
+     interpretation, history, multiselect items, visibility states, ...);
+   - **probes** — the declared probes;
+   - **expect** — the absolute expectations, on each side;
+   - **steps** — the step outcomes;
+   - **errors** — the NEW side must not throw more than the OLD side;
+   - **pixels** — screenshots: a pixel differs when any channel differs by
+     more than 2; strict scenarios fail above 0.1% of differing pixels.
+
+A scenario whose capture fails (e.g. no API traffic at all) is reported as
+**ERROR** and the run continues; ERROR, FAIL and XPASS make the exit code 1.
+A full run takes 7-25 min depending on the host (2 sides x ~3-8 s per
+scenario).
+
+## CI
+
+`.github/workflows/parity.yml` runs the component scenarios
+(`--tag legacy,multiselect,sort,controls,mock,keyboard`) on every pull
+request and the whole battery on manual dispatch, with Playwright pinned
+(Chromium 133: rendering and lazy loading depend on the browser build) and
+the recorded API responses cached between runs to keep the load on
+api.mpds.io minimal. The evidence (`report.json`, diffs, captures,
+screenshots) is uploaded as the `parity-out` artifact.
+
+## Drivers
+
+* `--driver playwright` (default when the package is installed): native
+  input, files and API served through request interception (no listening
+  sockets, no proxy process), Playwright's fake clock as virtual time, a
+  fresh browser per side. `--input synthetic` replays the steps with the
+  in-page executor instead (useful to check what the chrome-cli driver sees).
+  `--browser PATH` / `PARITY_BROWSER` and `--browser-arg` /
+  `PARITY_BROWSER_ARGS` select another Chromium build, e.g.
+  `--browser-arg=--single-process` for sandboxed macOS hosts.
+* `--driver chrome-cli`: the original approach, `google-chrome --dump-dom
+  --virtual-time-budget` with `python -m http.server` and
+  `deploy/dev_api_proxy.py --cache`; steps are replayed in-page with
+  synthetic DOM events, results are read back from the dumped DOM. No API
+  mocks, no external-request layer. Both drivers share the response cache
+  format of `deploy/dev_api_proxy.py` (POSTs are keyed by URL and body;
+  rate limits and server errors are never cached; redirects are passed to
+  the browser, not followed, and replayed with their `Location`). The
+  browser is `--browser` / `PARITY_BROWSER`, else the first Chrome/Chromium
+  found in `PATH` or `/Applications`.
+
+The Playwright driver is the default and never falls back to chrome-cli on
+its own: if this Python cannot import playwright, or its Chromium is not
+downloaded, the run stops and prints the exact install commands for the
+interpreter it runs under.
+
+## Freezes and interruptions
+
+A run cannot hang. With the Playwright driver every side runs in a worker
+process (its own process group) that reports what it is doing: launching,
+loading, each step, each live API request, capturing. A side that reports
+nothing for `--stall-timeout` seconds (default 90, env
+`PARITY_STALL_TIMEOUT`), or runs longer than `--side-timeout` (default 600,
+env `PARITY_SIDE_TIMEOUT`), is killed together with its browser and the
+scenario is reported as ERROR with its last activity, e.g.
+`SideFrozen: OLD side froze (no progress for 90 s), last activity: step 2/3:
+(click "#control_d")`; the next scenario gets a fresh worker. Three frozen
+scenarios in a row stop the run: the environment is then broken, not the
+scenarios. While a side runs longer than 15 s a heartbeat line shows what it
+is waiting for, so a slow API (`API GET /search/facet...`) is told apart from
+a freeze. Waiting for pending requests is capped at 60 s per side in total.
+
+`report.json` is rewritten after every scenario (`"complete": false` until
+the end); Ctrl-C stops the browsers at once, prints the partial summary and
+exits with 130. `--stall-timeout 0` runs in-process without the watchdog
+(for debugging the driver itself).
+
+## Artifacts
+
+`out/<scenario>/` (or `$PARITY_OUT/<scenario>/`): `old|new-dom.html`,
+`old|new.png`, `old|new-capture.json` (API log, step outcomes, probe
+values, errors), `pixel-diff.png`, `diff.txt`, the replayed `api-cache/`.
+`out/report.json` summarizes the run. `--fresh-cache` re-records the API.
+Both `out/` and `reference/` are gitignored.
+
+## Debugging aid
+
+`?trace=1` on either harness page records every `Math.random` call with a
+stack trace into the DOM (visible in the dumps), for diagnosing
+random-sequence divergence.
diff --git a/parity/config.json b/parity/config.json
new file mode 100644
index 0000000..5712d21
--- /dev/null
+++ b/parity/config.json
@@ -0,0 +1,40 @@
+{
+  "comment": [
+    "Ermac parity configuration: the defaults applied to every scenario, and the fixtures (real ids harvested from the OLD side, used as {name} in routes). The scenarios are in parity/scenarios.json, a list of scenario objects; see parity/README.md (\"Adding a parity test\").",
+    "Every scenario runs on the OLD and the NEW bundle under identical, deterministic conditions; all layers (api, ext, dom, probes, steps, errors, pixels) must agree. A scenario is a route + optional steps + optional probes."
+  ],
+  "defaults": {
+    "comment": [
+      "boot: virtual ms after page load, before the first step",
+      "step_after: virtual ms after each step (unless the step sets after)",
+      "settle: virtual ms after the last step, before the capture",
+      "probe: evaluated in EVERY scenario (cheap, broad UX invariants)",
+      "ignore_attributes: the accessibility markup (src_js/core/a11y.js) is stripped before old vs new comparisons; the a11y scenarios assert it on the NEW side"
+    ],
+    "boot": 3000,
+    "step_after": 400,
+    "settle": 3000,
+    "pixels": "strict",
+    "ignore_attributes": ["role", "tabindex", "aria-*", "inert", "data-a11y-*"],
+    "probe": [
+      "hash",
+      "title",
+      "focus",
+      "text:#notifybox",
+      "visible:#notifybox",
+      "texts:#search_holder .selectize-input > div[data-term]",
+      "value:#search_field-selectized",
+      "visible:#search_holder .selectize-dropdown",
+      "nvisible:div.modal",
+      "visible:#overlay",
+      "js:wmgui.view_mode",
+      "js:wmgui.search_type",
+      "js:wmgui.search",
+      "js:Object.keys(localStorage).sort()"
+    ]
+  },
+  "fixtures": [
+    {"name": "phid", "route": "#inquiry_phases/elements=Ag-O&classes=oxide", "probe": "attr:#databrowser div.gallery_img@rel"},
+    {"name": "bid", "route": "#search/Ag-O", "pattern": "ref_id=(\\d+)&amp;sid"}
+  ]
+}
diff --git a/parity/harness.js b/parity/harness.js
new file mode 100644
index 0000000..1a93e1b
--- /dev/null
+++ b/parity/harness.js
@@ -0,0 +1,467 @@
+/*
+ * Ermac parity harness, loaded BEFORE the application bundle (old or new).
+ *
+ *  1. determinism: Math.random() yields an identical seeded sequence on both
+ *     sides, the rotating legend interval is frozen, random-content ink is
+ *     masked identically;
+ *  2. error capture: uncaught errors, unhandled rejections and console.error
+ *     calls are recorded (window.__parity.errors), so a refactoring that
+ *     starts throwing is caught even when the DOM happens to look right;
+ *  3. probes: window.__parity.probe([...]) evaluates the declarative probe
+ *     strings of parity/scenarios.json (see parity/README.md) in-page, for
+ *     BOTH drivers, so the observation semantics are identical everywhere;
+ *  4. synthetic step executor: for the chrome-cli driver (no remote control),
+ *     the scenario is passed as ?p=<base64url JSON> and its steps are
+ *     replayed here with synthetic DOM events; the results are serialized
+ *     into <script id="__parity_result"> for the --dump-dom capture.
+ *     The playwright driver performs the SAME steps with native input instead.
+ *
+ * Nothing here may depend on the application internals beyond what the
+ * probes ask for: the harness must be equally valid for the old and the new code.
+ */
+
+(function(){
+    var params = new URLSearchParams(location.search);
+
+    // ------------------------------------------------------------------
+    // 1. determinism
+    // ------------------------------------------------------------------
+
+    var seed = 0x2F6E2B1;
+    Math.random = function(){
+        seed = (seed * 1664525 + 1013904223) >>> 0;
+        return seed / 4294967296;
+    };
+
+    // NB the rotating legend interval consumes random values at
+    // network-latency-dependent moments, which makes the page capture
+    // race-y (e.g. the examples box draws from different random sequence
+    // positions). The legend is therefore frozen at its boot state,
+    // identical on both sides; the no-op interval only keeps the headless
+    // Chrome virtual-time clock marching so the budget expires after
+    // the app has settled.
+    var real_set_timeout = window.setTimeout;
+    var real_set_interval = window.setInterval;
+    window.setInterval = function(fn, ms){
+        real_set_timeout.call(window, function(){
+            real_set_interval.call(window, function(){}, ms);
+        }, 20000);
+        return 0;
+    };
+
+    // NB parity debugging aid: ?trace=1 records every Math.random call
+    if (params.get('trace')){
+        window.name = (parseInt(window.name || '0', 10) + 1) + '';
+        var seeded_random = Math.random;
+        var calls = 0, stacks = [], values = [];
+        Math.random = function(){
+            calls++;
+            var value = seeded_random();
+            if (values.length < 60) values.push(value.toFixed(6));
+            if (stacks.length < 16) stacks.push('call#' + calls + ' <- ' + String(new Error().stack).split('\n').slice(2, 5).join(' | '));
+            var el = document.getElementById('__randtrace');
+            if (!el){
+                el = document.createElement('div');
+                el.id = '__randtrace';
+                (document.body || document.documentElement).appendChild(el);
+            }
+            el.textContent = 'LOADS=' + window.name + ' RANDCOUNT=' + calls + ' VALS=' + values.join(',') + ' STACKS=' + stacks.join(' ;; ');
+            return value;
+        };
+    }
+
+    // NB the old bundle consumes extra random values inside jQuery/Sizzle
+    // internals (the selector engine uses Math.random as its expando
+    // counter), so random-content elements (the rotating legend, the
+    // examples box) can never be content-aligned between the sides.
+    // Their text ink is masked IDENTICALLY on both sides, and their
+    // content parity is verified structurally by the runner instead.
+    var style = document.createElement('style');
+    style.textContent =
+        '#legend a, #examples li a { color: rgba(0,0,0,0) !important; }';
+    document.head.appendChild(style);
+
+    // ------------------------------------------------------------------
+    // 2. error capture
+    // ------------------------------------------------------------------
+
+    var errors = [];
+    window.addEventListener('error', function(e){
+        // NB resource load failures (blocked thumbnails etc.) are not script errors
+        if (!(e instanceof ErrorEvent)) return;
+        errors.push('error: ' + (e.message || 'unknown'));
+    });
+    window.addEventListener('unhandledrejection', function(e){
+        var reason = e.reason;
+        errors.push('unhandledrejection: ' + (reason && reason.message ? reason.message : String(reason)));
+    });
+    var real_console_error = console.error;
+    console.error = function(){
+        try {
+            errors.push('console.error: ' + Array.prototype.map.call(arguments, String).join(' ').slice(0, 300));
+        } catch (e) {}
+        return real_console_error.apply(console, arguments);
+    };
+
+    // ------------------------------------------------------------------
+    // 3. probes
+    // ------------------------------------------------------------------
+
+    function norm(text){
+        return text === null || text === undefined ? null : String(text).replace(/\s+/g, ' ').trim();
+    }
+
+    function side_neutral(text){
+        // NB the harness pages are old.html / new.html: links must compare equal
+        return text === null ? null : text.replace(/\b(old|new)\.html\b/g, 'app.html');
+    }
+
+    function is_visible(el){
+        if (!el) return null;
+        if (!el.isConnected || !el.getClientRects().length) return false;
+        var cs = window.getComputedStyle(el);
+        return cs.visibility !== 'hidden' && cs.display !== 'none';
+    }
+
+    function describe(el){
+        if (!el || el === document.body || el === document.documentElement) return el ? el.tagName.toLowerCase() : null;
+        if (el.id) return '#' + el.id;
+        var cls = (el.getAttribute('class') || '').trim().split(/\s+/).filter(Boolean).sort().join('.');
+        var parent = el.parentElement ? describe(el.parentElement) : '';
+        return parent + ' > ' + el.tagName.toLowerCase() + (cls ? '.' + cls : '');
+    }
+
+    function class_list(el){
+        if (!el) return null;
+        return (el.getAttribute('class') || '').trim().split(/\s+/).filter(Boolean).sort().join(' ');
+    }
+
+    function rect(el){
+        if (!el) return null;
+        var r = el.getBoundingClientRect();
+        return [Math.round(r.left), Math.round(r.top + window.scrollY), Math.round(r.width), Math.round(r.height)];
+    }
+
+    // kind -> [needs selector, needs @arg, evaluator(selector, arg)]
+    var KINDS = {
+        'text':     [1, 0, function(s){ var el = one(s); return el ? norm(el.textContent) : null; }],
+        'texts':    [1, 0, function(s){ return all(s).map(function(el){ return norm(el.textContent); }); }],
+        'html':     [1, 0, function(s){ var el = one(s); return el ? side_neutral(norm(el.innerHTML)) : null; }],
+        'value':    [1, 0, function(s){ var el = one(s); return el ? el.value : null; }],
+        'values':   [1, 0, function(s){ return all(s).map(function(el){ return el.value; }); }],
+        'checked':  [1, 0, function(s){ var el = one(s); return el ? !!el.checked : null; }],
+        'disabled': [1, 0, function(s){ var el = one(s); return el ? !!el.disabled : null; }],
+        'readonly': [1, 0, function(s){ var el = one(s); return el ? !!el.readOnly : null; }],
+        'count':    [1, 0, function(s){ return all(s).length; }],
+        'visible':  [1, 0, function(s){ return is_visible(one(s)); }],
+        'visibles': [1, 0, function(s){ return all(s).map(is_visible); }],
+        'nvisible': [1, 0, function(s){ return all(s).filter(is_visible).length; }],
+        'class':    [1, 0, function(s){ return class_list(one(s)); }],
+        'classes':  [1, 0, function(s){ return all(s).map(class_list); }],
+        'attr':     [1, 1, function(s, a){ var el = one(s); return el ? side_neutral(el.getAttribute(a)) : null; }],
+        'attrs':    [1, 1, function(s, a){ return all(s).map(function(el){ return side_neutral(el.getAttribute(a)); }); }],
+        'style':    [1, 1, function(s, a){ var el = one(s); return el ? window.getComputedStyle(el).getPropertyValue(a) : null; }],
+        'rect':     [1, 0, function(s){ return rect(one(s)); }],
+        'rects':    [1, 0, function(s){ return all(s).map(rect); }],
+        'focus':    [0, 0, function(){ return describe(document.activeElement); }],
+        'hash':     [0, 0, function(){ return location.hash; }],
+        'title':    [0, 0, function(){ return document.title; }],
+        'scroll':   [0, 0, function(){ return [Math.round(window.scrollX), Math.round(window.scrollY)]; }],
+        'history':  [0, 0, function(){ return history.length; }],
+        'selection':[0, 0, function(){ return norm(String(window.getSelection())); }],
+        'storage':  [1, 0, function(s){ return window.localStorage.getItem(s); }],
+        'js':       [1, 0, function(s){ return JSON.parse(JSON.stringify((0, eval)(s), function(k, v){ return v === undefined ? '__undefined__' : v; }) || 'null'); }]
+    };
+
+    function one(selector){ return document.querySelector(selector); }
+    function all(selector){ return Array.prototype.slice.call(document.querySelectorAll(selector)); }
+
+    function parse_probe(probe){
+        var colon = probe.indexOf(':');
+        var kind = colon === -1 ? probe : probe.slice(0, colon);
+        var rest = colon === -1 ? '' : probe.slice(colon + 1);
+        var spec = KINDS[kind];
+        if (!spec) throw new Error('unknown probe kind "' + kind + '"');
+        var arg = null;
+        if (spec[1]){
+            var at = rest.lastIndexOf('@');
+            if (at === -1) throw new Error('probe "' + probe + '" needs @argument');
+            arg = rest.slice(at + 1);
+            rest = rest.slice(0, at);
+        }
+        return {kind: kind, selector: rest, arg: arg, fn: spec[2]};
+    }
+
+    function probe(list){
+        var out = {};
+        (list || []).forEach(function(p){
+            try {
+                var parsed = parse_probe(p);
+                out[p] = parsed.fn(parsed.selector, parsed.arg);
+            } catch (e) {
+                out[p] = 'PROBE ERROR: ' + e.message;
+            }
+        });
+        return out;
+    }
+
+    // ------------------------------------------------------------------
+    // 4. synthetic step executor (chrome-cli driver)
+    // ------------------------------------------------------------------
+
+    var KEYCODES = {
+        Enter: 13, Escape: 27, Backspace: 8, Tab: 9, ArrowUp: 38, ArrowDown: 40,
+        ArrowLeft: 37, ArrowRight: 39, Delete: 46, ' ': 32, ',': 188, Home: 36, End: 35
+    };
+
+    function key_event(type, key, target){
+        var code = KEYCODES[key] || (key.length === 1 ? key.toUpperCase().charCodeAt(0) : 0);
+        var ev = new KeyboardEvent(type, {key: key, bubbles: true, cancelable: true});
+        // NB the app (and jQuery) read the legacy keyCode/which/charCode
+        var char_code = type === 'keypress' && key.length === 1 ? key.charCodeAt(0) : 0;
+        Object.defineProperty(ev, 'keyCode', {get: function(){ return type === 'keypress' ? char_code : code; }});
+        Object.defineProperty(ev, 'which', {get: function(){ return type === 'keypress' ? char_code : code; }});
+        Object.defineProperty(ev, 'charCode', {get: function(){ return char_code; }});
+        return target.dispatchEvent(ev);
+    }
+
+    function mouse(type, el){
+        var r = el.getBoundingClientRect();
+        el.dispatchEvent(new MouseEvent(type, {
+            bubbles: type !== 'mouseenter' && type !== 'mouseleave', cancelable: true, view: window,
+            clientX: r.left + r.width / 2, clientY: r.top + r.height / 2, button: 0
+        }));
+    }
+
+    function press(key, target, held){
+        target = target || document.activeElement || document.body;
+        var proceed = key_event('keydown', key, target);
+        if (proceed && key.length === 1) {
+            key_event('keypress', key, target);
+            insert_text(target, key);
+        } else if (proceed && key === 'Backspace' && 'value' in target && target.value) {
+            target.value = target.value.slice(0, -1);
+            target.dispatchEvent(new Event('input', {bubbles: true}));
+        }
+        // NB a held key (`key` steps): keyup after what keydown triggered,
+        // like the playwright driver's KEY_HOLD_MS
+        if (held) real_set_timeout(function(){ key_event('keyup', key, target); }, 30);
+        else key_event('keyup', key, target);
+    }
+
+    function insert_text(target, text){
+        if (!('value' in target) || target.readOnly) return;
+        target.value += text;
+        target.dispatchEvent(new InputEvent('input', {bubbles: true, data: text, inputType: 'insertText'}));
+    }
+
+    function target_of(step, key){
+        var els = all(step[key]);
+        return els[step.nth || 0] || null;
+    }
+
+    // step name -> handler(step) returning null (ok) or an outcome string
+    var STEPS = {
+        click: function(s){ var el = target_of(s, 'click'); if (!el) return 'missing'; mouse('mousedown', el); if (el.focus) el.focus(); mouse('mouseup', el); el.click(); },
+        dblclick: function(s){ var el = target_of(s, 'dblclick'); if (!el) return 'missing'; el.click(); el.click(); mouse('dblclick', el); },
+        mousedown: function(s){ var el = target_of(s, 'mousedown'); if (!el) return 'missing'; mouse('mousedown', el); },
+        hover: function(s){ var el = target_of(s, 'hover'); if (!el) return 'missing'; mouse('mouseover', el); mouse('mouseenter', el); mouse('mousemove', el); },
+        focus: function(s){ var el = target_of(s, 'focus'); if (!el) return 'missing'; el.focus(); },
+        blur: function(s){ var el = s.blur === true ? document.activeElement : target_of(s, 'blur'); if (!el) return 'missing'; el.blur(); },
+        type: function(s){
+            var el = target_of(s, 'type'); if (!el) return 'missing';
+            el.focus();
+            if (s.clear) { el.value = ''; el.dispatchEvent(new Event('input', {bubbles: true})); }
+            String(s.text).split('').forEach(function(ch){ press(ch, el); });
+        },
+        key: function(s){
+            var el = s.on ? all(s.on)[s.nth || 0] : document.activeElement;
+            if (!el) return 'missing';
+            if (s.on && el.focus) el.focus();
+            press(s.key, el, true);
+        },
+        fill: function(s){
+            var el = target_of(s, 'fill'); if (!el) return 'missing';
+            el.focus(); el.value = s.text;
+            el.dispatchEvent(new Event('input', {bubbles: true}));
+            el.dispatchEvent(new Event('change', {bubbles: true}));
+        },
+        check: function(s){ var el = target_of(s, 'check'); if (!el) return 'missing'; if (!el.checked) el.click(); },
+        uncheck: function(s){ var el = target_of(s, 'uncheck'); if (!el) return 'missing'; if (el.checked) el.click(); },
+        hash: function(s){ location.hash = s.hash; },
+        back: function(){ history.back(); },
+        scroll: function(s){ var el = target_of(s, 'scroll'); if (!el) return 'missing'; el.scrollIntoView(); },
+        scroll_y: function(s){ window.scrollTo(0, s.scroll_y); window.dispatchEvent(new Event('scroll')); },
+        eval: function(s){ (0, eval)(s.eval); },
+        wait: function(){},      // the delay itself is handled by the scheduler
+        wait_for: function(){},  // polled by the scheduler
+        wait_gone: function(){}  // polled by the scheduler
+    };
+
+    function step_name(step){
+        for (var name in STEPS) if (step.hasOwnProperty(name)) return name;
+        return null;
+    }
+
+    function run_steps(scenario, finish){
+        var steps = scenario.steps || [], log = [], i = 0;
+        var defaults = scenario.timing || {};
+        var step_after = defaults.step_after || 400, poll_limit = defaults.wait_for_timeout || 10000;
+
+        function next(){
+            if (i >= steps.length) return finish(log);
+            var step = steps[i++], name = step_name(step);
+            if (name === 'wait') { log.push('ok'); return real_set_timeout(next, step.wait); }
+            if (name === 'wait_for' || name === 'wait_gone') {
+                var waited = 0;
+                (function poll(){
+                    var present = !!one(step[name]);
+                    if (present === (name === 'wait_for')) { log.push('ok'); return real_set_timeout(next, 50); }
+                    if ((waited += 100) > (step.timeout || poll_limit)) {
+                        log.push('timeout');
+                        return abort();
+                    }
+                    real_set_timeout(poll, 100);
+                })();
+                return;
+            }
+            var outcome;
+            try { outcome = STEPS[name](step); } catch (e) { outcome = 'error: ' + e.message; }
+            log.push(outcome || 'ok');
+            if (outcome) return abort();
+            real_set_timeout(next, step.after !== undefined ? step.after : step_after);
+        }
+        function abort(){
+            while (i++ < steps.length) log.push('skipped');
+            finish(log);
+        }
+        next();
+    }
+
+    function write_result(scenario, log){
+        var node = document.getElementById('__parity_result');
+        if (!node){
+            node = document.createElement('script');
+            node.type = 'application/json';
+            node.id = '__parity_result';
+            document.documentElement.appendChild(node);
+        }
+        node.textContent = JSON.stringify({
+            steps: log, errors: errors.slice(),
+            probes: probe(scenario.probe || [])
+        });
+    }
+
+    window.__parity = {probe: probe, errors: errors, parse_probe: parse_probe, kinds: Object.keys(KINDS), steps: Object.keys(STEPS)};
+
+    var packed = params.get('p');
+    if (packed){
+        var scenario = JSON.parse(decodeURIComponent(escape(atob(packed.replace(/-/g, '+').replace(/_/g, '/')))));
+        // NB storage presets must land BEFORE the app bundle reads them
+        for (var key in (scenario.storage || {})) window.localStorage.setItem(key, scenario.storage[key]);
+        window.addEventListener('load', function(){
+            real_set_timeout(function(){
+                run_steps(scenario, function(log){
+                    // NB the probes are captured ONCE, `settle` ms after the
+                    // last step, exactly like the playwright driver: time-
+                    // sensitive observations (e.g. a notification that hides
+                    // after 4 s) must not depend on the driver's budget
+                    real_set_timeout(function(){
+                        write_result(scenario, log);
+                    }, (scenario.timing || {}).settle || 3000);
+                });
+            }, (scenario.timing || {}).boot || 3000);
+        });
+    }
+})();
+
+
+/*
+ * Accessibility audit (see the accessibility plan): window.__a11y() returns,
+ * for the current page, the Tab stops, the mouse-only controls (pointer
+ * cursor, not keyboard-reachable) by region, the focusable elements outside
+ * an open dialog, and the controls that cannot be brought into view (fixed
+ * and off-screen, or clipped). Used by the `a11y` scenarios, e.g.
+ * "js:window.__a11y().mouse_only_total".
+ */
+window.__a11y = function () {
+  var FOCUSABLE = 'a[href], button, input:not([type=hidden]), select, textarea, [tabindex], summary, [contenteditable=true]';
+  function desc(el) {
+    var s = el.tagName.toLowerCase() + (el.id ? '#' + el.id : '');
+    var cls = (el.getAttribute('class') || '').trim().split(/\s+/).filter(Boolean).slice(0, 2);
+    if (cls.length) s += '.' + cls.join('.');
+    var t = (el.getAttribute('aria-label') || el.getAttribute('title') || el.textContent || '').replace(/\s+/g, ' ').trim().slice(0, 32);
+    return t ? s + ' "' + t + '"' : s;
+  }
+  function region(el) {
+    var r = el.parentElement;
+    while (r && !(r.id && /^(userbox|search_box|legend|main|results|ptable_holder|ptable_area|refine_col|ctx_col|sim_col|right_col|advsbox|hy_box|loginbox|menubox|all_polyhedra_box|numericbox|examples|history|dtypes|interpret|header_entries|header_phases|header_articles|aetmap|tooltip)$/.test(r.id))) r = r.parentElement;
+    return r ? '#' + r.id : 'body';
+  }
+  function visible(el) {
+    if (!el.getClientRects().length) return false;
+    var cs = getComputedStyle(el);
+    return cs.visibility !== 'hidden' && cs.display !== 'none' && cs.opacity !== '0';
+  }
+  // NB roving widgets: one item is the Tab stop, the others (tabindex=-1) are
+  // reached with the arrow keys
+  var ROVING = '#ptable_area > ul, #databrowser, #all_polyhedra_content, [role=tablist], [role=radiogroup]';
+  function roving_member(el) {
+    var group = el.getAttribute('tabindex') === '-1' && el.closest(ROVING);
+    return !!(group && group.querySelector('[tabindex="0"]'));
+  }
+  function tabbable(el) { return el.matches(FOCUSABLE) && !el.disabled && !el.closest('[inert]') && (el.tabIndex >= 0 || roving_member(el)) && visible(el); }
+  var all = Array.prototype.slice.call(document.body.querySelectorAll('*')).filter(visible);
+  var tabs = all.filter(tabbable);
+  var mouse = all.filter(function (el) {
+    // NB [data-a11y-keyboard]: a documented keyboard alternative (e.g. Backspace removes a chip)
+    if (tabbable(el) || el.closest(FOCUSABLE) || el.closest('label') || el.closest('[data-a11y-keyboard]')) return false;
+    if (getComputedStyle(el).cursor !== 'pointer') return false;
+    var p = el.parentElement;
+    return !(p && getComputedStyle(p).cursor === 'pointer' && !p.closest(FOCUSABLE));
+  });
+  var by = {};
+  mouse.forEach(function (el) { var r = region(el); (by[r] = by[r] || []).push(desc(el)); });
+  var mouse_only = {};
+  Object.keys(by).forEach(function (r) { mouse_only[r] = {count: by[r].length, examples: by[r].slice(0, 6)}; });
+  var modal = all.filter(function (el) { return el.matches('div.modal.user_dialogue'); }).pop();
+  // NB #userbox stays above the overlay by design (it toggles the login and
+  // account dialogs), like in the deployed GUI: not a leak
+  var leaking = modal ? tabs.filter(function (el) { return !modal.contains(el) && !el.closest('#userbox'); }) : [];
+  var leak = modal ? leaking.length : null;
+  // zoom: what cannot be brought into view
+  var de = document.documentElement, hx = getComputedStyle(de).overflowX, bx = getComputedStyle(document.body).overflowX;
+  var maxX = (hx === 'hidden' || bx === 'hidden') ? innerWidth : de.scrollWidth;
+  var unreachable = [];
+  tabs.concat(mouse).forEach(function (el) {
+    var r = el.getBoundingClientRect(), fixed = false, clipped = false, a = el.parentElement;
+    for (var e = el; e && e !== document.body; e = e.parentElement) if (getComputedStyle(e).position === 'fixed') { fixed = true; break; }
+    while (a && a !== document.body) {
+      var cs = getComputedStyle(a);
+      if (cs.overflowX !== 'visible' || cs.overflowY !== 'visible') {
+        var ar = a.getBoundingClientRect();
+        if ((cs.overflowX === 'hidden' && (r.right > ar.right + 1 || r.left < ar.left - 1)) || (cs.overflowY === 'hidden' && (r.bottom > ar.bottom + 1 || r.top < ar.top - 1))) { clipped = true; break; }
+      }
+      a = a.parentElement;
+    }
+    // NB inside a fixed box, a vertically scrollable ancestor that is itself in view brings the element into view
+    var scroller = null;
+    for (var s = el.parentElement; fixed && s && s !== document.body; s = s.parentElement) {
+      var sy = getComputedStyle(s).overflowY;
+      if ((sy === 'auto' || sy === 'scroll') && s.scrollHeight > s.clientHeight) { scroller = s; break; }
+    }
+    var scroll_ok = scroller && scroller.getBoundingClientRect().bottom <= innerHeight + 4; // NB borders
+    var off = fixed ? (r.right > innerWidth + 1 || r.left < -1 || (!scroll_ok && r.bottom > innerHeight + 1)) : (r.left + scrollX < -1 || r.right + scrollX > maxX + 1);
+    if (clipped || off) unreachable.push((fixed ? '[fixed] ' : '') + (clipped ? '[clipped] ' : '') + region(el) + ' ' + desc(el));
+  });
+  return {
+    tab_count: tabs.length,
+    tab_order: tabs.slice(0, 40).map(function (el) { return region(el) + ' ' + desc(el); }),
+    mouse_only_total: mouse.length, mouse_only: mouse_only,
+    modal: modal ? '#' + modal.id : null, focusable_outside_modal: leak,
+    outside_modal: leaking.slice(0, 20).map(function (el) { return region(el) + ' ' + desc(el); }),
+    viewport: [innerWidth, innerHeight], scroll_width: de.scrollWidth, overflow_x: [hx, bx],
+    unreachable: unreachable.slice(0, 1000), unreachable_total: unreachable.length,
+    focus_after_open: document.activeElement ? desc(document.activeElement) : null
+  };
+};
diff --git a/parity/new.html b/parity/new.html
new file mode 100644
index 0000000..99b46a2
--- /dev/null
+++ b/parity/new.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+<meta charset="utf-8" />
+<link rel="stylesheet" type="text/css" href="./webassets/ermac.css" />
+</head>
+<body>
+<!-- NB parity harness page: the NEW (refactored) production bundle -->
+<script type="text/javascript" src="./harness.js"></script>
+<script type="text/javascript" src="./ermac.min.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/parity/old.html b/parity/old.html
new file mode 100644
index 0000000..bf21e8d
--- /dev/null
+++ b/parity/old.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+<meta charset="utf-8" />
+<link rel="stylesheet" type="text/css" href="./reference/ermac_old.css" />
+</head>
+<body>
+<!-- NB parity harness page: the OLD (reference) production bundle -->
+<script type="text/javascript" src="./harness.js"></script>
+<script type="text/javascript" src="./reference/ermac_old.min.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/parity/run_parity.py b/parity/run_parity.py
new file mode 100644
index 0000000..4f95ff0
--- /dev/null
+++ b/parity/run_parity.py
@@ -0,0 +1,1659 @@
+#!/usr/bin/env python3
+"""
+Ermac parity test: automated comparative testing of the refactored GUI
+against the previously deployed version (https://mpds-io.github.io/ermac).
+
+Every scenario of parity/scenarios.json (a hash route + optional scripted
+steps + optional probes, see parity/README.md) runs twice under identical,
+deterministic conditions: once with the OLD reference bundle, once with the
+NEW one. Then the two sides are compared layer by layer:
+
+  api      the MPDS API requests (method, path, sorted query, POST body)
+  ext      external requests (thumbnails, iframes, ...), blocked on both sides
+  dom      the legacy semantic DOM keys (title, tables, interpretation, ...)
+  probes   the scenario-declared probes (narrow, in-page observations)
+  expect   absolute assertions on probes, checked on EACH side
+  expect_new  absolute assertions checked on the NEW side only: they pin an
+           approved behaviour change (`xfail`, or `approved` for a change
+           confined to those probes) and fail the scenario even when it is
+           xfail
+  steps    the outcome of every scripted step (ok / missing / timeout / ...)
+  errors   uncaught JS errors: the new side must not throw more than the old
+  pixels   rendered screenshots (tolerance, strict or loose per scenario)
+
+Drivers:
+  playwright  (default) native input via Playwright, static files and API
+              served by request interception (no sockets, no proxy
+              process), Playwright fake clock = virtual time; every side
+              runs in a watched worker process, so a freeze costs at most
+              --stall-timeout seconds (see parity/README.md);
+  chrome-cli  google-chrome --dump-dom --virtual-time-budget, the static
+              server + deploy/dev_api_proxy.py; steps are replayed in-page
+              with synthetic events by parity/harness.js.
+
+Usage:
+    python3 parity/run_parity.py                       # everything
+    python3 parity/run_parity.py --only 'ms_*,start'   # names / globs
+    python3 parity/run_parity.py --tag multiselect
+    python3 parity/run_parity.py --list | --lint
+"""
+
+import argparse
+import base64
+import fnmatch
+import hashlib
+import importlib.util
+import json
+import mimetypes
+import os
+import re
+import queue
+import shutil
+import signal
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+
+try:
+    from PIL import Image, ImageChops
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+OUT = os.environ.get('PARITY_OUT') or os.path.join(HERE, 'out')
+SCENARIOS_PATH = os.path.join(HERE, 'scenarios.json')  # a list of scenario objects
+CONFIG_PATH = os.path.join(HERE, 'config.json')  # {"defaults": {...}, "fixtures": [...]}
+GUI_PORT = 5560
+API_PORT = 7070
+GUI_ORIGIN = 'http://localhost:%d' % GUI_PORT
+API_ORIGIN = 'http://localhost:%d' % API_PORT
+# NB the specification is PINNED: the gh-pages commit deployed from master
+# a71cabb (the merge base of the refactoring). The live demo URL must not be
+# used: once the refactoring is deployed, it serves the NEW bundle and the
+# suite would silently compare new against new.
+OLD_URL = ('https://raw.githubusercontent.com/mpds-io/ermac/'
+           '5978778447bcc3b1bf423088801163cbe5f28c4e/ermac.min.js')
+OLD_SHA1 = 'c8619d4c1d425b34b9dad5f34ea9e34448b8fd57'
+# NB the OLD side's stylesheet, pinned at the same gh-pages commit (it was
+# the working tree's on both sides before: CSS changes went unnoticed)
+OLD_CSS_URL = ('https://raw.githubusercontent.com/mpds-io/ermac/'
+               '5978778447bcc3b1bf423088801163cbe5f28c4e/webassets/ermac.css')
+OLD_CSS_SHA1 = '32cfd281dff9a050b7dee3056e0e0f19582deae6'
+TOL = 2  # per-channel pixel tolerance
+IDLE_BUDGET = 60.0  # s per side spent waiting for pending requests, in total
+KEY_HOLD_MS = 30  # real ms between keydown and keyup of a `key` step
+
+# NB keep in sync with parity/harness.js (checked at runtime by the playwright driver)
+STEP_KINDS = ['click', 'dblclick', 'mousedown', 'hover', 'focus', 'blur', 'type', 'key',
+              'fill', 'check', 'uncheck', 'hash', 'back', 'scroll', 'scroll_y', 'eval',
+              'wait', 'wait_for', 'wait_gone']
+STEP_OPTIONS = {'nth', 'after', 'text', 'clear', 'on', 'timeout'}
+PROBE_KINDS = {  # kind: (needs selector, needs @arg)
+    'text': (1, 0), 'texts': (1, 0), 'html': (1, 0), 'value': (1, 0), 'values': (1, 0),
+    'checked': (1, 0), 'disabled': (1, 0), 'readonly': (1, 0), 'count': (1, 0),
+    'visible': (1, 0), 'visibles': (1, 0), 'nvisible': (1, 0), 'class': (1, 0),
+    'classes': (1, 0), 'attr': (1, 1), 'attrs': (1, 1), 'style': (1, 1), 'rect': (1, 0),
+    'rects': (1, 0), 'focus': (0, 0), 'hash': (0, 0), 'title': (0, 0), 'scroll': (0, 0),
+    'history': (0, 0), 'selection': (0, 0), 'storage': (1, 0), 'js': (1, 0),
+}
+LAYERS = ['api', 'ext', 'dom', 'probes', 'expect', 'expect_new', 'steps', 'errors', 'pixels']
+# expect = { "<probe>" = value } or { "<probe>" = { <operator> = value } }
+EXPECT_OPERATORS = ['equals', 'not', 'contains', 'not_contains', 'matches', 'gt', 'ge', 'lt', 'le']
+DEFAULTS = {
+    'boot': 3000,             # virtual ms after page load, before the first step
+    'step_after': 400,        # virtual ms after every step (unless the step sets `after`)
+    'settle': 3000,           # virtual ms after the last step, before the capture
+    'wait_for_timeout': 10000,
+    'budget': None,           # chrome-cli: virtual-time budget, default boot+steps+settle+margin
+    'pixels': 'strict',       # strict | loose (reported, never fails) | off
+    'pixel_threshold': 0.001, # fraction of differing pixels tolerated in strict mode
+    'api': 'ordered',         # ordered | unordered | off
+    'semantics': True,        # the legacy semantic DOM keys
+    'probe': [],              # probes applied to every scenario
+    'ignore': [],             # layers (or "probe:<probe>" / "dom:<key>") not compared
+    'ignore_attributes': [],  # attributes stripped from the DOM and probe values before comparing
+                              # ("aria-*" = a prefix), e.g. the accessibility markup
+    'viewport': [1280, 2400],
+}
+SCENARIO_KEYS = set(DEFAULTS) | {'name', 'route', 'desc', 'steps', 'tags', 'skip', 'xfail', 'mock', 'storage', 'tooltips',
+                                 'expect', 'expect_new', 'approved'}
+# NB the app shows onboarding tooltips (landing: 4 s after boot, first search:
+# 3 s after the results) until 2 searches are logged; they cover the VIEW
+# controls. `tooltips = false` presets such a neutral 2-entry search log.
+QUIET_TOOLTIPS = {'wm_search_log_v5': '[{"elements":"Zr-Hf"},{"elements":"Nb-Ta"}]'}
+MOCK_KEYS = {'path', 'method', 'status', 'body', 'json', 'abort'}
+
+
+def banner(text):
+    print('\n' + '=' * 72 + '\n ' + text + '\n' + '=' * 72)
+
+
+def die(message):
+    sys.exit('FATAL: ' + message)
+
+
+# NB freeze protection: a side run reports what it is doing; in the worker
+# process (see WorkerDriver) this feeds the watchdog and the heartbeat lines
+_PROGRESS = None
+
+
+def progress(message):
+    if _PROGRESS is not None:
+        _PROGRESS(message)
+
+
+# ----------------------------------------------------------------------------
+# scenarios: loading and linting
+# ----------------------------------------------------------------------------
+
+def read_json(path, problems):
+    """JSON with the errors a hand-edited file needs: the line and column of a
+    syntax error, and duplicate keys (json would silently keep the last one)."""
+    label = os.path.relpath(path)
+
+    def no_duplicates(pairs):
+        seen, name = {}, dict(pairs).get('name')
+        for key, value in pairs:
+            if key in seen:
+                problems.append('%s: duplicate key "%s"%s' % (label, key, ' in "%s"' % name if isinstance(name, str) else ''))
+            seen[key] = value
+        return seen
+    try:
+        with open(path, encoding='utf-8') as f:
+            return json.load(f, object_pairs_hook=no_duplicates)
+    except FileNotFoundError:
+        problems.append('%s: not found' % label)
+    except ValueError as error:
+        problems.append('%s: invalid JSON: %s' % (label, error))
+    return None
+
+
+def strip_comments(value):
+    """`comment` (a string or a list of strings) is allowed on any object and ignored."""
+    if isinstance(value, dict):
+        return {k: strip_comments(v) for k, v in value.items() if k != 'comment'}
+    if isinstance(value, list):
+        return [strip_comments(v) for v in value]
+    return value
+
+
+def load_scenarios(path=SCENARIOS_PATH, config_path=CONFIG_PATH):
+    problems = []
+    config = read_json(config_path, problems)
+    listing = read_json(path, problems)
+    if config is None or listing is None:
+        return [], [], problems
+    if not isinstance(config, dict):
+        return [], [], problems + ['%s: must be an object {"defaults": {...}, "fixtures": [...]}' % os.path.relpath(config_path)]
+    for key in config:
+        if key not in ('comment', 'defaults', 'fixtures'):
+            problems.append('%s: unknown key "%s"' % (os.path.relpath(config_path), key))
+    if not isinstance(listing, list):
+        return [], [], problems + ['%s: must be a list of scenario objects' % os.path.relpath(path)]
+    for index, entry in enumerate(listing):
+        if not isinstance(entry, dict):
+            problems.append('%s: entry %d is not an object' % (os.path.relpath(path), index + 1))
+    data = {'defaults': strip_comments(config.get('defaults', {})),
+            'fixture': strip_comments(config.get('fixtures', [])),
+            'scenario': strip_comments([e for e in listing if isinstance(e, dict)])}
+    defaults = dict(DEFAULTS)
+    for key, value in data.get('defaults', {}).items():
+        if key not in DEFAULTS:
+            problems.append('defaults: unknown key "%s"' % key)
+        defaults[key] = value
+    for probe in defaults['probe']:
+        problems += lint_probe('defaults', probe)
+
+    fixtures = []
+    for fixture in data.get('fixture', []):
+        where = 'fixture "%s"' % fixture.get('name')
+        for key in fixture:
+            if key not in ('name', 'route', 'probe', 'pattern', 'steps'):
+                problems.append('%s: unknown key "%s"' % (where, key))
+        if not fixture.get('name') or not fixture.get('route'):
+            problems.append('%s: needs name and route' % where)
+        if not (fixture.get('probe') or fixture.get('pattern')):
+            problems.append('%s: needs probe or pattern' % where)
+        if fixture.get('probe'):
+            problems += lint_probe(where, fixture['probe'])
+        fixtures.append(fixture)
+
+    scenarios, seen = [], set()
+    for raw in data.get('scenario', []):
+        name = raw.get('name')
+        where = 'scenario "%s"' % name
+        if not name or not re.match(r'^[A-Za-z0-9_\-]+$', name):
+            problems.append('%s: needs a [A-Za-z0-9_-] name' % where)
+        if name in seen:
+            problems.append('%s: duplicate name' % where)
+        seen.add(name)
+        if not str(raw.get('route', '')).startswith('#'):
+            problems.append('%s: route must start with "#"' % where)
+        for key in raw:
+            if key not in SCENARIO_KEYS:
+                problems.append('%s: unknown key "%s"' % (where, key))
+        for i, step in enumerate(raw.get('steps', [])):
+            problems += lint_step('%s step %d' % (where, i + 1), step)
+        for probe in raw.get('probe', []):
+            problems += lint_probe(where, probe)
+        for layer in raw.get('ignore', []):
+            if layer.split(':')[0] not in LAYERS + ['probe']:
+                problems.append('%s: cannot ignore unknown layer "%s"' % (where, layer))
+        for mock in raw.get('mock', []):
+            if not str(mock.get('path', '')).startswith('/'):
+                problems.append('%s: mock needs a path starting with "/"' % where)
+            for key in mock:
+                if key not in MOCK_KEYS:
+                    problems.append('%s: unknown mock key "%s"' % (where, key))
+        tables = {}
+        for table in ('expect', 'expect_new'):
+            tables[table] = raw.get(table, {})
+            if not isinstance(tables[table], dict):
+                problems.append('%s: %s must be a table of "<probe>" = value' % (where, table))
+                tables[table] = {}
+            for probe, wanted in tables[table].items():
+                problems += lint_probe(where + ' ' + table, probe)
+                if isinstance(wanted, dict):
+                    if len(wanted) != 1 or list(wanted)[0] not in EXPECT_OPERATORS:
+                        problems.append('%s: %s "%s" needs exactly one operator of %s'
+                                        % (where, table, probe, ', '.join(EXPECT_OPERATORS)))
+                    elif list(wanted)[0] == 'matches':
+                        try:
+                            re.compile(wanted['matches'])
+                        except re.error as error:
+                            problems.append('%s: %s "%s": bad regex (%s)' % (where, table, probe, error))
+        if tables['expect_new'] and not (raw.get('xfail') or raw.get('approved')):
+            problems.append('%s: expect_new pins an approved change: it needs "xfail" or "approved": "<reason>"' % where)
+        if 'approved' in raw:
+            # an approved change confined to the expect_new probes: they are
+            # pinned on NEW instead of compared, every other layer still is
+            if not isinstance(raw['approved'], str) or not raw['approved'].strip():
+                problems.append('%s: approved needs a reason string' % where)
+            if not tables['expect_new']:
+                problems.append('%s: approved needs expect_new pinning the changed probes' % where)
+            if raw.get('xfail'):
+                problems.append('%s: approved and xfail exclude each other (xfail already tolerates every layer)' % where)
+        expect, expect_new = tables['expect'], tables['expect_new']
+        if not isinstance(raw.get('storage', {}), dict):
+            problems.append('%s: storage must be a table of key = "value"' % where)
+        if raw.get('pixels', 'strict') not in ('strict', 'loose', 'off'):
+            problems.append('%s: pixels must be strict, loose or off' % where)
+        if raw.get('api', 'ordered') not in ('ordered', 'unordered', 'off'):
+            problems.append('%s: api must be ordered, unordered or off' % where)
+
+        scenario = dict(defaults)
+        scenario.update(raw)
+        scenario['probe'] = list(defaults['probe']) + [p for p in raw.get('probe', []) if p not in defaults['probe']]
+        # NB expected probes are evaluated (and compared old vs new) like any other
+        scenario['probe'] += [p for p in list(expect) + list(expect_new) if p not in scenario['probe']]
+        scenario['expect'] = expect
+        scenario['expect_new'] = expect_new
+        scenario['ignore'] = list(defaults['ignore']) + list(raw.get('ignore', []))
+        scenario.setdefault('steps', [])
+        scenario.setdefault('tags', [])
+        scenario.setdefault('mock', [])
+        scenario.setdefault('storage', {})
+        if raw.get('tooltips') is False:
+            scenario['storage'] = dict(QUIET_TOOLTIPS, **scenario['storage'])
+        scenarios.append(scenario)
+    return scenarios, fixtures, problems
+
+
+def lint_step(where, step):
+    kinds = [k for k in step if k in STEP_KINDS]
+    if len(kinds) != 1:
+        return ['%s: exactly one action expected among %s, got %s' % (where, '/'.join(STEP_KINDS), sorted(step))]
+    unknown = [k for k in step if k not in STEP_KINDS and k not in STEP_OPTIONS]
+    problems = ['%s: unknown option "%s"' % (where, k) for k in unknown]
+    kind = kinds[0]
+    if kind == 'type' and 'text' not in step:
+        problems.append('%s: type needs text' % where)
+    if kind == 'fill' and 'text' not in step:
+        problems.append('%s: fill needs text' % where)
+    if kind in ('wait', 'scroll_y') and not isinstance(step[kind], int):
+        problems.append('%s: %s needs an integer' % (where, kind))
+    return problems
+
+
+def lint_probe(where, probe):
+    if not isinstance(probe, str):
+        return ['%s: probe must be a string, got %r' % (where, probe)]
+    kind, _, rest = probe.partition(':')
+    if kind not in PROBE_KINDS:
+        return ['%s: unknown probe kind "%s" in "%s" (known: %s)' % (where, kind, probe, ', '.join(sorted(PROBE_KINDS)))]
+    needs_selector, needs_arg = PROBE_KINDS[kind]
+    if needs_selector and not rest:
+        return ['%s: probe "%s" needs a selector' % (where, probe)]
+    if needs_arg and '@' not in rest:
+        return ['%s: probe "%s" needs @argument' % (where, probe)]
+    return []
+
+
+def select(scenarios, only=None, tags=None):
+    selected = scenarios
+    if only:
+        patterns = [p.strip() for p in only.split(',') if p.strip()]
+        selected = [s for s in selected if any(fnmatch.fnmatch(s['name'], p) for p in patterns)]
+        for pattern in patterns:
+            if not any(fnmatch.fnmatch(s['name'], pattern) for s in scenarios):
+                die('no scenario matches "%s"' % pattern)
+    if tags:
+        wanted = set(t.strip() for t in tags.split(','))
+        selected = [s for s in selected if wanted & set(s['tags'])]
+    return selected
+
+
+def total_virtual_ms(scenario):
+    ms = scenario['boot'] + scenario['settle']
+    for step in scenario['steps']:
+        if 'wait' in step:
+            ms += step['wait']
+        elif 'wait_for' in step or 'wait_gone' in step:
+            ms += step.get('timeout', scenario['wait_for_timeout'])
+        else:
+            ms += step.get('after', scenario['step_after'])
+    return ms
+
+
+def packed_scenario(scenario):
+    """The scenario as the in-page (synthetic) executor of harness.js sees it."""
+    payload = {
+        'steps': scenario['steps'],
+        'probe': scenario['probe'],
+        'storage': scenario.get('storage', {}),
+        'timing': {k: scenario[k] for k in ('boot', 'step_after', 'wait_for_timeout', 'settle')},
+    }
+    raw = json.dumps(payload, separators=(',', ':')).encode('utf-8')
+    return base64.urlsafe_b64encode(raw).decode('ascii')
+
+
+# ----------------------------------------------------------------------------
+# shared setup
+# ----------------------------------------------------------------------------
+
+def build_new_bundle():
+    print('building the new bundle...')
+    try:
+        subprocess.check_call([sys.executable, os.path.join(ROOT, 'deploy', 'build_js.py')],
+                              stdout=subprocess.DEVNULL, timeout=300)
+    except subprocess.TimeoutExpired:
+        die('deploy/build_js.py did not finish within 300 s')
+
+
+def ensure_reference_css(url=OLD_CSS_URL, expected_sha1=OLD_CSS_SHA1):
+    """parity/reference/ermac_old.css: the deployed stylesheet, its relative
+    image URLs pointed at the shared webassets/ (the images are not under test)."""
+    os.makedirs(os.path.join(HERE, 'reference'), exist_ok=True)
+    original = os.path.join(HERE, 'reference', 'ermac_old.orig.css')
+    if not os.path.exists(original):
+        print('fetching the OLD reference stylesheet from', url, '...')
+        with urllib.request.urlopen(url, timeout=60) as response:
+            data = response.read()
+        with open(original, 'wb') as f:
+            f.write(data)
+    with open(original, 'rb') as f:
+        data = f.read()
+    sha1 = hashlib.sha1(data).hexdigest()
+    if expected_sha1 and sha1 != expected_sha1:
+        die('parity/reference/ermac_old.orig.css has sha1 %s, expected %s (the pinned '
+            'specification); delete it to re-fetch, or pass --reference-css-sha1 to move '
+            'the specification deliberately' % (sha1, expected_sha1))
+    css = re.sub(rb'url\((?![\'"]?(?:data:|https?:|/))([\'"]?)', rb'url(\1../webassets/', data)
+    with open(os.path.join(HERE, 'reference', 'ermac_old.css'), 'wb') as f:
+        f.write(css)
+    print('reference stylesheet: %d bytes, sha1 %s (pinned)' % (len(data), sha1[:12]))
+
+
+def ensure_reference(url=OLD_URL, expected_sha1=OLD_SHA1):
+    os.makedirs(os.path.join(HERE, 'reference'), exist_ok=True)
+    reference = os.path.join(HERE, 'reference', 'ermac_old.min.js')
+    if not os.path.exists(reference):
+        print('fetching the OLD reference bundle from', url, '...')
+        with urllib.request.urlopen(url, timeout=60) as response:
+            data = response.read()
+        if expected_sha1 and hashlib.sha1(data).hexdigest() != expected_sha1:
+            die('the downloaded reference has sha1 %s, expected %s: refusing to use it'
+                % (hashlib.sha1(data).hexdigest(), expected_sha1))
+        with open(reference, 'wb') as f:
+            f.write(data)
+    with open(reference, 'rb') as f:
+        sha1 = hashlib.sha1(f.read()).hexdigest()
+    if expected_sha1 and sha1 != expected_sha1:
+        die('parity/reference/ermac_old.min.js has sha1 %s, expected %s (the pinned '
+            'specification); delete it to re-fetch, or pass --reference-sha1 to move '
+            'the specification deliberately' % (sha1, expected_sha1))
+    print('reference bundle: %d bytes, sha1 %s (pinned)' % (os.path.getsize(reference), sha1[:12]))
+
+
+def load_proxy_module():
+    """deploy/dev_api_proxy.py: its response cache format is shared by both drivers."""
+    spec = importlib.util.spec_from_file_location('dev_api_proxy', os.path.join(ROOT, 'deploy', 'dev_api_proxy.py'))
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def normalize_request(method, path, body=None, content_type=None):
+    """A comparable one-line description of an API request."""
+    path, _, query = path.partition('?')
+    pairs = sorted(query.split('&')) if query else []
+    line = method + ' ' + path + '?' + '&'.join(pairs)
+    if method == 'POST':
+        body = body or b''
+        text = body.decode('utf-8', 'replace')
+        if (content_type or '').startswith('application/x-www-form-urlencoded'):
+            text = '&'.join(sorted(text.split('&'))) if text else ''
+        line += ' [%s] %s' % ((content_type or '-').split(';')[0], text[:400])
+    return line
+
+
+# ----------------------------------------------------------------------------
+# driver: playwright
+# ----------------------------------------------------------------------------
+
+class PlaywrightDriver(object):
+    """Native input, request interception, fake clock: no sockets needed."""
+
+    name = 'playwright'
+
+    def __init__(self, browser_path=None, browser_args=(), synthetic=False, live=False, defer_close=False):
+        from playwright.sync_api import sync_playwright
+        self.synthetic = synthetic
+        self.live = live
+        # NB in the worker, the browser is closed AFTER the result is sent: a
+        # browser that does not close then costs a worker, not the result
+        self.defer_close = defer_close
+        self._pending_close = []
+        self.proxy = load_proxy_module()
+        self._pw = sync_playwright().start()
+        self.launch = {'headless': True, 'args': list(browser_args)}
+        if browser_path:
+            self.launch['executable_path'] = browser_path
+
+    def close_pending(self):
+        while self._pending_close:
+            try:
+                self._pending_close.pop().close()
+            except Exception:
+                pass
+
+    def close(self):
+        self.close_pending()
+        self._pw.stop()
+
+    # -- network ------------------------------------------------------------
+
+    def _static(self, route, request):
+        path = urllib.parse.unquote(urllib.parse.urlsplit(request.url).path)
+        candidates = [os.path.join(ROOT, path.lstrip('/'))]
+        if path.startswith('/parity/'):
+            # NB app_folder is /parity on the harness pages: shared assets resolve to the root
+            candidates.append(os.path.join(ROOT, path[len('/parity/'):]))
+        for candidate in candidates:
+            candidate = os.path.normpath(candidate)
+            if candidate.startswith(ROOT) and os.path.isfile(candidate):
+                with open(candidate, 'rb') as f:
+                    body = f.read()
+                ctype = mimetypes.guess_type(candidate)[0] or 'application/octet-stream'
+                return route.fulfill(status=200, body=body, headers={'Content-Type': ctype})
+        route.fulfill(status=404, body=b'not found', headers={'Content-Type': 'text/plain'})
+
+    def _api(self, route, request, run):
+        url = request.url
+        path = url[len(API_ORIGIN):] or '/'
+        method = request.method
+        origin = request.headers.get('origin', GUI_ORIGIN)
+        cors = {'Access-Control-Allow-Origin': origin, 'Access-Control-Allow-Credentials': 'true'}
+        if method == 'OPTIONS':
+            cors.update({'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                         'Access-Control-Allow-Headers': 'Content-Type'})
+            return route.fulfill(status=200, body=b'', headers=cors)
+        body = request.post_data_buffer if method == 'POST' else None
+        content_type = request.headers.get('content-type')
+        line = normalize_request(method, path, body, content_type)
+        # NB fire-and-forget anonymous IP login: kept out of the comparison,
+        # exactly as in the proxy-based driver
+        if not path.startswith('/users/ip'):
+            run['api'].append(line)
+
+        for mock in run['mock']:
+            if path.split('?')[0].startswith(mock['path']) and mock.get('method', method) == method:
+                if mock.get('abort'):
+                    return route.abort('connectionrefused')
+                payload = json.dumps(mock['json']) if 'json' in mock else mock.get('body', '')
+                headers = dict(cors)
+                headers['Content-Type'] = 'application/json'
+                return route.fulfill(status=mock.get('status', 200), body=payload, headers=headers)
+
+        self.proxy.CACHE_DIR = run['cache']
+        # NB the cache keys of deploy/dev_api_proxy.py: both drivers share one cache
+        key = self.proxy.cache_key_path(method, path, body)
+        cached = None if self.live else self.proxy.cache_lookup(method, key)
+        if cached is None:
+            headers = {k: v for k, v in (('Content-Type', content_type),
+                                          ('Accept-Language', request.headers.get('accept-language')))
+                       if v}
+            progress('API %s %s' % (method, path[:120]))
+            # NB redirects are NOT followed, exactly as in deploy/dev_api_proxy.py
+            status, response_headers, payload = self.proxy.fetch_remote(method, path, body, headers)
+            # NB a transport failure (502, no headers) carries a JSON error payload
+            ctype = (response_headers or {}).get('Content-Type', '') or ('application/json' if status == 502 else '')
+            location = (response_headers or {}).get('Location', '')
+            # NB transient failures must not become permanent in the replay cache
+            if self.proxy.cacheable(status):
+                self.proxy.cache_store(method, key, status, ctype, payload, location)
+            cached = (status, ctype, payload, location)
+        status, ctype, payload, location = cached
+        headers = dict(cors)
+        if ctype:
+            headers['Content-Type'] = ctype
+        if location:
+            headers['Location'] = self.proxy.local_location(location, path, API_ORIGIN)
+        route.fulfill(status=status, body=payload, headers=headers)
+
+    def _external(self, route, request, run):
+        # NB external assets (thumbnails, ptable SVGs, ...) fail identically on both sides.
+        # Images are not logged: <img loading="lazy"> fetches depend on the browser
+        # build's lazy-load distance, not on the app; their URLs are compared via the DOM
+        if request.resource_type != 'image':
+            run['ext'].append(request.method + ' ' + request.url)
+        route.abort('connectionrefused')
+
+    # -- virtual time -------------------------------------------------------
+
+    def _idle(self, page, run, limit=30.0):
+        """Wait for the pending requests, at most `limit` s per call and
+        IDLE_BUDGET s per side in total: a request that never completes must
+        not cost `limit` seconds again at every virtual-time chunk."""
+        if not run['inflight']:
+            return
+        started = time.time()
+        deadline = started + min(limit, run['idle_left'])
+        reported = started
+        while run['inflight'] and time.time() < deadline:
+            page.wait_for_timeout(10)
+            if time.time() - reported > 2:
+                reported = time.time()
+                pending = sorted(q.url for q in list(run['inflight']))
+                progress('waiting %.0f s for %d request(s): %s' % (reported - started, len(pending),
+                                                                  pending[0][:120] if pending else '?'))
+        run['idle_left'] -= time.time() - started
+        if run['inflight']:
+            run['notes'].append('network not idle after %.0fs (%d in flight: %s)%s' % (
+                time.time() - started, len(run['inflight']),
+                ', '.join(sorted(q.url for q in list(run['inflight'])))[:200],
+                '; idle budget exhausted' if run['idle_left'] <= 0 else ''))
+            run['inflight'].clear()
+
+    def _vrun(self, page, run, ms, chunk=50):
+        """Advance the fake clock by ms, pausing it while network fetches are pending
+        (the same policy as Chrome's --virtual-time-budget)."""
+        elapsed = 0
+        while elapsed < ms:
+            self._idle(page, run)
+            step = min(chunk, ms - elapsed)
+            page.clock.run_for(step)
+            page.wait_for_timeout(2)
+            elapsed += step
+
+    # -- steps --------------------------------------------------------------
+
+    def _native_step(self, page, run, scenario, step):
+        kind = [k for k in step if k in STEP_KINDS][0]
+        target = step[kind]
+        nth = step.get('nth', 0)
+        timeout = 5000
+
+        def locate(selector):
+            if page.locator(selector).count() <= nth:
+                return None
+            return page.locator(selector).nth(nth)
+
+        if kind == 'wait':
+            self._vrun(page, run, step['wait'])
+            return 'ok'
+        if kind in ('wait_for', 'wait_gone'):
+            limit, waited = step.get('timeout', scenario['wait_for_timeout']), 0
+            while True:
+                present = page.locator(target).count() > 0
+                if present == (kind == 'wait_for'):
+                    self._vrun(page, run, 50)
+                    return 'ok'
+                if waited > limit:
+                    return 'timeout'
+                self._vrun(page, run, 100)
+                waited += 100
+
+        if kind == 'hash':
+            page.evaluate('h => { location.hash = h; }', target)
+        elif kind == 'back':
+            page.evaluate('() => history.back()')
+        elif kind == 'scroll_y':
+            page.evaluate('y => window.scrollTo(0, y)', target)
+        elif kind == 'eval':
+            page.evaluate('js => (0, eval)(js)', target)
+        elif kind == 'key':
+            # NB the key is held KEY_HOLD_MS like a person does: what keydown
+            # triggers (e.g. a hashchange route) runs before keyup, instead of
+            # racing it (back-to-back CDP keydown/keyup)
+            if step.get('on'):
+                el = page.locator(step['on'])
+                if el.count() <= nth:
+                    return 'missing'
+                el.nth(nth).press(target, timeout=timeout, delay=KEY_HOLD_MS)
+            else:
+                page.keyboard.press(target, delay=KEY_HOLD_MS)
+        elif kind == 'blur' and target is True:
+            page.evaluate('() => document.activeElement && document.activeElement.blur()')
+        else:
+            el = locate(target)
+            if el is None:
+                return 'missing'
+            if kind == 'click':
+                el.click(timeout=timeout)
+            elif kind == 'dblclick':
+                el.dblclick(timeout=timeout)
+            elif kind == 'mousedown':
+                el.dispatch_event('mousedown')
+            elif kind == 'hover':
+                el.hover(timeout=timeout)
+            elif kind == 'focus':
+                el.focus(timeout=timeout)
+            elif kind == 'blur':
+                el.blur(timeout=timeout)
+            elif kind == 'type':
+                if step.get('clear'):
+                    el.fill('', timeout=timeout)
+                el.focus(timeout=timeout)
+                el.press_sequentially(str(step['text']), timeout=timeout)
+            elif kind == 'fill':
+                el.fill(str(step['text']), timeout=timeout)
+            elif kind == 'check':
+                el.check(timeout=timeout)
+            elif kind == 'uncheck':
+                el.uncheck(timeout=timeout)
+            elif kind == 'scroll':
+                el.scroll_into_view_if_needed(timeout=timeout)
+        self._vrun(page, run, step.get('after', scenario['step_after']))
+        return 'ok'
+
+    # -- a side run ---------------------------------------------------------
+
+    def run(self, side, scenario, route_str, side_dir, cache_dir, budget=None):
+        import datetime
+        run = {'api': [], 'ext': [], 'inflight': set(), 'notes': [], 'cache': cache_dir,
+               'mock': scenario.get('mock', []), 'idle_left': IDLE_BUDGET}
+        progress('launching the browser')
+        width, height = scenario['viewport']
+        # NB a fresh browser per side run: a clean profile (no localStorage
+        # carry-over), and single-process builds cannot close contexts
+        try:
+            browser = self._pw.chromium.launch(**self.launch)
+        except Exception as error:
+            if "Executable doesn't exist" in str(error) or 'playwright install' in str(error):
+                die("playwright is installed but its Chromium is not: run\n"
+                    "  %s -m playwright install chromium\n"
+                    "(or point PARITY_BROWSER / --browser at a Chromium executable)\n%s"
+                    % (sys.executable, str(error).strip().split('\n')[0]))
+            raise
+        context = browser.new_context(
+            viewport={'width': width, 'height': height}, device_scale_factor=1,
+            locale='en-US', timezone_id='UTC')
+        try:
+            context.route('**/*', lambda r, q: self._external(r, q, run))
+            context.route(API_ORIGIN + '/**', lambda r, q: self._api(r, q, run))
+            context.route(GUI_ORIGIN + '/**', self._static)
+            context.on('request', lambda q: run['inflight'].add(q))
+            context.on('requestfinished', lambda q: run['inflight'].discard(q))
+            context.on('requestfailed', lambda q: run['inflight'].discard(q))
+            if scenario.get('storage'):
+                # NB init scripts run in EVERY document of the page; frames with an
+                # opaque origin have no localStorage (and would throw a pageerror)
+                context.add_init_script(
+                    'if (location.origin === %s) { var s = %s; '
+                    'for (var k in s) window.localStorage.setItem(k, s[k]); }'
+                    % (json.dumps(GUI_ORIGIN), json.dumps(scenario['storage'])))
+            page = context.new_page()
+            # NB no Playwright call may wait forever (evaluate() itself has no
+            # timeout: a renderer stuck in JS is the watchdog's job)
+            page.set_default_timeout(30000)
+            page.set_default_navigation_timeout(120000)
+            page_errors = []
+            page.on('pageerror', lambda e: page_errors.append(str(e)))
+
+            # NB fake clock with a fixed epoch: timers only fire when the
+            # driver advances virtual time, identically on both sides.
+            # NB pause_at must stay AHEAD of the running fake clock: after
+            # install(time=t0) the clock ticks in real time, and the RPC
+            # roundtrip already puts it past t0 + 1ms ("fast-forward to the
+            # past" crash), hence a comfortable 1s margin below
+            t0 = datetime.datetime(2026, 1, 15, 12, 0, 0, tzinfo=datetime.timezone.utc)
+            page.clock.install(time=t0)
+            page.clock.pause_at(t0 + datetime.timedelta(seconds=1))
+
+            query = ('?p=' + packed_scenario(scenario)) if self.synthetic else ''
+            url = '%s/parity/%s.html%s%s' % (GUI_ORIGIN, side, query, route_str)
+            progress('loading %s' % (route_str or '/'))
+            page.goto(url, wait_until='load', timeout=120000)
+
+            try:
+                kinds = page.evaluate('() => window.__parity && window.__parity.kinds')
+            except Exception:
+                kinds = None  # NB the app navigated away during boot
+            if kinds is not None and set(kinds) != set(PROBE_KINDS):
+                die('harness.js and run_parity.py disagree on probe kinds: %s' % sorted(set(kinds) ^ set(PROBE_KINDS)))
+
+            if self.synthetic:
+                self._vrun(page, run, budget or total_virtual_ms(scenario) + 2000)
+                raw = page.evaluate("() => { var n = document.getElementById('__parity_result'); return n ? n.textContent : null; }")
+                result = json.loads(raw) if raw else {'steps': ['harness did not finish'], 'errors': [], 'probes': {}}
+            else:
+                progress('boot (%d virtual ms)' % scenario['boot'])
+                self._vrun(page, run, scenario['boot'])
+                steps_log = []
+                for index, step in enumerate(scenario['steps']):
+                    if steps_log and steps_log[-1] != 'ok':
+                        steps_log.append('skipped')
+                        continue
+                    progress('step %d/%d: %s' % (index + 1, len(scenario['steps']), step_label(scenario, index)))
+                    try:
+                        outcome = self._native_step(page, run, scenario, step)
+                    except Exception as error:
+                        outcome = 'error: ' + str(error).split('\n')[0][:120]
+                    steps_log.append(outcome)
+                progress('settle (%d virtual ms)' % scenario['settle'])
+                self._vrun(page, run, scenario['settle'])
+                progress('capturing the probes')
+                try:
+                    result = page.evaluate(
+                        '(probes) => ({probes: window.__parity.probe(probes), errors: window.__parity.errors.slice()})',
+                        scenario['probe'])
+                except Exception:
+                    # NB the app left the harness page (e.g. a redirect to mpds.io)
+                    result = {'probes': {p: 'UNAVAILABLE: page left' for p in scenario['probe']}, 'errors': []}
+                result['steps'] = steps_log
+            result.setdefault('probes', {})['(url)'] = re.sub(r'\b(old|new)\.html\b', 'app.html', page.url)
+
+            # NB uncaught errors are seen by both the harness and Playwright: de-duplicate
+            for error in page_errors:
+                if not any(error.split('\n')[0] in e for e in result['errors']):
+                    result['errors'].append('pageerror: ' + error.split('\n')[0])
+            progress('capturing the DOM and the screenshot')
+            dom = page.content()
+            shot = os.path.join(side_dir, side + '.png')
+            page.screenshot(path=shot, timeout=60000, animations='allow', caret='hide')
+            return {'dom': dom, 'shot': shot, 'api': run['api'], 'ext': sorted(run['ext']),
+                    'result': result, 'notes': run['notes']}
+        finally:
+            if self.defer_close:
+                self._pending_close.append(browser)
+            else:
+                try:
+                    browser.close()
+                except Exception:
+                    pass
+
+
+# ----------------------------------------------------------------------------
+# driver: chrome-cli (the original approach: real servers + proxy)
+# ----------------------------------------------------------------------------
+
+class ChromeCliDriver(object):
+    """google-chrome --dump-dom with --virtual-time-budget; synthetic in-page steps."""
+
+    name = 'chrome-cli'
+    synthetic = True
+
+    def __init__(self, browser_path=None, browser_args=()):
+        self.chrome = browser_path or find_chrome()
+        self.browser_args = list(browser_args)
+        for label, port in (('static server', GUI_PORT), ('API proxy', API_PORT)):
+            if not port_free(port):
+                die('port %d is busy (%s): stop the leftover process first' % (port, label))
+        stale = subprocess.run(['ps', '-eo', 'pid,args'], capture_output=True, text=True).stdout
+        stale_chrome = [l for l in stale.splitlines() if 'headless' in l and 'parity/out/profile' in l]
+        if stale_chrome:
+            die('stale headless chrome processes hold the parity profiles: ' + '; '.join(stale_chrome)[:300])
+        # NB shared assets under parity/ (app_folder is /parity for the harness pages)
+        for name in ('webassets', 'labs', 'oauth', 'crystvis', 'ermac.min.js'):
+            link, target = os.path.join(HERE, name), os.path.join(ROOT, name)
+            if os.path.islink(link) and os.readlink(link) != target:
+                os.remove(link)
+            if not os.path.exists(link):
+                os.symlink(target, link)
+        self.server = subprocess.Popen([sys.executable, '-m', 'http.server', str(GUI_PORT)],
+                                       cwd=ROOT, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        wait_for_port(GUI_PORT, 5)
+
+    def close(self):
+        self.server.terminate()
+        self.server.wait()
+
+    def run(self, side, scenario, route_str, side_dir, cache_dir, budget=None):
+        if scenario.get('mock'):
+            raise NotSupported('API mocks need the playwright driver')
+        log_path = os.path.join(side_dir, side + '-api.log')
+        log = open(log_path, 'w')
+        proxy = subprocess.Popen([sys.executable, '-u', os.path.join(ROOT, 'deploy', 'dev_api_proxy.py'),
+                                  '--cache', cache_dir], stdout=log, stderr=subprocess.STDOUT)
+        try:
+            wait_for_port(API_PORT, 5)
+            url = '%s/parity/%s.html?p=%s%s' % (GUI_ORIGIN, side, packed_scenario(scenario), route_str)
+            dom_path = os.path.join(side_dir, side + '-dom.html')
+            shot = os.path.join(side_dir, side + '.png')
+            self._chrome(url, dom_path, shot, os.path.join(OUT, 'profile-' + side),
+                         budget or total_virtual_ms(scenario) + 5000, scenario['viewport'])
+        finally:
+            time.sleep(0.3)
+            proxy.terminate()
+            proxy.wait()
+            log.close()
+        with open(dom_path, encoding='utf-8', errors='replace') as f:
+            dom = f.read()
+        match = re.search(r'<script type="application/json" id="__parity_result">(.*?)</script>', dom, re.S)
+        result = json.loads(match.group(1)) if match else {'steps': ['harness did not finish'], 'errors': [], 'probes': {}}
+        return {'dom': dom, 'shot': shot, 'api': parse_proxy_log(log_path), 'ext': [],
+                'result': result, 'notes': []}
+
+    def _chrome(self, url, dom_path, shot_path, user_data_dir, budget, viewport, attempts=3):
+        cmd = [self.chrome, '--headless=new', '--disable-gpu', '--no-sandbox', '--hide-scrollbars',
+               '--window-size=%d,%d' % tuple(viewport), '--force-device-scale-factor=1',
+               '--default-background-color=FFFFFFFF',
+               '--host-resolver-rules=MAP mpds.io 127.0.0.1, MAP *.mpds.io 127.0.0.1',
+               '--disk-cache-size=1', '--media-cache-size=1', '--user-data-dir=' + user_data_dir,
+               '--virtual-time-budget=%d' % budget, '--screenshot=' + shot_path, '--dump-dom'
+               ] + self.browser_args + [url]
+        last_error = None
+        for attempt in range(attempts):
+            for _ in range(4):
+                if not os.path.exists(user_data_dir):
+                    break
+                shutil.rmtree(user_data_dir, ignore_errors=True)
+                time.sleep(0.5)
+            try:
+                result = subprocess.run(cmd, capture_output=True, timeout=300)
+                with open(dom_path, 'wb') as f:
+                    f.write(result.stdout)
+                if os.path.exists(shot_path) and len(result.stdout) > 10000:
+                    return
+                last_error = IOError('incomplete capture (dom %d bytes)' % len(result.stdout))
+            except subprocess.TimeoutExpired as error:
+                last_error = error
+            print('    (chrome attempt %d failed (%s), retrying)' % (attempt + 1, last_error))
+        die('chrome failed for %s: %s' % (url, last_error))
+
+
+class NotSupported(Exception):
+    pass
+
+
+def parse_proxy_log(log_path):
+    requests = []
+    with open(log_path) as f:
+        for line in f:
+            if not line.startswith('proxy: '):
+                continue
+            match = re.search(r'"(GET|POST|HEAD) (\S+)', line)
+            if not match:
+                continue
+            method, target = match.group(1), re.sub(r' HTTP/\d\.\d$', '', match.group(2))
+            if target.startswith('/users/ip'):
+                continue
+            requests.append(normalize_request(method, target))
+    return requests
+
+
+def port_free(port):
+    import socket
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            s.bind(('127.0.0.1', port))
+            return True
+        except OSError:
+            return False
+
+
+def wait_for_port(port, timeout):
+    import socket
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.settimeout(0.2)
+            try:
+                s.connect(('127.0.0.1', port))
+                return
+            except OSError:
+                time.sleep(0.05)
+    die('port %d did not open in time' % port)
+
+
+# ----------------------------------------------------------------------------
+# comparison layers
+# ----------------------------------------------------------------------------
+
+def region(html, open_pattern, close_pattern='</ul>'):
+    match = re.search(open_pattern + r'(.*?)' + close_pattern, html, re.S)
+    return collapse(match.group(1)) if match else None
+
+
+def collapse(text):
+    return re.sub(r'\s+', ' ', text).strip()
+
+
+def short_md5(text):
+    return None if text is None else hashlib.md5(text.encode('utf-8')).hexdigest()[:12]
+
+
+def outer_of(html, element_id):
+    match = re.search(r'<[^>]*id="%s"[^>]*>.*?(?=<div id="footer"|</body>)' % element_id, html, re.S)
+    return collapse(match.group(0))[:600] if match else None
+
+
+def extract_semantics(html):
+    """The legacy semantic DOM keys of the original parity suite (unchanged)."""
+    html = re.sub(r'<script type="application/json" id="__parity_result">.*?</script>', '', html, flags=re.S)
+    html = html.replace('old.html', 'app.html').replace('new.html', 'app.html')
+    keys = {}
+
+    def set_key(name, value):
+        if value is not None:
+            keys[name] = value
+
+    match = re.search(r'<title>(.*?)</title>', html, re.S)
+    set_key('title', match.group(1) if match else '')
+    match = re.search(r'<body class="([^"]*)"', html)
+    set_key('body_class', match.group(1) if match else '')
+    set_key('notifybox', region(html, r'<div id="notifybox"[^>]*>', r'</div>'))
+    match = re.search(r'<div id="notifybox" style="([^"]*)"', html)
+    set_key('notifybox_display', match.group(1) if match else '')
+    set_key('interpret', region(html, r'<ul id="interpret">'))
+    match = re.search(r'<table id="databrowser" class="([^"]*)"', html)
+    set_key('databrowser_class', match.group(1) if match else '')
+    set_key('databrowser_ids', ' '.join(re.findall(r'id="(e__[^"]*)"', html)))
+    set_key('databrowser_md5', short_md5(region(html, r'<table id="databrowser"[^>]*>', '</table>')))
+    set_key('multiselect_items', ' | '.join(
+        a + ':' + b for a, b in re.findall(r'data-facet="([^"]*)" data-term="([^"]*)"', html)))
+    match = re.search(r'id="search_field-selectized"[^>]*value="([^"]*)"', html)
+    set_key('search_input_rest', match.group(1) if match else '')
+    set_key('refine_links', ' '.join(collapse(a) for a in re.findall(
+        r'<li class="(?:new_rfn_facet )?fct_\w+"><a href="(#[^"]*)">', html)))
+    examples = re.findall(r'<a href="(#[^"]*)">', region(html, r'<div id="examples" class="examples">') or '')
+    set_key('examples_shape', '%d links, all valid: %s' % (
+        len(examples), all(link.startswith('#search/') for link in examples)))
+    set_key('history_links', ' '.join(re.findall(r'<a href="(#[^"]*)">', region(html, r'<div id="history">') or '')))
+    for element in ['entryno', 'ind_title', 'phase_info', 'sim_legend', 'own_phase', 'ind_link']:
+        set_key(element, outer_of(html, element))
+    set_key('d_icon_hrefs', ' '.join(re.findall(r'<a rel="\w+" href="([^"]*)" target="_blank"', html)))
+    set_key('iframe_srcs', ' | '.join(re.findall(r'<iframe[^>]* src="([^"]*)"', html)))
+    set_key('active_controls', ' '.join(sorted(
+        m[0] + '=' + (m[1] or '') for m in re.findall(r'<div id="(control_[a-f])"(?: class="([^"]*)")?', html))))
+    for element, pattern in [
+        ('header_entries', r'<div id="header_entries" style="([^"]*)"'),
+        ('header_phases', r'<div id="header_phases" style="([^"]*)"'),
+        ('header_articles', r'<div id="header_articles" style="([^"]*)"'),
+        ('phases_ctx', r'<div id="phases_ctx" style="([^"]*)"'),
+        ('dtypes_phid_box', r'<div id="dtypes_phid" style="([^"]*)"'),
+        ('ind_col', r'<div id="ind_col" class="[^"]*" style="([^"]*)"'),
+        ('ctx_col', r'<div id="ctx_col" class="[^"]*" style="([^"]*)"'),
+        ('sim_col', r'<div id="sim_col" class="[^"]*" style="([^"]*)"'),
+        ('hy_box', r'<div id="hy_box"[^>]*style="([^"]*)"'),
+        ('advsbox', r'<div id="advsbox"[^>]*style="([^"]*)"'),
+        ('loginbox', r'<div id="loginbox"[^>]*style="([^"]*)"'),
+        ('overlay', r'<div id="overlay" style="([^"]*)"'),
+        ('toomuch', r'<div id="toomuch" class="context_msg" style="([^"]*)"'),
+        ('plthint', r'<div id="plthint" class="context_msg" style="([^"]*)"'),
+        ('apihint', r'<div id="apihint" class="context_msg" style="([^"]*)"'),
+        ('loadscroll', r'<div id="loadscroll" class="context_msg" style="([^"]*)"'),
+        ('numericbox', r'<div id="numericbox" style="([^"]*)"'),
+    ]:
+        match = re.search(pattern, html)
+        set_key(element + '_display', match.group(1) if match else 'ABSENT')
+    set_key('numericbox_md5', short_md5(region(html, r'<div id="numericbox">', r'</div>\s*<div id="footer"')))
+    for hierarchy in ['hy_scalars', 'hy_complex', 'hy_arrays']:
+        set_key(hierarchy + '_md5', short_md5(region(html, r'<div id="%s" class="hy_tabs[^>]*>' % hierarchy)))
+    set_key('polyhedra_md5', short_md5(region(html, r'<div id="all_polyhedra_content">')))
+    set_key('header_th', ' '.join(re.findall(r'<th class="([^"]*)"', html)))
+    return keys
+
+
+def compare_pixels(old_path, new_path, diff_path):
+    if not PIL_AVAILABLE:
+        return None, 'Pillow not available'
+    old_img = Image.open(old_path).convert('RGB')
+    new_img = Image.open(new_path).convert('RGB')
+    if old_img.size != new_img.size:
+        return 1.0, 'size mismatch: %s vs %s' % (old_img.size, new_img.size)
+    diff = ImageChops.difference(old_img, new_img)
+    # NB a pixel differs when ANY channel exceeds the tolerance: threshold
+    # every band, then combine them (a plain .convert('L') of the
+    # thresholded image would count only pixels differing in all channels)
+    red, green, blue = [band.point(lambda p: 255 if p > TOL else 0) for band in diff.split()]
+    mask = ImageChops.lighter(ImageChops.lighter(red, green), blue)
+    fraction = mask.histogram()[255] / float(old_img.size[0] * old_img.size[1])
+    if diff.getbbox():
+        overlay = new_img.copy()
+        overlay.paste(Image.new('RGB', old_img.size, (255, 0, 0)), mask)
+        Image.blend(new_img, overlay, 0.5).save(diff_path)
+    elif os.path.exists(diff_path):
+        os.remove(diff_path)
+    return fraction, None
+
+
+def ignored(scenario, layer, key=None):
+    ignore = scenario['ignore']
+    return layer in ignore or (key is not None and '%s:%s' % (layer, key) in ignore)
+
+
+def attribute_stripper(names):
+    """A function removing the given attributes from markup in any value
+    (strings, lists, dicts); 'aria-*' is a prefix. Covers name="v", name='v'
+    and bare boolean attributes (inert)."""
+    if not names:
+        return lambda value: value
+    alternatives = '|'.join(re.escape(n[:-1]) + r'[\w-]*' if n.endswith('*') else re.escape(n) + r'(?![\w-])'
+                            for n in names)
+    pattern = re.compile(r'\s(?:%s)(?:\s*=\s*(?:"[^"]*"|\'[^\']*\'))?(?=[\s/>])' % alternatives)
+
+    def strip(value):
+        if isinstance(value, str):
+            return pattern.sub('', value) if '<' in value else value
+        if isinstance(value, list):
+            return [strip(v) for v in value]
+        if isinstance(value, dict):
+            return {k: strip(v) for k, v in value.items()}
+        return value
+    return strip
+
+
+def compare(scenario, old, new, pixels_enabled, side_dir):
+    """Returns {layer: [difference descriptions]} and vacuity warnings."""
+    diffs, warnings = {}, []
+    strip = attribute_stripper(scenario.get('ignore_attributes'))
+
+    if scenario['api'] != 'off' and not ignored(scenario, 'api'):
+        a, b = old['api'], new['api']
+        if scenario['api'] == 'unordered':
+            a, b = sorted(a), sorted(b)
+        if a != b:
+            diffs['api'] = multiset_diff(old['api'], new['api']) or ['same requests, different order']
+    if not ignored(scenario, 'ext') and old['ext'] != new['ext']:
+        diffs['ext'] = multiset_diff(old['ext'], new['ext'])
+
+    if scenario['semantics'] and not ignored(scenario, 'dom'):
+        so, sn = extract_semantics(strip(old['dom'])), extract_semantics(strip(new['dom']))
+        keys = [k for k in sorted(set(so) | set(sn)) if so.get(k) != sn.get(k) and not ignored(scenario, 'dom', k)]
+        if keys:
+            diffs['dom'] = ['%s: OLD %r | NEW %r' % (k, clip(so.get(k)), clip(sn.get(k))) for k in keys]
+
+    po, pn = old['result'].get('probes', {}), new['result'].get('probes', {})
+    # NB the expectations below see the raw values (they may assert the attributes)
+    so_probes, sn_probes = strip(po), strip(pn)
+    probe_diffs = []
+    # NB `approved`: the probes pinned by expect_new are not compared
+    approved = set(scenario.get('expect_new', {})) if scenario.get('approved') else set()
+    for probe in scenario['probe'] + ['(url)']:
+        if ignored(scenario, 'probe', probe) or probe in approved:
+            continue
+        if so_probes.get(probe) != sn_probes.get(probe):
+            probe_diffs.append('%s: OLD %s | NEW %s' % (probe, clip(so_probes.get(probe)), clip(sn_probes.get(probe))))
+        elif po.get(probe) is None and probe != '(url)':
+            warnings.append('vacuous probe (null on both sides): ' + probe)
+        elif isinstance(po.get(probe), str) and po[probe].startswith('PROBE ERROR'):
+            warnings.append('%s -> %s' % (probe, po[probe]))
+    if probe_diffs:
+        diffs['probes'] = probe_diffs
+
+    # absolute expectations: BOTH sides must meet them (a failing OLD side
+    # means the data or the specification changed, not the refactoring)
+    if not ignored(scenario, 'expect'):
+        expect_diffs = []
+        for probe, wanted in scenario.get('expect', {}).items():
+            for side, captured in (('OLD', po), ('NEW', pn)):
+                violation = check_expectation(captured.get(probe), wanted)
+                if violation:
+                    expect_diffs.append('%s %s %s' % (side, probe, violation))
+        if expect_diffs:
+            diffs['expect'] = expect_diffs
+    # NEW-only expectations of an approved change (see the verdict: they make
+    # an xfail scenario FAIL, otherwise it would be XFAIL whatever NEW does)
+    if not ignored(scenario, 'expect_new'):
+        new_diffs = []
+        for probe, wanted in scenario.get('expect_new', {}).items():
+            violation = check_expectation(pn.get(probe), wanted)
+            if violation:
+                new_diffs.append('NEW %s %s' % (probe, violation))
+        if new_diffs:
+            diffs['expect_new'] = new_diffs
+
+    so, sn = old['result'].get('steps', []), new['result'].get('steps', [])
+    if not ignored(scenario, 'steps') and so != sn:
+        diffs['steps'] = ['step %d %s: OLD %s | NEW %s' % (i + 1, step_label(scenario, i), a, b)
+                          for i, (a, b) in enumerate(zip(so, sn)) if a != b] or ['OLD %s | NEW %s' % (so, sn)]
+    bad_old = [i for i, outcome in enumerate(so) if outcome != 'ok']
+    # NB an approved change (expect_new) may well target controls the OLD side lacks
+    if bad_old and not scenario.get('expect_new'):
+        warnings.append('the OLD side itself failed step %d %s (%s): the scenario does not exercise what it claims'
+                        % (bad_old[0] + 1, step_label(scenario, bad_old[0]), so[bad_old[0]]))
+
+    eo, en = old['result'].get('errors', []), new['result'].get('errors', [])
+    if not ignored(scenario, 'errors') and len(en) > len(eo):
+        diffs['errors'] = ['NEW side throws %d error(s), OLD side %d' % (len(en), len(eo))] + \
+                          ['NEW: ' + e[:200] for e in en[:5]]
+
+    fraction, note = None, 'skipped'
+    if pixels_enabled and scenario['pixels'] != 'off' and not ignored(scenario, 'pixels'):
+        fraction, note = compare_pixels(old['shot'], new['shot'], os.path.join(side_dir, 'pixel-diff.png'))
+        if fraction is not None and scenario['pixels'] == 'strict' and fraction > scenario['pixel_threshold']:
+            diffs['pixels'] = ['%.4f%% pixels differ (threshold %.3f%%)%s' % (
+                fraction * 100, scenario['pixel_threshold'] * 100, (', ' + note) if note else '')]
+    return diffs, warnings, fraction
+
+
+def check_expectation(value, wanted):
+    """None if value meets wanted, else a description of the violation."""
+    operator, target = ('equals', wanted)
+    if isinstance(wanted, dict):
+        operator, target = list(wanted.items())[0]
+    try:
+        if operator == 'equals':
+            ok = value == target
+        elif operator == 'not':
+            ok = value != target
+        elif operator == 'contains':
+            ok = value is not None and target in value
+        elif operator == 'not_contains':
+            ok = value is None or target not in value
+        elif operator == 'matches':
+            ok = isinstance(value, str) and re.search(target, value) is not None
+        else:
+            ok = isinstance(value, (int, float)) and not isinstance(value, bool) and {
+                'gt': value > target, 'ge': value >= target,
+                'lt': value < target, 'le': value <= target}[operator]
+    except TypeError:
+        ok = False
+    if ok:
+        return None
+    return 'is %s, expected %s %s' % (clip(value), operator, clip(target))
+
+
+def step_label(scenario, index):
+    if index >= len(scenario['steps']):
+        return ''
+    step = scenario['steps'][index]
+    kind = [k for k in step if k in STEP_KINDS][0]
+    return '(%s %s)' % (kind, json.dumps(step[kind]))
+
+
+def multiset_diff(old, new):
+    remaining_new, out = list(new), []
+    for item in old:
+        if item in remaining_new:
+            remaining_new.remove(item)
+        else:
+            out.append('only in OLD: ' + item[:220])
+    out += ['only in NEW: ' + item[:220] for item in remaining_new]
+    return out
+
+
+def clip(value, limit=260):
+    text = json.dumps(value, ensure_ascii=False) if not isinstance(value, str) else repr(value)
+    return text if len(text) <= limit else text[:limit] + '...'
+
+
+# ----------------------------------------------------------------------------
+# main
+# ----------------------------------------------------------------------------
+
+def harvest_fixtures(driver, fixtures):
+    """Run the fixture routes on the OLD side to harvest real ids (phid, bid, ...)."""
+    values = {}
+    for fixture in fixtures:
+        fixture_dir = os.path.join(OUT, '_fixtures', fixture['name'])
+        os.makedirs(fixture_dir, exist_ok=True)
+        scenario = dict(DEFAULTS)
+        scenario.update({'name': '_fixture_' + fixture['name'], 'route': fixture['route'],
+                         'steps': fixture.get('steps', []),
+                         'probe': [fixture['probe']] if fixture.get('probe') else []})
+        side = driver.run('old', scenario, fixture['route'].format(**values), fixture_dir,
+                          os.path.join(fixture_dir, 'api-cache'))
+        value = None
+        if fixture.get('probe'):
+            value = side['result'].get('probes', {}).get(fixture['probe'])
+        else:
+            match = re.search(fixture['pattern'], side['dom'])
+            value = match.group(1) if match else None
+        if value in (None, '', []):
+            die('could not extract fixture %s from the old side' % fixture['name'])
+        values[fixture['name']] = value
+    return values
+
+
+# ----------------------------------------------------------------------------
+# freeze protection: every Playwright side run happens in a worker process
+# ----------------------------------------------------------------------------
+
+class SideFrozen(Exception):
+    pass
+
+
+class WorkerDriver(object):
+    """Runs the Playwright driver in a child process with its own process
+    group, so that ANY freeze is bounded: a renderer stuck in JS, a CDP call
+    that never returns, a request that never completes, a browser that does
+    not close. The worker streams progress; no progress for `stall` seconds,
+    or more than `cap` seconds for one side, kills the whole group (worker,
+    Playwright's node driver and, through its SIGTERM handler, Chromium) and
+    the side raises SideFrozen. The next side gets a fresh worker."""
+
+    name = 'playwright'
+    HEARTBEAT = 15  # s between "still running" lines
+    CLOSE_TIMEOUT = 20  # s for the worker to close the previous browser
+
+    def __init__(self, config, stall, cap):
+        self.config = config
+        self.synthetic = config['synthetic']
+        self.stall, self.cap = stall, cap
+        self.proc, self.lines, self.awaiting_ready = None, None, False
+
+    def _start(self):
+        self.proc = subprocess.Popen(
+            [sys.executable, '-u', os.path.abspath(__file__), '--_worker', json.dumps(self.config)],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None,
+            start_new_session=True, text=True, encoding='utf-8', bufsize=1)
+        self.lines = queue.Queue()
+
+        def reader(stream, sink):
+            for line in stream:
+                try:
+                    sink.put(json.loads(line))
+                except ValueError:
+                    pass  # NB not protocol: ignore
+            sink.put(None)  # EOF: the worker is gone
+        threading.Thread(target=reader, args=(self.proc.stdout, self.lines), daemon=True).start()
+        self.awaiting_ready = False
+
+    def _kill(self):
+        proc, self.proc = self.proc, None
+        if proc is None or proc.poll() is not None:
+            return
+        # NB SIGTERM first: Playwright's node driver then kills the browsers it
+        # launched (they live in process groups of their own); SIGKILL after 5 s
+        for sig, grace in ((signal.SIGTERM, 5), (signal.SIGKILL, 5)):
+            try:
+                os.killpg(proc.pid, sig)
+            except (ProcessLookupError, PermissionError, AttributeError):
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+            try:
+                proc.wait(timeout=grace)
+                return
+            except subprocess.TimeoutExpired:
+                continue
+
+    def _next(self, timeout):
+        try:
+            return self.lines.get(timeout=timeout)
+        except queue.Empty:
+            return 'timeout'
+
+    def _await_ready(self):
+        """The worker closes the previous browser after sending its result."""
+        if not self.awaiting_ready:
+            return
+        deadline = time.time() + self.CLOSE_TIMEOUT
+        while time.time() < deadline:
+            message = self._next(deadline - time.time())
+            if message is None or message == 'timeout':
+                break
+            if message.get('ready'):
+                self.awaiting_ready = False
+                return
+        print('      NB the browser of the previous side did not close within %d s: worker restarted'
+              % self.CLOSE_TIMEOUT, flush=True)
+        self._kill()
+
+    def run(self, side, scenario, route_str, side_dir, cache_dir, budget=None):
+        self._await_ready()
+        if self.proc is None or self.proc.poll() is not None:
+            self._start()
+        job = {'op': 'run', 'side': side, 'scenario': scenario, 'route': route_str,
+               'side_dir': side_dir, 'cache_dir': cache_dir, 'budget': budget}
+        try:
+            self.proc.stdin.write(json.dumps(job) + '\n')
+            self.proc.stdin.flush()
+        except (BrokenPipeError, OSError):
+            self._kill()
+            raise RuntimeError('the worker process died before the %s side started' % side.upper())
+        started = last_progress = last_beat = time.time()
+        activity = 'starting'
+        while True:
+            now = time.time()
+            wait = min(self.stall - (now - last_progress), self.cap - (now - started),
+                       self.HEARTBEAT - (now - last_beat))
+            message = self._next(max(wait, 0.05))
+            now = time.time()
+            if message == 'timeout':
+                if now - last_progress >= self.stall or now - started >= self.cap:
+                    self._kill()
+                    why = ('no progress for %d s' % self.stall) if now - last_progress >= self.stall \
+                        else ('over the %d s cap' % self.cap)
+                    raise SideFrozen('%s side froze (%s), last activity: %s' % (side.upper(), why, activity))
+                if now - last_beat >= self.HEARTBEAT:
+                    print('      ... %s %s side, %.0f s: %s' % (scenario['name'], side.upper(), now - started,
+                                                              activity), flush=True)
+                    last_beat = now
+                continue
+            if message is None:
+                code = self.proc.poll() if self.proc else None
+                self._kill()
+                raise RuntimeError('the worker process exited (code %s) during the %s side, last activity: %s'
+                                   % (code, side.upper(), activity))
+            if 'progress' in message:
+                activity, last_progress = message['progress'], now
+            elif 'fatal' in message:
+                self._kill()
+                die(message['fatal'].replace('FATAL: ', '', 1))
+            elif 'error' in message:
+                self.awaiting_ready = True
+                if message.get('type') == 'NotSupported':
+                    raise NotSupported(message['error'])
+                raise RuntimeError(message['error'])
+            elif 'result' in message:
+                self.awaiting_ready = True
+                return message['result']
+
+    def close(self):
+        proc = self.proc
+        if proc is not None and proc.poll() is None:
+            try:
+                proc.stdin.write(json.dumps({'op': 'stop'}) + '\n')
+                proc.stdin.flush()
+                proc.wait(timeout=10)
+            except Exception:
+                pass
+        self._kill()
+
+
+def worker_main(config_json):
+    """The worker side of WorkerDriver: one JSON job per stdin line; protocol
+    messages (progress, result, error, ready) on the original stdout, which
+    is then pointed at stderr so stray output cannot corrupt the protocol."""
+    global _PROGRESS
+    config = json.loads(config_json)
+    channel = os.fdopen(os.dup(1), 'w', encoding='utf-8', buffering=1)
+    os.dup2(2, 1)
+    lock = threading.Lock()
+
+    def send(message):
+        with lock:
+            channel.write(json.dumps(message) + '\n')
+            channel.flush()
+    _PROGRESS = lambda text: send({'progress': text})
+    try:
+        driver = PlaywrightDriver(config['browser'], config['browser_args'], synthetic=config['synthetic'],
+                                  live=config['live'], defer_close=True)
+    except SystemExit as error:
+        send({'fatal': str(error.code)})
+        return
+    try:
+        for line in sys.stdin:
+            job = json.loads(line)
+            if job.get('op') == 'stop':
+                break
+            try:
+                send({'result': driver.run(job['side'], job['scenario'], job['route'], job['side_dir'],
+                                           job['cache_dir'], budget=job.get('budget'))})
+            except SystemExit as error:
+                send({'fatal': str(error.code)})
+                return
+            except NotSupported as error:
+                send({'error': str(error), 'type': 'NotSupported'})
+            except Exception as error:
+                send({'error': '%s: %s' % (type(error).__name__, str(error).split('\n')[0][:300])})
+            finally:
+                driver.close_pending()
+                send({'ready': True})
+    finally:
+        try:
+            driver.close()
+        except Exception:
+            pass
+
+
+def make_driver(args):
+    browser_args = list(args.browser_arg or [])
+    if args.driver == 'chrome-cli':
+        return ChromeCliDriver(args.browser, browser_args)
+    # NB no silent fallback to chrome-cli: it needs a Chrome binary and real
+    # sockets, and its synthetic input misses focus/blur regressions
+    try:
+        import playwright  # noqa: F401
+    except ImportError:
+        die('the playwright driver needs playwright, which this Python cannot import:\n'
+            '  %s (Python %s)\n'
+            '`pip` may have installed it for another interpreter. Install it for this one:\n'
+            '  %s -m pip install playwright==1.50.0\n'
+            '  %s -m playwright install chromium\n'
+            '(or run with --driver chrome-cli and an installed Chrome: synthetic input only)'
+            % (sys.executable, sys.version.split()[0], sys.executable, sys.executable))
+    if args.stall_timeout > 0:
+        return WorkerDriver({'browser': args.browser, 'browser_args': browser_args,
+                             'synthetic': args.input == 'synthetic', 'live': args.live},
+                            stall=args.stall_timeout, cap=args.side_timeout)
+    return PlaywrightDriver(args.browser, browser_args, synthetic=(args.input == 'synthetic'), live=args.live)
+
+
+CHROME_CANDIDATES = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'chrome',
+                     '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                     '/Applications/Chromium.app/Contents/MacOS/Chromium']
+
+
+def find_chrome():
+    for candidate in CHROME_CANDIDATES:
+        found = shutil.which(candidate) or (os.path.isfile(candidate) and candidate)
+        if found:
+            return found
+    die('--driver chrome-cli found no Chrome/Chromium (tried %s): set PARITY_BROWSER or --browser'
+        % ', '.join(os.path.basename(c) for c in CHROME_CANDIDATES))
+
+
+def main():
+    if len(sys.argv) == 3 and sys.argv[1] == '--_worker':
+        return worker_main(sys.argv[2])
+    # NB progress must show even when the output is piped (CI logs, | tee)
+    try:
+        sys.stdout.reconfigure(line_buffering=True)
+    except AttributeError:
+        pass
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument('--only', help='comma-separated scenario names or glob patterns')
+    parser.add_argument('--tag', help='comma-separated tags')
+    parser.add_argument('--list', action='store_true', help='list the scenarios and exit')
+    parser.add_argument('--lint', action='store_true', help='validate scenarios.json and config.json and exit')
+    parser.add_argument('--scenarios', default=SCENARIOS_PATH, help='a JSON list of scenario objects')
+    parser.add_argument('--config', default=CONFIG_PATH, help='JSON {"defaults": {...}, "fixtures": [...]}')
+    parser.add_argument('--driver', choices=['playwright', 'chrome-cli'], default='playwright')
+    parser.add_argument('--input', choices=['native', 'synthetic'], default='native',
+                        help='playwright driver: native input (default) or the in-page synthetic executor')
+    parser.add_argument('--browser', default=os.environ.get('PARITY_BROWSER'),
+                        help='browser executable (env PARITY_BROWSER)')
+    parser.add_argument('--browser-arg', action='append',
+                        help='extra browser flag, repeatable (env PARITY_BROWSER_ARGS, space-separated)')
+    parser.add_argument('--no-pixels', action='store_true')
+    parser.add_argument('--fresh-cache', action='store_true', help='drop the recorded API responses first')
+    parser.add_argument('--live', action='store_true', help='playwright driver: never replay the API cache')
+    parser.add_argument('--no-build', action='store_true', help='do not rebuild ermac.min.js')
+    parser.add_argument('--stall-timeout', type=float, default=float(os.environ.get('PARITY_STALL_TIMEOUT', 90)),
+                        help='playwright: kill a side that reports no progress for this many seconds '
+                             '(env PARITY_STALL_TIMEOUT, default 90; 0 runs in-process, unguarded)')
+    parser.add_argument('--side-timeout', type=float, default=float(os.environ.get('PARITY_SIDE_TIMEOUT', 600)),
+                        help='playwright: hard cap per side in seconds (env PARITY_SIDE_TIMEOUT, default 600)')
+    parser.add_argument('--reference-url', default=OLD_URL, help='where to fetch the OLD bundle')
+    parser.add_argument('--reference-css-url', default=OLD_CSS_URL, help='where to fetch the OLD stylesheet')
+    parser.add_argument('--reference-css-sha1', default=OLD_CSS_SHA1,
+                        help='expected sha1 of the OLD stylesheet ("" disables the check)')
+    parser.add_argument('--reference-sha1', default=OLD_SHA1,
+                        help='expected sha1 of the OLD bundle ("" disables the check)')
+    args = parser.parse_args()
+    if not args.browser_arg and os.environ.get('PARITY_BROWSER_ARGS'):
+        args.browser_arg = os.environ['PARITY_BROWSER_ARGS'].split()
+
+    scenarios, fixtures, problems = load_scenarios(args.scenarios, args.config)
+    if problems:
+        print('\n'.join(problems))
+        die('%d problem(s) in %s' % (len(problems), args.scenarios))
+    selected = select(scenarios, args.only, args.tag)
+    if args.lint:
+        print('%s: %d scenarios, %d fixtures, OK' % (os.path.relpath(args.scenarios), len(scenarios), len(fixtures)))
+        return
+    if args.list:
+        for s in selected:
+            flag = ' [skip: %s]' % s['skip'] if s.get('skip') else (' [xfail: %s]' % s['xfail'] if s.get('xfail') else '')
+            print('%-34s %-58s %s%s' % (s['name'], s['route'][:58], ','.join(s['tags']), flag))
+        print('%d scenarios' % len(selected))
+        return
+
+    os.makedirs(OUT, exist_ok=True)
+    if not args.no_build:
+        build_new_bundle()
+    ensure_reference(args.reference_url, args.reference_sha1)
+    ensure_reference_css(args.reference_css_url, args.reference_css_sha1)
+    driver = make_driver(args)
+    print('driver: %s%s%s' % (driver.name, ' (synthetic input)' if driver.synthetic else '',
+                              (', watchdog: stall %ds, cap %ds per side' % (args.stall_timeout, args.side_timeout))
+                              if isinstance(driver, WorkerDriver) else ''))
+    results = []
+    interrupted = False
+    frozen_in_a_row = 0
+    try:
+        needed = set(re.findall(r'\{(\w+)\}', ' '.join(s['route'] for s in selected)))
+        fixture_values = {}
+        if needed:
+            banner('harvesting fixtures from the OLD side: %s' % ', '.join(sorted(needed)))
+            try:
+                fixture_values = harvest_fixtures(driver, [f for f in fixtures if f['name'] in needed])
+            except SideFrozen as error:
+                die('harvesting the fixtures froze: %s' % error)
+            print('fixtures:', fixture_values)
+
+        banner('running %d scenarios x 2 sides' % len(selected))
+        for scenario in selected:
+            name = scenario['name']
+            if scenario.get('skip'):
+                results.append({'name': name, 'verdict': 'SKIP', 'reason': scenario['skip']})
+                print('%-34s SKIP (%s)' % (name, scenario['skip']))
+                continue
+            side_dir = os.path.join(OUT, name)
+            cache_dir = os.path.join(side_dir, 'api-cache')
+            if args.fresh_cache and os.path.isdir(cache_dir):
+                shutil.rmtree(cache_dir)
+            os.makedirs(side_dir, exist_ok=True)
+            route_str = scenario['route'].format(**fixture_values)
+            started = time.time()
+            sides = {}
+            try:
+                for side in ('old', 'new'):
+                    # NB the old side populates the API cache, the new side replays it
+                    sides[side] = driver.run(side, scenario, route_str, side_dir, cache_dir,
+                                             budget=scenario.get('budget'))
+            except NotSupported as reason:
+                results.append({'name': name, 'verdict': 'SKIP', 'reason': str(reason)})
+                print('%-34s SKIP (%s)' % (name, reason))
+                continue
+            except Exception as error:
+                message = '%s: %s' % (type(error).__name__, str(error).split('\n')[0][:300])
+                results.append({'name': name, 'verdict': 'ERROR', 'reason': message,
+                                'seconds': round(time.time() - started, 1)})
+                print('%-34s ERROR %s' % (name, message))
+                write_report(driver, results, complete=False)
+                frozen_in_a_row = frozen_in_a_row + 1 if isinstance(error, SideFrozen) else 0
+                if frozen_in_a_row >= 3:
+                    die('%d scenarios in a row froze: the environment (browser, network, API) is likely '
+                        'broken rather than the scenarios; see the ERROR lines above and %s'
+                        % (frozen_in_a_row, os.path.relpath(os.path.join(OUT, 'report.json'))))
+                continue
+            frozen_in_a_row = 0
+            for side in ('old', 'new'):
+                with open(os.path.join(side_dir, side + '-dom.html'), 'w', encoding='utf-8') as f:
+                    f.write(sides[side]['dom'])
+                with open(os.path.join(side_dir, side + '-capture.json'), 'w', encoding='utf-8') as f:
+                    json.dump({k: v for k, v in sides[side].items() if k != 'dom'}, f, indent=1, ensure_ascii=False)
+            if not sides['old']['api']:
+                message = 'infrastructure error: no API requests at all (is the API reachable?)'
+                results.append({'name': name, 'verdict': 'ERROR', 'reason': message})
+                print('%-34s ERROR %s' % (name, message))
+                continue
+            diffs, warnings, fraction = compare(scenario, sides['old'], sides['new'], not args.no_pixels, side_dir)
+            verdict = 'FAIL' if diffs else 'PASS'
+            if scenario.get('xfail'):
+                verdict = 'XFAIL' if diffs else 'XPASS'
+                if 'expect_new' in diffs:
+                    verdict = 'FAIL'  # the approved new behaviour itself broke
+            entry = {'name': name, 'verdict': verdict, 'diffs': diffs, 'warnings': warnings,
+                     'pixels': fraction, 'seconds': round(time.time() - started, 1),
+                     'notes': sides['old']['notes'] + sides['new']['notes']}
+            if scenario.get('approved'):
+                entry['approved'] = scenario['approved']
+            results.append(entry)
+            with open(os.path.join(side_dir, 'diff.txt'), 'w', encoding='utf-8') as f:
+                for layer, items in diffs.items():
+                    f.write('== %s ==\n%s\n\n' % (layer, '\n'.join(items)))
+                for warning in warnings:
+                    f.write('WARN %s\n' % warning)
+            pixel_text = ('%.4f%%' % (fraction * 100)) if fraction is not None else '-'
+            print('%-34s %-5s %5.1fs  pixels %-9s %s' % (
+                name, verdict, entry['seconds'], pixel_text,
+                ('differs: ' + ', '.join(diffs)) if diffs else ''))
+            for layer, items in diffs.items():
+                for item in items[:4]:
+                    print('      %-6s %s' % (layer, item))
+                if len(items) > 4:
+                    print('      %-6s ... %d more (see %s)' % (layer, len(items) - 4, os.path.relpath(os.path.join(side_dir, 'diff.txt'))))
+            for warning in warnings:
+                print('      WARN   %s' % warning)
+            write_report(driver, results, complete=False)
+    except KeyboardInterrupt:
+        interrupted = True
+        print('\ninterrupted: stopping the browser processes...', flush=True)
+        if isinstance(driver, WorkerDriver):
+            driver._kill()  # NB no polite stop: the worker may be mid-scenario
+    finally:
+        driver.close()
+
+    write_report(driver, results, complete=not interrupted)
+    banner('summary' + (' (INTERRUPTED: partial)' if interrupted else ''))
+    counts = {}
+    for r in results:
+        counts[r['verdict']] = counts.get(r['verdict'], 0) + 1
+    approved = sum(1 for r in results if r.get('approved') and r['verdict'] == 'PASS')
+    print('  '.join('%s %d' % kv for kv in sorted(counts.items()))
+          + ('  (PASS incl. %d with an approved probe change)' % approved if approved else ''))
+    failed = [r['name'] for r in results if r['verdict'] in ('FAIL', 'XPASS', 'ERROR')]
+    if failed:
+        print('failing:', ' '.join(failed))
+    print('report: %s' % os.path.relpath(os.path.join(OUT, 'report.json')))
+    sys.exit(130 if interrupted else (1 if failed else 0))
+
+
+def write_report(driver, results, complete):
+    """Rewritten after every scenario: a run that is killed or interrupted
+    still leaves its results so far."""
+    path = os.path.join(OUT, 'report.json')
+    with open(path + '.tmp', 'w', encoding='utf-8') as f:
+        json.dump({'driver': driver.name, 'synthetic': driver.synthetic, 'complete': complete,
+                   'results': results}, f, indent=1)
+    os.replace(path + '.tmp', path)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/parity/scenarios.json b/parity/scenarios.json
new file mode 100644
index 0000000..c358190
--- /dev/null
+++ b/parity/scenarios.json
@@ -0,0 +1,4323 @@
+[
+  {
+    "comment": "section: routes (the original battery)",
+    "name": "start",
+    "route": "#start",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "search",
+    "route": "#search/Ag-O",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "inquiry_oxide",
+    "route": "#inquiry/elements=Ag-O&classes=oxide",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "inquiry_tabled",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "phases",
+    "route": "#inquiry_phases/elements=Ag-O&classes=oxide",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "articles",
+    "route": "#inquiry_articles/elements=Ag-O&classes=oxide",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "numeric",
+    "route": "#inquiry/numeric=volume%2C%3E%2C3000%3B",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "entry",
+    "route": "#entry/S1410618",
+    "pixels": "loose",
+    "settle": 6000,
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "phase_id",
+    "route": "#phase_id/{phid}",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "article",
+    "route": "#article/{bid}",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "interlinkage",
+    "route": "#interlinkage/{phid}",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "hierarchy",
+    "route": "#hierarchy",
+    "tags": ["route", "legacy"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): an opened dialog takes the focus",
+    "expect_new": {
+      "focus": "#hy_box"
+    }
+  },
+  {
+    "name": "polyhedra",
+    "route": "#polyhedra",
+    "tags": ["route", "legacy"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): an opened dialog takes the focus",
+    "expect_new": {
+      "focus": "#all_polyhedra_box"
+    }
+  },
+  {
+    "name": "modal_login",
+    "route": "#modal/login",
+    "tags": ["route", "legacy"]
+  },
+  {
+    "name": "plot_pie",
+    "route": "#plot/pie/inquiry/elements=Ag-O",
+    "pixels": "loose",
+    "settle": 6000,
+    "tags": ["route", "legacy"]
+  },
+  {
+    "comment": "section: clicks (the original battery, formerly hard-coded in harness.js)",
+    "name": "click_advsearch",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#databrowser div.gallery_item, #databrowser tr.tcell"
+      },
+      {
+        "click": "#advsearch_init_trigger"
+      }
+    ],
+    "tags": ["click", "legacy"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): an opened dialog takes the focus",
+    "expect_new": {
+      "focus": "#advsbox"
+    }
+  },
+  {
+    "name": "click_entry_ctx",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell"
+      }
+    ],
+    "tags": ["click", "legacy"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#e__S311308"
+    }
+  },
+  {
+    "name": "click_sort",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c2.header"
+      },
+      {
+        "click": "#dataheader_entries th.c2.header"
+      }
+    ],
+    "tags": ["click", "sort", "legacy"]
+  },
+  {
+    "name": "click_sort_desc",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c2.header"
+      },
+      {
+        "click": "#dataheader_entries th.c2.header",
+        "after": 500
+      },
+      {
+        "click": "#dataheader_entries th.c2.header"
+      }
+    ],
+    "tags": ["click", "sort", "legacy"]
+  },
+  {
+    "name": "click_refine",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#refine_col a.extd_refine"
+      },
+      {
+        "click": "#refine_col a.extd_refine"
+      }
+    ],
+    "tags": ["click", "legacy"]
+  },
+  {
+    "comment": "section: main search box (the vanilla multiselect replacing selectize)",
+    "name": "ms_type_opens_suggestions",
+    "desc": "typing opens the suggestion dropdown with the same options, order and highlight",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "texts:#search_holder .selectize-dropdown-content [data-selectable]",
+      "classes:#search_holder .selectize-dropdown-content [data-selectable]",
+      "class:#search_holder .selectize-input"
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_enter_after_typing",
+    "desc": "Enter right after suggestions appear: selectize picks the auto-highlighted first option",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "key": "Enter"
+      }
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_arrowdown_enter",
+    "desc": "ArrowDown then Enter adds the highlighted option as an item",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "key": "ArrowDown"
+      },
+      {
+        "key": "Enter"
+      }
+    ],
+    "probe": ["class:#search_holder .selectize-input"],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_arrowdown_twice_highlight",
+    "desc": "two ArrowDown presses move the highlight to the expected option",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "key": "ArrowDown"
+      },
+      {
+        "key": "ArrowDown"
+      }
+    ],
+    "probe": [
+      "classes:#search_holder .selectize-dropdown-content [data-selectable]"
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_arrowup_highlight",
+    "desc": "ArrowUp on an open dropdown highlights the expected option",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "key": "ArrowUp"
+      }
+    ],
+    "probe": [
+      "classes:#search_holder .selectize-dropdown-content [data-selectable]"
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_escape_closes_dropdown",
+    "desc": "Escape closes the dropdown and keeps the typed text",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "key": "Escape"
+      }
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_click_option",
+    "desc": "clicking a suggestion adds it, closes the dropdown, keeps the focus",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "click": "#search_holder .selectize-dropdown-content [data-selectable]"
+      }
+    ],
+    "probe": [
+      "class:#search_holder .selectize-input",
+      "classes:#ptable_area li[data-pos='47']"
+    ],
+    "tags": ["multiselect", "mouse"]
+  },
+  {
+    "name": "ms_hover_option",
+    "desc": "hovering a suggestion moves the highlight",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "hover": "#search_holder .selectize-dropdown-content [data-selectable]",
+        "nth": 1
+      }
+    ],
+    "probe": [
+      "classes:#search_holder .selectize-dropdown-content [data-selectable]"
+    ],
+    "tags": ["multiselect", "mouse"]
+  },
+  {
+    "name": "ms_backspace_removes_last_item",
+    "desc": "Backspace in the empty input removes the last item",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "focus": "#search_field-selectized"
+      },
+      {
+        "key": "Backspace",
+        "after": 1200
+      }
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_backspace_twice",
+    "desc": "two Backspaces remove two items, in order",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "focus": "#search_field-selectized"
+      },
+      {
+        "key": "Backspace",
+        "after": 1200
+      },
+      {
+        "key": "Backspace",
+        "after": 1200
+      }
+    ],
+    "probe": ["class:#search_holder .selectize-input"],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_backspace_edits_text_first",
+    "desc": "Backspace with typed text deletes a character, not an item",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Cu"
+      },
+      {
+        "key": "Backspace",
+        "after": 1200
+      }
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_remove_button",
+    "desc": "the item x button removes exactly that item",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "click": "#search_holder .selectize-input > div[data-term] a.remove",
+        "after": 1200
+      }
+    ],
+    "tags": ["multiselect", "mouse"]
+  },
+  {
+    "name": "ms_click_item",
+    "desc": "clicking an item: selection highlight and focus as in selectize",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "click": "#search_holder .selectize-input > div[data-term]"
+      }
+    ],
+    "probe": ["classes:#search_holder .selectize-input > div[data-term]"],
+    "tags": ["multiselect", "mouse"]
+  },
+  {
+    "name": "ms_click_item_then_backspace",
+    "desc": "selectize: Backspace deletes the clicked (active) item, not the last one",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "click": "#search_holder .selectize-input > div[data-term]"
+      },
+      {
+        "key": "Backspace",
+        "after": 1200
+      }
+    ],
+    "tags": ["multiselect", "keyboard", "mouse"]
+  },
+  {
+    "name": "ms_blur_preserves_text",
+    "desc": "preserve_on_blur: leaving the input keeps the typed text and closes the dropdown",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "click": "#ermac_logo",
+        "after": 600
+      }
+    ],
+    "probe": ["class:#search_holder .selectize-input"],
+    "tags": ["multiselect", "mouse"]
+  },
+  {
+    "name": "ms_refocus_reopens",
+    "desc": "focusing the input again after a blur: dropdown state as in selectize",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "blur": true,
+        "after": 600
+      },
+      {
+        "focus": "#search_field-selectized",
+        "after": 600
+      }
+    ],
+    "probe": ["class:#search_holder .selectize-input"],
+    "tags": ["multiselect"]
+  },
+  {
+    "name": "ms_already_selected_hidden",
+    "desc": "an item already in the box is not offered again (selectize hideSelected)",
+    "route": "#search/Ag",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "texts:#search_holder .selectize-dropdown-content [data-selectable]"
+    ],
+    "tags": ["multiselect"]
+  },
+  {
+    "name": "ms_options_filtered_by_query",
+    "desc": "options of an earlier query do not leak into the dropdown of a later one",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      },
+      {
+        "type": "#search_field-selectized",
+        "text": "Cu",
+        "clear": true,
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "texts:#search_holder .selectize-dropdown-content [data-selectable]"
+    ],
+    "tags": ["multiselect"]
+  },
+  {
+    "name": "ms_ctrl_a_select_all",
+    "desc": "Cmd/Ctrl+A selects all chips, Backspace then removes them all",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "focus": "#search_field-selectized"
+      },
+      {
+        "key": "ControlOrMeta+a"
+      },
+      {
+        "key": "Backspace",
+        "after": 1200
+      }
+    ],
+    "probe": ["class:#search_holder .selectize-input"],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_arrow_left_caret",
+    "desc": "ArrowLeft moves the caret before the last chip: Backspace removes the one before the caret",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "focus": "#search_field-selectized"
+      },
+      {
+        "key": "ArrowLeft"
+      },
+      {
+        "key": "Backspace",
+        "after": 1200
+      }
+    ],
+    "tags": ["multiselect", "keyboard"]
+  },
+  {
+    "name": "ms_original_select_options",
+    "desc": "the hidden original <select> mirrors the chips (host pages may read it)",
+    "route": "#search/Ag-O",
+    "probe": [
+      "texts:#search_field option",
+      "attr:#search_field@multiple",
+      "attr:#search_field@class",
+      "attr:#search_field-selectized@type"
+    ],
+    "tags": ["multiselect", "contract"]
+  },
+  {
+    "name": "ms_max_items",
+    "desc": "more than maxItems=10 terms: which items are kept, the input state",
+    "route": "#search/H-He-Li-Be-B-C-N-O-F-Ne-Na-Mg",
+    "probe": [
+      "class:#search_holder .selectize-input",
+      "readonly:#search_field-selectized"
+    ],
+    "tags": ["multiselect", "route"]
+  },
+  {
+    "name": "ms_input_autogrow",
+    "desc": "long typed text: input width grows as in selectize",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "superconductivity of ternary oxides",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "rect:#search_field-selectized",
+      "rect:#search_holder .selectize-input"
+    ],
+    "pixels": "loose",
+    "tags": ["multiselect", "layout"]
+  },
+  {
+    "name": "ms_initial_focus",
+    "desc": "the search input is focused at boot (onInitialize)",
+    "route": "#start",
+    "probe": ["class:#search_holder .selectize-input"],
+    "tags": ["multiselect"]
+  },
+  {
+    "comment": "section: search triggering",
+    "name": "search_enter_raw_text",
+    "desc": "Enter on raw free text (no suggestion chosen) runs the search",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag2O cubic",
+        "after": 100
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "tags": ["search", "keyboard"]
+  },
+  {
+    "name": "search_button_raw_text",
+    "desc": "the search button merges items and raw text into one inquiry",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "oxide",
+        "after": 100
+      },
+      {
+        "click": "#search_trigger",
+        "after": 1500
+      }
+    ],
+    "tags": ["search", "mouse"]
+  },
+  {
+    "name": "search_button_same_query",
+    "desc": "re-submitting the current inquiry re-triggers it (the hash-hack)",
+    "route": "#inquiry/elements=Ag-O",
+    "steps": [
+      {
+        "click": "#search_trigger",
+        "after": 1500
+      }
+    ],
+    "tags": ["search", "mouse"]
+  },
+  {
+    "name": "search_empty",
+    "desc": "submitting an empty box notifies 'unrecognized input'",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#search_trigger"
+      }
+    ],
+    "tags": ["search", "notify"]
+  },
+  {
+    "name": "search_trailing_comma",
+    "desc": "a trailing comma or space of the raw text is dropped",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag2O,",
+        "after": 100
+      },
+      {
+        "click": "#search_trigger",
+        "after": 1500
+      }
+    ],
+    "tags": ["search"]
+  },
+  {
+    "name": "search_numeric_text",
+    "desc": "a numeric expression typed in the box becomes a numeric search",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "band gap > 3",
+        "after": 100
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "probe": ["visible:#numericbox", "count:#numericbox div.slider_numerics"],
+    "tags": ["search", "numeric"],
+    "xfail": "APPROVED CHANGE: the old GUI passed the numeric arrays of wmutils.guess() to $.param(), giving numeric[0][]=... keys the router cannot read ('Unrecognized input'); the new GUI writes the router's own prop,sign,value;... form (inquiry_param)",
+    "expect_new": {
+      "hash": "#inquiry/numeric=band%20gap%2C%3E%2C3",
+      "js:JSON.stringify(wmgui.search.numeric)": "[[\"band gap\",\">\",\"3\"]]",
+      "js:wmgui.search_type": 1,
+      "text:#notifybox": {
+        "not_contains": "Unrecognized"
+      }
+    }
+  },
+  {
+    "name": "search_numeric_text_two_conditions",
+    "desc": "two numeric conditions typed in the box become one numeric search with both",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "band gap > 3 seebeck coefficient < 100",
+        "after": 100
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "probe": ["visible:#numericbox", "count:#numericbox div.slider_numerics"],
+    "tags": ["search", "numeric"],
+    "xfail": "APPROVED CHANGE: the old GUI passed the numeric arrays of wmutils.guess() to $.param(), giving numeric[0][]=... keys the router cannot read ('Unrecognized input'); the new GUI writes the router's own prop,sign,value;... form (inquiry_param)",
+    "expect_new": {
+      "hash": "#inquiry/numeric=band%20gap%2C%3E%2C3%3Bseebeck%20coefficient%2C%3C%2C100",
+      "js:JSON.stringify(wmgui.search.numeric)": "[[\"band gap\",\">\",\"3\"],[\"seebeck coefficient\",\"<\",\"100\"]]",
+      "text:#notifybox": {
+        "not_contains": "Unrecognized"
+      }
+    }
+  },
+  {
+    "name": "search_numeric_text_with_formula",
+    "desc": "a formula plus a numeric condition typed in the box keeps both",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Bi2Te3 seebeck coefficient > 100",
+        "after": 100
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "tags": ["search", "numeric"],
+    "xfail": "APPROVED CHANGE: the old GUI passed the numeric arrays of wmutils.guess() to $.param(), giving numeric[0][]=... keys the router cannot read ('Unrecognized input'); the new GUI writes the router's own prop,sign,value;... form (inquiry_param)",
+    "expect_new": {
+      "hash": "#inquiry/formulae=Bi2Te3&numeric=seebeck%20coefficient%2C%3E%2C100",
+      "js:JSON.stringify(wmgui.search.numeric)": "[[\"seebeck coefficient\",\">\",\"100\"]]"
+    }
+  },
+  {
+    "name": "numeric_route_two_conditions",
+    "desc": "a two-condition numeric route is parsed identically (router format, no serialization involved)",
+    "route": "#inquiry/numeric=band%20gap%2C%3E%2C3%3Bseebeck%20coefficient%2C%3C%2C100",
+    "probe": [
+      "js:JSON.stringify(wmgui.search.numeric)",
+      "js:wmgui.search_type",
+      "count:#numericbox div.slider_numerics"
+    ],
+    "tags": ["route", "numeric"]
+  },
+  {
+    "name": "numeric_hint_links",
+    "desc": "the 'Show only unaries/...' links of a numeric search reuse the current hash (no serialization involved)",
+    "route": "#inquiry/numeric=band%20gap%2C%3C%2C1",
+    "probe": ["attrs:#interpret li[rel]@rel"],
+    "tags": ["numeric", "refine"],
+    "expect": {
+      "attrs:#interpret li[rel]@rel": {
+        "contains": "#inquiry/classes=unary&numeric=band%20gap%2C%3C%2C1"
+      }
+    }
+  },
+  {
+    "name": "numeric_view_phases_button",
+    "desc": "the (only) phases VIEW button of a numeric search keeps the numeric condition",
+    "route": "#inquiry/numeric=volume%2C%3E%2C3000%3B",
+    "steps": [
+      {
+        "click": "#control_b",
+        "after": 1500
+      }
+    ],
+    "tags": ["numeric", "controls"],
+    "xfail": "APPROVED CHANGE: the old GUI passed the numeric arrays of wmutils.guess() to $.param(), giving numeric[0][]=... keys the router cannot read ('Unrecognized input'); the new GUI writes the router's own prop,sign,value;... form (inquiry_param)",
+    "expect_new": {
+      "hash": "#inquiry_phases/numeric=volume%2C%3E%2C3000=",
+      "js:JSON.stringify(wmgui.search.numeric)": "[[\"volume\",\">\",\"3000\"]]"
+    }
+  },
+  {
+    "name": "legend_click",
+    "desc": "the e.g. legend link searches its own text (the text is pinned: its random pick differs per side)",
+    "route": "#start",
+    "steps": [
+      {
+        "eval": "document.querySelector('#legend a').textContent = 'phase transitions of TiH\u2082'"
+      },
+      {
+        "click": "#legend a",
+        "after": 1500
+      }
+    ],
+    "tags": ["search", "mouse"]
+  },
+  {
+    "name": "logo_click_home",
+    "desc": "the logo returns to the landing page",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "click": "#ermac_logo a",
+        "after": 1500
+      }
+    ],
+    "tags": ["mouse", "route"]
+  },
+  {
+    "comment": "section: table sorting (the vanilla tablesort replacing jquery.tablesorter)",
+    "name": "sort_formula",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c1.header"
+      },
+      {
+        "click": "#dataheader_entries th.c1.header"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_year",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c4.header"
+      },
+      {
+        "click": "#dataheader_entries th.c4.header"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_ref_numeric",
+    "desc": "the Ref. column sorts numerically, not lexically",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c5.header"
+      },
+      {
+        "click": "#dataheader_entries th.c5.header"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_journal",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.cj.header"
+      },
+      {
+        "click": "#dataheader_entries th.cj.header"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_two_columns",
+    "desc": "sorting by one column then another: last click wins, header classes reset",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c4.header"
+      },
+      {
+        "click": "#dataheader_entries th.c4.header"
+      },
+      {
+        "click": "#dataheader_entries th.c1.header"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_dblclick_no_text_selection",
+    "desc": "double-clicking a header does not select its text (tablesorter cancelSelection)",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c2.header"
+      },
+      {
+        "dblclick": "#dataheader_entries th.c2.header"
+      }
+    ],
+    "probe": ["selection", "attrs:#databrowser tr.tcell@id"],
+    "tags": ["sort", "mouse"]
+  },
+  {
+    "name": "sort_unsortable_column",
+    "desc": "the Show column (cp) is not sortable",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#dataheader_entries th.cp"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_after_second_search",
+    "desc": "sorting after a second search: the header handlers of the first table must not also fire",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "hash": "#inquiry/formulae=AgO&props=crystal%20structure",
+        "after": 2500
+      },
+      {
+        "wait_for": "#dataheader_entries th.c5.header"
+      },
+      {
+        "click": "#dataheader_entries th.c5.header"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_ctrl_multi",
+    "desc": "ctrl-click adds a second sort key (sortMultiSortKey)",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dataheader_entries th.c2.header"
+      },
+      {
+        "click": "#dataheader_entries th.c2.header"
+      },
+      {
+        "eval": "document.querySelector('#dataheader_entries th.c4.header').dispatchEvent(new MouseEvent('click', {bubbles: true, cancelable: true, ctrlKey: true}))"
+      }
+    ],
+    "probe": [
+      "attrs:#databrowser tr.tcell@id",
+      "classes:#dataheader_entries th"
+    ],
+    "tags": ["sort"]
+  },
+  {
+    "name": "sort_phases_table",
+    "tooltips": false,
+    "route": "#inquiry_phases/elements=Ag-O&classes=oxide",
+    "steps": [
+      {
+        "wait_for": "#control_c"
+      },
+      {
+        "click": "#control_c",
+        "after": 1500
+      },
+      {
+        "wait_for": "#dataheader_phases th.header"
+      },
+      {
+        "click": "#dataheader_phases th.header"
+      }
+    ],
+    "probe": ["classes:#dataheader_phases th", "attrs:#databrowser tr@id"],
+    "tags": ["sort"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#control_c"
+    }
+  },
+  {
+    "comment": "section: periodic table",
+    "name": "ptable_click_element",
+    "desc": "clicking Ag selects it in the table and adds it to the search box",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "classes:#ptable_area li[data-pos='47'], #ptable_area li[data-pos='8']",
+      "visible:#ptable_results"
+    ],
+    "tags": ["ptable", "mouse"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#ptable_area > ul > li.cat_0.selected_a.type_6"
+    }
+  },
+  {
+    "name": "ptable_click_binary",
+    "desc": "Ag then O: binary system selected, phase diagram fetched",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 1500
+      },
+      {
+        "click": "#ptable_area li[data-pos='8']",
+        "after": 2500
+      }
+    ],
+    "probe": [
+      "classes:#ptable_area li[data-pos='47'], #ptable_area li[data-pos='8']",
+      "visible:#ptable_results",
+      "visible:#ptable_vis"
+    ],
+    "tags": ["ptable", "mouse"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#ptable_area > ul > li.active_a.selected_b"
+    }
+  },
+  {
+    "name": "ptable_click_toggle_off",
+    "desc": "clicking a selected element again deselects it",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 1500
+      },
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 1500
+      }
+    ],
+    "probe": ["classes:#ptable_area li[data-pos='47']"],
+    "tags": ["ptable", "mouse"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#ptable_area > ul > li.cat_0.type_6"
+    }
+  },
+  {
+    "name": "ptable_remove_item_deselects",
+    "desc": "removing an element item from the box deselects it in the table",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 1500
+      },
+      {
+        "click": "#search_holder .selectize-input > div[data-term] a.remove",
+        "after": 1500
+      }
+    ],
+    "probe": ["classes:#ptable_area li[data-pos='47']"],
+    "tags": ["ptable", "multiselect"]
+  },
+  {
+    "name": "ptable_dtypes_counts",
+    "desc": "switching the table to crystal structure counts \u2014 settle 6000: the embedded cifplayer iframe boots and fetches its phase data asynchronously",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 2500
+      },
+      {
+        "click": "label[for='ptable_dtypes_2']",
+        "after": 2500
+      }
+    ],
+    "probe": [
+      "checked:#ptable_dtypes_2",
+      "html:#ptable_area li[data-pos='8']",
+      "classes:#ptable_area li[data-pos='8']",
+      "visible:#ptable_results"
+    ],
+    "tags": ["ptable"],
+    "settle": 6000
+  },
+  {
+    "name": "ptable_dtypes_empty",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 2500
+      },
+      {
+        "click": "label[for='ptable_dtypes_0']",
+        "after": 2000
+      }
+    ],
+    "probe": [
+      "checked:#ptable_dtypes_0",
+      "classes:#ptable_area li[data-pos='8']"
+    ],
+    "tags": ["ptable"]
+  },
+  {
+    "name": "ptable_scroll_hides_legend",
+    "desc": "scrolling past 40px hides the legend and un-results the dtypes box",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#ptable_area li[data-pos='47']",
+        "after": 1500
+      },
+      {
+        "scroll_y": 300,
+        "after": 1000
+      }
+    ],
+    "probe": [
+      "class:#ptable_dtypes_box",
+      "style:#legend@display",
+      "class:#ptable_vis",
+      "scroll"
+    ],
+    "viewport": [1280, 800],
+    "tags": ["ptable", "scroll"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#ptable_area > ul > li.cat_0.selected_a.type_6"
+    }
+  },
+  {
+    "name": "ptable_route_selects",
+    "desc": "a #search route with elements also highlights them on the landing table",
+    "route": "#search/Cu-Zn",
+    "steps": [
+      {
+        "click": "#ermac_logo a",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "classes:#ptable_area li[data-pos='29'], #ptable_area li[data-pos='30']"
+    ],
+    "tags": ["ptable"]
+  },
+  {
+    "comment": "section: advanced search box",
+    "name": "advs_open_default_tab",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      }
+    ],
+    "probe": [
+      "visibles:div.advstab",
+      "classes:#advstab_options li",
+      "visible:#advsbox"
+    ],
+    "tags": ["advsearch"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): an opened dialog takes the focus",
+    "expect_new": {
+      "focus": "#advsbox"
+    }
+  },
+  {
+    "name": "advs_switch_tabs",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_bib]"
+      }
+    ],
+    "probe": ["visibles:div.advstab", "classes:#advstab_options li"],
+    "tags": ["advsearch"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#advstab_options > li.working"
+    }
+  },
+  {
+    "name": "advs_legend_fills_input",
+    "desc": "an e.g. link fills the plain input and focuses it",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "click": ".advs_formulae .advs_legend a"
+      }
+    ],
+    "probe": ["value:#advs_fct_formulae"],
+    "tags": ["advsearch"]
+  },
+  {
+    "name": "advs_legend_fills_multiselect",
+    "desc": "an e.g. link of a multiselect facet writes an item",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "click": ".advs_classes .advs_legend a"
+      }
+    ],
+    "probe": ["texts:#advstab_main .selectize-input > div[data-term]"],
+    "tags": ["advsearch", "multiselect"]
+  },
+  {
+    "name": "advs_submit_formula",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "fill": "#advs_fct_formulae",
+        "text": "Ag2O"
+      },
+      {
+        "click": "#advsearch_do_trigger",
+        "after": 1500
+      }
+    ],
+    "tags": ["advsearch", "search"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing a dialog returns the focus to the control that opened it",
+    "expect_new": {
+      "focus": "#advsearch_init_trigger"
+    }
+  },
+  {
+    "name": "advs_submit_enter",
+    "desc": "Enter in an advanced input submits (document keydown handler)",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "type": "#advs_fct_elements",
+        "text": "Ag, O"
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "tags": ["advsearch", "keyboard"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing a dialog returns the focus to the control that opened it",
+    "expect_new": {
+      "focus": "#advsearch_init_trigger"
+    }
+  },
+  {
+    "name": "advs_submit_empty",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advsearch_do_trigger"
+      }
+    ],
+    "tags": ["advsearch", "notify"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#advsearch_do_trigger"
+    }
+  },
+  {
+    "name": "advs_doi_normalized",
+    "desc": "a doi.org URL is stripped down to the DOI",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_bib]"
+      },
+      {
+        "fill": "#advs_fct_doi",
+        "text": "http://dx.doi.org/10.1103/PhysRevB.25.5150"
+      },
+      {
+        "click": "#advsearch_do_trigger",
+        "after": 1500
+      }
+    ],
+    "tags": ["advsearch", "search"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing a dialog returns the focus to the control that opened it",
+    "expect_new": {
+      "focus": "#advsearch_init_trigger"
+    }
+  },
+  {
+    "name": "advs_drop_clears",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "fill": "#advs_fct_formulae",
+        "text": "Ag2O"
+      },
+      {
+        "click": ".advs_classes .advs_legend a"
+      },
+      {
+        "click": "#advsearch_drop_trigger"
+      }
+    ],
+    "probe": [
+      "values:input.advs_input",
+      "texts:#advsbox .selectize-input > div[data-term]"
+    ],
+    "tags": ["advsearch"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#advsearch_drop_trigger"
+    }
+  },
+  {
+    "name": "advs_close_cross",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_cry div.close_advs_dialogue"
+      }
+    ],
+    "tags": ["advsearch", "mouse"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing a dialog returns the focus to the control that opened it",
+    "expect_new": {
+      "focus": "#advsearch_init_trigger"
+    }
+  },
+  {
+    "name": "advs_escape_closes",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "key": "Escape"
+      }
+    ],
+    "tags": ["advsearch", "keyboard"]
+  },
+  {
+    "name": "advs_classes_suggestions",
+    "desc": "local (wmdata) suggestions of a facet multiselect",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "type": "#advs_fct_classes-selectized",
+        "text": "ox",
+        "after": 1000
+      }
+    ],
+    "probe": [
+      "texts:#advstab_main .selectize-dropdown-content [data-selectable]",
+      "visible:#advstab_main .selectize-dropdown"
+    ],
+    "tags": ["advsearch", "multiselect"]
+  },
+  {
+    "name": "advs_classes_pick_with_keys",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "type": "#advs_fct_classes-selectized",
+        "text": "ox",
+        "after": 1000
+      },
+      {
+        "key": "ArrowDown"
+      },
+      {
+        "key": "Enter"
+      }
+    ],
+    "probe": [
+      "texts:#advstab_main .selectize-input > div[data-term]",
+      "visible:#advstab_main .selectize-dropdown"
+    ],
+    "tags": ["advsearch", "multiselect", "keyboard"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing a dialog returns the focus to the control that opened it",
+    "expect_new": {
+      "focus": "#advsearch_init_trigger"
+    }
+  },
+  {
+    "name": "advs_props_autocomplete",
+    "desc": "the simple autocomplete of the property input",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "type": "#advs_fct_props",
+        "text": "band",
+        "after": 1000
+      }
+    ],
+    "probe": [
+      "texts:div.autocomplete-suggestions .autocomplete-suggestion",
+      "visibles:div.autocomplete-suggestions"
+    ],
+    "tags": ["advsearch", "autocomplete"]
+  },
+  {
+    "name": "advs_props_autocomplete_pick",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "type": "#advs_fct_props",
+        "text": "band",
+        "after": 1000
+      },
+      {
+        "key": "ArrowDown"
+      },
+      {
+        "key": "ArrowDown"
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "probe": ["value:#advs_fct_props", "visibles:div.autocomplete-suggestions"],
+    "tags": ["advsearch", "autocomplete", "keyboard"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing a dialog returns the focus to the control that opened it",
+    "expect_new": {
+      "focus": "#advsearch_init_trigger"
+    }
+  },
+  {
+    "name": "advs_props_autocomplete_click",
+    "desc": "a property suggestion is picked with the mouse (the suggestions live in <body>, outside the dialog)",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_options li[rev=advstab_main]"
+      },
+      {
+        "type": "#advs_fct_props",
+        "text": "band",
+        "after": 1000
+      },
+      {
+        "click": "div.autocomplete-suggestions div.autocomplete-suggestion",
+        "nth": 1,
+        "after": 1500
+      }
+    ],
+    "probe": ["value:#advs_fct_props", "visibles:div.autocomplete-suggestions"],
+    "expect": {
+      "value:#advs_fct_props": {
+        "contains": "band"
+      }
+    },
+    "tags": ["advsearch", "autocomplete"]
+  },
+  {
+    "name": "advs_aet_limit",
+    "desc": "the polyhedra limit checkbox adds the matching class keyword",
+    "route": "#polyhedra",
+    "steps": [
+      {
+        "wait_for": "#all_polyhedra_content div.gallery_item"
+      },
+      {
+        "click": "#all_polyhedra_content div.gallery_item",
+        "nth": 5,
+        "after": 1500
+      },
+      {
+        "click": "#aet_limit",
+        "after": 800
+      }
+    ],
+    "probe": [
+      "checked:#aet_limit",
+      "texts:#advstab_main .selectize-input > div[data-term]"
+    ],
+    "tags": ["advsearch", "notify"]
+  },
+  {
+    "name": "polyhedra_pick",
+    "desc": "picking a polyhedron writes the aetypes item and shows the map",
+    "route": "#polyhedra",
+    "steps": [
+      {
+        "wait_for": "#all_polyhedra_content div.gallery_item"
+      },
+      {
+        "click": "#all_polyhedra_content div.gallery_item",
+        "nth": 5,
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "texts:#advstab_cry .selectize-input > div[data-term]",
+      "visible:#aetmap",
+      "visible:#advsbox"
+    ],
+    "tags": ["advsearch", "polyhedra"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): an opened dialog takes the focus",
+    "expect_new": {
+      "focus": "#advsbox"
+    }
+  },
+  {
+    "name": "interpret_click_opens_advsearch",
+    "tooltips": false,
+    "desc": "clicking an interpretation chip opens the matching advanced tab",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#interpret li"
+      },
+      {
+        "click": "#interpret li"
+      }
+    ],
+    "probe": ["visibles:div.advstab", "classes:#advstab_options li"],
+    "tags": ["advsearch", "results"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): an opened dialog takes the focus",
+    "expect_new": {
+      "focus": "#advsbox"
+    }
+  },
+  {
+    "comment": "section: modals, user box, keyboard",
+    "name": "userbox_opens_login",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "click": "#userbox",
+        "after": 1000
+      }
+    ],
+    "probe": ["visible:#loginbox"],
+    "tags": ["modal", "mouse"]
+  },
+  {
+    "name": "userbox_toggle_restores_hash",
+    "desc": "clicking the user box twice returns to the page it was opened from",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "click": "#userbox",
+        "after": 1000
+      },
+      {
+        "click": "#userbox",
+        "after": 1500
+      }
+    ],
+    "probe": ["visible:#loginbox"],
+    "tags": ["modal", "mouse"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#userbox"
+    }
+  },
+  {
+    "name": "login_escape_closes",
+    "route": "#modal/login",
+    "steps": [
+      {
+        "key": "Escape",
+        "after": 1000
+      }
+    ],
+    "probe": ["visible:#loginbox"],
+    "tags": ["modal", "keyboard"]
+  },
+  {
+    "name": "modal_restore",
+    "route": "#modal/restore",
+    "probe": ["visible:#restorebox", "visible:#loginbox"],
+    "tags": ["modal", "route"]
+  },
+  {
+    "name": "modal_factor",
+    "route": "#modal/factor",
+    "probe": ["visible:#factorbox", "visibles:#factorbox input"],
+    "tags": ["modal", "route"]
+  },
+  {
+    "name": "modal_menu_logged_out",
+    "desc": "the account menu redirects anonymous users to the login",
+    "route": "#modal/menu",
+    "probe": ["visible:#loginbox", "visible:#menubox"],
+    "tags": ["modal", "route"]
+  },
+  {
+    "name": "modal_unknown",
+    "route": "#modal/nonsense",
+    "tags": ["modal", "route", "notify"]
+  },
+  {
+    "name": "login_enter_submits",
+    "desc": "Enter in the password field submits the login form (mocked API)",
+    "route": "#modal/login",
+    "mock": [
+      {
+        "path": "/users/login",
+        "json": {
+          "error": "Wrong login or password"
+        }
+      }
+    ],
+    "steps": [
+      {
+        "fill": "#login_email",
+        "text": "someone@example.invalid"
+      },
+      {
+        "type": "#login_password",
+        "text": "secret"
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "probe": ["text:#login_trigger", "visible:#loginbox"],
+    "tags": ["modal", "keyboard", "mock"]
+  },
+  {
+    "name": "login_click_error",
+    "desc": "a refused login: notification text, button label restored (mocked API)",
+    "route": "#modal/login",
+    "mock": [
+      {
+        "path": "/users/login",
+        "json": {
+          "error": "Wrong login or password"
+        }
+      }
+    ],
+    "probe": [
+      "text:#login_trigger",
+      "visible:#loginbox",
+      "value:#login_password"
+    ],
+    "tags": ["modal", "mock"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#login_trigger"
+    },
+    "steps": [
+      {
+        "fill": "#login_email",
+        "text": "someone@example.invalid"
+      },
+      {
+        "fill": "#login_password",
+        "text": "secret"
+      },
+      {
+        "click": "#login_trigger",
+        "after": 1500
+      }
+    ]
+  },
+  {
+    "name": "login_network_error",
+    "desc": "the login request failing at network level (mocked)",
+    "route": "#modal/login",
+    "mock": [
+      {
+        "path": "/users/login",
+        "abort": true
+      }
+    ],
+    "probe": ["text:#login_trigger", "visible:#loginbox"],
+    "tags": ["modal", "mock"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#login_trigger"
+    },
+    "steps": [
+      {
+        "fill": "#login_email",
+        "text": "someone@example.invalid"
+      },
+      {
+        "fill": "#login_password",
+        "text": "secret"
+      },
+      {
+        "click": "#login_trigger",
+        "after": 1500
+      }
+    ]
+  },
+  {
+    "name": "factor_digits_advance",
+    "desc": "typing digits into the 2FA boxes moves the focus forward (mocked API)",
+    "route": "#modal/factor",
+    "mock": [
+      {
+        "path": "/users/factor",
+        "json": {
+          "error": "Wrong code"
+        }
+      }
+    ],
+    "steps": [
+      {
+        "type": "#factor_form_resp_0",
+        "text": "12"
+      }
+    ],
+    "probe": ["values:#factorbox input.factor_form_resp"],
+    "tags": ["modal", "keyboard", "mock"]
+  },
+  {
+    "name": "tooltip_shown_on_landing",
+    "desc": "the landing tooltip appears 4s after boot and is dismissed with OK",
+    "route": "#start",
+    "steps": [
+      {
+        "wait": 4500
+      },
+      {
+        "click": "#tooltip span",
+        "after": 800
+      }
+    ],
+    "probe": ["visible:#tooltip", "js:wmgui.tooltip_counter"],
+    "tags": ["tooltip", "mouse"]
+  },
+  {
+    "name": "darkmode_toggle",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#darkmode_trigger",
+        "after": 1000
+      }
+    ],
+    "probe": ["text:#darkmode_trigger", "class:body", "storage:darkmode"],
+    "pixels": "loose",
+    "tags": ["darkmode", "mouse"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#darkmode_trigger"
+    }
+  },
+  {
+    "comment": "section: hierarchy and numeric search",
+    "name": "hy_switch_tab",
+    "route": "#hierarchy",
+    "steps": [
+      {
+        "click": "#hy_options > li[rev=hy_complex]"
+      }
+    ],
+    "probe": ["visibles:div.hy_tabs", "classes:#hy_options > li"],
+    "tags": ["hierarchy"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#hy_options > li.working"
+    }
+  },
+  {
+    "name": "hy_expand",
+    "desc": "expand toggles the nested lists (jQuery .toggle(): restores style=\"\")",
+    "route": "#hierarchy",
+    "steps": [
+      {
+        "click": "#hy_scalars li > span"
+      }
+    ],
+    "probe": ["texts:#hy_scalars li > span", "nvisible:#hy_scalars ul ul"],
+    "tags": ["hierarchy"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#hy_scalars > ul > li > span.hy1"
+    }
+  },
+  {
+    "name": "hy_dynprop",
+    "desc": "clicking a property in the hierarchy searches for it",
+    "route": "#hierarchy",
+    "steps": [
+      {
+        "click": "#hy_scalars a.dynprop",
+        "after": 1500
+      }
+    ],
+    "tags": ["hierarchy", "search"]
+  },
+  {
+    "name": "hy_numeric_slider",
+    "desc": "a numeric property opens a slider block in the numeric box",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=alat]",
+        "after": 1000
+      }
+    ],
+    "probe": [
+      "visible:#numericbox",
+      "count:#numericbox div.slider_numerics",
+      "texts:#numericbox div.slider_numerics",
+      "html:#numericbox ul"
+    ],
+    "tags": ["advsearch", "numeric", "slider"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#crtab > div > strong.numeric"
+    }
+  },
+  {
+    "name": "hy_numeric_three_sliders_warns",
+    "desc": "a third numeric block warns 'expect no results'",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=alat]",
+        "after": 600
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=blat]",
+        "after": 600
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=clat]",
+        "after": 600
+      }
+    ],
+    "probe": ["count:#numericbox div.slider_numerics"],
+    "tags": ["advsearch", "numeric", "notify"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#crtab > div > strong.numeric"
+    }
+  },
+  {
+    "name": "numeric_submit",
+    "desc": "submitting the numeric box serializes the slider into the inquiry",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=alat]",
+        "after": 1000
+      },
+      {
+        "click": "#numericbox_do_trigger",
+        "after": 2000
+      }
+    ],
+    "tags": ["numeric", "search"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#numericbox_do_trigger"
+    }
+  },
+  {
+    "name": "numeric_drop",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=alat]",
+        "after": 1000
+      },
+      {
+        "click": "#numericbox_drop_trigger",
+        "after": 1000
+      }
+    ],
+    "probe": ["visible:#numericbox", "count:#numericbox div.slider_numerics"],
+    "tags": ["numeric"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#numericbox_drop_trigger"
+    }
+  },
+  {
+    "name": "numeric_close",
+    "route": "#start",
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=alat]",
+        "after": 1000
+      },
+      {
+        "click": "#close_numericbox",
+        "after": 1000
+      }
+    ],
+    "probe": ["visible:#numericbox", "count:#numericbox div.slider_numerics"],
+    "tags": ["numeric"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing the sliders returns the focus to the numeric control that opened them",
+    "expect_new": {
+      "focus": "#crtab > div > strong.numeric"
+    }
+  },
+  {
+    "name": "numeric_route_slider_values",
+    "desc": "a numeric route restores the slider handles and their labels",
+    "route": "#inquiry/numeric=volume%2C%3E%2C3000%3B",
+    "probe": [
+      "html:#numericbox ul",
+      "texts:#numericbox .noUi-tooltip",
+      "attrs:#numericbox .noUi-handle@aria-valuenow"
+    ],
+    "tags": ["numeric", "slider", "route"]
+  },
+  {
+    "name": "numeric_remove_item_closes_box",
+    "desc": "removing the numeric item from the search box destroys the numeric box",
+    "route": "#inquiry/numeric=volume%2C%3E%2C3000%3B",
+    "steps": [
+      {
+        "click": "#search_holder .selectize-input > div[data-term] a.remove",
+        "after": 1200
+      }
+    ],
+    "probe": ["visible:#numericbox", "count:#numericbox div.slider_numerics"],
+    "tags": ["numeric", "multiselect"]
+  },
+  {
+    "comment": "section: results pages",
+    "name": "refine_expand_collapse",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#refine_col a.extd_refine"
+      },
+      {
+        "click": "#refine_col a.extd_refine",
+        "after": 1500
+      },
+      {
+        "wait_for": "#refine_col a.collapse_refine"
+      },
+      {
+        "click": "#refine_col a.collapse_refine",
+        "after": 800
+      }
+    ],
+    "probe": ["nvisible:#refine_col li", "texts:#refine_col li a"],
+    "tags": ["results", "refine"]
+  },
+  {
+    "name": "refine_link_click",
+    "desc": "a refinement link narrows the search",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#refine_col li.fct_elements a"
+      },
+      {
+        "click": "#refine_col li.fct_elements a",
+        "after": 1500
+      }
+    ],
+    "tags": ["results", "refine"]
+  },
+  {
+    "name": "control_phases",
+    "tooltips": false,
+    "desc": "the 'phases' switch keeps the inquiry and changes the view",
+    "route": "#inquiry/elements=Ag-O&classes=oxide",
+    "steps": [
+      {
+        "wait_for": "#control_b"
+      },
+      {
+        "click": "#control_b",
+        "after": 1500
+      }
+    ],
+    "probe": ["classes:div.controlswitch > div"],
+    "tags": ["results", "controls"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#control_b"
+    }
+  },
+  {
+    "name": "control_articles",
+    "tooltips": false,
+    "route": "#inquiry/elements=Ag-O&classes=oxide",
+    "steps": [
+      {
+        "wait_for": "#control_f"
+      },
+      {
+        "click": "#control_f",
+        "after": 1500
+      }
+    ],
+    "probe": ["classes:div.controlswitch > div"],
+    "tags": ["results", "controls"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#control_f"
+    }
+  },
+  {
+    "name": "control_table_to_previews",
+    "tooltips": false,
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#control_d"
+      },
+      {
+        "click": "#control_d",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "classes:div.controlswitch > div",
+      "count:#databrowser div.gallery_item",
+      "count:#databrowser tr.tcell"
+    ],
+    "tags": ["results", "controls"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#control_d"
+    }
+  },
+  {
+    "name": "control_previews_to_table",
+    "tooltips": false,
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#control_c"
+      },
+      {
+        "click": "#control_c",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "classes:div.controlswitch > div",
+      "count:#databrowser div.gallery_item",
+      "count:#databrowser tr.tcell"
+    ],
+    "tags": ["results", "controls"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#control_c"
+    }
+  },
+  {
+    "name": "control_plots",
+    "tooltips": false,
+    "desc": "the 'plots' switch picks a (seeded) random plot type",
+    "route": "#inquiry/elements=Ag-O&classes=oxide",
+    "steps": [
+      {
+        "wait_for": "#control_e"
+      },
+      {
+        "click": "#control_e",
+        "after": 2500
+      }
+    ],
+    "pixels": "loose",
+    "tags": ["results", "controls", "plot"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#control_e"
+    }
+  },
+  {
+    "name": "dtypes_click",
+    "tooltips": false,
+    "desc": "a data-type link augments the current search",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#dtypes li"
+      },
+      {
+        "click": "#dtypes li[data-term='phase diagram']",
+        "after": 1500
+      }
+    ],
+    "tags": ["results"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#dtypes > ul > li.dtypes_props.fct_props"
+    }
+  },
+  {
+    "name": "dtypes_class_replaces_class",
+    "tooltips": false,
+    "desc": "peer-reviewed / machine-learning / ab initio are mutually exclusive",
+    "route": "#inquiry/elements=Ag-O&classes=machine-learning",
+    "steps": [
+      {
+        "wait_for": "#dtypes li"
+      },
+      {
+        "click": "#dtypes li[data-term='peer-reviewed']",
+        "after": 1500
+      }
+    ],
+    "tags": ["results"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#dtypes > ul > li.dtypes_classes.fct_classes"
+    }
+  },
+  {
+    "name": "phases_show_entries_link",
+    "tooltips": false,
+    "route": "#inquiry_phases/elements=Ag-O&classes=oxide",
+    "steps": [
+      {
+        "wait_for": "#databrowser a.launch_id"
+      },
+      {
+        "click": "#databrowser a.launch_id",
+        "after": 2000
+      }
+    ],
+    "tags": ["results", "phases"]
+  },
+  {
+    "name": "phases_strict_uncheck",
+    "tooltips": false,
+    "desc": "unchecking 'include phases commonly reported together' re-requests with strict",
+    "route": "#inquiry_phases/elements=Ag-O&classes=oxide",
+    "steps": [
+      {
+        "wait_for": "#databrowser div.gallery_item"
+      },
+      {
+        "click": "#ctx_strict_phases_trigger",
+        "after": 2000
+      }
+    ],
+    "probe": [
+      "checked:#ctx_strict_phases_trigger",
+      "js:wmgui.ctx_strict_phases"
+    ],
+    "tags": ["results", "phases"]
+  },
+  {
+    "name": "ref_mousedown_marks_visited",
+    "desc": "pressing a reference link marks all its occurrences visited and stores the bid",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser a.resolve_ref"
+      },
+      {
+        "mousedown": "#databrowser a.resolve_ref"
+      }
+    ],
+    "probe": ["classes:#databrowser a.resolve_ref", "storage:bid_history"],
+    "tags": ["results"]
+  },
+  {
+    "name": "visited_refs_restored",
+    "desc": "references stored as visited are marked on load",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "storage": {
+      "bid_history": "[84283, 7814]"
+    },
+    "probe": ["classes:#databrowser a.resolve_ref"],
+    "tags": ["results", "storage"]
+  },
+  {
+    "name": "entry_show_button",
+    "tooltips": false,
+    "desc": "the row 'Show' button opens the context column with the visualization",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser span.launch_v"
+      },
+      {
+        "click": "#databrowser span.launch_v",
+        "after": 3000
+      }
+    ],
+    "probe": [
+      "visible:#ctx_col",
+      "visible:#visavis_col",
+      "classes:#databrowser tr.tcell"
+    ],
+    "pixels": "loose",
+    "tags": ["results", "context"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#e__S311308 > td.cp > span.launch_v"
+    }
+  },
+  {
+    "name": "entry_ctx_close",
+    "tooltips": false,
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell",
+        "after": 2000
+      },
+      {
+        "click": "#ctx_col div.cross",
+        "after": 800
+      }
+    ],
+    "probe": [
+      "visible:#ctx_col",
+      "visible:#sim_col",
+      "classes:#databrowser tr.tcell"
+    ],
+    "tags": ["results", "context"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#e__S311308"
+    }
+  },
+  {
+    "name": "entry_ctx_second_row",
+    "tooltips": false,
+    "desc": "opening another row moves the active highlight",
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell",
+        "after": 2000
+      },
+      {
+        "click": "#databrowser tr.tcell",
+        "nth": 2,
+        "after": 2000
+      }
+    ],
+    "probe": ["classes:#databrowser tr.tcell", "text:#entryno"],
+    "tags": ["results", "context"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#e__S530743"
+    }
+  },
+  {
+    "name": "thumb_click_context",
+    "tooltips": false,
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#databrowser div.gallery_item"
+      },
+      {
+        "click": "#databrowser div.gallery_item",
+        "nth": 1,
+        "after": 2000
+      }
+    ],
+    "probe": ["visible:#ctx_col", "classes:#databrowser div.gallery_item"],
+    "tags": ["results", "context"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#e__S1832060"
+    },
+    "pixels": "loose",
+    "desc": "text rasterization only: the ctx_col/sim_col glyphs render with grayscale AA in one capture and LCD-subpixel AA in the other (0 pixels differ at channel tolerance 40, the DOM/probes/API are identical and live behavior was verified identical); a Chrome compositing-path artifact, not an app difference"
+  },
+  {
+    "name": "infinite_scroll",
+    "desc": "scrolling to the bottom of a long result list fetches the next page",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#databrowser div.gallery_item"
+      },
+      {
+        "scroll_y": 100000,
+        "after": 2500
+      }
+    ],
+    "probe": [
+      "count:#databrowser div.gallery_item",
+      "js:wmgui.unfinished_page"
+    ],
+    "viewport": [1280, 900],
+    "pixels": "off",
+    "tags": ["results", "scroll"]
+  },
+  {
+    "name": "phase_id_rankfilter",
+    "desc": "the phase data-type filters toggle on and off",
+    "route": "#phase_id/{phid}",
+    "steps": [
+      {
+        "wait_for": "#dtypes_phid li"
+      },
+      {
+        "click": "#dtypes_phid li",
+        "after": 2000
+      },
+      {
+        "click": "#dtypes_phid li",
+        "after": 2000
+      }
+    ],
+    "probe": ["classes:#dtypes_phid li"],
+    "tags": ["results", "phases"],
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#dtypes_phid > ul > li.dtypes_props.fct_props"
+    }
+  },
+  {
+    "name": "sim_col_click",
+    "desc": "a 'see also' link of an opened entry",
+    "tooltips": false,
+    "route": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell",
+        "after": 2000
+      },
+      {
+        "wait_for": "#sim_col > ul > li > a"
+      },
+      {
+        "click": "#sim_col > ul > li > a",
+        "after": 2000
+      }
+    ],
+    "probe": ["classes:#sim_col > ul > li"],
+    "tags": ["results", "interlinkage"]
+  },
+  {
+    "comment": "section: routing edge cases",
+    "name": "route_unknown",
+    "route": "#nonsense/abc",
+    "tags": ["route", "notify"]
+  },
+  {
+    "name": "route_search_empty",
+    "route": "#search/",
+    "tags": ["route"]
+  },
+  {
+    "name": "route_search_unicode",
+    "desc": "subscripts, en dashes and spaces in a free-text search",
+    "route": "#search/TiH%E2%82%82%20phase%20transitions",
+    "tags": ["route"]
+  },
+  {
+    "name": "route_search_garbage",
+    "route": "#search/qqqzzzxxx",
+    "tags": ["route", "notify"]
+  },
+  {
+    "name": "route_inquiry_unknown_facet",
+    "route": "#inquiry/foo=bar",
+    "tags": ["route"]
+  },
+  {
+    "name": "route_inquiry_entries",
+    "route": "#inquiry_entries/elements=Ag-O&classes=oxide",
+    "tags": ["route"]
+  },
+  {
+    "name": "route_phase_triplet",
+    "route": "#phase/Ag2O/224/cP6",
+    "tags": ["route"]
+  },
+  {
+    "name": "route_entry_unknown",
+    "route": "#entry/S0000000",
+    "tags": ["route", "notify"]
+  },
+  {
+    "name": "route_plot_graph",
+    "route": "#plot/graph/inquiry/elements=Ag-O",
+    "pixels": "loose",
+    "settle": 6000,
+    "tags": ["route", "plot"]
+  },
+  {
+    "name": "route_plot_matrix",
+    "route": "#plot/matrix/inquiry/elements=Ag-O",
+    "pixels": "loose",
+    "settle": 6000,
+    "tags": ["route", "plot"]
+  },
+  {
+    "name": "route_junction_anon",
+    "desc": "the junction page redirects anonymous users",
+    "route": "#junction",
+    "tags": ["route"]
+  },
+  {
+    "name": "route_access_mocked",
+    "desc": "a secret access link (mocked API refusal)",
+    "route": "#access/0123456789abcdef",
+    "mock": [
+      {
+        "path": "/users/access",
+        "json": {
+          "error": "This link is expired"
+        }
+      }
+    ],
+    "tags": ["route", "mock"]
+  },
+  {
+    "name": "route_ratify_mocked",
+    "route": "#ratify/0123456789abcdef",
+    "mock": [
+      {
+        "path": "/users/ratify",
+        "json": {
+          "error": "This link is expired"
+        }
+      }
+    ],
+    "tags": ["route", "mock"]
+  },
+  {
+    "name": "nav_back",
+    "desc": "browser Back after an in-app search restores the previous view",
+    "route": "#search/Ag-O",
+    "steps": [
+      {
+        "wait_for": "#databrowser div.gallery_item"
+      },
+      {
+        "hash": "#search/Cu-Zn",
+        "after": 2500
+      },
+      {
+        "back": true,
+        "after": 2500
+      }
+    ],
+    "tags": ["route", "history"]
+  },
+  {
+    "name": "nav_hash_from_landing",
+    "route": "#start",
+    "steps": [
+      {
+        "hash": "#inquiry/formulae=Ag2O&props=crystal%20structure",
+        "after": 2500
+      }
+    ],
+    "tags": ["route"]
+  },
+  {
+    "comment": "section: persisted state (localStorage presets)",
+    "name": "history_restored",
+    "desc": "the 'last searches' box is built from the stored log",
+    "route": "#search/Ag-O",
+    "storage": {
+      "wm_search_log_v5": "[{\"elements\":\"Cu-Zn\"},{\"formulae\":\"Ag2O\",\"props\":\"crystal structure\"},{\"classes\":\"oxide\",\"elements\":\"Ti-O\"}]"
+    },
+    "probe": ["texts:#history li", "attrs:#history li a@href"],
+    "tags": ["storage", "history"]
+  },
+  {
+    "name": "history_dedup_and_cap",
+    "desc": "a repeated search is not logged twice; the log stays capped",
+    "route": "#search/Cu-Zn",
+    "storage": {
+      "wm_search_log_v5": "[{\"elements\":\"Cu-Zn\"},{\"elements\":\"A-B\"},{\"elements\":\"C-D\"},{\"elements\":\"E-F\"},{\"elements\":\"G-H\"},{\"elements\":\"I-J\"},{\"elements\":\"K-L\"},{\"elements\":\"M-N\"},{\"elements\":\"O-P\"}]"
+    },
+    "probe": ["texts:#history li", "storage:wm_search_log_v5"],
+    "tags": ["storage", "history"]
+  },
+  {
+    "name": "history_suppresses_tooltip",
+    "desc": "returning users (stored history) do not get the landing tooltip",
+    "route": "#start",
+    "storage": {
+      "wm_search_log_v5": "[{\"elements\":\"Cu-Zn\"},{\"elements\":\"Ag-O\"}]"
+    },
+    "steps": [
+      {
+        "wait": 5000
+      }
+    ],
+    "probe": ["visible:#tooltip", "js:wmgui.tooltip_counter"],
+    "tags": ["storage", "tooltip"]
+  },
+  {
+    "name": "darkmode_restored",
+    "route": "#start",
+    "storage": {
+      "darkmode": "true"
+    },
+    "probe": ["text:#darkmode_trigger", "class:body"],
+    "pixels": "loose",
+    "tags": ["storage", "darkmode"]
+  },
+  {
+    "comment": "section: API failure paths (mocked)",
+    "name": "api_search_error_message",
+    "desc": "a search answered with an error object",
+    "route": "#inquiry/elements=Ag-O",
+    "mock": [
+      {
+        "path": "/search/facet",
+        "json": {
+          "error": "Sorry, the search is too broad"
+        }
+      }
+    ],
+    "tags": ["mock", "notify"]
+  },
+  {
+    "name": "api_search_unreachable",
+    "desc": "the search endpoint down: 'connection lost' handling",
+    "route": "#inquiry/elements=Ag-O",
+    "mock": [
+      {
+        "path": "/search/facet",
+        "abort": true
+      }
+    ],
+    "tags": ["mock", "notify"]
+  },
+  {
+    "name": "api_search_http_500",
+    "route": "#inquiry/elements=Ag-O",
+    "mock": [
+      {
+        "path": "/search/facet",
+        "status": 500,
+        "body": "Internal Server Error"
+      }
+    ],
+    "tags": ["mock", "notify"]
+  },
+  {
+    "name": "api_search_empty",
+    "desc": "zero results",
+    "route": "#inquiry/elements=Ag-O",
+    "mock": [
+      {
+        "path": "/search/facet",
+        "json": {
+          "out": [],
+          "total_count": 0,
+          "error": false
+        }
+      }
+    ],
+    "tags": ["mock"]
+  },
+  {
+    "name": "api_autocomplete_down",
+    "desc": "typing while the suggestion endpoint is down",
+    "route": "#start",
+    "mock": [
+      {
+        "path": "/search/selectize",
+        "abort": true
+      }
+    ],
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Ag",
+        "after": 1500
+      }
+    ],
+    "tags": ["mock", "multiselect"]
+  },
+  {
+    "comment": "section: absolute expectations (`expect`: checked on EACH side, not only old vs new)",
+    "name": "search_ru_am_has_hits",
+    "desc": "Ru and Am together do have hits (8 entries as recorded on 2026-10-23)",
+    "route": "#search/Ru-Am",
+    "probe": ["texts:#search_holder .selectize-input > div[data-term]"],
+    "expect": {
+      "count:#databrowser tr.tcell, #databrowser div.gallery_item": {
+        "gt": 0
+      },
+      "title": {
+        "matches": "^\\d+ results?$"
+      }
+    },
+    "tags": ["search", "expect"]
+  },
+  {
+    "comment": "settle: NB the notification hides 4 s after it appears",
+    "name": "search_am_ru_binary_similar",
+    "desc": "free text 'Am Ru binary': no exact binary Am-Ru, the server's 'similar data shown' notice is displayed",
+    "route": "#start",
+    "steps": [
+      {
+        "type": "#search_field-selectized",
+        "text": "Am Ru binary",
+        "after": 300
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "settle": 1000,
+    "tags": ["search", "notify", "expect"],
+    "expect": {
+      "text:#notifybox": {
+        "contains": "similar data shown"
+      },
+      "visible:#notifybox": true,
+      "hash": "#inquiry/elements=Am-Ru&classes=binary"
+    }
+  },
+  {
+    "comment": "section: entry context: the \"See also\" column (#sim_col) and closing panels by ESC",
+    "name": "sim_col_property_entry",
+    "desc": "clicking a property entry fills 'See also' with similar values of that property \u2014 text rasterization only: the ctx_col/sim_col glyphs render with grayscale AA in one capture and LCD-subpixel AA in the other (0 pixels differ at channel tolerance 40, the DOM/probes/API are identical and live behavior was verified identical); a Chrome compositing-path artifact, not an app difference",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell[id*='P']",
+        "after": 2500
+      }
+    ],
+    "probe": [
+      "visible:#sim_col",
+      "text:#sim_legend",
+      "texts:#sim_col > ul li",
+      "attrs:#sim_col > ul a@href",
+      "visible:#own_phase",
+      "visible:#ctx_col"
+    ],
+    "tags": ["context", "sim"],
+    "expect": {
+      "text:#sim_legend": {
+        "contains": "Similar"
+      },
+      "count:#sim_col > ul li": {
+        "gt": 0
+      }
+    },
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#e__P601158-1"
+    },
+    "pixels": "loose"
+  },
+  {
+    "name": "sim_col_property_entry_thumbs",
+    "desc": "the same in the thumbnail view (the property name is read from the selected thumbnail) \u2014 text rasterization only: the ctx_col/sim_col glyphs render with grayscale AA in one capture and LCD-subpixel AA in the other (0 pixels differ at channel tolerance 40, the DOM/probes/API are identical and live behavior was verified identical); a Chrome compositing-path artifact, not an app difference",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#control_d",
+        "after": 3000
+      },
+      {
+        "wait_for": "#databrowser div.gallery_item"
+      },
+      {
+        "click": "#databrowser div.gallery_item[id*='P'] div.gallery_img",
+        "after": 2500
+      }
+    ],
+    "probe": [
+      "visible:#sim_col",
+      "text:#sim_legend",
+      "texts:#sim_col > ul li",
+      "attrs:#sim_col > ul a@href",
+      "visible:#own_phase"
+    ],
+    "tags": ["context", "sim", "thumbs"],
+    "expect": {
+      "text:#sim_legend": {
+        "contains": "Similar"
+      },
+      "count:#sim_col > ul li": {
+        "gt": 0
+      }
+    },
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked control is focusable now and keeps the focus, like a native button",
+    "expect_new": {
+      "focus": "#e__P601158-1"
+    },
+    "pixels": "loose"
+  },
+  {
+    "name": "esc_closes_entry_columns",
+    "desc": "ESC closes the entry and 'See also' columns of a selected entry",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell[id*='P']",
+        "after": 2500
+      },
+      {
+        "key": "Escape",
+        "after": 800
+      }
+    ],
+    "probe": [
+      "visible:#ctx_col",
+      "visible:#sim_col",
+      "count:#databrowser .busy_entry"
+    ],
+    "tags": ["context", "keyboard"],
+    "expect": {
+      "visible:#ctx_col": false,
+      "visible:#sim_col": false
+    },
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the clicked row keeps the focus; after ESC (keyboard modality) it shows its focus ring (0.12% of the pixels)",
+    "expect_new": {
+      "focus": "#e__P601158-1"
+    },
+    "pixel_threshold": 0.0015
+  },
+  {
+    "name": "esc_closes_all_visible_panels",
+    "desc": "ESC clicks every visible close-cross at once (entry columns, advanced search, numeric box), like $('div.cross:visible').trigger('click')",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell[id*='P']",
+        "after": 2500
+      },
+      {
+        "click": "#advsearch_init_trigger"
+      },
+      {
+        "click": "#advstab_cry strong.numeric[rel=alat]",
+        "after": 1000
+      },
+      {
+        "key": "Escape",
+        "after": 1500
+      }
+    ],
+    "probe": [
+      "visible:#ctx_col",
+      "visible:#sim_col",
+      "visible:#numericbox",
+      "nvisible:div.cross",
+      "hash"
+    ],
+    "tags": ["context", "keyboard", "numeric", "advsearch"],
+    "expect": {
+      "visible:#ctx_col": false,
+      "visible:#numericbox": false,
+      "nvisible:div.cross": 0
+    },
+    "approved": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): closing a dialog returns the focus to the control that opened it",
+    "expect_new": {
+      "focus": "#advsearch_init_trigger"
+    }
+  },
+  {
+    "name": "a11y_audit_start",
+    "desc": "start page: every control keyboard-reachable",
+    "route": "#start",
+    "tooltips": false,
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0
+    },
+    "comment": "section: accessibility (VPAT 2.1.1 Keyboard, 1.4.4 Resize Text): window.__a11y() is the audit in parity/harness.js; every scenario is an approved change pinned with expect_new"
+  },
+  {
+    "name": "a11y_audit_results",
+    "desc": "results (table): every control keyboard-reachable",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0
+    }
+  },
+  {
+    "name": "a11y_audit_entry_selected",
+    "desc": "entry selected: Entry and See also columns keyboard-reachable",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell[id*='P']",
+        "after": 2500
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0,
+      "js:window.__a11y().unreachable_total": 0
+    }
+  },
+  {
+    "name": "a11y_audit_phases",
+    "desc": "phases (thumbnails): every control keyboard-reachable",
+    "route": "#inquiry_phases/elements=Ag-O&classes=oxide",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser div.gallery_item"
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0
+    }
+  },
+  {
+    "name": "a11y_audit_advsearch",
+    "desc": "advanced search: focus inside, the page behind inert",
+    "route": "#start",
+    "tooltips": false,
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger",
+        "after": 1000
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0,
+      "js:window.__a11y().focusable_outside_modal": 0,
+      "js:document.getElementById('advsbox').contains(document.activeElement)": true
+    }
+  },
+  {
+    "name": "a11y_audit_hierarchy",
+    "desc": "properties hierarchy: focus inside, the page behind inert",
+    "route": "#hierarchy",
+    "tooltips": false,
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0,
+      "js:window.__a11y().focusable_outside_modal": 0,
+      "js:document.getElementById('hy_box').contains(document.activeElement)": true
+    }
+  },
+  {
+    "name": "a11y_audit_login",
+    "desc": "login dialog: focus inside, the page behind inert",
+    "route": "#modal/login",
+    "tooltips": false,
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0,
+      "js:window.__a11y().focusable_outside_modal": 0,
+      "js:document.activeElement && (document.activeElement.id || document.activeElement.getAttribute('aria-label') || document.activeElement.className)": "login_email"
+    }
+  },
+  {
+    "name": "a11y_audit_polyhedra",
+    "desc": "polyhedra dialog: thumbnails keyboard-reachable, the page behind inert",
+    "route": "#polyhedra",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#all_polyhedra_content div.gallery_item"
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__a11y().mouse_only_total": 0,
+      "js:window.__a11y().focusable_outside_modal": 0
+    }
+  },
+  {
+    "name": "a11y_zoom150_start",
+    "desc": "150% zoom: the whole periodic table can be scrolled to",
+    "route": "#start",
+    "tooltips": false,
+    "viewport": [853, 533],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 150% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0,
+      "js:document.getElementById('ptable_holder').getBoundingClientRect().left": {
+        "ge": 0
+      }
+    }
+  },
+  {
+    "name": "a11y_zoom150_results",
+    "desc": "150% zoom: grid, filters and side columns reachable",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "viewport": [853, 533],
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 150% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0
+    }
+  },
+  {
+    "name": "a11y_zoom150_entry",
+    "desc": "150% zoom: Entry and See also reachable, close crosses visible",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "viewport": [853, 533],
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell[id*='P']",
+        "after": 2500
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 150% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0
+    }
+  },
+  {
+    "name": "a11y_zoom150_advsearch",
+    "desc": "150% zoom: the advanced search box fits or scrolls",
+    "route": "#start",
+    "tooltips": false,
+    "viewport": [853, 533],
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger",
+        "after": 1000
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 150% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0,
+      "js:window.__a11y().focusable_outside_modal": 0
+    }
+  },
+  {
+    "name": "a11y_zoom150_hierarchy",
+    "desc": "150% zoom: the properties hierarchy dialog stays in the window, its items are not cut",
+    "route": "#hierarchy",
+    "viewport": [853, 533],
+    "tooltips": false,
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 150% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0
+    }
+  },
+  {
+    "name": "a11y_zoom200_start",
+    "desc": "200% zoom (WCAG 1.4.4): the whole periodic table can be scrolled to",
+    "route": "#start",
+    "tooltips": false,
+    "viewport": [640, 400],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 200% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0,
+      "js:document.getElementById('ptable_holder').getBoundingClientRect().left": {
+        "ge": 0
+      }
+    }
+  },
+  {
+    "name": "a11y_zoom200_results",
+    "desc": "200% zoom (WCAG 1.4.4): grid, filters and side columns reachable",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "viewport": [640, 400],
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 200% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0
+    }
+  },
+  {
+    "name": "a11y_zoom200_entry",
+    "desc": "200% zoom (WCAG 1.4.4): Entry and See also reachable, close crosses visible",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "viewport": [640, 400],
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "click": "#databrowser tr.tcell[id*='P']",
+        "after": 2500
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 200% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0
+    }
+  },
+  {
+    "name": "a11y_zoom200_advsearch",
+    "desc": "200% zoom (WCAG 1.4.4): the advanced search box fits or scrolls",
+    "route": "#start",
+    "tooltips": false,
+    "viewport": [640, 400],
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger",
+        "after": 1000
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 200% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0,
+      "js:window.__a11y().focusable_outside_modal": 0
+    }
+  },
+  {
+    "name": "a11y_zoom200_hierarchy",
+    "desc": "200% zoom (WCAG 1.4.4): the properties hierarchy dialog stays in the window, its items are not cut",
+    "route": "#hierarchy",
+    "viewport": [640, 400],
+    "tooltips": false,
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 1.4.4 Resize Text): at 200% the deployed layout cuts content off",
+    "expect_new": {
+      "js:window.__a11y().unreachable_total": 0
+    }
+  },
+  {
+    "name": "a11y_view_control_enter",
+    "desc": "a VIEW control is operated with Enter",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "focus": "#control_b"
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "hash": {
+        "matches": "^#inquiry_phases/"
+      },
+      "js:document.getElementById('control_b').getAttribute('role')": "radio"
+    }
+  },
+  {
+    "name": "a11y_ptable_arrows",
+    "desc": "periodic table: ArrowDown from H reaches Li, Enter selects it",
+    "route": "#start",
+    "tooltips": false,
+    "steps": [
+      {
+        "focus": "#ptable_area li[data-pos='1']"
+      },
+      {
+        "key": "ArrowDown"
+      },
+      {
+        "key": "Enter",
+        "after": 1500
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:document.activeElement && (document.activeElement.id || document.activeElement.getAttribute('aria-label') || document.activeElement.className)": {
+        "contains": "Lithium"
+      },
+      "js:document.activeElement.getAttribute('aria-pressed')": "true",
+      "js:document.querySelectorAll('#ptable_area li[tabindex=\"0\"]').length": 1
+    }
+  },
+  {
+    "name": "a11y_dialog_round_trip",
+    "desc": "advanced search by keyboard: focus moves in, stays in on Tab, ESC returns it",
+    "route": "#start",
+    "tooltips": false,
+    "steps": [
+      {
+        "focus": "#advsearch_init_trigger"
+      },
+      {
+        "key": "Enter",
+        "after": 1000
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "key": "Tab"
+      },
+      {
+        "eval": "window.__in_dialog = document.getElementById('advsbox').contains(document.activeElement)"
+      },
+      {
+        "key": "Escape",
+        "after": 1000
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__in_dialog": true,
+      "js:document.activeElement && (document.activeElement.id || document.activeElement.getAttribute('aria-label') || document.activeElement.className)": "advsearch_init_trigger",
+      "visible:#advsbox": false
+    }
+  },
+  {
+    "name": "a11y_advsearch_tabs",
+    "desc": "advanced search tabs: arrows move between tabs, Enter opens one",
+    "route": "#start",
+    "tooltips": false,
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger",
+        "after": 1000
+      },
+      {
+        "focus": "#advstab_options li[rev=advstab_cry]"
+      },
+      {
+        "key": "ArrowLeft"
+      },
+      {
+        "key": "Enter",
+        "after": 800
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:document.querySelector('#advstab_options li[rev=advstab_bib]').getAttribute('aria-selected')": "true",
+      "visible:#advstab_bib": true,
+      "js:document.activeElement && (document.activeElement.id || document.activeElement.getAttribute('aria-label') || document.activeElement.className)": {
+        "contains": "working"
+      }
+    }
+  },
+  {
+    "name": "a11y_results_row_context",
+    "desc": "results: arrows move between rows, Enter opens the entry and focuses it, ESC returns to the row",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "focus": "#databrowser tr.tcell[tabindex='0']"
+      },
+      {
+        "key": "ArrowDown"
+      },
+      {
+        "key": "Enter",
+        "after": 2500
+      },
+      {
+        "eval": "window.__ctx_focus = !!document.activeElement.closest('#ctx_col')"
+      },
+      {
+        "key": "Escape",
+        "after": 1000
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__ctx_focus": true,
+      "visible:#ctx_col": false,
+      "js:document.activeElement.matches('#databrowser tr.tcell')": true,
+      "js:Array.prototype.indexOf.call(document.querySelectorAll('#databrowser tr.tcell'), document.activeElement)": 1
+    }
+  },
+  {
+    "name": "a11y_hierarchy_expand",
+    "desc": "properties hierarchy: an expand control works with Enter and reports its state",
+    "route": "#hierarchy",
+    "tooltips": false,
+    "steps": [
+      {
+        "focus": "#hy_box span[class^='hy']"
+      },
+      {
+        "key": "Enter",
+        "after": 800
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:document.activeElement.getAttribute('aria-expanded')": "true",
+      "js:document.activeElement && (document.activeElement.id || document.activeElement.getAttribute('aria-label') || document.activeElement.className)": {
+        "matches": "^hy"
+      }
+    }
+  },
+  {
+    "name": "a11y_numeric_open_close",
+    "desc": "advanced search: a numeric control opens a slider by keyboard; its close cross closes it and focus returns to the control",
+    "route": "#start",
+    "tooltips": false,
+    "steps": [
+      {
+        "click": "#advsearch_init_trigger",
+        "after": 1000
+      },
+      {
+        "focus": "#advstab_cry strong.numeric[rel=alat]"
+      },
+      {
+        "key": "Enter",
+        "after": 1000
+      },
+      {
+        "eval": "window.__slider = !!document.querySelector('#numericbox .noUi-handle[aria-label]')"
+      },
+      {
+        "focus": "#close_numericbox"
+      },
+      {
+        "key": "Enter",
+        "after": 800
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__slider": true,
+      "visible:#numericbox": false,
+      "js:document.activeElement.matches('strong.numeric[rel=alat]')": true
+    }
+  },
+  {
+    "name": "a11y_userbox_enter",
+    "desc": "the upper-right menu opens the login dialog by keyboard; ESC returns to it",
+    "route": "#start",
+    "tooltips": false,
+    "steps": [
+      {
+        "focus": "#userbox"
+      },
+      {
+        "key": "Enter",
+        "after": 1000
+      },
+      {
+        "eval": "window.__login = document.activeElement.id"
+      },
+      {
+        "key": "Escape",
+        "after": 1000
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:window.__login": "login_email",
+      "js:document.activeElement && (document.activeElement.id || document.activeElement.getAttribute('aria-label') || document.activeElement.className)": "userbox"
+    }
+  },
+  {
+    "name": "a11y_skip_to_results",
+    "desc": "the skip control moves focus into the results",
+    "route": "#inquiry/formulae=TiO2&props=band%20gap",
+    "tooltips": false,
+    "steps": [
+      {
+        "wait_for": "#databrowser tr.tcell"
+      },
+      {
+        "focus": "#a11y_skip"
+      },
+      {
+        "key": "Enter",
+        "after": 500
+      }
+    ],
+    "tags": ["a11y"],
+    "xfail": "APPROVED CHANGE (VPAT 2.1.1 Keyboard): the deployed GUI has mouse-only controls and dialogs that do not manage focus",
+    "expect_new": {
+      "js:!!document.activeElement.closest('#databrowser')": true
+    }
+  },
+  {
+    "comment": [
+      "section: QA: result counts (78 facet searches from a QA list, re-recorded from the live API on 2026-10-24: the original qa.json counts were outdated)",
+      "Each case is an inquiry route; the count is the one the GUI reports in the page title (\"[At least ]N result(s)\", the API estimated_count). The checks are loose so that growing data keeps them green:",
+      "- nonzero cases expect at least the recorded count (ge);",
+      "- cases that hit the server's fuzzy fallback also expect its \"similar data shown\" notice;",
+      "- zero cases expect 0 plus their notice (\"No hits\" / \"Unrecognized property\"), so a page that failed to load cannot pass as 0.",
+      "The desc keeps the original qa.json value. Runs replay the recorded API responses; only --fresh-cache / --live re-check the counts against the API."
+    ],
+    "name": "qa_01_formulae_tio2",
+    "desc": "formulae=tio2: >= 1717 results (recorded 2026-10-24; the outdated qa.json had 989)",
+    "route": "#inquiry/formulae=tio2",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 1717
+      }
+    }
+  },
+  {
+    "name": "qa_02_formulae_al2o3",
+    "desc": "formulae=al2o3: >= 963 results (recorded 2026-10-24; the outdated qa.json had 594)",
+    "route": "#inquiry/formulae=al2o3",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 963
+      }
+    }
+  },
+  {
+    "name": "qa_03_formulae_culamnseo",
+    "desc": "formulae=CuLaMnSeO: >= 16 results (recorded 2026-10-24; the outdated qa.json had 16)",
+    "route": "#inquiry/formulae=CuLaMnSeO",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 16
+      }
+    }
+  },
+  {
+    "name": "qa_04_formulae_coseru",
+    "desc": "formulae=coseru: >= 1 results (recorded 2026-10-24; the outdated qa.json had 0)",
+    "route": "#inquiry/formulae=coseru",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 1
+      },
+      "text:#notifybox": {
+        "contains": "similar data shown"
+      }
+    }
+  },
+  {
+    "name": "qa_05_formulae_nac60",
+    "desc": "formulae=nac60: >= 1 results (recorded 2026-10-24; the outdated qa.json had 1)",
+    "route": "#inquiry/formulae=nac60",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 1
+      }
+    }
+  },
+  {
+    "name": "qa_06_formulae_aggatese",
+    "desc": "formulae=AgGaTeSe: >= 20 results (recorded 2026-10-24; the outdated qa.json had 10)",
+    "route": "#inquiry/formulae=AgGaTeSe",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 20
+      }
+    }
+  },
+  {
+    "name": "qa_07_formulae_geo",
+    "desc": "formulae=geo: >= 6 results (recorded 2026-10-24; the outdated qa.json had 1)",
+    "route": "#inquiry/formulae=geo",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 6
+      }
+    }
+  },
+  {
+    "name": "qa_08_formulae_beo",
+    "desc": "formulae=beo: >= 376 results (recorded 2026-10-24; the outdated qa.json had 320)",
+    "route": "#inquiry/formulae=beo",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 376
+      }
+    }
+  },
+  {
+    "name": "qa_09_formulae_ersi",
+    "desc": "formulae=ErSi: >= 78 results (recorded 2026-10-24; the outdated qa.json had 33)",
+    "route": "#inquiry/formulae=ErSi",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 78
+      }
+    }
+  },
+  {
+    "name": "qa_10_formulae_ersi",
+    "desc": "formulae=ErSI: >= 26 results (recorded 2026-10-24; the outdated qa.json had 2)",
+    "route": "#inquiry/formulae=ErSI",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 26
+      }
+    }
+  },
+  {
+    "name": "qa_11_formulae_ca3_po4_2",
+    "desc": "formulae=Ca3(PO4)2: >= 166 results (recorded 2026-10-24; the outdated qa.json had 44)",
+    "route": "#inquiry/formulae=Ca3%28PO4%292",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 166
+      }
+    }
+  },
+  {
+    "name": "qa_12_formulae_ca3_po4_2",
+    "desc": "formulae=Ca3[PO4]2: >= 166 results (recorded 2026-10-24; the outdated qa.json had 44)",
+    "route": "#inquiry/formulae=Ca3%5BPO4%5D2",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 166
+      }
+    }
+  },
+  {
+    "name": "qa_13_classes_ternary_oxide",
+    "desc": "classes=ternary, oxide: >= 235798 results (recorded 2026-10-24; the outdated qa.json had 78404)",
+    "route": "#inquiry/classes=ternary%2C%20oxide",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 235798
+      }
+    }
+  },
+  {
+    "name": "qa_14_classes_nonmetal",
+    "desc": "classes=nonmetal: >= 398412 results (recorded 2026-10-24; the outdated qa.json had 317859)",
+    "route": "#inquiry/classes=nonmetal",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 398412
+      }
+    }
+  },
+  {
+    "name": "qa_15_classes_lanthanoid_unary",
+    "desc": "classes=lanthanoid, unary: >= 14307 results (recorded 2026-10-24; the outdated qa.json had 8475)",
+    "route": "#inquiry/classes=lanthanoid%2C%20unary",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 14307
+      }
+    }
+  },
+  {
+    "name": "qa_16_classes_conductor",
+    "desc": "classes=conductor: >= 823766 results (recorded 2026-10-24; the outdated qa.json had 412863)",
+    "route": "#inquiry/classes=conductor",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 823766
+      }
+    }
+  },
+  {
+    "name": "qa_17_classes_deuterium",
+    "desc": "classes=deuterium: >= 22068 results (recorded 2026-10-24; the outdated qa.json had 5736)",
+    "route": "#inquiry/classes=deuterium",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 22068
+      }
+    }
+  },
+  {
+    "name": "qa_18_classes_tritium",
+    "desc": "classes=tritium: >= 60 results (recorded 2026-10-24; the outdated qa.json had 13)",
+    "route": "#inquiry/classes=tritium",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 60
+      }
+    }
+  },
+  {
+    "name": "qa_19_props_phase_diagram",
+    "desc": "props=phase diagram: >= 140255 results (recorded 2026-10-24; the outdated qa.json had 227809)",
+    "route": "#inquiry/props=phase%20diagram",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 140255
+      }
+    }
+  },
+  {
+    "name": "qa_20_props_grueneisen_coefficients",
+    "desc": "props=Grueneisen coefficients: >= 1984 results (recorded 2026-10-24; the outdated qa.json had 1260)",
+    "route": "#inquiry/props=Grueneisen%20coefficients",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 1984
+      }
+    }
+  },
+  {
+    "name": "qa_21_props_seebeck_coefficient",
+    "desc": "props=Seebeck coefficient: >= 127050 results (recorded 2026-10-24; the outdated qa.json had 6837)",
+    "route": "#inquiry/props=Seebeck%20coefficient",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 127050
+      }
+    }
+  },
+  {
+    "name": "qa_22_props_figure_of_merit",
+    "desc": "props=figure of merit: >= 2146 results (recorded 2026-10-24; the outdated qa.json had 469)",
+    "route": "#inquiry/props=figure%20of%20merit",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 2146
+      }
+    }
+  },
+  {
+    "name": "qa_23_props_conductivity",
+    "desc": "props=conductivity: >= 313256 results (recorded 2026-10-24; the outdated qa.json had 88703)",
+    "route": "#inquiry/props=conductivity",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 313256
+      }
+    }
+  },
+  {
+    "name": "qa_24_props_valence",
+    "desc": "props=valence: >= 15802 results (recorded 2026-10-24; the outdated qa.json had 15941)",
+    "route": "#inquiry/props=valence",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 15802
+      }
+    }
+  },
+  {
+    "name": "qa_25_elements_ti_o",
+    "desc": "elements=ti-o: >= 125649 results (recorded 2026-10-24; the outdated qa.json had 55956)",
+    "route": "#inquiry/elements=ti-o",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 125649
+      }
+    }
+  },
+  {
+    "name": "qa_26_elements_o",
+    "desc": "elements=O: >= 1336183 results (recorded 2026-10-24; the outdated qa.json had 573839)",
+    "route": "#inquiry/elements=O",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 1336183
+      }
+    }
+  },
+  {
+    "name": "qa_27_elements_rg",
+    "desc": "elements=Rg: >= 10 results (recorded 2026-10-24; the outdated qa.json had 1)",
+    "route": "#inquiry/elements=Rg",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 10
+      },
+      "text:#notifybox": {
+        "contains": "similar data shown"
+      }
+    }
+  },
+  {
+    "name": "qa_28_elements_f",
+    "desc": "elements=F: >= 135634 results (recorded 2026-10-24; the outdated qa.json had 44094)",
+    "route": "#inquiry/elements=F",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 135634
+      }
+    }
+  },
+  {
+    "name": "qa_29_elements_cl",
+    "desc": "elements=Cl: >= 104057 results (recorded 2026-10-24; the outdated qa.json had 34885)",
+    "route": "#inquiry/elements=Cl",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 104057
+      }
+    }
+  },
+  {
+    "name": "qa_30_elements_br",
+    "desc": "elements=Br: >= 47670 results (recorded 2026-10-24; the outdated qa.json had 14611)",
+    "route": "#inquiry/elements=Br",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 47670
+      }
+    }
+  },
+  {
+    "name": "qa_31_elements_i",
+    "desc": "elements=I: >= 48146 results (recorded 2026-10-24; the outdated qa.json had 16581)",
+    "route": "#inquiry/elements=I",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 48146
+      }
+    }
+  },
+  {
+    "name": "qa_32_elements_at",
+    "desc": "elements=At: >= 88 results (recorded 2026-10-24; the outdated qa.json had 13)",
+    "route": "#inquiry/elements=At",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 88
+      }
+    }
+  },
+  {
+    "name": "qa_33_classes_halogen",
+    "desc": "classes=halogen: >= 321042 results (recorded 2026-10-24; the outdated qa.json had 102998)",
+    "route": "#inquiry/classes=halogen",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 321042
+      }
+    }
+  },
+  {
+    "name": "qa_34_lattices_cubic",
+    "desc": "lattices=cubic: >= 708486 results (recorded 2026-10-24; the outdated qa.json had 324635)",
+    "route": "#inquiry/lattices=cubic",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 708486
+      }
+    }
+  },
+  {
+    "name": "qa_35_lattices_rhomb",
+    "desc": "lattices=rhomb: >= 282602 results (recorded 2026-10-24; the outdated qa.json had 94925)",
+    "route": "#inquiry/lattices=rhomb",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 282602
+      }
+    }
+  },
+  {
+    "name": "qa_36_protos_ca2nb2o7_cf88_227",
+    "desc": "protos=Ca2Nb2O7 cF88 227: >= 12199 results (recorded 2026-10-24; the outdated qa.json had 5082)",
+    "route": "#inquiry/protos=Ca2Nb2O7%20cF88%20227",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 12199
+      }
+    }
+  },
+  {
+    "name": "qa_37_protos_h2o",
+    "desc": "protos=H2O: no hits (recorded 2026-10-24; the outdated qa.json had 0)",
+    "route": "#inquiry/protos=H2O",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": 0,
+      "text:#notifybox": {
+        "contains": "No hits"
+      }
+    }
+  },
+  {
+    "name": "qa_38_sgs_pbnm",
+    "desc": "sgs=Pbnm: >= 15701 results (recorded 2026-10-24; the outdated qa.json had 0)",
+    "route": "#inquiry/sgs=Pbnm",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 15701
+      }
+    }
+  },
+  {
+    "name": "qa_39_sgs_pnma",
+    "desc": "sgs=Pnma: >= 81268 results (recorded 2026-10-24; the outdated qa.json had 46213)",
+    "route": "#inquiry/sgs=Pnma",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 81268
+      }
+    }
+  },
+  {
+    "name": "qa_40_sgs_i4_mcm",
+    "desc": "sgs=i4/mcm: >= 15416 results (recorded 2026-10-24; the outdated qa.json had 9856)",
+    "route": "#inquiry/sgs=i4%2Fmcm",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 15416
+      }
+    }
+  },
+  {
+    "name": "qa_41_sgs_79",
+    "desc": "sgs=79: >= 676 results (recorded 2026-10-24; the outdated qa.json had 247)",
+    "route": "#inquiry/sgs=79",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 676
+      }
+    }
+  },
+  {
+    "name": "qa_42_sgs_211",
+    "desc": "sgs=211: >= 18 results (recorded 2026-10-24; the outdated qa.json had 1)",
+    "route": "#inquiry/sgs=211",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 18
+      }
+    }
+  },
+  {
+    "name": "qa_43_authors_evarestov",
+    "desc": "authors=Evarestov: >= 9 results (recorded 2026-10-24; the outdated qa.json had 53)",
+    "route": "#inquiry/authors=Evarestov",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 9
+      }
+    }
+  },
+  {
+    "name": "qa_44_authors_blokhin",
+    "desc": "authors=Blokhin: >= 28 results (recorded 2026-10-24; the outdated qa.json had 46)",
+    "route": "#inquiry/authors=Blokhin",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 28
+      }
+    }
+  },
+  {
+    "name": "qa_45_authors_okamoto",
+    "desc": "authors=Okamoto: >= 16731 results (recorded 2026-10-24; the outdated qa.json had 14424)",
+    "route": "#inquiry/authors=Okamoto",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 16731
+      }
+    }
+  },
+  {
+    "name": "qa_46_authors_villars",
+    "desc": "authors=Villars: >= 464 results (recorded 2026-10-24; the outdated qa.json had 387)",
+    "route": "#inquiry/authors=Villars",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 464
+      }
+    }
+  },
+  {
+    "name": "qa_47_elements_at_props_cell",
+    "desc": "elements=At, props=cell: >= 10 results (recorded 2026-10-24; the outdated qa.json had 1)",
+    "route": "#inquiry/elements=At&props=cell",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 10
+      },
+      "text:#notifybox": {
+        "contains": "similar data shown"
+      }
+    }
+  },
+  {
+    "name": "qa_48_formulae_tio2_props_band_gap",
+    "desc": "formulae=tio2, props=band gap: >= 93 results (recorded 2026-10-24; the outdated qa.json had 140)",
+    "route": "#inquiry/formulae=tio2&props=band%20gap",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 93
+      }
+    }
+  },
+  {
+    "name": "qa_49_formulae_o3al2_props_elastic_properties",
+    "desc": "formulae=O3Al2, props=elastic properties: no hits (recorded 2026-10-24; the outdated qa.json had 37)",
+    "route": "#inquiry/formulae=O3Al2&props=elastic%20properties",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": 0,
+      "text:#notifybox": {
+        "contains": "Unrecognized property"
+      }
+    }
+  },
+  {
+    "name": "qa_50_props_optical_properties_formulae_likso4",
+    "desc": "props=optical properties, formulae=LiKSO4: >= 97 results (recorded 2026-10-24; the outdated qa.json had 66)",
+    "route": "#inquiry/props=optical%20properties&formulae=LiKSO4",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 97
+      }
+    }
+  },
+  {
+    "name": "qa_51_formulae_gdniin_props_conductivity",
+    "desc": "formulae=gdniin, props=conductivity: >= 5 results (recorded 2026-10-24; the outdated qa.json had 2)",
+    "route": "#inquiry/formulae=gdniin&props=conductivity",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 5
+      }
+    }
+  },
+  {
+    "name": "qa_52_props_band_gap_classes_chloride",
+    "desc": "props=band gap, classes=chloride: >= 4578 results (recorded 2026-10-24; the outdated qa.json had 680)",
+    "route": "#inquiry/props=band%20gap&classes=chloride",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 4578
+      }
+    }
+  },
+  {
+    "name": "qa_53_classes_rare_earth_chalcogen_organic_props_magnetism",
+    "desc": "classes=rare earth, chalcogen, organic, props=magnetism: >= 364 results (recorded 2026-10-24; the outdated qa.json had 245)",
+    "route": "#inquiry/classes=rare%20earth%2C%20chalcogen%2C%20organic&props=magnetism",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 364
+      }
+    }
+  },
+  {
+    "name": "qa_54_elements_te_sn_classes_metal_transitional",
+    "desc": "elements=Te-Sn, classes=metal, transitional: >= 431 results (recorded 2026-10-24; the outdated qa.json had 81)",
+    "route": "#inquiry/elements=Te-Sn&classes=metal%2C%20transitional",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 431
+      }
+    }
+  },
+  {
+    "name": "qa_55_classes_radioactive_nonmetal_props_conductivity",
+    "desc": "classes=radioactive, nonmetal, props=conductivity: >= 626 results (recorded 2026-10-24; the outdated qa.json had 629)",
+    "route": "#inquiry/classes=radioactive%2C%20nonmetal&props=conductivity",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 626
+      }
+    }
+  },
+  {
+    "name": "qa_56_classes_noble_gas_props_superconductivity",
+    "desc": "classes=noble gas, props=superconductivity: >= 8 results (recorded 2026-10-24; the outdated qa.json had 16)",
+    "route": "#inquiry/classes=noble%20gas&props=superconductivity",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 8
+      }
+    }
+  },
+  {
+    "name": "qa_57_classes_quaternary_perovskite_props_thermodynamics",
+    "desc": "classes=quaternary, perovskite, props=thermodynamics: >= 26463 results (recorded 2026-10-24; the outdated qa.json had 2047)",
+    "route": "#inquiry/classes=quaternary%2C%20perovskite&props=thermodynamics",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 26463
+      }
+    }
+  },
+  {
+    "name": "qa_58_props_crystalline_structure_classes_binary",
+    "desc": "props=crystalline structure, classes=binary: >= 66845 results (recorded 2026-10-24; the outdated qa.json had 75532)",
+    "route": "#inquiry/props=crystalline%20structure&classes=binary",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 66845
+      }
+    }
+  },
+  {
+    "name": "qa_59_props_crystal_cell_classes_binary",
+    "desc": "props=crystal cell, classes=binary: >= 66845 results (recorded 2026-10-24; the outdated qa.json had 75532)",
+    "route": "#inquiry/props=crystal%20cell&classes=binary",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 66845
+      }
+    }
+  },
+  {
+    "name": "qa_60_props_phases_classes_ferromagnet_ternary",
+    "desc": "props=phases, classes=ferromagnet, ternary: >= 6601 results (recorded 2026-10-24; the outdated qa.json had 2639)",
+    "route": "#inquiry/props=phases&classes=ferromagnet%2C%20ternary",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 6601
+      }
+    }
+  },
+  {
+    "name": "qa_61_classes_carbide_semiconductor_props_electronic_propert",
+    "desc": "classes=carbide, semiconductor, props=electronic properties: >= 647 results (recorded 2026-10-24; the outdated qa.json had 343)",
+    "route": "#inquiry/classes=carbide%2C%20semiconductor&props=electronic%20properties",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 647
+      }
+    }
+  },
+  {
+    "name": "qa_62_classes_lanthanoid_transitional_props_electronic_prope",
+    "desc": "classes=lanthanoid, transitional, props=electronic properties: >= 111239 results (recorded 2026-10-24; the outdated qa.json had 43583)",
+    "route": "#inquiry/classes=lanthanoid%2C%20transitional&props=electronic%20properties",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 111239
+      }
+    }
+  },
+  {
+    "name": "qa_63_elements_in_classes_binary_oxide_metal",
+    "desc": "elements=In, classes=binary, oxide, metal: >= 416 results (recorded 2026-10-24; the outdated qa.json had 185)",
+    "route": "#inquiry/elements=In&classes=binary%2C%20oxide%2C%20metal",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 416
+      }
+    }
+  },
+  {
+    "name": "qa_64_classes_organic_elements_pb_i",
+    "desc": "classes=organic, elements=pb-i: >= 84 results (recorded 2026-10-24; the outdated qa.json had 53)",
+    "route": "#inquiry/classes=organic&elements=pb-i",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 84
+      }
+    }
+  },
+  {
+    "name": "qa_65_classes_organic_perovskite_elements_pb_i",
+    "desc": "classes=organic, perovskite, elements=pb-i: >= 5 results (recorded 2026-10-24; the outdated qa.json had 0)",
+    "route": "#inquiry/classes=organic%2C%20perovskite&elements=pb-i",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 5
+      },
+      "text:#notifybox": {
+        "contains": "similar data shown"
+      }
+    }
+  },
+  {
+    "name": "qa_66_elements_mn_be_classes_halogen",
+    "desc": "elements=Mn-Be, classes=halogen: >= 143 results (recorded 2026-10-24; the outdated qa.json had 18)",
+    "route": "#inquiry/elements=Mn-Be&classes=halogen",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 143
+      }
+    }
+  },
+  {
+    "name": "qa_67_elements_pd_classes_hydride_props_lattice",
+    "desc": "elements=Pd, classes=hydride, props=lattice: >= 146 results (recorded 2026-10-24; the outdated qa.json had 98)",
+    "route": "#inquiry/elements=Pd&classes=hydride&props=lattice",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 146
+      }
+    }
+  },
+  {
+    "name": "qa_68_classes_perovskite_props_phase_diagram",
+    "desc": "classes=perovskite, props=phase diagram: >= 1768 results (recorded 2026-10-24; the outdated qa.json had 15000)",
+    "route": "#inquiry/classes=perovskite&props=phase%20diagram",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 1768
+      }
+    }
+  },
+  {
+    "name": "qa_69_props_thermodynamics_classes_superconductor_elements_f",
+    "desc": "props=thermodynamics, classes=superconductor, elements=fe: >= 3252 results (recorded 2026-10-24; the outdated qa.json had 525)",
+    "route": "#inquiry/props=thermodynamics&classes=superconductor&elements=fe",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 3252
+      }
+    }
+  },
+  {
+    "name": "qa_70_props_superconductivity_classes_superconductor_element",
+    "desc": "props=superconductivity, classes=superconductor, elements=C: >= 2165 results (recorded 2026-10-24; the outdated qa.json had 1307)",
+    "route": "#inquiry/props=superconductivity&classes=superconductor&elements=C",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 2165
+      }
+    }
+  },
+  {
+    "name": "qa_71_elements_y_classes_oxide_ternary_props_lattice",
+    "desc": "elements=Y, classes=oxide, ternary, props=lattice: >= 1982 results (recorded 2026-10-24; the outdated qa.json had 1239)",
+    "route": "#inquiry/elements=Y&classes=oxide%2C%20ternary&props=lattice",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 1982
+      }
+    }
+  },
+  {
+    "name": "qa_72_formulae_srtio3_classes_ternary_lattices_tetragonal",
+    "desc": "formulae=srtio3, classes=ternary, lattices=tetragonal: >= 404 results (recorded 2026-10-24; the outdated qa.json had 571)",
+    "route": "#inquiry/formulae=srtio3&classes=ternary&lattices=tetragonal",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 404
+      }
+    }
+  },
+  {
+    "name": "qa_73_lattices_tetragonal_formulae_srtio3_props_phonons",
+    "desc": "lattices=tetragonal, formulae=SrTiO3, props=phonons: >= 21 results (recorded 2026-10-24; the outdated qa.json had 23)",
+    "route": "#inquiry/lattices=tetragonal&formulae=SrTiO3&props=phonons",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 21
+      }
+    }
+  },
+  {
+    "name": "qa_74_props_band_gap_lattices_hexagonal_formulae_zno",
+    "desc": "props=band gap, lattices=hexagonal, formulae=ZnO: >= 139 results (recorded 2026-10-24; the outdated qa.json had 142)",
+    "route": "#inquiry/props=band%20gap&lattices=hexagonal&formulae=ZnO",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 139
+      }
+    }
+  },
+  {
+    "name": "qa_75_elements_cr_fe_lattices_tricl",
+    "desc": "elements=cr-fe, lattices=tricl: >= 117 results (recorded 2026-10-24; the outdated qa.json had 14)",
+    "route": "#inquiry/elements=cr-fe&lattices=tricl",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 117
+      }
+    }
+  },
+  {
+    "name": "qa_76_lattices_hexagonal_classes_carbide_semiconductor_props",
+    "desc": "lattices=hexagonal, classes=carbide, semiconductor, props=electronic properties: >= 231 results (recorded 2026-10-24; the outdated qa.json had 107)",
+    "route": "#inquiry/lattices=hexagonal&classes=carbide%2C%20semiconductor&props=electronic%20properties",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 231
+      }
+    }
+  },
+  {
+    "name": "qa_77_classes_intermetallic_binary_props_lattice_lattices_cu",
+    "desc": "classes=intermetallic, binary, props=lattice, lattices=cubic: >= 10825 results (recorded 2026-10-24; the outdated qa.json had 9624)",
+    "route": "#inquiry/classes=intermetallic%2C%20binary&props=lattice&lattices=cubic",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 10825
+      }
+    }
+  },
+  {
+    "name": "qa_78_props_magnetism_classes_ferromagnet_chalcogen_lattices",
+    "desc": "props=magnetism, classes=ferromagnet, chalcogen, lattices=monocl: >= 5593 results (recorded 2026-10-24; the outdated qa.json had 2106)",
+    "route": "#inquiry/props=magnetism&classes=ferromagnet%2C%20chalcogen&lattices=monocl",
+    "tags": ["qa", "expect", "count"],
+    "expect": {
+      "js:(document.title.match(/(\\d+) results?$/) || [0, 0])[1] * 1": {
+        "ge": 5593
+      }
+    }
+  }
+]
diff --git a/src_js/app/events.js b/src_js/app/events.js
new file mode 100644
index 0000000..b0cd5ef
--- /dev/null
+++ b/src_js/app/events.js
@@ -0,0 +1,2162 @@
+/**
+ * Ermac event wiring: register_events() binds all DOM listeners.
+ */
+
+import wmgui from '../core/settings.js';
+import { a11y_context_opened, a11y_context_closed } from '../core/a11y.js';
+import { wmutils } from '../core/utils.js';
+import {
+  $,
+  $$,
+  show,
+  hide,
+  toggle_display,
+  set_html,
+  append_html,
+  after_html,
+  empty,
+  remove,
+  isVisible,
+  on,
+  position,
+  offset,
+  scroll_top,
+  window_height,
+  data,
+  fade_out,
+  slide_up,
+  slide_down,
+} from '../core/dom.js';
+import { ajax, is_empty } from '../core/ajax.js';
+import {
+  create_floating_slider,
+  destroy_numericbox,
+  serialize_numeric,
+  inquiry_param,
+} from '../components/sliders.js';
+import {
+  select_ptable_el,
+  select_ptable_series,
+  ajax_download,
+  render_left,
+} from './ptable.js';
+import {
+  request_search,
+  re_view_request,
+  show_advsbox,
+  show_aetmap,
+  show_tooltip,
+  show_hints,
+  open_context,
+  close_vibox,
+  launch_db_iframed,
+  build_cells,
+  build_thumbs,
+  update_databrowser_sort,
+  user_login,
+  user_logout,
+  force_relogin,
+  tab_user_login,
+  submit_factor_form_resp,
+  describe_perms,
+  get_visavis_url,
+} from './search.js';
+import { url_redraw_react } from './router.js';
+
+export function register_events() {
+  document
+    .querySelector('#ptable_area > ul')
+    .addEventListener('click', function (event) {
+      var that = event.target;
+      if (!that.hasAttribute || !that.hasAttribute('data-pos')) return;
+
+      wmgui.ptable.update_selectize = true;
+      var selected_el = wmgui.ptable.elements[that.getAttribute('data-pos')];
+      select_ptable_el(selected_el, that);
+    });
+
+  var radios = document.querySelectorAll('input[name="ptable_dtypes"]');
+  for (var i = 0; i < radios.length; i++) {
+    radios[i].addEventListener('change', function () {
+      if (!this.checked) return;
+      wmgui.ptable.dtypes = this.value;
+      var check = wmgui.multiselects['main'].read();
+      select_ptable_series(check.elements);
+    });
+  }
+
+  // NB an <a href="#"> element: like the old jQuery return false,
+  // the default navigation must be suppressed explicitly
+  $('#search_trigger').addEventListener('click', function (event) {
+    event.preventDefault();
+    var query = wmgui.multiselects['main'].read(),
+      val = $('#search_field-selectized')
+        ? $('#search_field-selectized').value
+        : '';
+
+    if (val) {
+      if (val.endsWith(' ') || val.endsWith(','))
+        val = val.substr(0, val.length - 1);
+      var parsed = wmutils.guess(val);
+
+      for (var key in parsed) {
+        if (key == 'ignored') continue;
+        else if (query[key] && key == 'elements')
+          query[key] += '-' + parsed[key];
+        else if (query[key] && key == 'classes')
+          query[key] += ', ' + parsed[key];
+        else query[key] = parsed[key];
+      }
+    }
+
+    if (wmgui.search.numeric && !query.numeric) {
+      query.numeric = '';
+      wmgui.search.numeric.forEach(function (item) {
+        query.numeric += serialize_numeric.apply(this, item); // unpack
+      });
+      delete query.props; // NB to make the numeric results "more clear"
+    }
+
+    if (is_empty(query)) {
+      wmgui.notify('Sorry, unrecognized input');
+      return false;
+    }
+
+    wmgui.ctx_strict_phases = '';
+    $('#ctx_strict_phases_trigger').checked = true;
+
+    var urlstr = inquiry_param(query);
+    if (window.location.hash == '#inquiry/' + urlstr) {
+      // hash-hack FIXME?
+      if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
+      else urlstr += '=';
+    }
+    window.location.hash = '#inquiry/' + urlstr;
+    return false;
+  });
+
+  $('#advsearch_do_trigger').addEventListener('click', function () {
+    var curval = '',
+      rest_input = '',
+      query = {};
+
+    wmgui.simple_facets.forEach(function (item) {
+      curval = $('#advs_fct_' + item).value;
+      if (curval) {
+        if (item == 'formulae') curval = wmutils.termify_formulae(curval);
+        else if (item == 'elements')
+          curval = curval.replaceAll(',', '').replaceAll(' ', '-');
+        else if (item == 'doi')
+          curval = curval
+            .replace('http:\/\/dx\.doi\.org\/', '')
+            .replace('http:\/\/doi\.org\/', '')
+            .trim();
+        else if (item == 'codens') curval = wmgui.journal_converter.j2c(curval);
+        query[item] = curval;
+      }
+    });
+
+    wmgui.multi_facets.forEach(function (item) {
+      curval = wmgui.multiselects[item].read();
+
+      if (curval[item]) {
+        curval = curval[item];
+        if (item == 'authors')
+          curval = curval
+            .replace(/'/g, '')
+            .replaceAll('\\.', ' ')
+            .replaceAll('\\b\\w{1}\\b', '')
+            .trim();
+        query[item] = curval;
+      }
+      rest_input = $('#advs_fct_' + item + '-selectized')
+        ? $('#advs_fct_' + item + '-selectized').value
+        : '';
+      if (rest_input) {
+        if (query[item]) query[item] += ', ' + rest_input;
+        else query[item] = rest_input;
+      }
+    });
+
+    if (wmgui.search.numeric) {
+      query.numeric = '';
+      wmgui.search.numeric.forEach(function (item) {
+        query.numeric += serialize_numeric.apply(this, item); // unpack
+      });
+      delete query.props; // NB to make the numeric results "more clear"
+    }
+
+    if (is_empty(query)) return wmgui.notify('Sorry, search is empty');
+
+    wmgui.ctx_strict_phases = '';
+    $('#ctx_strict_phases_trigger').checked = true;
+
+    var urlstr = inquiry_param(query);
+    if (window.location.hash == '#inquiry/' + urlstr) {
+      // hash-hack FIXME?
+      if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
+      else urlstr += '=';
+    }
+    window.location.hash = '#inquiry/' + urlstr;
+  });
+
+  $('#advsearch_drop_trigger').addEventListener('click', function () {
+    $$('input.advs_input').forEach(function (input) {
+      input.value = '';
+    });
+
+    wmgui.multi_facets.forEach(function (item) {
+      const rest_input = $('#advs_fct_' + item + '-selectized');
+      if (rest_input) rest_input.value = '';
+      wmgui.multiselects[item].clear();
+    });
+
+    hide($('#aetmap'));
+    $('#aet_limit').checked = false;
+
+    destroy_numericbox();
+    delete wmgui.search.numeric;
+    // TODO? delete wmgui.search
+  });
+
+  // NB an <a href="#"> element: like the old jQuery return false,
+  // the default navigation must be suppressed explicitly
+  $('#advsearch_init_trigger').addEventListener('click', function (event) {
+    event.preventDefault();
+    $$('#advstab_options li').forEach(function (li) {
+      li.classList.remove('working');
+    });
+    $$('#advstab_options li[rev=advstab_cry]').forEach(function (li) {
+      li.classList.add('working');
+    });
+    show($('#advstab_cry'));
+    hide($$('#advstab_main, #advstab_bib'));
+    show_advsbox();
+    return false;
+  });
+
+  on($('#search_box'), '#legend a', 'click', function (event) {
+    var legend = this.textContent;
+    window.location.hash = '#search/' + encodeURIComponent(legend);
+    event.preventDefault();
+    return false;
+  });
+
+  $$('div.advs_legend > a').forEach(function (a) {
+    a.addEventListener('click', function (event) {
+      var legend = a.getAttribute('rel') || a.textContent,
+        multiselects = a.parentNode.dataset.multiselects;
+
+      if (multiselects) {
+        const rest_input = $('#advs_fct_' + multiselects + '-selectized');
+        if (rest_input) rest_input.value = '';
+        wmgui.multiselects[multiselects].clear();
+        var obj = {};
+        obj[multiselects] = legend;
+        wmgui.multiselects[multiselects].write(obj);
+        //wmgui.multiselects[multiselects].write({[multiselects]: legend});
+      } else {
+        const target_input = a.parentNode.parentNode.querySelector('input');
+        if (target_input) {
+          target_input.value = legend;
+          target_input.focus();
+        }
+      }
+      //if (legend.indexOf('-vertex') !== -1) show_aetmap(legend);
+
+      event.preventDefault();
+      return false;
+    });
+  });
+
+  on($('#databrowser'), 'div.gallery_img', 'click', function (event) {
+    handle_gallery_img_click(this, event);
+  });
+  on($('#ptable_results'), 'div.gallery_img', 'click', function (event) {
+    handle_gallery_img_click(this, event);
+  });
+
+  function handle_gallery_img_click(el, event) {
+    if (el.getAttribute('rel')) {
+      if (wmgui.view_mode === 1 && wmgui.ptable.dtypes > 1) {
+        var phid = el.getAttribute('rel');
+
+        if (wmgui.ptable.dtypes == 2)
+          document.querySelector(
+            '#ptable_vis > iframe',
+          ).contentWindow.location.hash =
+            '#' + wmgui.phase_endpoint + '?phid=' + phid + '&struct=1';
+        else
+          document
+            .querySelector('#ptable_vis > iframe')
+            .contentWindow.location.replace(
+              get_visavis_url({ phid: phid }, 'graph', window.innerHeight - 50),
+            );
+
+        $$('div.gallery_item.active').forEach(function (item) {
+          item.classList.remove('active');
+        });
+        el.parentNode.classList.add('active');
+      } else {
+        var path = el.getAttribute('data-path') || 'phase_id';
+        window.location.hash = '#' + path + '/' + el.getAttribute('rel');
+      }
+    }
+  }
+
+  on($('#databrowser'), 'a.resolve_ref', 'mousedown', function (event) {
+    var bid = this.getAttribute('rel');
+    $$('a.resolve_ref[rel="' + bid + '"]').forEach(function (a) {
+      a.classList.add('visited');
+    }); // :visited
+    wmgui.bid_history.push(parseInt(bid));
+    window.localStorage.setItem(
+      wmgui.store_bids_key,
+      JSON.stringify(wmgui.bid_history),
+    );
+    return true;
+  });
+
+  on(
+    $('#databrowser'),
+    'tr.tcell, div.gallery_item',
+    'click',
+    function (event) {
+      open_context(this, false);
+      // NB event.detail is 0 for a keyboard activation (Enter / Space)
+      a11y_context_opened(this, event.detail === 0);
+    },
+  );
+
+  on($('#databrowser'), 'span.launch_v', 'click', function (event) {
+    wmgui.cancel_event(event);
+    var parent_row = this.closest('tr');
+    parent_row.classList.remove('busy_entry');
+    open_context(parent_row, true);
+  });
+
+  on($('#databrowser'), 'a.launch_id', 'click', function (event) {
+    wmgui.cancel_event(event);
+    var phid_link = this.getAttribute('href');
+    if (window.location.hash == phid_link) {
+      // hash-hack FIXME?
+      phid_link += '.';
+    }
+    window.location.hash = phid_link;
+    return false;
+  });
+
+  on(
+    $('#all_polyhedra_content'),
+    'div.gallery_item',
+    'click',
+    function (event) {
+      $$('#advstab_options li').forEach(function (li) {
+        li.classList.remove('working');
+      });
+      $$('#advstab_options li[rev=advstab_cry]').forEach(function (li) {
+        li.classList.add('working');
+      });
+      hide($$('div.advstab'));
+      show($('#advstab_cry'));
+      hide($$('div.modal'));
+      show($$('#advsbox, #overlay'));
+
+      var term = this.getAttribute('rel'),
+        selected_aetypes = (
+          wmgui.multiselects['aetypes'].read()['aetypes'] || ''
+        ).split(', ');
+      if (selected_aetypes.indexOf(term) == -1)
+        wmgui.multiselects['aetypes'].write({ aetypes: term });
+      show_aetmap(term);
+    },
+  );
+
+  $('#aet_limit').addEventListener('click', function (event) {
+    var selected_classes = (
+      wmgui.multiselects['classes'].read()['classes'] || ''
+    ).split(', ');
+
+    if (this.checked) {
+      var selected_aetypes = (
+          wmgui.multiselects['aetypes'].read()['aetypes'] || ''
+        )
+          .split(', ')
+          .filter(function (x) {
+            return x;
+          }),
+        limit_kwd = wmgui.poly_limits[selected_aetypes.length];
+
+      if (!limit_kwd) {
+        wmgui.cancel_event(event);
+        wmgui.notify('Sorry, only up to 3 supported');
+        return false;
+      }
+      if (selected_classes.indexOf(limit_kwd) == -1) {
+        wmgui.multiselects['classes'].write({ classes: limit_kwd });
+      }
+    } else {
+      var poly_limits = Object.values(wmgui.poly_limits);
+      wmgui.multiselects['classes'].clear();
+      wmgui.multiselects['classes'].write({
+        classes: selected_classes
+          .filter(function (x) {
+            return poly_limits.indexOf(x) == -1;
+          })
+          .join(', '),
+      });
+    }
+    return true;
+  });
+
+  $$('#visualize, #xrpdize').forEach(function (el) {
+    el.addEventListener('click', function () {
+      close_vibox();
+      launch_db_iframed(parseInt(this.getAttribute('data-rank')));
+    });
+  });
+
+  /*$('#absolidize').click(function(){
+        ... commented out in the original ...
+    });*/
+
+  on($('#refine_col'), 'a.extd_refine', 'click', async function (event) {
+    var facet = this.getAttribute('rel');
+    event.preventDefault();
+
+    if ($('#refine_col > ul > li.extd_rfns.fct_' + facet)) {
+      $$('#refine_col > ul > li:not(.fct_' + facet + ')').forEach(
+        function (li) {
+          li.classList.add('hidden_rfns');
+        },
+      );
+      $$('#refine_col > ul > li:not(.fct_' + facet + ')').forEach(
+        function (li) {
+          if (li.classList.contains('hidden_rfns')) slide_up(li, 400);
+        },
+      );
+      $$('#refine_col > ul > li.extd_rfns.fct_' + facet).forEach(function (li) {
+        li.style.display = 'list-item';
+      });
+      $$('a.extd_refine[rel="' + facet + '"]').forEach(function (a) {
+        a.parentNode.style.display = 'none';
+      });
+      return false;
+    }
+    var given_search = { extd_refine: facet };
+    Object.assign(given_search, wmgui.search);
+    try {
+      wmgui.active_ajax.abort();
+    } catch (e) {}
+
+    wmgui.active_ajax = ajax({
+      type: 'GET',
+      url: wmgui.rfn_endpoint,
+      data: { q: JSON.stringify(given_search) },
+    });
+
+    let found_data;
+    try {
+      found_data = await wmgui.active_ajax;
+    } catch (error) {
+      if (!(error && error.aborted))
+        wmgui.notify(
+          'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+        );
+      return false;
+    }
+
+    if (found_data.error) return wmgui.notify(found_data.error);
+    var html = '';
+    delete given_search['numeric'];
+    delete given_search['extd_refine'];
+    //if (given_search.classes) given_search.classes = given_search.classes.split(',').join(' ');
+
+    var inquiry = false;
+    for (var n = 0; n < wmgui.inquiries.length; n++) {
+      if (given_search[wmgui.inquiries[n]]) {
+        inquiry = true;
+        break;
+      }
+    }
+
+    found_data.payload.forEach(function (found, i) {
+      // FIXME: duplicating
+      var link_base = '',
+        orepr = {};
+      //count_text = ' ('+found[1]+')';
+
+      for (var key in given_search) {
+        const val = given_search[key];
+        if (key == 'search_type') continue;
+        else if (
+          facet == 'elements' &&
+          (key == 'elements' || key == 'formulae')
+        )
+          continue;
+        else if (facet == 'props' && key == 'props') continue;
+
+        link_base += val + ' ';
+
+        if (orepr[key]) orepr[key] += ', ' + val;
+        else orepr[key] = val;
+      }
+
+      //if (facet == 'elements') count_text = '';
+      if (facet == 'props') {
+        found[0] = found[0].replace(/\(|\)/g, '').replace(/\/[\w\-]*/g, ''); // FIXME
+      }
+
+      if (orepr[facet]) orepr[facet] += ', ' + found[0];
+      else orepr[facet] = found[0];
+
+      if (orepr['elements'])
+        orepr['elements'] = orepr['elements'].replaceAll(', ', '-');
+
+      if (inquiry)
+        html +=
+          '<li class="extd_rfns fct_' +
+          facet +
+          '"><a href="#inquiry/' +
+          inquiry_param(orepr) +
+          '">' +
+          found[0] +
+          '</a></li>';
+      else
+        html +=
+          '<li class="extd_rfns fct_' +
+          facet +
+          '"><a href="#search/' +
+          link_base +
+          found[0] +
+          '">' +
+          found[0] +
+          '</a></li>';
+    });
+
+    html +=
+      '<li class="extd_rfns fct_' +
+      facet +
+      ' collapse_refine"><a class="collapse_refine" rel="' +
+      facet +
+      '" href="#">Show less&nbsp;</a></li>';
+    $$('#refine_col > ul > li:not(.fct_' + facet + ')').forEach(function (li) {
+      li.classList.add('hidden_rfns');
+      slide_up(li, 400);
+    });
+    $$('a.extd_refine[rel="' + facet + '"]').forEach(function (a) {
+      a.parentNode.style.display = 'none';
+    });
+    const anchor = $$('a.extd_refine[rel="' + facet + '"]')[0];
+    if (anchor) after_html(anchor.parentNode, wmgui.clean(html));
+
+    return false;
+  });
+
+  on($('#refine_col'), 'a.collapse_refine', 'click', function (event) {
+    var facet = this.getAttribute('rel');
+    event.preventDefault();
+    $$('a.extd_refine[rel="' + facet + '"]').forEach(function (a) {
+      a.parentNode.style.display = 'list-item';
+    });
+    $$('#refine_col > ul > li.hidden_rfns').forEach(function (li) {
+      li.classList.remove('hidden_rfns');
+      slide_down(li, 250);
+    });
+    $$('#refine_col > ul > li.extd_rfns').forEach(function (li) {
+      li.style.display = 'none';
+    });
+    return false;
+  });
+
+  /*$('#fdwidget').on('click', 'span', function(){
+        ... commented out in the original ...
+    });*/
+
+  on($('#tagcloudbox'), 'a.collateral', 'click', function (event) {
+    data($('#userbox'), 'saved_hash', false);
+    var act = this.getAttribute('rel');
+    event.preventDefault();
+
+    if (act == 'adv') {
+      $('#advsearch_init_trigger').click();
+      hide($$('div.menu_collateral'));
+    } else if (act == 'idea') {
+      window.location.hash =
+        '#plot/' +
+        wmgui.get_random_term(['pie', 'lit', 'graph']) +
+        '/search/' +
+        wmgui.get_interesting()['text'];
+    } else if (act == 'sod') {
+      var now = new Date(),
+        pick = now.getDate() % wmgui.s_examples.length,
+        start = new Date(now.getFullYear(), 0, 0),
+        diff =
+          now -
+          start +
+          (start.getTimezoneOffset() - now.getTimezoneOffset()) * 60 * 1000,
+        nday = Math.floor(diff / (1000 * 60 * 60 * 24)),
+        sod = wmgui.s_examples[pick] + nday;
+      window.location.hash = '#entry/S' + sod;
+    } else if (act == 'my') {
+      var locals = JSON.parse(
+        window.localStorage.getItem(wmgui.store_user_key) || '{}',
+      );
+      if (locals.ipbased) {
+        window.location.hash = '#inquiry/orgs=' + locals.name;
+      } else if (locals.name) {
+        var names = locals.name.split(' ');
+        window.location.hash =
+          '#inquiry/authors=' + encodeURIComponent(names[names.length - 1]);
+      }
+    }
+    return false;
+  });
+
+  on($('#hintsbox_msg'), 'div.wmbutton', 'click', function () {
+    // copy to clipbox functionality
+    var range = document.createRange();
+    range.selectNode($('#hintsbox_msg > pre'));
+    window.getSelection().removeAllRanges();
+    window.getSelection().addRange(range);
+    document.execCommand('copy');
+    wmgui.notify('Copied');
+  });
+
+  on($('#tooltip'), 'span', 'click', function () {
+    var act = this.getAttribute('rel'),
+      forced = this.classList.contains('forced');
+    document.getElementById('tooltip').style.display = 'none';
+    if (act && wmgui.tooltips[act]) show_tooltip(wmgui.tooltips[act], forced);
+  });
+
+  on($('#sim_col'), 'li > a', 'click', function () {
+    $$('#sim_col > ul > li').forEach(function (li) {
+      li.classList.remove('selected');
+    });
+    this.parentNode.classList.add('selected');
+    wmgui.passive_sim_col = false;
+    return true;
+  });
+
+  $$('div.close_user_dialogue').forEach(function (cross) {
+    cross.addEventListener('click', function () {
+      $('#userbox').click();
+    });
+  });
+
+  $$('div.close_advs_dialogue').forEach(function (cross) {
+    cross.addEventListener('click', function () {
+      hide($$('#advsbox, #overlay, #aetmap'));
+    });
+  });
+
+  const close_inquiry = $('#close_inquiry_dialogue');
+  if (close_inquiry)
+    close_inquiry.addEventListener('click', function () {
+      hide($('#inquirybox'));
+    });
+
+  $('#close_ss_dialogue').addEventListener('click', function () {
+    var x_sort = $('#ss_x > ul > li.ss_x').getAttribute('rel').split('_')[1],
+      y_sort = $('#ss_y > ul > li.ss_y').getAttribute('rel').split('_')[1],
+      x_op = $('#sops_x > ul > li.sops_x').textContent,
+      y_op = $('#sops_y > ul > li.sops_y').textContent,
+      x_op = x_op == 'none' ? false : x_op,
+      y_op = y_op == 'none' ? false : y_op;
+
+    if (isVisible($('#ss_z'))) {
+      var z_sort = $('#ss_z > ul > li.ss_z').getAttribute('rel').split('_')[1],
+        z_op = $('#sops_z > ul > li.sops_z').textContent,
+        z_op = z_op == 'none' ? false : z_op;
+
+      $$('#ctxpanel_cube > ul > li.embodied').forEach(function (li) {
+        li.classList.remove('embodied');
+      });
+      $('#viscube_' + x_sort).classList.add('embodied');
+      $$('#ctxpanel_cube > ul > li.ss_y').forEach(function (li) {
+        li.classList.remove('ss_y');
+      });
+      $('#viscube_' + y_sort).classList.add('ss_y');
+      $$('#ctxpanel_cube > ul > li.ss_z').forEach(function (li) {
+        li.classList.remove('ss_z');
+      });
+      $('#viscube_' + z_sort).classList.add('ss_z');
+
+      remove($$('span.sops'));
+      if (x_op)
+        append_html(
+          $('#viscube_' + x_sort),
+          '<span class="sops" rel="x">' + x_op + '</span>',
+        );
+      if (y_op)
+        append_html(
+          $('#viscube_' + y_sort),
+          '<span class="sops" rel="y">' + y_op + '</span>',
+        );
+      if (z_op)
+        append_html(
+          $('#viscube_' + z_sort),
+          '<span class="sops" rel="z">' + z_op + '</span>',
+        );
+
+      if (
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.location.hash.indexOf('fixel=1') !== -1
+      )
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.matrix_order(x_sort, y_sort, x_op, y_op);
+      else
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.cube_order(x_sort, y_sort, z_sort, x_op, y_op, z_op);
+    } else {
+      if ((x_op && x_sort == 'count') || (y_op && y_sort == 'count'))
+        return wmgui.notify('Sorry, data counts are not supported');
+
+      $$('#ctxpanel_matrix > ul > li.embodied').forEach(function (li) {
+        li.classList.remove('embodied');
+      });
+      $('#vismatrix_' + x_sort).classList.add('embodied');
+      $$('#ctxpanel_matrix > ul > li.ss_y').forEach(function (li) {
+        li.classList.remove('ss_y');
+      });
+      $('#vismatrix_' + y_sort).classList.add('ss_y');
+
+      remove($$('span.sops'));
+      if (x_op)
+        append_html(
+          $('#vismatrix_' + x_sort),
+          '<span class="sops" rel="x">' + x_op + '</span>',
+        );
+      if (y_op)
+        append_html(
+          $('#vismatrix_' + y_sort),
+          '<span class="sops" rel="y">' + y_op + '</span>',
+        );
+
+      document
+        .getElementById('visavis_iframe')
+        .contentWindow.matrix_order(x_sort, y_sort, x_op, y_op);
+    }
+
+    hide($$('#ss_custom_box, #overlay'));
+    empty($$('div.ss_col > ul'));
+  });
+
+  $('#close_dc_dialogue').addEventListener('click', function () {
+    hide($$('#discovery_custom_box, #overlay'));
+    empty($$('#discovery_enabled, #discovery_disabled'));
+    document.getElementById('visavis_iframe').contentWindow.discovery_rerun();
+    $('#select_cmp_trigger').value = 'X';
+  });
+
+  // not handled by ermac?
+  const close_formal = $('#close_formal_dialogue');
+  if (close_formal)
+    close_formal.addEventListener('click', function () {
+      window.location.hash = '#start';
+    });
+
+  // not handled by ermac?
+  $$(
+    '#close_ph_dialogue, div.close_hy_dialogue, div.close_product_dialogue',
+  ).forEach(function (cross) {
+    cross.addEventListener('click', function () {
+      if (document.referrer.indexOf(window.location.host) == -1)
+        window.location.hash = '#start'; // FIXME: empty referrer
+      else {
+        var prev = window.location.href;
+        window.history.go(-1);
+        setTimeout(function () {
+          if (window.location.href == prev) window.location.hash = '#start';
+        }, 500);
+      }
+    });
+  });
+
+  /** $('#overlay').click(function(){
+        $('div.modal:visible').each(function(){
+            $(this).find('div.cross').trigger('click');
+        });
+    }); **/
+
+  $$('div._close_ctx').forEach(function (cross) {
+    cross.addEventListener('click', function () {
+      try {
+        wmgui.quick_ajax.abort();
+      } catch (e) {}
+      $$('.busy_entry').forEach(function (el) {
+        el.classList.remove('busy_entry');
+      });
+      hide($$('#ctx_col, #sim_col'));
+      wmgui.passive_sim_col = true;
+      close_vibox();
+      a11y_context_closed();
+    });
+  });
+
+  on($('#hy_box'), 'span', 'click', function () {
+    var hyid = this.getAttribute('class');
+    $$('span.' + hyid.split(' ')[0]).forEach(function (el) {
+      el.parentNode.querySelectorAll('ul').forEach(function (ul) {
+        toggle_display(ul, 'block');
+      });
+      el.textContent == 'expand'
+        ? (el.textContent = 'collapse')
+        : (el.textContent = 'expand');
+    });
+  });
+
+  on($('#hy_box'), 'a.dynprop', 'click', function (event) {
+    // FIXME cannot process with the optimade NLP parser
+    //if (wmgui.view_mode == 1)
+    //    return true;
+
+    var value = this.getAttribute('data-val');
+    window.location.hash = wmgui.aug_search_cmd('props', value);
+    event.preventDefault();
+    return false;
+  });
+
+  // numeric search
+  on($('#hy_box'), 'strong.numeric', 'click', function () {
+    var prop = this.getAttribute('rel'),
+      num_data = wmgui.numerics[prop],
+      prop_id = num_data[0],
+      units = num_data[1],
+      min = num_data[2],
+      max = num_data[3],
+      step = num_data[4];
+    var nblocks = $$('div.slider_numerics').length;
+    if (nblocks >= 2)
+      wmgui.notify(
+        'Too little phases have all these properties reported &mdash; expect no results',
+      );
+    if (nblocks >= 8) return;
+    create_floating_slider(prop, prop_id, units, min, max, step);
+  });
+
+  $$('strong.numeric').forEach(function (el) {
+    el.addEventListener('click', function () {
+      var prop = this.getAttribute('rel'),
+        num_data = wmgui.numerics[prop],
+        prop_id = num_data[0],
+        units = num_data[1],
+        min = num_data[2],
+        max = num_data[3],
+        step = num_data[4];
+      create_floating_slider(prop, prop_id, units, min, max, step);
+    });
+  });
+
+  $$('#hy_options > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      var desttab = this.getAttribute('rev');
+      if (desttab == 'hy_vis') {
+        window.open(wmgui.static_host + '/labs/ontology');
+        return;
+      }
+      this.classList.add('working');
+      $$('#hy_options > li').forEach(function (other) {
+        if (other !== this) other.classList.remove('working');
+      }, this);
+      hide($$('div.hy_tabs'));
+      show($('#' + desttab));
+    });
+  });
+
+  $$('#dtypes > ul > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      var facet = this.getAttribute('data-facet'),
+        term = this.getAttribute('data-term');
+
+      if (facet == 'classes') {
+        if (wmgui.search.classes)
+          // FIXME?
+          wmgui.search.classes = wmgui.search.classes
+            .replace('peer-reviewed', '')
+            .replace('peer-review', '')
+            .replace('machine-learning', '')
+            .replace('machine learning', '')
+            .replace('ab initio calculations', '')
+            .split(',')
+            .map(function (x) {
+              return x.trim();
+            })
+            .filter(function (x) {
+              return x;
+            })
+            .join(', ');
+        //wmgui.inquiries.forEach(function(item){
+        //    if (wmgui.search[item]) delete wmgui.search[item];
+        //});
+      }
+      window.location.hash = wmgui.aug_search_cmd(facet, term);
+    });
+  });
+
+  $$('#dtypes_phid > ul > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      // NB jQuery .data() converted numeric attribute strings to numbers,
+      // and the server expects {"rankfilter": 5}, not "5"
+      var rankfilter = this.getAttribute('data-rankfilter'),
+        active = this.classList.contains('active'),
+        legend = this.textContent;
+      if (rankfilter !== null && String(+rankfilter) === rankfilter)
+        rankfilter = +rankfilter;
+      request_search(
+        { phid: wmgui.search.phid, rankfilter: active ? null : rankfilter },
+        legend + ' of phase ' + wmgui.search.phid,
+        true,
+      );
+      $$('#dtypes_phid > ul > li').forEach(function (other) {
+        other.classList.remove('active');
+      });
+      active ? this.classList.remove('active') : this.classList.add('active');
+    });
+  });
+
+  window.addEventListener(
+    'scroll',
+    wmgui.debounce(function () {
+      if (wmgui.view_mode == 2) {
+        if (wmgui.unfinished_page) {
+          if (offset($('#footer')).top - scroll_top() - window_height() < 50) {
+            // footer pos - scrolling - window height
+
+            wmgui.unfinished_page = false;
+            var cur_search = { offset: wmgui.quick_page_size };
+            Object.assign(cur_search, wmgui.search);
+
+            // NB no abort of the other requests!
+            wmgui.show_preloader();
+            const request = ajax({
+              type: 'GET',
+              url: wmgui.search_endpoint,
+              data: {
+                q: JSON.stringify(cur_search),
+                strict: wmgui.ctx_strict_phases,
+                //subphases: wmgui.ctx_subphases,
+                sid: wmgui.sid,
+              },
+            });
+            wmgui.active_ajax = request;
+
+            request
+              .then(function (fetch_data) {
+                wmgui.hide_preloader();
+                if (fetch_data.error) return wmgui.notify(fetch_data.error);
+                hide($$('div.context_msg'));
+                show_hints();
+                if (!fetch_data.out.length) return;
+                if (wmgui.thumbed_display) {
+                  $$('#databrowser tr td').forEach(function (td) {
+                    append_html(td, build_thumbs(fetch_data.out));
+                  });
+                } else {
+                  append_html(
+                    $('#databrowser tbody'),
+                    build_cells(fetch_data.out),
+                  );
+                  update_databrowser_sort();
+                }
+              })
+              .catch(function (error) {
+                wmgui.hide_preloader();
+                if (!(error && error.aborted))
+                  wmgui.notify(
+                    'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+                  );
+              });
+          }
+        }
+        var iframe = $('#iframe');
+        if (iframe && !wmgui.is_inview(iframe)) close_vibox();
+      } else if (wmgui.ptable.activated) {
+        var scroll_pos = window.scrollY;
+        //console.log(scroll_pos);
+
+        if (scroll_pos > 40) {
+          document
+            .getElementById('ptable_dtypes_box')
+            .classList.remove('resulted');
+          document.getElementById('legend').style.display = 'none';
+
+          wmgui.ptable.vis_fixed && scroll_pos > 550
+            ? document.getElementById('ptable_vis').classList.add('fixed')
+            : document.getElementById('ptable_vis').classList.remove('fixed');
+        } else {
+          document
+            .getElementById('ptable_dtypes_box')
+            .classList.add('resulted');
+          document.getElementById('legend').style.display = 'block';
+          document.getElementById('ptable_vis').classList.remove('fixed');
+        }
+      }
+    }, 300),
+  );
+
+  $('#userbox').addEventListener('click', function () {
+    var that = this;
+    if (window.location.hash == data(that, 'saved_hash'))
+      data(that, 'saved_hash', false);
+
+    if (data(that, 'saved_hash')) {
+      window.location.replace(data(that, 'saved_hash'));
+      data(that, 'saved_hash', false);
+    } else {
+      if (window.location.hash.indexOf('modal') !== -1) {
+        window.location.replace('#start');
+      } else {
+        data(that, 'saved_hash', window.location.hash);
+
+        if (wmgui.sid) window.location.replace('#modal/menu');
+        else window.location.replace('#modal/login');
+      }
+    }
+  });
+
+  $$('span.href[rel]').forEach(function (el) {
+    el.addEventListener('click', function () {
+      window.location.replace(this.getAttribute('rel'));
+    });
+  });
+
+  $$('div.spinoff_pane').forEach(function (pane) {
+    on(pane, 'span.extd', 'click', function () {
+      const legend = this.parentNode.querySelector('span.legend');
+      if (legend) toggle_display(legend, 'block');
+      this.textContent == 'Show more info...'
+        ? (this.textContent = 'Hide more info...')
+        : (this.textContent = 'Show more info...');
+    });
+  });
+
+  on($('#interpret'), 'li', 'click', function () {
+    var link = this.getAttribute('rel');
+    if (!!link) {
+      // search only ... arity
+      window.location.hash = link;
+      return;
+    }
+
+    var csscls = this.getAttribute('class') || '';
+
+    if (csscls.indexOf('numeric') !== -1) {
+      window.location.hash = '#hierarchy';
+    } else if (
+      csscls.indexOf('authors') !== -1 ||
+      csscls.indexOf('years') !== -1 ||
+      csscls.indexOf('codens') !== -1 ||
+      csscls.indexOf('doi') !== -1 ||
+      csscls.indexOf('geos') !== -1 ||
+      csscls.indexOf('orgs') !== -1
+    ) {
+      $$('#advstab_options li').forEach(function (li) {
+        li.classList.remove('working');
+      });
+      $$('#advstab_options li[rev=advstab_bib]').forEach(function (li) {
+        li.classList.add('working');
+      });
+      hide($$('div.advstab'));
+      show($('#advstab_bib'));
+      show_advsbox();
+    } else if (
+      csscls.indexOf('formulae') !== -1 ||
+      csscls.indexOf('props') !== -1 ||
+      csscls.indexOf('elements') !== -1 ||
+      csscls.indexOf('classes') !== -1
+    ) {
+      $$('#advstab_options li').forEach(function (li) {
+        li.classList.remove('working');
+      });
+      $$('#advstab_options li[rev=advstab_main]').forEach(function (li) {
+        li.classList.add('working');
+      });
+      hide($$('div.advstab'));
+      show($('#advstab_main'));
+      show_advsbox();
+    } else {
+      $$('#advstab_options li').forEach(function (li) {
+        li.classList.remove('working');
+      });
+      $$('#advstab_options li[rev=advstab_cry]').forEach(function (li) {
+        li.classList.add('working');
+      });
+      hide($$('div.advstab'));
+      show($('#advstab_cry'));
+      show_advsbox();
+      if (wmgui.search.aetypes) show_aetmap(wmgui.search.aetypes);
+    }
+  });
+
+  $$('#tab_links > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      try {
+        wmgui.active_ajax.abort();
+      } catch (e) {}
+      try {
+        wmgui.quick_ajax.abort();
+      } catch (e) {}
+
+      var desttab = this.getAttribute('rev');
+
+      this.classList.add('working');
+      $$('#tab_links > li').forEach(function (other) {
+        if (other !== this) other.classList.remove('working');
+      }, this);
+      hide($$('div.menu_tabs'));
+      show($('#' + desttab));
+
+      if (desttab == 'usr_tab_api_key') {
+        set_html($('#hintsbox_msg'), wmgui.api_msg);
+
+        wmgui.show_preloader();
+        const request = ajax({
+          type: 'POST',
+          url: wmgui.api_key_endpoint,
+          data: { sid: wmgui.sid },
+        });
+        wmgui.active_ajax = request;
+
+        request
+          .then(function (data) {
+            wmgui.hide_preloader();
+            if (data.error) return wmgui.notify(data.error);
+            set_html($('#usr_api_key'), data.msg);
+            if (data.revokable) show($('#revoke_usr_api_key_holder'));
+            else if (data.creatable) show($('#create_usr_api_key_holder'));
+            else
+              return wmgui.notify(
+                'Your session ended: please, <span class="href relogin">log in again</span>',
+              );
+          })
+          .catch(function (error) {
+            wmgui.hide_preloader();
+            if (!(error && error.aborted))
+              wmgui.notify(
+                'Your session ended: please, <span class="href relogin">log in again</span>',
+              );
+            set_html($('#usr_api_key'), 'authentication error');
+          });
+      } else if (desttab == 'usr_tab_perms') {
+        set_html($('#hintsbox_msg'), wmgui.get_random_term(wmgui.welcome_msgs));
+
+        var locals = JSON.parse(
+          window.localStorage.getItem(wmgui.store_user_key) || '{}',
+        );
+
+        wmgui.show_preloader();
+        const request = ajax({
+          type: 'POST',
+          url: locals.ipbased ? wmgui.ip_perms_endpoint : wmgui.perms_endpoint,
+          data: { sid: wmgui.sid },
+        });
+        wmgui.active_ajax = request;
+
+        request
+          .then(function (data) {
+            wmgui.hide_preloader();
+            if (data.error) return wmgui.notify(data.error);
+            if (!data.hasOwnProperty('gui') || !data.hasOwnProperty('api'))
+              return wmgui.notify(
+                'Your session ended: please, <span class="href relogin">log in again</span>',
+              );
+            set_html($('#perms_view'), describe_perms(data));
+          })
+          .catch(function (error) {
+            wmgui.hide_preloader();
+            if (!(error && error.aborted))
+              wmgui.notify(
+                'Your session ended: please, <span class="href relogin">log in again</span>',
+              );
+            set_html($('#perms_view'), 'authentication error');
+          });
+      } else if (desttab == 'usr_tab_ctrl') {
+        // redirect to an external app
+        window.location.href = '/ctrl/?' + Math.floor(Math.random() * 1000);
+      } else if (desttab == 'usr_tab_absolidix') {
+        // redirect to an external app
+        window.location.href = wmgui.mydata_addr;
+      } else if (desttab == 'usr_tab_account') {
+        set_html($('#hintsbox_msg'), wmgui.get_random_term(wmgui.welcome_msgs));
+      }
+    });
+  });
+
+  $$('#advstab_options > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      var desttab = this.getAttribute('rev');
+
+      this.classList.add('working');
+      $$('#advstab_options > li').forEach(function (other) {
+        if (other !== this) other.classList.remove('working');
+      }, this);
+
+      hide($$('div.advstab'));
+      show($('#' + desttab));
+    });
+  });
+
+  $$('a.link_adjuster').forEach(function (a) {
+    a.addEventListener('click', function (event) {
+      // hash-hack FIXME?
+      if (window.location.hash == '#polyhedra') {
+        window.location.hash = '#polyhedra/';
+        event.preventDefault();
+        return false;
+      } else if (window.location.hash == '#polyhedra/') {
+        window.location.hash = '#polyhedra';
+        event.preventDefault();
+        return false;
+      } else return true;
+    });
+  });
+
+  $('#create_usr_api_key').addEventListener('click', function () {
+    hide(this.parentNode);
+    try {
+      wmgui.active_ajax.abort();
+    } catch (e) {}
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'POST',
+      url: wmgui.api_key_endpoint,
+      data: { sid: wmgui.sid, create: true },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (data) {
+        wmgui.hide_preloader();
+        if (data.error) return wmgui.notify(data.error);
+        set_html($('#usr_api_key'), data.msg);
+        show($('#revoke_usr_api_key_holder'));
+      })
+      .catch(function (error) {
+        wmgui.hide_preloader();
+        if (!(error && error.aborted))
+          wmgui.notify(
+            'Your session ended: please, <span class="href relogin">log in again</span>',
+          );
+      });
+  });
+
+  $('#revoke_usr_api_key').addEventListener('click', function () {
+    hide(this.parentNode);
+    try {
+      wmgui.active_ajax.abort();
+    } catch (e) {}
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'POST',
+      url: wmgui.api_key_endpoint,
+      data: { sid: wmgui.sid, revoke: true },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (data) {
+        wmgui.hide_preloader();
+        if (data.error) return wmgui.notify(data.error);
+        set_html($('#usr_api_key'), 'Successfully revoked');
+        show($('#create_usr_api_key_holder'));
+      })
+      .catch(function (error) {
+        wmgui.hide_preloader();
+        if (!(error && error.aborted))
+          wmgui.notify(
+            'Your session ended: please, <span class="href relogin">log in again</span>',
+          );
+      });
+  });
+
+  $('#login_trigger').addEventListener('click', function () {
+    if (data(this, 'busy')) return;
+    data(this, 'busy', true);
+    this.textContent = 'In process...';
+
+    try {
+      wmgui.active_ajax.abort();
+    } catch (e) {}
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'POST',
+      url: wmgui.login_endpoint,
+      data: {
+        login: $('#login_email').value.trim(),
+        pass: $('#login_password').value,
+        ed: wmgui.edition,
+      },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (answer) {
+        data($('#login_trigger'), 'busy', false);
+        $('#login_trigger').textContent = 'Login';
+        wmgui.hide_preloader();
+
+        if (answer.error) return wmgui.notify(answer.error);
+        if (!answer.sid || !answer.name || !answer.acclogin)
+          return wmgui.notify(
+            'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+          );
+        user_login(
+          answer.sid,
+          answer.name,
+          answer.acclogin,
+          answer.admin,
+          answer.oauths,
+        );
+        $('#userbox').click();
+      })
+      .catch(function (error) {
+        data($('#login_trigger'), 'busy', false);
+        $('#login_trigger').textContent = 'Login';
+        wmgui.hide_preloader();
+        wmgui.notify('Login unsuccessful');
+      });
+  });
+
+  $('#factor_trigger').addEventListener('click', function () {
+    if (data(this, 'busy')) return;
+    data(this, 'busy', true);
+    this.textContent = 'Sending...';
+
+    try {
+      wmgui.active_ajax.abort();
+    } catch (e) {}
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'POST',
+      url: wmgui.factor_endpoint,
+      data: { login: $('#factor_by_email').value.trim() },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (answer) {
+        data($('#factor_trigger'), 'busy', false);
+        $('#factor_trigger').textContent = 'Send code';
+        wmgui.hide_preloader();
+
+        if (answer.error) return wmgui.notify(answer.error);
+        wmgui.notify('Please, check your inbox (and spam)');
+
+        // handle factor log in step two...
+        document.getElementById('factor_trigger').style.display = 'none';
+        document.getElementById('factor_form_step_one').style.display = 'none';
+        document.getElementById('factor_form_step_two').style.display = 'block';
+        document.getElementById('factor_form_resp_0').focus();
+      })
+      .catch(function (error) {
+        data($('#factor_trigger'), 'busy', false);
+        $('#factor_trigger').textContent = 'Send code';
+        wmgui.hide_preloader();
+        if (!(error && error.aborted))
+          wmgui.notify('Sorry, a network error occured. Please, try again');
+      });
+  });
+
+  $('#restore_trigger').addEventListener('click', function () {
+    if (data(this, 'busy')) return;
+    data(this, 'busy', true);
+    this.textContent = 'Sending...';
+
+    try {
+      wmgui.active_ajax.abort();
+    } catch (e) {}
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'POST',
+      url: wmgui.restore_endpoint,
+      data: { login: $('#restore_by_email').value.trim(), ed: wmgui.edition },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (answer) {
+        data($('#restore_trigger'), 'busy', false);
+        $('#restore_trigger').textContent = 'Send link';
+        wmgui.hide_preloader();
+
+        if (answer.error) return wmgui.notify(answer.error);
+        wmgui.notify('Please, check your inbox (and spam)');
+        $('#userbox').click();
+      })
+      .catch(function (error) {
+        data($('#restore_trigger'), 'busy', false);
+        $('#restore_trigger').textContent = 'Send link';
+        wmgui.hide_preloader();
+        if (!(error && error.aborted))
+          wmgui.notify('Sorry, a network error occured. Please, try again');
+      });
+  });
+
+  $('#accpass_trigger').addEventListener('click', function () {
+    if (this.classList.contains('disabled')) return false;
+
+    toggle_display($('#account_pass_change'));
+  });
+
+  $('#password_trigger').addEventListener('click', function () {
+    var p1 = $('#new_password_1').value,
+      p2 = $('#new_password_2').value;
+    if (!p1 || !p2)
+      return wmgui.notify('Please, type your new password in both fields');
+    if (p1 !== p2) return wmgui.notify('Passwords do not match (typo?)');
+
+    if (data(this, 'busy')) return;
+    data(this, 'busy', true);
+    this.textContent = 'Changing...';
+
+    try {
+      wmgui.active_ajax.abort();
+    } catch (e) {}
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'POST',
+      url: wmgui.password_endpoint,
+      data: { new_password: p2, sid: wmgui.sid, ed: wmgui.edition },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (answer) {
+        data($('#password_trigger'), 'busy', false);
+        $('#password_trigger').textContent = 'Change';
+        wmgui.hide_preloader();
+
+        if (answer.error) return wmgui.notify(answer.error);
+        user_login(
+          answer.sid,
+          answer.name,
+          answer.acclogin,
+          answer.admin,
+          answer.oauths,
+        );
+        window.location.replace('#start');
+        hide($('#account_pass_change'));
+      })
+      .catch(function (error) {
+        data($('#password_trigger'), 'busy', false);
+        $('#password_trigger').textContent = 'Change';
+        wmgui.hide_preloader();
+        if (!(error && error.aborted))
+          wmgui.notify(
+            'Your session ended: please, <span class="href relogin">log in again</span>',
+          );
+      });
+  });
+
+  $('#logout_trigger').addEventListener('click', function () {
+    if (this.classList.contains('disabled')) return false;
+
+    ajax({
+      type: 'POST',
+      url: wmgui.logout_endpoint,
+      data: { sid: wmgui.sid },
+    })
+      .then(function () {})
+      .catch(function () {});
+    user_logout();
+    $('#userbox').click();
+  });
+
+  on($('#notifybox'), 'span.relogin', 'click', function () {
+    force_relogin();
+  });
+
+  var resps = document.getElementsByClassName('factor_form_resp');
+  for (var i = 0; i < resps.length; i++) {
+    resps[i].addEventListener('keyup', function (evt) {
+      // back, left arrow
+      if (evt.keyCode == 8 || evt.keyCode == 37) {
+        var prev = this.previousElementSibling;
+        if (prev) {
+          prev.focus();
+          prev.select();
+        }
+      } else if (evt.keyCode > 47 && evt.keyCode < 58) {
+        submit_factor_form_resp();
+
+        var next = this.nextElementSibling;
+        if (next) {
+          next.focus();
+          next.select();
+        }
+      }
+    });
+
+    resps[i].addEventListener('paste', function (evt) {
+      var pasted = (evt.clipboardData || window.clipboardData).getData('text');
+      if (!pasted || !pasted.length) return false;
+
+      for (var i = 0; i < 6; i++) {
+        document.getElementById('factor_form_resp_' + i).value =
+          pasted.charAt(i);
+      }
+      submit_factor_form_resp();
+    });
+  }
+
+  $('#search_holder').addEventListener('keydown', function (e) {
+    var key = window.event ? e.keyCode : e.which;
+    if (key == 13) $('#search_trigger').click();
+  });
+
+  // switch sliders: first row abf
+  $('#control_a').addEventListener('click', function () {
+    // entries
+    ///re_view_request(0);
+    var orepr = {};
+    for (var key in wmgui.search) {
+      if (['search_type', 'phid'].indexOf(key) !== -1) continue;
+      orepr[key] = wmgui.search[key];
+    }
+
+    wmgui.search_type = 0;
+    wmgui.search.search_type = wmgui.search_type;
+
+    var urlstr = inquiry_param(orepr);
+    if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
+    else urlstr += '=';
+
+    window.location.hash = '#inquiry_entries/' + urlstr;
+  });
+  $('#control_b').addEventListener('click', function () {
+    // phases
+    ///re_view_request(1);
+    var orepr = {};
+    for (var key in wmgui.search) {
+      if (['search_type', 'phid'].indexOf(key) !== -1) continue;
+      orepr[key] = wmgui.search[key];
+    }
+
+    wmgui.search_type = 1;
+    wmgui.search.search_type = wmgui.search_type;
+
+    var urlstr = inquiry_param(orepr);
+    if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
+    else urlstr += '=';
+
+    window.location.hash = '#inquiry_phases/' + urlstr;
+  });
+  $('#control_f').addEventListener('click', function () {
+    // articles
+    ///re_view_request(2);
+    var orepr = {};
+    for (var key in wmgui.search) {
+      if (['search_type', 'phid'].indexOf(key) !== -1) continue;
+      orepr[key] = wmgui.search[key];
+    }
+
+    wmgui.search_type = 2;
+    wmgui.search.search_type = wmgui.search_type;
+
+    var urlstr = inquiry_param(orepr);
+    if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
+    else urlstr += '=';
+
+    window.location.hash = '#inquiry_articles/' + urlstr;
+  });
+
+  // switch sliders: second row cde
+  $('#control_c').addEventListener('click', function () {
+    // table
+    wmgui.visavis_terminating = true;
+    wmgui.thumbed_display = false;
+    if (wmgui.visavis_working) {
+      var orepr = {};
+      for (var key in wmgui.search) {
+        if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
+        orepr[key] = wmgui.search[key];
+      }
+      var urlstr = inquiry_param(orepr);
+      if (window.location.hash == '#inquiry/' + urlstr) {
+        // hash-hack FIXME?
+        if (urlstr.slice(-1) == '=')
+          urlstr = urlstr.substr(0, urlstr.length - 1);
+        else urlstr += '=';
+      }
+      window.location.hash = '#inquiry/' + urlstr;
+    } else re_view_request(wmgui.search_type);
+    wmgui.chosen_table_browser = true;
+  });
+  $('#control_d').addEventListener('click', function () {
+    // previews
+    wmgui.visavis_terminating = true;
+    wmgui.thumbed_display = true;
+    if (wmgui.visavis_working) {
+      var orepr = {};
+      for (var key in wmgui.search) {
+        if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
+        orepr[key] = wmgui.search[key];
+      }
+      var urlstr = inquiry_param(orepr);
+      if (window.location.hash == '#inquiry/' + urlstr) {
+        // hash-hack FIXME?
+        if (urlstr.slice(-1) == '=')
+          urlstr = urlstr.substr(0, urlstr.length - 1);
+        else urlstr += '=';
+      }
+      window.location.hash = '#inquiry/' + urlstr;
+    } else re_view_request(wmgui.search_type);
+    wmgui.chosen_table_browser = true;
+  });
+  $('#control_e').addEventListener('click', function () {
+    // plotting
+    var orepr = {};
+    for (var key in wmgui.search) {
+      if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
+      orepr[key] = wmgui.search[key];
+    }
+    while (true) {
+      var plot_type = wmgui.get_random_term(['matrix', 'cube']); // the most interesting visualization types
+      if (plot_type != wmgui.visavis_curtype) break;
+    }
+    window.location.hash = '#plot/' + plot_type + '/inquiry/' + inquiry_param(orepr);
+  });
+
+  $('#ctx_strict_phases_trigger').addEventListener('change', function (e) {
+    //$('#ctx_subphases_trigger').prop('checked', false);
+
+    if (!wmgui.search.elements) {
+      wmgui.cancel_event(e);
+      return false;
+    }
+
+    var arity_kwd = wmutils.arity_keys[wmgui.search.elements.split('-').length],
+      kwd_exists = false;
+
+    if (wmgui.search.classes) {
+      var arity_keys = wmutils.arity_keys.slice(1);
+      for (var num = 0; num < arity_keys.length; num++) {
+        if (num == 6) break;
+
+        var value = arity_keys[num];
+        if (wmgui.search.classes.indexOf(value) !== -1) {
+          kwd_exists = true;
+          break;
+        }
+      }
+
+      if (!kwd_exists) {
+        wmgui.search.classes += ', ' + arity_kwd;
+        wmgui.multiselects['main'].write({ classes: arity_kwd });
+      }
+    } else {
+      wmgui.search.classes = arity_kwd;
+      wmgui.multiselects['main'].write({ classes: arity_kwd });
+    }
+
+    wmgui.ctx_strict_phases = $('#ctx_strict_phases_trigger').checked
+      ? ''
+      : '1';
+    re_view_request(wmgui.search_type);
+  });
+  /*$('#ctx_subphases_trigger').change(function(){
+        //$('#ctx_strict_phases_trigger').prop('checked', false);
+        wmgui.ctx_subphases = wmgui.search.elements && $('#ctx_subphases_trigger').is(':checked') ? '1' : '';
+        re_view_request(wmgui.search_type);
+    });*/
+
+  // visavis ctx
+  $$('#ctxpanel_matrix > ul > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      if (
+        this.classList.contains('embodied') ||
+        this.classList.contains('ss_y')
+      )
+        return;
+      var type = this.id.split('_')[1];
+      $$('#ctxpanel_matrix > ul > li.embodied').forEach(function (el) {
+        el.classList.remove('embodied');
+      });
+      $$('#ctxpanel_matrix > ul > li.ss_y').forEach(function (el) {
+        el.classList.remove('ss_y');
+      });
+      this.classList.add('embodied');
+      remove($$('span.sops'));
+
+      document
+        .getElementById('visavis_iframe')
+        .contentWindow.matrix_order(type);
+    });
+  });
+  $$('#ctxpanel_cube > ul > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      if (
+        this.classList.contains('embodied') ||
+        this.classList.contains('ss_y') ||
+        this.classList.contains('ss_z')
+      )
+        return;
+      var type = this.id.split('_')[1];
+      $$('#ctxpanel_cube > ul > li.embodied').forEach(function (el) {
+        el.classList.remove('embodied');
+      });
+      $$('#ctxpanel_cube > ul > li.ss_y').forEach(function (el) {
+        el.classList.remove('ss_y');
+      });
+      $$('#ctxpanel_cube > ul > li.ss_z').forEach(function (el) {
+        el.classList.remove('ss_z');
+      });
+      this.classList.add('embodied');
+      remove($$('span.sops'));
+
+      if (
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.location.hash.indexOf('fixel=1') !== -1
+      )
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.matrix_order(type);
+      else
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.cube_order(type, type, type);
+    });
+  });
+  $$('#ctxpanel_graph > ul > li').forEach(function (li) {
+    li.addEventListener('click', function () {
+      if (this.classList.contains('embodied')) return;
+      var type = this.id.split('_')[1];
+      $$('#ctxpanel_graph > ul > li.embodied').forEach(function (el) {
+        el.classList.remove('embodied');
+      });
+      this.classList.add('embodied');
+
+      document
+        .getElementById('visavis_iframe')
+        .contentWindow.graph_rebuild(type);
+    });
+  });
+  $('#select_cmp_trigger').addEventListener('change', function () {
+    var value = this.value,
+      title = this.options[this.selectedIndex].text;
+
+    wmgui.dc_ctrl_flag = true;
+
+    if (value == 'X') return;
+    else if (value == 'Y') {
+      document
+        .getElementById('visavis_iframe')
+        .contentWindow.cmp_discard(wmgui.visavis_curtype);
+      return;
+    }
+
+    if (['matrix', 'cube', 'discovery'].indexOf(wmgui.visavis_curtype) == -1)
+      return;
+
+    var url = wmgui.vis_endpoint + '/' + wmgui.visavis_curtype + '?q=' + value;
+    document
+      .getElementById('visavis_iframe')
+      .contentWindow.cmp_download(url, wmgui.visavis_curtype);
+  });
+  $$('li.discovery_custom').forEach(function (li) {
+    li.addEventListener('click', function () {
+      if (
+        !document.getElementById('visavis_iframe') ||
+        !document.getElementById('visavis_iframe').contentWindow
+      )
+        return false;
+
+      var list =
+          document.getElementById('visavis_iframe').contentWindow.visavis
+            .elementals_on,
+        html_list_on = '',
+        html_list_off = '';
+
+      for (var prop in wmgui.elemental_names) {
+        if (list.indexOf(prop) !== -1)
+          html_list_on +=
+            '<div class="rearrange" rel="' +
+            prop +
+            '">' +
+            wmgui.elemental_names[prop] +
+            ' (&minus;)</div>';
+        else
+          html_list_off +=
+            '<div class="rearrange" rel="' +
+            prop +
+            '">' +
+            wmgui.elemental_names[prop] +
+            ' (+)</div>';
+      }
+      if (html_list_off) set_html($('#discovery_disabled'), html_list_off);
+
+      set_html($('#discovery_enabled'), html_list_on);
+      show($$('#discovery_custom_box, #overlay'));
+    });
+  });
+  on($('#discovery_custom_box'), 'div.rearrange', 'click', function () {
+    var prop = this.getAttribute('rel'),
+      idx = document
+        .getElementById('visavis_iframe')
+        .contentWindow.visavis.elementals_on.indexOf(prop);
+    if (this.parentNode.id == 'discovery_enabled') {
+      if ($$('#discovery_enabled div.rearrange').length == 1) return false;
+      if (idx !== -1)
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.visavis.elementals_on.splice(idx, 1);
+      append_html(
+        $('#discovery_disabled'),
+        '<div class="rearrange" rel="' +
+          prop +
+          '">' +
+          wmgui.elemental_names[prop] +
+          ' (+)</div>',
+      );
+      hide($('#dc_' + prop));
+    } else {
+      if (idx == -1)
+        document
+          .getElementById('visavis_iframe')
+          .contentWindow.visavis.elementals_on.push(prop);
+      append_html(
+        $('#discovery_enabled'),
+        '<div class="rearrange" rel="' +
+          prop +
+          '">' +
+          wmgui.elemental_names[prop] +
+          ' (&minus;)</div>',
+      );
+      show($('#dc_' + prop));
+    }
+    this.remove();
+  });
+  $$('#ss_gear_matrix, #ss_gear_cube').forEach(function (gear) {
+    gear.addEventListener('click', function () {
+      var domain = this.id.substr(8); // ss_gear_
+      if (domain == 'matrix') {
+        hide($$('#ss_z, #sops_z'));
+        $$('#ss_x, #ss_y, #sops_x, #sops_y').forEach(function (el) {
+          el.style.width = '50%';
+        });
+      } else {
+        $$('#ss_x, #ss_y, #ss_z, #sops_x, #sops_y, #sops_z').forEach(
+          function (el) {
+            el.style.width = '33%';
+          },
+        );
+        show($$('#ss_z, #sops_z'));
+      }
+
+      // ss_ logic
+      var common_type = $(
+          '#ctxpanel_' + domain + ' > ul > li.embodied',
+        ).id.split('_')[1], // NB embodied, not ss_x
+        y_id = $('#ctxpanel_' + domain + ' > ul > li.ss_y'),
+        z_id = $('#ctxpanel_' + domain + ' > ul > li.ss_z'),
+        x_type = common_type,
+        y_type = y_id ? y_id.id.split('_')[1] : common_type,
+        z_type = z_id ? z_id.id.split('_')[1] : common_type,
+        x_orders_html = '',
+        y_orders_html = '',
+        z_orders_html = '';
+
+      $$('#ctxpanel_' + domain + ' > ul > li').forEach(function (li) {
+        var type = li.id.split('_')[1],
+          text_nodes = Array.prototype.slice
+            .call(li.childNodes)
+            .filter(function (node) {
+              return node.nodeType !== 1;
+            }),
+          label = (
+            text_nodes.length ? text_nodes[0].data : li.textContent
+          ).substr(3), // filter text only, then cut "by "
+          cls_html = type == x_type ? ' class="ss_x"' : '';
+        x_orders_html +=
+          '<li rev="ss_x" rel="x_' +
+          type +
+          '"' +
+          cls_html +
+          '>' +
+          label +
+          '</li>';
+        cls_html = type == y_type ? ' class="ss_y"' : '';
+        y_orders_html +=
+          '<li rev="ss_y" rel="y_' +
+          type +
+          '"' +
+          cls_html +
+          '>' +
+          label +
+          '</li>';
+        if (domain == 'matrix') return;
+        cls_html = type == z_type ? ' class="ss_z"' : '';
+        z_orders_html +=
+          '<li rev="ss_z" rel="z_' +
+          type +
+          '"' +
+          cls_html +
+          '>' +
+          label +
+          '</li>';
+      });
+
+      set_html($('#ss_x > ul'), x_orders_html);
+      set_html($('#ss_y > ul'), y_orders_html);
+      if (domain == 'cube') set_html($('#ss_z > ul'), z_orders_html);
+
+      // sops_ logic
+      $$('li.sops_x').forEach(function (el) {
+        el.classList.remove('sops_x');
+      });
+      $$('li.sops_y').forEach(function (el) {
+        el.classList.remove('sops_y');
+      });
+      $$('li.sops_z').forEach(function (el) {
+        el.classList.remove('sops_z');
+      });
+
+      var sops_types = ['x', 'y', 'z'];
+      $$('span.sops').forEach(function (span) {
+        var op = span.textContent,
+          type = span.getAttribute('rel');
+        $$('#sops_' + type + ' > ul > li').forEach(function (li) {
+          if (li.textContent.indexOf(op) !== -1)
+            li.classList.add('sops_' + type);
+        });
+        sops_types = sops_types.filter(function (x) {
+          return x !== type;
+        });
+      });
+      sops_types.forEach(function (item) {
+        $$('#sops_' + item + ' > ul > li').forEach(function (li) {
+          if (li.textContent.indexOf('none') !== -1)
+            li.classList.add('sops_' + item);
+        });
+      });
+
+      show($$('#ss_custom_box, #overlay'));
+    });
+  });
+  $$('div.ss_col').forEach(function (col) {
+    on(col, 'li', 'click', function () {
+      var rowid = this.getAttribute('rev'),
+        rel_dat = this.getAttribute('rel').split('_'),
+        axis = rel_dat[0],
+        clsname = axis == 'x' ? 'ss_x' : axis == 'y' ? 'ss_y' : 'ss_z';
+      $$('#' + rowid + ' > ul > li.' + clsname).forEach(function (li) {
+        li.classList.remove(clsname);
+      });
+      this.classList.add(clsname);
+    });
+  });
+  $$('div.sops_col').forEach(function (col) {
+    on(col, 'li', 'click', function () {
+      var rowid = this.closest('.sops_col').id,
+        axis = rowid.split('_')[1],
+        clsname = axis == 'x' ? 'sops_x' : axis == 'y' ? 'sops_y' : 'sops_z';
+      $$('#' + rowid + ' > ul > li.' + clsname).forEach(function (li) {
+        li.classList.remove(clsname);
+      });
+      this.classList.add(clsname);
+    });
+  });
+
+  const tips_trigger = $('#tips_trigger');
+  if (tips_trigger)
+    tips_trigger.addEventListener('click', function () {
+      wmgui.tooltip_counter = 0;
+      show_tooltip(wmgui.tooltips[wmgui.tooltip_landing]);
+      return false;
+    });
+
+  // numeric search
+  on($('#numericbox'), 'div.slider_close', 'click', function () {
+    if ($$('div.slider_numerics').length == 1) {
+      destroy_numericbox();
+      delete wmgui.search.numeric;
+      const main_input = $('#search_field-selectized');
+      if (main_input) main_input.value = '';
+      wmgui.multiselects['main'].clear();
+      wmgui.multiselects['main'].write(wmgui.search);
+      return false;
+    }
+    const slider = this.parentNode.querySelector('div.slider_numerics');
+    if (slider && slider.noUiSlider) slider.noUiSlider.destroy();
+    const li = this.closest('li');
+    if (li)
+      fade_out(li, 250, function () {
+        li.remove();
+      });
+  });
+
+  $('#numericbox_do_trigger').addEventListener('click', function () {
+    var sliders_numerics = document.getElementsByClassName('slider_numerics'),
+      numeric = [];
+
+    for (var i = 0; i < sliders_numerics.length; i++) {
+      var sdata = sliders_numerics[i].noUiSlider.get(),
+        srange = sliders_numerics[i].noUiSlider.options.range,
+        srange = [srange.min, srange.max];
+      //if (sdata[0] == srange[0] && sdata[1] == srange[1]) continue;
+      //console.log(sdata);
+
+      var prop = sliders_numerics[i].getAttribute('rel');
+      numeric.push([prop, '>', sdata[0]]);
+      numeric.push([prop, '<', sdata[1]]);
+    }
+
+    if (numeric.length) wmgui.search.numeric = numeric;
+
+    if (isVisible($('#advsbox'))) $('#advsearch_do_trigger').click();
+    else $('#search_trigger').click();
+  });
+
+  $('#numericbox_drop_trigger').addEventListener('click', function () {
+    var sliders_numerics = document.getElementsByClassName('slider_numerics');
+
+    //console.log(sliders_numerics);
+
+    for (var i = 0; i < sliders_numerics.length; i++) {
+      var srange = sliders_numerics[i].noUiSlider.options.range;
+      sliders_numerics[i].noUiSlider.set([srange.min, srange.max]);
+    }
+  });
+
+  $('#close_numericbox').addEventListener('click', function () {
+    destroy_numericbox();
+    delete wmgui.search.numeric;
+    const main_input = $('#search_field-selectized');
+    if (main_input) main_input.value = '';
+    wmgui.multiselects['main'].clear();
+    wmgui.multiselects['main'].write(wmgui.search);
+  });
+
+  // mobile version switching
+  /*$('#mobilebox span').click(function(){
+        window.location.href = '/m/' + window.location.hash;
+    });
+    $('#mobilebox a').click(function(){
+        $('#mobilebox').remove();
+        return false;
+    });*/
+
+  // keys press
+  document.addEventListener('keydown', function (e) {
+    var key = window.event ? e.keyCode : e.which;
+    if (key == 13) {
+      // ENTER: input must trigger submit button via two parent divs!
+      var focused = document.activeElement;
+      //console.log(focused);
+
+      if (
+        focused &&
+        focused.classList &&
+        focused.classList.contains('submitter')
+      ) {
+        const target = focused.parentElement.parentElement.querySelector(
+          'div.def_submittable',
+        );
+        if (target) target.click();
+      } else if (
+        focused &&
+        focused.classList &&
+        (focused.classList.contains('advs_input') ||
+          (focused.id || '').startswith('advs_fct_'))
+      ) {
+        $('#advsearch_do_trigger').click();
+      }
+    } else if (key == 27) {
+      // ESC
+      // NB like $('div.cross:visible').trigger('click'): ALL visible crosses
+      // (collected first, as one click may hide the others)
+      $$('div.cross')
+        .filter(isVisible)
+        .forEach(function (cross) {
+          cross.click();
+        });
+    }
+  });
+
+  window.addEventListener('hashchange', url_redraw_react);
+
+  // execute a command in all the active GUI windows (except the current) e.g. setting a new state
+  const storage_runnables = {
+    tab_user_login: tab_user_login,
+    user_logout: user_logout,
+  };
+  window.addEventListener('storage', function (ev) {
+    if (ev.key != wmgui.store_comm_exec_key) return;
+
+    var runnable_name = ev.newValue;
+    if (runnable_name && storage_runnables[runnable_name])
+      storage_runnables[runnable_name]();
+  });
+
+  /*$(window).resize(function(){
+        //document.title = document.body.clientWidth + ' px';
+        if (document.body.clientWidth < 1000) $('#mobilebox').show();
+        else                                  $('#mobilebox').hide();
+    });*/
+
+  document
+    .querySelector('#ptable_previews')
+    .addEventListener('click', function (event) {
+      if (event.target.classList.contains('subphases_trigger')) {
+        var state = parseInt(event.target.getAttribute('data-state')),
+          req = Object.assign({}, wmgui.ptable.query),
+          param_str;
+
+        if (state === 1) {
+          param_str = 'strict=1';
+        } else {
+          param_str = 'subphases=1';
+          delete req.classes;
+        }
+        ajax_download(
+          wmgui.search_endpoint + '?q=' + JSON.stringify(req) + '&' + param_str,
+          render_left,
+          true,
+        );
+        wmgui.ptable.subphases_set(state);
+      }
+    });
+
+  // theme switcher
+  document.getElementById('darkmode_trigger').onclick = function () {
+    wmgui.darkmode.toggle();
+    document.getElementById('darkmode_trigger').innerHTML =
+      wmgui.darkmode.isActivated() ? 'enabled' : 'disabled';
+    document
+      .getElementById('comms')
+      .contentWindow.postMessage(
+        JSON.stringify({ darkmode: wmgui.darkmode.isActivated() ? 1 : 2 }),
+        '*',
+      );
+  };
+
+  // cross-site comms
+  window.addEventListener('message', function (message) {
+    //if (message.origin === 'https://trusted.com') {
+    var received = {};
+    try {
+      received = JSON.parse(message.data);
+    } catch (ignore) {}
+    var darkmode = received.darkmode;
+    if (darkmode !== undefined) {
+      darkmode = darkmode === 1;
+      if (darkmode !== wmgui.darkmode.isActivated()) wmgui.darkmode.toggle();
+      document.getElementById('darkmode_trigger').innerHTML =
+        wmgui.darkmode.isActivated() ? 'enabled' : 'disabled';
+    }
+    //}
+  });
+  // EOF register_events
+}
diff --git a/src_js/markup.js b/src_js/app/markup.js
old mode 100755
new mode 100644
similarity index 93%
rename from src_js/markup.js
rename to src_js/app/markup.js
index b553ec0..a9e4d62
--- a/src_js/markup.js
+++ b/src_js/app/markup.js
@@ -1,9 +1,13 @@
-"use strict";
+/**
+ * Ermac UI markup: injects the full application HTML into <body>.
+ */
 
-var wmgui = window.wmgui || {};
+export function register_html() {
+  document.body.insertAdjacentHTML(
+    'beforeend',
+    `
+<button type="button" id="a11y_skip">Skip to content</button>
 
-function register_html(){
-    $('body').append(`
 <div id="notifybox">Web-browser is either busy or not supported: try to <a href="javascript:location.reload()" rel="nofollow">restart</a></div>
 
 <div id="preloader"><div></div></div>
@@ -23,16 +27,16 @@ function register_html(){
 </div>
 
 <!-- SEARCH -->
-<div id="search_box">
+<div id="search_box" role="search">
     <div id="ermac_logo"><a href="#start"></a></div>
 
     <div id="search_area">
         <div id="search_holder">
             <select id="search_field" autocomplete="off" autofocus></select>
         </div>
-        <a href="#hierarchy" id="hierarchy_trigger" class="wmbutton" title="Show list of properties">&mu;<span><sub>x</sub><sup>&deg;</sup></span></a>
-        <a href="#" id="advsearch_init_trigger" class="wmbutton" title="Show search options">&#9776;</a>
-        <a href="#" id="search_trigger" class="wmbutton" title="Search">&#x23ce;</a>
+        <a href="#hierarchy" id="hierarchy_trigger" class="wmbutton" title="Show list of properties" aria-label="Show list of properties">&mu;<span><sub>x</sub><sup>&deg;</sup></span></a>
+        <a href="#" id="advsearch_init_trigger" class="wmbutton" title="Show search options" aria-label="Show search options">&#9776;</a>
+        <a href="#" id="search_trigger" class="wmbutton" title="Search" aria-label="Search">&#x23ce;</a>
     </div>
 
     <div id="legend"></div>
@@ -76,8 +80,74 @@ function register_html(){
     </div>
 </div>
 
+<!-- NB the side columns come before the results: Tab order (they are position:fixed) -->
+<!-- LEFT MAIN COLUMN -->
+<div id="refine_col" class="side_cols" role="navigation" aria-label="Filters">
+    <div class="col_title">Filters</div>
+    <div id="rfn_preloader"><div class="rect1"></div><div class="rect2"></div><div class="rect3"></div><div class="rect4"></div><div class="rect5"></div></div>
+    <ul></ul>
+
+    <div id="phases_ctx">
+        <div class="col_title">Distinct phases</div>
+        <br />
+        <div style="text-align:center;"><input type="checkbox" id="ctx_strict_phases_trigger" checked />&nbsp;<label for="ctx_strict_phases_trigger">include phases commonly reported together</label></div>
+        <!-- br />
+        &nbsp;<input type="checkbox" id="ctx_subphases_trigger" />&nbsp;<label for="ctx_subphases_trigger">constituent phases</label -->
+        <span>See the <a target="_blank" href="https://github.com/mpds-io/mpds-distinct-phases">public dumps</a> of the distinct phases appeared at least once in the literature.</span>
+    </div>
+
+    <div id="examples" class="examples">
+        <div class="col_title">Examples</div>
+        <ul></ul>
+    </div>
+</div>
+
+<!-- RIGHT MAIN COLUMN -->
+<div id="right_col" class="side_cols" role="complementary" aria-label="View and data types">
+    <div class="col_title">View</div>
+
+    <div class="controlswitch">
+        <div id="control_a">entries</div><div id="control_b">phases</div><div id="control_f">articles</div>
+    </div>
+
+    <div class="controlswitch">
+        <div id="control_c">table</div><div id="control_d">previews</div><div id="control_e">plots</div>
+    </div>
+
+    <ul id="interpret"></ul>
+
+    <div id="dtypes">
+        <div class="col_title">Data types</div>
+        <ul>
+            <li class="fct_props dtypes_props" data-facet="props" data-term="crystal structure">crystal structures</li>
+            <li class="fct_props dtypes_props" data-facet="props" data-term="phase diagram">phase diagrams</li>
+            <li class="fct_props dtypes_props" data-facet="props" data-term="physical properties">physical properties</li>
+            <li class="fct_classes dtypes_classes" data-facet="classes" data-term="peer-reviewed" style="margin-top:13px;">peer-reviewed experimental</li>
+            <li class="fct_classes dtypes_classes" data-facet="classes" data-term="machine-learning">machine learning</li>
+            <li class="fct_classes dtypes_classes" data-facet="classes" data-term="ab initio calculations">ab initio modeling</li>
+        </ul>
+    </div>
+
+    <div id="dtypes_phid" style="display:none;">
+        <div class="col_title">This phase</div>
+        <ul>
+            <li class="fct_props dtypes_props" data-rankfilter="5">crystal structures</li>
+            <li class="fct_props dtypes_props" data-rankfilter="3">phase diagrams</li>
+            <li class="fct_props dtypes_props" data-rankfilter="0,1,2,4,7,8,9,10">physical properties</li>
+            <li class="fct_classes dtypes_classes" data-rankfilter="0,1,2,3,4,5" style="margin-top:13px;">peer-reviewed experimental</li>
+            <li class="fct_classes dtypes_classes" data-rankfilter="7">machine learning</li>
+            <li class="fct_classes dtypes_classes" data-rankfilter="8,9,10">ab initio modeling</li>
+        </ul>
+    </div>
+
+    <div id="history">
+        <div class="col_title">Last searches</div>
+        <ul></ul>
+    </div>
+</div>
+
 <!-- DATAGRID -->
-<div id="main">
+<div id="main" role="main">
     <div id="results"><table id="databrowser"></table></div>
 
     <div id="loadscroll" class="context_msg">Getting the rest of data...</div>
@@ -301,29 +371,8 @@ function register_html(){
     </div>
 </div>
 
-<!-- LEFT MAIN COLUMN -->
-<div id="refine_col" class="side_cols">
-    <div class="col_title">Filters</div>
-    <div id="rfn_preloader"><div class="rect1"></div><div class="rect2"></div><div class="rect3"></div><div class="rect4"></div><div class="rect5"></div></div>
-    <ul></ul>
-
-    <div id="phases_ctx">
-        <div class="col_title">Distinct phases</div>
-        <br />
-        <div style="text-align:center;"><input type="checkbox" id="ctx_strict_phases_trigger" checked />&nbsp;<label for="ctx_strict_phases_trigger">include phases commonly reported together</label></div>
-        <!-- br />
-        &nbsp;<input type="checkbox" id="ctx_subphases_trigger" />&nbsp;<label for="ctx_subphases_trigger">constituent phases</label -->
-        <span>See the <a target="_blank" href="https://github.com/mpds-io/mpds-distinct-phases">public dumps</a> of the distinct phases appeared at least once in the literature.</span>
-    </div>
-
-    <div id="examples" class="examples">
-        <div class="col_title">Examples</div>
-        <ul></ul>
-    </div>
-</div>
-
 <!-- LEFT CONTEXT COLUMN -->
-<div id="ctx_col" class="side_cols">
+<div id="ctx_col" class="side_cols" role="complementary" aria-label="Entry">
     <div class="col_title">Entry <span id="entryno"></span> <div class="cross _close_ctx" style="margin:12px 2px 0 0;"></div></div>
 
     <div id="ml_data" class="spinoff_pane">
@@ -448,52 +497,8 @@ function register_html(){
     </div>
 </div>
 
-<!-- RIGHT MAIN COLUMN -->
-<div id="right_col" class="side_cols">
-    <div class="col_title">View</div>
-
-    <div class="controlswitch">
-        <div id="control_a">entries</div><div id="control_b">phases</div><div id="control_f">articles</div>
-    </div>
-
-    <div class="controlswitch">
-        <div id="control_c">table</div><div id="control_d">previews</div><div id="control_e">plots</div>
-    </div>
-
-    <ul id="interpret"></ul>
-
-    <div id="dtypes">
-        <div class="col_title">Data types</div>
-        <ul>
-            <li class="fct_props dtypes_props" data-facet="props" data-term="crystal structure">crystal structures</li>
-            <li class="fct_props dtypes_props" data-facet="props" data-term="phase diagram">phase diagrams</li>
-            <li class="fct_props dtypes_props" data-facet="props" data-term="physical properties">physical properties</li>
-            <li class="fct_classes dtypes_classes" data-facet="classes" data-term="peer-reviewed" style="margin-top:13px;">peer-reviewed experimental</li>
-            <li class="fct_classes dtypes_classes" data-facet="classes" data-term="machine-learning">machine learning</li>
-            <li class="fct_classes dtypes_classes" data-facet="classes" data-term="ab initio calculations">ab initio modeling</li>
-        </ul>
-    </div>
-
-    <div id="dtypes_phid" style="display:none;">
-        <div class="col_title">This phase</div>
-        <ul>
-            <li class="fct_props dtypes_props" data-rankfilter="5">crystal structures</li>
-            <li class="fct_props dtypes_props" data-rankfilter="3">phase diagrams</li>
-            <li class="fct_props dtypes_props" data-rankfilter="0,1,2,4,7,8,9,10">physical properties</li>
-            <li class="fct_classes dtypes_classes" data-rankfilter="0,1,2,3,4,5" style="margin-top:13px;">peer-reviewed experimental</li>
-            <li class="fct_classes dtypes_classes" data-rankfilter="7">machine learning</li>
-            <li class="fct_classes dtypes_classes" data-rankfilter="8,9,10">ab initio modeling</li>
-        </ul>
-    </div>
-
-    <div id="history">
-        <div class="col_title">Last searches</div>
-        <ul></ul>
-    </div>
-</div>
-
 <!-- RIGHT CONTEXT COLUMN -->
-<div id="sim_col" class="side_cols">
+<div id="sim_col" class="side_cols" role="complementary" aria-label="See also">
     <div class="col_title">See also <div class="cross _close_ctx" style="margin:12px 2px 0 0;"></div></div>
     <div id="sim_preloader"><div class="rect1"></div><div class="rect2"></div><div class="rect3"></div><div class="rect4"></div><div class="rect5"></div></div>
 
@@ -519,7 +524,7 @@ function register_html(){
 </div>
 
 <!-- ADVANCED SEARCH MODAL -->
-<div id="advsbox" class="modal user_dialogue">
+<div id="advsbox" class="modal user_dialogue" aria-label="Search options">
     <ul id="advstab_options">
         <li rev="advstab_bib">bibliography</li>
         <li rev="advstab_cry">crystallography</li>
@@ -532,22 +537,22 @@ function register_html(){
         <div class="advs advs_formulae">
             <div class="advs_capt">Chemical formula</div>
             <input type="text" id="advs_fct_formulae" class="advs_input" maxlength="200" spellcheck="false" /><!-- no autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">Ca3(PO4)2</a> or <a href="#" tabindex="-1">ABC3</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">Ca3(PO4)2</a> or <a href="#">ABC3</a></div>
         </div>
         <div class="advs advs_elements">
             <div class="advs_capt">Chemical elements</div>
             <input type="text" id="advs_fct_elements" class="advs_input" maxlength="100" spellcheck="false" /><!-- no autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">Co-Te-Pb</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">Co-Te-Pb</a></div>
         </div>
         <div class="advs advs_props">
             <div class="advs_capt">Physical property</div>
             <input type="text" id="advs_fct_props" class="advs_input" rel="props" maxlength="200" spellcheck="true" /><!-- simple autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">crystal structure</a> or <a href="#" tabindex="-1">EXAFS</a>, <span>see <a href="#hierarchy" style="color:#c00;border-bottom:1px solid #c00;">the hierarchy</a></span></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">crystal structure</a> or <a href="#">EXAFS</a>, <span>see <a href="#hierarchy" style="color:#c00;border-bottom:1px solid #c00;">the hierarchy</a></span></div>
         </div>
         <div class="advs advs_classes" style="margin-bottom:3vmin;">
             <div class="advs_capt">Materials class</div>
             <select id="advs_fct_classes" autocomplete="false"></select><!-- multiselect autocomplete -->
-            <div class="advs_legend" data-multiselects="classes"><i>e.g.</i> <a href="#" tabindex="-1">hydride, nonmetal</a> or <a href="#" tabindex="-1">olivine, ternary</a></div>
+            <div class="advs_legend" data-multiselects="classes"><i>e.g.</i> <a href="#">hydride, nonmetal</a> or <a href="#">olivine, ternary</a></div>
         </div>
     </div>
 
@@ -557,32 +562,32 @@ function register_html(){
         <div class="advs advs_authors">
             <div class="advs_capt">Publication author</div>
             <select id="advs_fct_authors" autocomplete="false"></select><!-- multiselect autocomplete -->
-            <div class="advs_legend" data-multiselects="authors"><i>e.g.</i> <a href="#" tabindex="-1">Maier, Merkle</a></div>
+            <div class="advs_legend" data-multiselects="authors"><i>e.g.</i> <a href="#">Maier, Merkle</a></div>
         </div>
         <div class="advs advs_years">
             <div class="advs_capt">Publication years</div>
             <input type="text" id="advs_fct_years" class="advs_input" maxlength="20" spellcheck="false" /><!-- no autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">2000-2021</a> or <a href="#" tabindex="-1">1955</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">2000-2021</a> or <a href="#">1955</a></div>
         </div>
         <div class="advs advs_codens">
             <div class="advs_capt">Journal or book</div>
             <input type="text" id="advs_fct_codens" class="advs_input" rel="codens" maxlength="200" style="letter-spacing:-1px;" spellcheck="true" /><!-- simple autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">Physical Review Letters</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">Physical Review Letters</a></div>
         </div>
         <div class="advs advs_doi">
             <div class="advs_capt">Publication DOI</div>
             <input type="text" id="advs_fct_doi" class="advs_input u-url url" maxlength="200" style="letter-spacing:-1px;" spellcheck="false" /><!-- no autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">10.1103/physrevb.88.241407</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">10.1103/physrevb.88.241407</a></div>
         </div>
         <div class="advs advs_geos">
             <div class="advs_capt">Geography</div>
             <input type="text" id="advs_fct_geos" class="advs_input geo" rel="geos" maxlength="150" spellcheck="true" /><!-- simple autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">USA</a> or <a href="#" tabindex="-1">Haikou, Hainan, China</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">USA</a> or <a href="#">Haikou, Hainan, China</a></div>
         </div>
         <div class="advs advs_orgs" style="margin-bottom:3vmin;">
             <div class="advs_capt">Organization</div>
             <input type="text" id="advs_fct_orgs" class="advs_input p-org org" rel="orgs" maxlength="200" spellcheck="true" /><!-- simple autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">Thermo-Calc</a> or <a href="#" tabindex="-1">Boeing</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">Thermo-Calc</a> or <a href="#">Boeing</a></div>
         </div>
     </div>
 
@@ -592,32 +597,32 @@ function register_html(){
         <div class="advs advs_lattices">
             <div class="advs_capt">Crystal system</div>
             <input type="text" id="advs_fct_lattices" class="advs_input" rel="lattices" maxlength="20" spellcheck="true" /><!-- simple autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">cubic</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">cubic</a></div>
         </div>
         <div class="advs advs_sgs">
             <div class="advs_capt">Space group</div>
             <input type="text" id="advs_fct_sgs" class="advs_input" rel="sgs" maxlength="10" spellcheck="false" /><!-- simple autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">Fm-3m</a> or <a href="#" tabindex="-1">225</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">Fm-3m</a> or <a href="#">225</a></div>
         </div>
         <div class="advs advs_wyckoff">
             <div class="advs_capt">Wyckoff search</div>
             <select id="advs_fct_wyckoff" autocomplete="false"></select><!-- multiselect autocomplete -->
-            <div class="advs_legend" data-multiselects="wyckoff"><i>e.g.</i> <a href="#" tabindex="-1">4a, 4b</a> or <a href="#" tabindex="-1" rel="dc2a">dc&#x00B2;a</a></div>
+            <div class="advs_legend" data-multiselects="wyckoff"><i>e.g.</i> <a href="#">4a, 4b</a> or <a href="#" rel="dc2a">dc&#x00B2;a</a></div>
         </div>
         <div class="advs advs_protos">
             <div class="advs_capt">Prototype</div>
             <input type="text" id="advs_fct_protos" class="advs_input" rel="protos" maxlength="100" spellcheck="false" /><!-- simple autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">Ca2Nb2O7 cF88 227</a> or <a href="#" tabindex="-1">D51</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">Ca2Nb2O7 cF88 227</a> or <a href="#">D51</a></div>
         </div>
         <div class="advs advs_aetypes">
             <div class="advs_capt">Polyhedral types</div>
             <select id="advs_fct_aetypes" autocomplete="false"></select><!-- multiselect autocomplete -->
-            <div class="advs_legend" data-multiselects="aetypes"><i>e.g.</i> <a href="#" tabindex="-1">octahedron 6-vertex</a>, <span>see <a href="#polyhedra" class="link_adjuster" style="color:#c00;border-bottom:1px solid #c00;">all polyhedra</a></span></div>
+            <div class="advs_legend" data-multiselects="aetypes"><i>e.g.</i> <a href="#">octahedron 6-vertex</a>, <span>see <a href="#polyhedra" class="link_adjuster" style="color:#c00;border-bottom:1px solid #c00;">all polyhedra</a></span></div>
         </div>
         <div class="advs advs_aeatoms">
             <div class="advs_capt">Polyhedron atoms</div>
             <input type="text" id="advs_fct_aeatoms" class="advs_input" maxlength="100" spellcheck="false" /><!-- no autocomplete -->
-            <div class="advs_legend"><i>e.g.</i> <a href="#" tabindex="-1">U</a> or <a href="#" tabindex="-1">X-Se</a> or <a href="#" tabindex="-1">UO6</a> or <a href="#" tabindex="-1">UX7</a></div>
+            <div class="advs_legend"><i>e.g.</i> <a href="#">U</a> or <a href="#">X-Se</a> or <a href="#">UO6</a> or <a href="#">UX7</a></div>
         </div>
 
         <div id="crtab">
@@ -639,7 +644,7 @@ function register_html(){
 </div>
 
 <!-- LOGIN MODAL -->
-<div id="loginbox" class="modal user_dialogue">
+<div id="loginbox" class="modal user_dialogue" aria-label="Log in">
     <div class="cross close_user_dialogue"></div>
     <br />
 
@@ -655,7 +660,7 @@ function register_html(){
 </div>
 
 <!-- FACTOR MODAL -->
-<div id="factorbox" class="modal user_dialogue">
+<div id="factorbox" class="modal user_dialogue" aria-label="Log in with an access code">
     <div class="cross close_user_dialogue"></div>
     <br />
 
@@ -680,7 +685,7 @@ function register_html(){
 </div>
 
 <!-- RESTORE MODAL -->
-<div id="restorebox" class="modal user_dialogue">
+<div id="restorebox" class="modal user_dialogue" aria-label="Restore the password">
     <div class="cross close_user_dialogue"></div>
     <br />
 
@@ -694,7 +699,7 @@ function register_html(){
 </div>
 
 <!-- USER MENU MODAL -->
-<div id="menubox" class="modal user_dialogue">
+<div id="menubox" class="modal user_dialogue" aria-label="Account">
     <ul id="tab_links">
         <li rev="usr_tab_account" class="working">account</li>
         <li rev="usr_tab_perms">data access</li>
@@ -796,7 +801,7 @@ function register_html(){
 <div id="tagcloudbox" class="menu_collateral"></div>
 
 <!-- NEW PROPS HIERARCHY MODAL -->
-<div id="hy_box" class="modal user_dialogue">
+<div id="hy_box" class="modal user_dialogue" aria-label="Physical properties">
     <ul id="hy_options">
         <li rev="hy_scalars" class="working">scalars</li>
         <li rev="hy_complex">objects</li>
@@ -827,7 +832,7 @@ function register_html(){
 <div id="visavis"><iframe id="visavis_iframe" frameborder=0 scrolling="no" width="100%" height="100%"></iframe></div>
 
 <!-- DISCOVERY SETTINGS MODAL -->
-<div id="discovery_custom_box" class="modal user_dialogue">
+<div id="discovery_custom_box" class="modal user_dialogue" aria-label="Discovery settings">
     <div id="close_dc_dialogue" class="cross"></div>
     <h3>Used properties</h3>
     <div id="discovery_enabled"></div>
@@ -838,7 +843,7 @@ function register_html(){
 </div>
 
 <!-- ALL POLYHEDRA MODAL -->
-<div id="all_polyhedra_box" class="modal user_dialogue">
+<div id="all_polyhedra_box" class="modal user_dialogue" aria-label="Polyhedral types">
     <div id="close_ph_dialogue" class="cross" style="margin:18px;"></div>
     <div style="width:100%;text-align:center;font-size:1.25em;line-height:4vh;letter-spacing:0.5px;padding:2.6em 0 0.5em;">The most common polyhedral types</div>
     <div class="divider"></div>
@@ -846,7 +851,7 @@ function register_html(){
 </div>
 
 <!-- SORTING SETTINGS MODAL -->
-<div id="ss_custom_box" class="modal user_dialogue">
+<div id="ss_custom_box" class="modal user_dialogue" aria-label="Plot settings">
     <div id="close_ss_dialogue" class="cross"></div>
     <div style="clear:both;width:100%;"></div>
     <div id="ss_x" class="ss_col"><h3>First axis</h3><ul></ul></div>
@@ -877,5 +882,6 @@ function register_html(){
 <!-- CROSS-SITE COMMS -->
 <iframe id="comms" src="https://app.absolidix.com/comms.html" style="width:0;height:0;border:none;position:absolute;"></iframe>
 <!-- iframe id="comms" src="http://localhost:5000/comms.html" style="width:0;height:0;border:none;position:absolute;"></iframe -->
-`);
+    `,
+  );
 }
diff --git a/src_js/app/ptable.js b/src_js/app/ptable.js
new file mode 100644
index 0000000..5b4b09d
--- /dev/null
+++ b/src_js/app/ptable.js
@@ -0,0 +1,639 @@
+/**
+ * Ermac interactive periodic table.
+ */
+
+import wmgui from '../core/settings.js';
+import { wmutils } from '../core/utils.js';
+import { ajax } from '../core/ajax.js';
+import { $, $$, hide, show } from '../core/dom.js';
+import { get_visavis_url } from './search.js';
+
+const ptable = {};
+wmgui.ptable = ptable;
+
+ptable.update_selectize = false;
+ptable.active_ajax = null;
+ptable.query = null;
+ptable.els_data = [];
+ptable.pdsvg_path = wmgui.static_host + '/pds_svgs';
+ptable.crsvg_path = wmgui.static_host + '/crs_svgs';
+ptable.ppsvg_path = wmgui.static_host + '/pps_svgs';
+ptable.first_el = null;
+ptable.second_el = null;
+ptable.visible = false; // needed to debounce
+ptable.activated = false; // should it "jump" on top by input
+ptable.dtypes = 1; // 0, 1, 2, or 3, see #ptable_dtypes
+ptable.subphases_button = '';
+ptable.vis_fixed = false;
+ptable.elements = ['X'].concat(wmutils.periodic_elements_cased);
+
+// patch display keyword unary to elementary
+ptable.arity_keys = wmutils.arity_keys.slice();
+ptable.arity_keys[1] = 'elementary';
+
+ptable.show = function () {
+  if (ptable.visible) return;
+  document.getElementById('ptable_holder').style.display = 'block';
+  ptable.visible = true;
+};
+
+ptable.hide = function () {
+  if (!ptable.visible) return;
+  document.getElementById('ptable_holder').style.display = 'none';
+  ptable.visible = false;
+};
+
+ptable.activate = function () {
+  ptable.activated = true;
+  document.getElementById('ermac_logo').classList.add('resulted');
+  document.getElementById('ptable_holder').classList.add('resulted');
+  if (window.scrollY <= 40)
+    document.getElementById('ptable_dtypes_box').classList.add('resulted');
+  wmgui.mpdsgui.ptable_activate();
+};
+
+ptable.deactivate = function () {
+  ptable.activated = false;
+  document.getElementById('ermac_logo').classList.remove('resulted');
+  document.getElementById('ptable_holder').classList.remove('resulted');
+  document.getElementById('ptable_dtypes_box').classList.remove('resulted');
+  wmgui.mpdsgui.ptable_deactivate();
+};
+
+ptable.decide = function () {
+  const scroll_pos = window.scrollY;
+  //console.log(scroll_pos);
+
+  if (scroll_pos > 60)
+    // forward to intro_stats screen
+    ptable.hide(); // back to ptable screen
+  else ptable.show();
+};
+
+ptable.subphases_set = function (state) {
+  if (!state) {
+    ptable.subphases_button = '';
+  } else if (state === 1) {
+    ptable.subphases_button =
+      '<div class="wmbutton subphases_trigger" data-state="2">Load binary and ternary phases <span>&uarr;</span></div>';
+  } else {
+    ptable.subphases_button =
+      '<div class="wmbutton subphases_trigger" data-state="1">Load ternary phases only <span>&uarr;</span></div>';
+  }
+};
+
+export function read_ptable_html() {
+  let unaries_data = [{}]; // NB zero-th element (X)
+
+  ptable.elements.forEach(function (_, idx) {
+    if (idx == 0 || idx > 103)
+      // X - Lr
+      return;
+
+    const item = document.querySelector(
+      '#ptable_area > ul > li[data-pos="' + idx + '"]',
+    );
+    let elem_data = { pos: idx, classes: [] }; // NB prop html:
+
+    item.classList.forEach(function (cls) {
+      elem_data.classes.push(cls);
+    });
+
+    unaries_data.push(elem_data);
+  });
+  return unaries_data;
+}
+
+function removeAllCls(cls) {
+  const collection = document.getElementsByClassName(cls);
+  while (collection.length) collection[0].classList.remove(cls);
+}
+
+function clear_results_area() {
+  try {
+    ptable.active_ajax.abort();
+  } catch (e) {}
+  document.getElementById('ptable_previews').innerHTML = '';
+  document.getElementById('ptable_vis').innerHTML = '';
+  ptable.deactivate();
+}
+
+function refresh_ptable_results(elA, elB, elC) {
+  if (wmgui.view_mode !== 1) return;
+
+  //console.log('Refreshing table with ' + [elA, elB, elC]);
+
+  const els = [elA, elB, elC].filter(function (item) {
+      return !!item;
+    }),
+    query_ph = els.length
+      ? {
+          search_type: 1,
+          classes: wmutils.arity_keys[els.length],
+          elements: els.join('-'),
+        }
+      : false;
+
+  if (ptable.update_selectize) {
+    ptable.update_selectize = false;
+
+    wmgui.multiselects['main'].clear();
+    wmgui.multiselects['main'].write({ elements: els.join('-') });
+  }
+
+  ptable.subphases_set();
+
+  if (query_ph) {
+    ptable.query = query_ph;
+    ptable.vis_fixed = false;
+
+    let iframe_addr,
+      iframe_height = 900;
+
+    if (els.length == 1) {
+      if (ptable.dtypes == 2) {
+        iframe_addr = wmgui.engines_addrs['cifplayer'];
+        ptable.vis_fixed = true;
+      } else if (ptable.dtypes == 3) {
+        iframe_addr = wmgui.engines_addrs['visavis'];
+        ptable.vis_fixed = true;
+      } else document.getElementById('ptable_vis').innerHTML = '';
+    } else if (els.length == 2) {
+      iframe_height = 800;
+
+      if (ptable.dtypes == 1) {
+        const query_pds = {
+          search_type: 0,
+          classes: wmutils.arity_keys[els.length],
+          elements: els.join('-'),
+          props: 'phase diagram',
+        };
+        ajax_download(
+          wmgui.search_endpoint + '?q=' + JSON.stringify(query_pds),
+          render_right,
+          false,
+        );
+      } else if (ptable.dtypes == 2) {
+        iframe_addr = wmgui.engines_addrs['cifplayer'];
+        ptable.vis_fixed = true;
+      } else if (ptable.dtypes == 3) {
+        iframe_addr = wmgui.engines_addrs['visavis'];
+        ptable.vis_fixed = true;
+      } else document.getElementById('ptable_vis').innerHTML = '';
+    } else {
+      ptable.subphases_set(1);
+      iframe_height = window.innerHeight - 200;
+      ptable.vis_fixed = true;
+
+      if (ptable.dtypes == 1) {
+        iframe_addr = wmgui.v_pd_3d_addr + els.join('-');
+      } else if (ptable.dtypes == 2) {
+        iframe_addr = wmgui.engines_addrs['cifplayer'];
+      } else if (ptable.dtypes == 3) {
+        iframe_addr = wmgui.engines_addrs['visavis'];
+      } else document.getElementById('ptable_vis').innerHTML = '';
+    }
+    ajax_download(
+      wmgui.search_endpoint + '?q=' + JSON.stringify(query_ph) + '&strict=1',
+      render_left,
+      true,
+    );
+
+    if (iframe_addr)
+      document.getElementById('ptable_vis').innerHTML =
+        '<iframe frameborder=0 scrolling="no" width="100%" height="' +
+        iframe_height +
+        '" src="' +
+        iframe_addr +
+        '"></iframe>';
+
+    ptable.activate();
+  } else clear_results_area();
+}
+
+export function ajax_download(url, callback, reuse) {
+  wmgui.show_preloader();
+  if (reuse && ptable.active_ajax && ptable.active_ajax.abort) {
+    try {
+      ptable.active_ajax.abort();
+    } catch (e) {}
+  }
+  const request = ajax({ url: url, dataType: 'text' });
+  if (reuse) ptable.active_ajax = request;
+  request
+    .then(function (response_text) {
+      wmgui.hide_preloader();
+      callback(response_text);
+    })
+    .catch(function (error) {
+      wmgui.hide_preloader();
+      if (error && !error.aborted)
+        console.error(
+          'Error: HTTP ' +
+            error.status +
+            ' status received during data retrieval from the server',
+        );
+    });
+}
+
+export function render_left(data) {
+  data = JSON.parse(data);
+  if (data.error) return wmgui.notify(data.error);
+
+  const header =
+    '<h4>Reported phases of ' +
+    ptable.arity_keys[wmutils.arity_keys.indexOf(ptable.query.classes)] +
+    ' ' +
+    ptable.query.elements +
+    (ptable.query.elements.indexOf('-') == -1 ? '' : ' system') +
+    '</h4>';
+
+  const parent = document.getElementById('ptable_previews');
+  parent.className = '';
+  parent.classList.add('ptable_dtype_' + ptable.dtypes);
+  parent.innerHTML =
+    header +
+    (data.out.length ? build_thumbs_ph(data.out) : '<p>No results</p>') +
+    ptable.subphases_button;
+
+  if (data.out.length < 10) ptable.vis_fixed = false; // prevent screen jumping
+
+  if (ptable.dtypes == 2) {
+    const els = document.querySelectorAll(
+      '#ptable_results div.gallery_img.renderable',
+    );
+    if (els.length) {
+      const rnd_i = Math.floor(Math.random() * els.length);
+      els[rnd_i].parentNode.classList.add('active');
+      const phid = els[rnd_i].getAttribute('rel'),
+        target = document.querySelector('#ptable_vis > iframe'),
+        target_addr =
+          '#' + wmgui.phase_endpoint + '?phid=' + phid + '&struct=1';
+
+      if (target) target.contentWindow.location.hash = target_addr;
+      else
+        document.getElementById('ptable_vis').innerHTML =
+          '<iframe frameborder=0 scrolling="no" width="100%" height="850" src="' +
+          wmgui.engines_addrs['cifplayer'] +
+          target_addr +
+          '"></iframe>';
+    } else document.getElementById('ptable_vis').innerHTML = '';
+  } else if (ptable.dtypes == 3) {
+    const els = document.querySelectorAll(
+      '#ptable_results div.gallery_img.renderable',
+    );
+    if (els.length) {
+      const rnd_i = Math.floor(Math.random() * els.length);
+      els[rnd_i].parentNode.classList.add('active');
+      const phid = els[rnd_i].getAttribute('rel'),
+        target = document.querySelector('#ptable_vis > iframe'),
+        target_addr = get_visavis_url(
+          { phid: phid },
+          'graph',
+          window.innerHeight - 50,
+        );
+
+      if (target) target.contentWindow.location.replace(target_addr);
+      else
+        document.getElementById('ptable_vis').innerHTML =
+          '<iframe frameborder=0 scrolling="no" width="100%" height="850" src="' +
+          target_addr +
+          '"></iframe>';
+    } else document.getElementById('ptable_vis').innerHTML = '';
+  }
+}
+
+function render_right(data) {
+  data = JSON.parse(data);
+  if (data.error) return wmgui.notify(data.error);
+
+  if (data.fuzzy_notice || !data.out.length)
+    document.getElementById('ptable_vis').innerHTML = '';
+  else
+    document.getElementById('ptable_vis').innerHTML =
+      '<h4>Reported phase diagrams of ' +
+      ptable.query.elements +
+      ' system</h4>' +
+      build_thumbs_pd(data.out);
+}
+
+function render_unaries() {
+  if (!ptable.first_el) return;
+
+  ptable.els_data.forEach(function (elem_data) {
+    if (!elem_data.pos) return;
+
+    const that = document.querySelector(
+      '#ptable_area > ul > li[data-pos="' + elem_data.pos + '"]',
+    );
+    that.style.backgroundImage = 'none';
+    //that.innerHTML = elem_data.html;
+    that.className = '';
+    that.classList.add(...elem_data.classes);
+  });
+
+  ptable.first_el = null;
+}
+
+function render_binaries(elA, elB) {
+  //console.log('RENDERING BINARIES FOR: ' + [elA, elB]);
+
+  document.querySelectorAll('#ptable_area > ul > li').forEach(function (item) {
+    if (!item.hasAttribute('data-pos')) return;
+
+    const current_el = ptable.elements[parseInt(item.getAttribute('data-pos'))];
+
+    if (ptable.dtypes == 1) {
+      if (current_el != elA && current_el != elB) {
+        item.style.backgroundImage =
+          "url('" +
+          ptable.pdsvg_path +
+          '/bin/' +
+          elA +
+          '-' +
+          current_el +
+          ".svg')";
+        item.className = 'active_a';
+      }
+    } else if (ptable.dtypes == 2) {
+      if (current_el != elA && current_el != elB) {
+        let pair = [elA, current_el];
+        pair.sort();
+        item.style.backgroundImage =
+          "url('" + ptable.crsvg_path + '/bin/' + pair.join('-') + ".svg')";
+        item.className = 'active_a';
+      }
+    } else if (ptable.dtypes == 3) {
+      if (current_el != elA && current_el != elB) {
+        let pair = [elA, current_el];
+        pair.sort();
+        item.style.backgroundImage =
+          "url('" + ptable.ppsvg_path + '/bin/' + pair.join('-') + ".svg')";
+        item.className = 'active_a';
+      }
+    } else {
+      if (current_el != elA && current_el != elB) {
+        item.style.backgroundImage = 'none';
+        item.className = 'active_a';
+      } else if (current_el == elA) {
+        item.className = 'selected_a';
+        item.classList.add(
+          ...ptable.els_data[parseInt(item.getAttribute('data-pos'))].classes,
+        );
+      }
+    }
+  });
+}
+
+function render_ternaries(elA, elB) {
+  //console.log('RENDERING TERNARIES FOR: ' + [elA, elB]);
+
+  document.querySelectorAll('#ptable_area > ul > li').forEach(function (item) {
+    if (!item.hasAttribute('data-pos')) return;
+
+    const current_el = ptable.elements[parseInt(item.getAttribute('data-pos'))];
+
+    if (ptable.dtypes == 1) {
+      if (current_el != elA && current_el != elB) {
+        let triple = [elA, elB, current_el];
+        triple.sort();
+        item.style.backgroundImage =
+          "url('" + ptable.pdsvg_path + '/ter/' + triple.join('-') + ".svg')";
+        item.classList.add('active_b');
+      }
+    } else if (ptable.dtypes == 2) {
+      if (current_el != elA && current_el != elB) {
+        let triple = [elA, elB, current_el];
+        triple.sort();
+        item.style.backgroundImage =
+          "url('" + ptable.crsvg_path + '/ter/' + triple.join('-') + ".svg')";
+        item.classList.add('active_b');
+      }
+    } else if (ptable.dtypes == 3) {
+      if (current_el != elA && current_el != elB) {
+        let triple = [elA, elB, current_el];
+        triple.sort();
+        item.style.backgroundImage =
+          "url('" + ptable.ppsvg_path + '/ter/' + triple.join('-') + ".svg')";
+        item.classList.add('active_b');
+      }
+    } else {
+      if (current_el != elA && current_el != elB) {
+        item.style.backgroundImage = 'none';
+        item.classList.add('active_b');
+      } else if (current_el == elA) {
+        item.className = 'selected_a';
+        item.classList.add(
+          ...ptable.els_data[parseInt(item.getAttribute('data-pos'))].classes,
+        );
+      } else if (current_el == elB) {
+        item.className = 'selected_b';
+      }
+    }
+  });
+}
+
+function build_thumbs_ph(json) {
+  // FIXME duplicates another function *build_thumbs*
+  let result_html = '';
+
+  json.sort(function (a, b) {
+    return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
+  });
+
+  json.forEach(function (row) {
+    result_html += '<div class="gallery_item">';
+    result_html +=
+      '  <div class="gallery_img' +
+      (row[2] !== '&mdash;' ? ' renderable' : '') +
+      '" rel="' +
+      row[0] +
+      '" style="background-image:url(https://mpds.io/phid_thumbs/' +
+      row[0] +
+      '.png);"><span><p>' +
+      row[1] +
+      '<br />space group ' +
+      row[2] +
+      '</p></span></div>';
+    result_html +=
+      '  <div class="gallery_label"><a class="launch_id" href="#phase_id/' +
+      row[0] +
+      '">Show ' +
+      row[3] +
+      (row[3] == 1 ? ' entry' : ' entries') +
+      '</a><br />Publications: ' +
+      row[4] +
+      '</div>';
+    result_html += '</div>';
+  });
+  return result_html;
+}
+
+function build_thumbs_pd(json) {
+  // FIXME duplicates another function *build_thumbs*
+  let result_html = '';
+
+  json.sort(function (a, b) {
+    return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
+  });
+
+  json.forEach(function (row) {
+    if (row[3] == 0)
+      // filter unprocs
+      return;
+    row[2] = row[2].split(';')[0];
+    row[2] = row[2].split(' ')[row[2].split(' ').length - 1];
+    const content =
+      '<img alt="' +
+      row[0] +
+      '" src="https://mpds.io/pd_thumbs/' +
+      row[0].split('-')[0] +
+      '.png" /><p>' +
+      row[2] +
+      '</p>';
+
+    result_html +=
+      '<div class="gallery_item' + (row[4] ? ' opened' : '') + '">';
+    result_html +=
+      '  <div class="gallery_img" rel="' +
+      row[0] +
+      '" data-path="entry">' +
+      content +
+      '</div>';
+    result_html +=
+      '  <div class="gallery_label"><a class="launch_id" href="#entry/' +
+      row[0] +
+      '">' +
+      row[0] +
+      '</a>' +
+      '<br />[' +
+      row[5] +
+      '&rsquo;' +
+      row[6].toString().substr(2, 2) +
+      ']' +
+      '</div>';
+    result_html += '</div>';
+  });
+  return result_html;
+}
+
+export function select_ptable_el(selected_el, dom_el) {
+  //console.log('Selected element is ' + selected_el);
+
+  if (!dom_el) {
+    const found = document.querySelector(
+      '#ptable_area > ul > li[data-pos="' +
+        ptable.elements.indexOf(selected_el) +
+        '"]',
+    );
+    if (!found) return wmgui.notify('Sorry, wrong element: ' + selected_el);
+    dom_el = found;
+  }
+
+  if (dom_el.classList.contains('selected_a')) {
+    // first element removal
+    dom_el.classList.remove('selected_a');
+    render_unaries();
+    refresh_ptable_results();
+  } else if (dom_el.classList.contains('selected_b')) {
+    // second element removal
+    dom_el.classList.remove('selected_b');
+    render_binaries(ptable.first_el, selected_el);
+    ptable.second_el = null;
+    refresh_ptable_results(ptable.first_el);
+  } else if (dom_el.classList.contains('selected_c')) {
+    // third element removal
+    dom_el.classList.remove('selected_c');
+    refresh_ptable_results(ptable.first_el, ptable.second_el);
+  } else if (dom_el.classList.contains('active_b')) {
+    // third element selection
+    removeAllCls('selected_c');
+    dom_el.classList.add('selected_c');
+    refresh_ptable_results(ptable.first_el, ptable.second_el, selected_el);
+  } else if (dom_el.classList.contains('active_a')) {
+    // second element selection
+    removeAllCls('selected_b');
+    dom_el.classList.add('selected_b');
+    render_ternaries(ptable.first_el, selected_el);
+    ptable.second_el = selected_el;
+    refresh_ptable_results(ptable.first_el, selected_el);
+  } else {
+    // first element selection
+    dom_el.classList.add('selected_a');
+    ptable.first_el = selected_el;
+    render_binaries(ptable.first_el, selected_el);
+    refresh_ptable_results(selected_el);
+  }
+}
+
+export function select_ptable_series(els) {
+  //console.log('Received for TABLE DRAW: ' + els);
+  if (!els) {
+    render_unaries();
+    clear_results_area();
+    return;
+  }
+
+  els = els.split('-');
+  if (els.length > 3) els = els.slice(0, 3);
+
+  ptable.first_el = els[0];
+  ptable.second_el = els[1] || null;
+
+  const domelA = document.querySelector(
+    '#ptable_area > ul > li[data-pos="' +
+      ptable.elements.indexOf(els[0]) +
+      '"]',
+  );
+
+  if (domelA) {
+    removeAllCls('selected_a');
+    domelA.classList.add('selected_a');
+  }
+
+  if (els.length == 1) {
+    render_binaries(els[0], els[0]);
+  } else if (els.length == 2) {
+    const domelB = document.querySelector(
+      '#ptable_area > ul > li[data-pos="' +
+        ptable.elements.indexOf(els[1]) +
+        '"]',
+    );
+
+    if (domelB) {
+      removeAllCls('selected_b');
+      domelB.classList.add('selected_b');
+      domelB.classList.add(
+        ...ptable.els_data[parseInt(domelB.getAttribute('data-pos'))].classes,
+      );
+      domelB.style.backgroundImage = 'none';
+    }
+    render_ternaries(els[0], els[1]);
+  } else {
+    const domelB = document.querySelector(
+        '#ptable_area > ul > li[data-pos="' +
+          ptable.elements.indexOf(els[1]) +
+          '"]',
+      ),
+      domelC = document.querySelector(
+        '#ptable_area > ul > li[data-pos="' +
+          ptable.elements.indexOf(els[2]) +
+          '"]',
+      );
+
+    if (domelB) {
+      removeAllCls('selected_b');
+      domelB.classList.add('selected_b');
+      domelB.classList.add(
+        ...ptable.els_data[parseInt(domelB.getAttribute('data-pos'))].classes,
+      );
+      domelB.style.backgroundImage = 'none';
+    }
+    if (domelC) {
+      removeAllCls('selected_c');
+      domelC.classList.add('selected_c');
+    }
+    render_ternaries(els[0], els[1]);
+  }
+  refresh_ptable_results(...els);
+}
diff --git a/src_js/app/router.js b/src_js/app/router.js
new file mode 100644
index 0000000..a6e0445
--- /dev/null
+++ b/src_js/app/router.js
@@ -0,0 +1,530 @@
+/**
+ * Ermac hash-based router: the url__<route>() functions.
+ * Dispatch happens via an explicit route registry instead of the old window globals.
+ */
+
+import wmgui from '../core/settings.js';
+import { wmutils } from '../core/utils.js';
+import { $, $$, show, hide, set_html, set_val } from '../core/dom.js';
+import { ajax } from '../core/ajax.js';
+import {
+  switch_view_mode,
+  show_interpretation,
+  request_search,
+  show_tooltip,
+  show_modal,
+  arrange_menu_collateral,
+  user_login,
+  force_relogin,
+  describe_perms,
+  start_visavis,
+  render_all_polyhedra,
+} from './search.js';
+
+export function url_redraw_react() {
+  var anchors = window.location.hash.substr(1).split('/');
+
+  if (!anchors.length) return;
+  hide($$('#overlay, #aetmap, #dtypes_phid, div.modal, div.menu_collateral'));
+  $$('#dtypes_phid > ul > li').forEach(function (li) {
+    li.classList.remove('active');
+  });
+
+  try {
+    wmgui.active_ajax.abort();
+  } catch (e) {}
+  try {
+    wmgui.quick_ajax.abort();
+  } catch (e) {}
+
+  const route = routes[anchors[0]];
+  if (route) route(anchors.slice(1).join('/'));
+  else wmgui.notify('Sorry, unknown route requested');
+}
+
+/**
+ * The main landing route /#start
+ */
+function url__start(arg) {
+  switch_view_mode(1);
+  if (wmgui.tooltip_counter < 2)
+    setTimeout(function () {
+      show_tooltip(wmgui.tooltips[wmgui.tooltip_landing]);
+    }, 4000);
+}
+
+/**
+ * A free-form fuzzy search /#search/arg
+ * given by the OptimadeNLP wmutils
+ */
+function url__search(arg, no_sync) {
+  var query = decodeURIComponent(arg),
+    parsed = wmutils.guess(query);
+  //console.log(parsed);
+
+  if (parsed.numeric) wmgui.search_type = 1;
+
+  show_interpretation(parsed);
+  delete parsed.ignored;
+
+  const main_input = $('#search_field-selectized');
+  if (main_input) main_input.value = '';
+  wmgui.multiselects['main'].clear();
+  wmgui.multiselects['main'].write(parsed);
+
+  wmgui.search = parsed;
+  parsed.search_type = wmgui.search_type;
+
+  if (!no_sync) request_search(parsed, query, wmgui.search_type);
+}
+
+/**
+ * The parameters-based exact search /#inquiry/arg
+ */
+function url__inquiry(arg, no_sync) {
+  var inquiry = arg.split('&').map(
+    function (n) {
+      return ((n = n.split('=')), (this[n[0]] = n[1]), this);
+    }.bind({}),
+  )[0];
+
+  wmgui.facets.forEach(function (item) {
+    if (inquiry[item])
+      inquiry[item] = decodeURIComponent(inquiry[item].replaceAll('+', ' '));
+  });
+
+  // re-inventing serialization for numeric nested arrays
+  if (inquiry.numeric) {
+    inquiry.numeric = decodeURIComponent(inquiry.numeric)
+      .split(';')
+      .map(function (item) {
+        return item.split(',');
+      });
+    inquiry.numeric = inquiry.numeric.filter(function (item) {
+      return item.length == 3;
+    });
+    wmgui.search_type = 1; // force phases search type
+  }
+  //console.log(inquiry);
+
+  show_interpretation(inquiry);
+  delete inquiry.ignored;
+
+  var caption_items = [];
+  for (var k in inquiry) {
+    caption_items.push(inquiry[k]);
+  }
+
+  const main_input = $('#search_field-selectized');
+  if (main_input) main_input.value = '';
+  wmgui.multiselects['main'].clear();
+  wmgui.multiselects['main'].write(inquiry);
+
+  wmgui.search = inquiry;
+  inquiry.search_type = wmgui.search_type;
+
+  if (!no_sync)
+    request_search(
+      inquiry,
+      caption_items.join(' ').replaceAll(',', ' '),
+      wmgui.search_type,
+    );
+}
+
+/**
+ * The 3 brothers routing exact search into the search_type (TODO?)
+ */
+function url__inquiry_entries(arg) {
+  wmgui.search_type = 0;
+  return url__inquiry(arg);
+}
+function url__inquiry_phases(arg) {
+  wmgui.search_type = 1;
+  return url__inquiry(arg);
+}
+function url__inquiry_articles(arg) {
+  wmgui.search_type = 2;
+  return url__inquiry(arg);
+}
+
+/**
+ * The plotting subsystem (Vis-a-vis) /#plot/arg
+ */
+function url__plot(arg) {
+  var q = arg.split('/'),
+    plot_type = q[0],
+    search_verb = q[1],
+    query = q[2];
+
+  if (!plot_type || !search_verb || !query)
+    return wmgui.notify('Sorry, unknown route: ' + arg);
+
+  if (search_verb == 'search') url__search(query, true);
+  else if (search_verb == 'inquiry') url__inquiry(query, true);
+  else return wmgui.notify('Sorry, unknown route: ' + arg);
+
+  wmgui.visavis_curtype = plot_type;
+
+  //if (wmgui.view_mode == 1)
+  switch_view_mode(2);
+
+  setTimeout(function () {
+    start_visavis(plot_type);
+  }, 0);
+
+  if (
+    wmgui.tooltip_counter < 2 &&
+    (plot_type == 'matrix' || plot_type == 'cube')
+  ) {
+    setTimeout(function () {
+      show_tooltip(wmgui.tooltips['ss_axes'], true);
+    }, 3000);
+  }
+}
+
+/**
+ * The individual entry display /#entry/ID
+ */
+function url__entry(arg) {
+  wmgui.search_type = 0;
+  wmgui.visavis_terminating = true;
+  request_search({ entry: arg }, 'entry ' + arg, true);
+  wmgui.search = {}; // mockup to reset previous properties
+  wmgui.passive_sim_col = true;
+  const main_input = $('#search_field-selectized');
+  if (main_input) main_input.value = '';
+  wmgui.multiselects['main'].clear();
+  show_interpretation();
+}
+
+/**
+ * The individual phase display /#phase_id/integer
+ */
+function url__phase_id(arg) {
+  wmgui.search_type = 0;
+  if (!wmgui.ptable.visible) {
+    const main_input = $('#search_field-selectized');
+    if (main_input) main_input.value = '';
+    wmgui.multiselects['main'].clear();
+  }
+  show_interpretation();
+  var phid = parseInt(arg);
+  wmgui.search = { phid: phid };
+  wmgui.search.search_type = wmgui.search_type;
+  request_search({ phid: phid }, 'phase ' + phid, true);
+}
+
+/**
+ * The individual phase display /#phase/ID
+ */
+function url__phase(arg) {
+  var phase_data = arg.split('/'),
+    formula = phase_data[0],
+    spg = phase_data[1],
+    pearson = phase_data[2];
+
+  if (formula && spg && pearson) {
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'GET',
+      url: wmgui.phph_endpoint,
+      data: { phase: [formula, spg, pearson].join('/') },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (data) {
+        wmgui.hide_preloader();
+        if (data.error) return wmgui.notify(data.error);
+        window.location.replace('#phase_id/' + data.phid);
+      })
+      .catch(function (error) {
+        wmgui.hide_preloader();
+        if (!(error && error.aborted))
+          wmgui.notify('Sorry, a network error occured. Please, try again');
+      });
+  } else return wmgui.notify('Sorry, wrong phase given');
+}
+
+/**
+ * The individual B-entry display /#article/integer
+ */
+function url__article(arg) {
+  wmgui.search_type = 0;
+  const main_input = $('#search_field-selectized');
+  if (main_input) main_input.value = '';
+  wmgui.multiselects['main'].clear();
+  show_interpretation();
+  var bentry = parseInt(arg);
+  wmgui.search = { bid: bentry };
+  wmgui.search.search_type = wmgui.search_type;
+  request_search({ bid: bentry }, 'B' + bentry, true);
+}
+
+/**
+ * The display of menu with all the physical props
+ */
+function url__hierarchy() {
+  document.body.classList.remove('noscroll');
+  show($('#overlay'));
+  window.scrollTo(0, 0);
+  show($('#hy_box'));
+}
+
+/**
+ * The different types of modal windows
+ */
+function url__modal(arg) {
+  //var url_params = new URLSearchParams(window.location.search),
+  //    redir = url_params.get('redir');
+
+  if (arg == 'login') {
+    if (wmgui.sid) return window.location.replace('#modal/menu');
+
+    // edition-based OAuth login (mpdsgui only)
+    if (wmgui.edition == 1) {
+      return window.location.replace('oauth/asm.html'); // NB history replacement
+    }
+    show_modal(arg);
+  } else if (arg == 'restore' || arg == 'factor') {
+    if (wmgui.sid) return window.location.replace('#modal/menu');
+    show_modal(arg);
+  } else if (arg == 'menu') {
+    if (!wmgui.sid) return window.location.replace('#modal/login');
+    set_val($('#new_password_1'), '');
+    set_val($('#new_password_2'), '');
+    arrange_menu_collateral();
+    show($$('#menubox, div.menu_collateral'));
+  } else return wmgui.notify('Sorry, unknown modal window');
+
+  show($('#overlay'));
+}
+
+/**
+ * Retrieving the access via email by the secret link
+ */
+function url__access(arg) {
+  ajax({
+    type: 'POST',
+    url: wmgui.access_endpoint,
+    data: { a: arg, ed: wmgui.edition },
+  })
+    .then(function (data) {
+      if (data.error) {
+        window.location.replace('#start');
+        return wmgui.notify(data.error);
+      }
+      if (!data.sid || !data.name || !data.acclogin) {
+        window.location.replace('#start');
+        return wmgui.notify(
+          'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+        );
+      }
+      user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
+      window.location.replace('#start');
+    })
+    .catch(function () {
+      window.location.replace('#start');
+      return wmgui.notify('Sorry, a network error occured. Please, try again');
+    });
+}
+
+/**
+ * Confirming the access via email by the secret link
+ */
+function url__ratify(arg) {
+  ajax({
+    type: 'POST',
+    url: wmgui.ratify_endpoint,
+    data: { a: arg, ed: wmgui.edition },
+  })
+    .then(function (data) {
+      if (data.error) {
+        window.location.replace('#start');
+        return wmgui.notify(data.error);
+      }
+      if (!data.sid || !data.name || !data.acclogin) {
+        window.location.replace('#start');
+        return wmgui.notify(
+          'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+        );
+      }
+      user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
+      window.location.replace('#modal/menu');
+    })
+    .catch(function () {
+      window.location.replace('#start');
+      return wmgui.notify('Sorry, a network error occured. Please, try again');
+    });
+}
+
+/**
+ * A special display of the related entries
+ */
+function url__interlinkage(arg) {
+  wmgui.search_type = 1;
+  request_search({ interlinkage: arg }, 'linked phases for ' + arg, true);
+  wmgui.search = { numeric: true }; // mockup FIXME?
+  //$('#search_field-selectized').val('');
+  //wmgui.multiselects['main'].clear();
+  show_interpretation();
+}
+
+/**
+ * All polyhedra menu
+ */
+function url__polyhedra(arg) {
+  document.body.classList.remove('noscroll');
+  show($('#overlay'));
+  window.scrollTo(0, 0);
+  render_all_polyhedra();
+  show($('#all_polyhedra_box'));
+}
+
+/**
+ * Access denied route: trying to identify the reason
+ */
+function url__junction(arg) {
+  if (!wmgui.sid) return window.location.replace('#products');
+
+  var locals = JSON.parse(
+    window.localStorage.getItem(wmgui.store_user_key) || '{}',
+  );
+
+  wmgui.show_preloader();
+  const request = ajax({
+    type: 'POST',
+    url: locals.ipbased ? wmgui.ip_perms_endpoint : wmgui.perms_endpoint,
+    data: { sid: wmgui.sid },
+  });
+  wmgui.active_ajax = request;
+
+  request
+    .then(function (data) {
+      wmgui.hide_preloader();
+
+      if (data.error) return wmgui.notify(data.error);
+
+      if (!data.hasOwnProperty('gui') || !data.hasOwnProperty('api'))
+        return force_relogin('Please, re-login');
+
+      window.location.replace('#modal/menu');
+      $$('#tab_links > li').forEach(function (li) {
+        li.classList.remove('working');
+      });
+      $$('#tab_links > li[rev=usr_tab_perms]').forEach(function (li) {
+        li.classList.add('working');
+      });
+      hide($$('div.menu_tabs'));
+      show($('#usr_tab_perms'));
+      set_html($('#perms_view'), describe_perms(data));
+      setTimeout(function () {
+        wmgui.notify('Please, check your data access.');
+      }, 1500);
+    })
+    .catch(function (error) {
+      wmgui.hide_preloader();
+      if (!(error && error.aborted)) return force_relogin('Please, re-login');
+    });
+}
+
+/**
+ * Moved from mpdsgui
+ */
+function url__products(arg) {
+  if (!wmgui.mpds_native)
+    window.location.href = wmgui.static_host + '/#products';
+
+  if (wmgui.edition === 1) {
+    // NB no history replacement and no new windows
+    window.location.href =
+      'https://www.asminternational.org/asm-materials-platform-for-data-science-api';
+  } else {
+    show($('#overlay'));
+    window.scrollTo(0, 0);
+    show($('#productbox'));
+  }
+}
+
+/**
+ * Moved from mpdsgui
+ */
+function url__formal(arg) {
+  if (!wmgui.mpds_native)
+    window.location.href = wmgui.static_host + '/#formal/' + arg;
+
+  var header = '',
+    addr = '';
+
+  if (arg == 'terms')
+    ((header = 'Website Terms &amp; Conditions'), (addr = '/terms.json'));
+  else if (arg == 'api')
+    ((header = 'MPDS API Terms &amp; Conditions'), (addr = '/api.json'));
+  else if (arg == 'usfed')
+    ((header = 'Procurement Details'), (addr = '/usfed.json'));
+  else if (arg == 'refunds')
+    ((header = 'Refund Policy'), (addr = '/refunds.json'));
+  else if (arg == 'privacy')
+    ((header = 'Privacy Policy'), (addr = '/privacy.json'));
+  else return wmgui.notify('Sorry, unknown document requested');
+
+  wmgui.show_preloader();
+
+  $$('#formalbox_navi > ul > li').forEach(function (li) {
+    li.classList.remove('working');
+  });
+  $$('a[href="#formal/' + arg + '"]').forEach(function (a) {
+    a.parentNode.classList.add('working');
+  });
+
+  const request = ajax({
+    url: addr,
+    type: 'GET',
+    data: { nocache: Math.floor(Math.random() * 1000) },
+  });
+  request
+    .then(function (answer) {
+      wmgui.hide_preloader();
+      var html = '<h2>' + header + '</h2>';
+      answer.forEach(function (value, n) {
+        html +=
+          '<strong>&sect;' +
+          (n + 1) +
+          '. ' +
+          value.header +
+          '</strong><p>' +
+          value.content +
+          '</p>';
+      });
+      set_html($('#formalbox_content'), html);
+      show($$('#formalbox, #overlay'));
+      window.scrollTo(0, 0);
+      wmgui.hide_preloader();
+    })
+    .catch(function () {
+      wmgui.hide_preloader();
+    });
+}
+
+const routes = {
+  start: url__start,
+  search: url__search,
+  inquiry: url__inquiry,
+  inquiry_entries: url__inquiry_entries,
+  inquiry_phases: url__inquiry_phases,
+  inquiry_articles: url__inquiry_articles,
+  plot: url__plot,
+  entry: url__entry,
+  phase_id: url__phase_id,
+  phase: url__phase,
+  article: url__article,
+  hierarchy: url__hierarchy,
+  modal: url__modal,
+  access: url__access,
+  ratify: url__ratify,
+  interlinkage: url__interlinkage,
+  polyhedra: url__polyhedra,
+  junction: url__junction,
+  products: url__products,
+  formal: url__formal,
+};
diff --git a/src_js/app/run.js b/src_js/app/run.js
new file mode 100644
index 0000000..7865fa9
--- /dev/null
+++ b/src_js/app/run.js
@@ -0,0 +1,32 @@
+/**
+ * Ermac entry point.
+ */
+
+import { assign_edition } from './search.js';
+import { register_html } from './markup.js';
+import { satisfy_requirements } from './startup.js';
+import { register_events } from './events.js';
+import wmgui from '../core/settings.js';
+import { install_a11y, open_dialog, release_dialog } from '../core/a11y.js';
+
+// now, run everything
+
+assign_edition();
+
+register_html();
+
+satisfy_requirements();
+
+register_events();
+
+// keyboard and assistive-technology support, see src_js/core/a11y.js
+install_a11y();
+// NB public API (window.wmgui): the host page's own dialogs, e.g. #productbox on mpds.io
+wmgui.open_dialog = open_dialog;
+wmgui.release_dialog = release_dialog;
+
+// use MPDS API, please
+console.log(
+  '%cWeb-scraping or automated usage apart of the public MPDS API is in violation of our ToS (https://mpds.io/formal/terms) and results in banned account.',
+  'color:red;font-size:16px;',
+);
diff --git a/src_js/app/search.js b/src_js/app/search.js
new file mode 100644
index 0000000..64d6061
--- /dev/null
+++ b/src_js/app/search.js
@@ -0,0 +1,2488 @@
+/**
+ * Ermac search logic: request_search, display/render functions,
+ * user session handling, and the selectize read/write helpers.
+ */
+
+import wmgui from '../core/settings.js';
+import { wmutils } from '../core/utils.js';
+import {
+  $,
+  $$,
+  show,
+  hide,
+  set_html,
+  append_html,
+  prepend_html,
+  empty,
+  remove,
+  isVisible,
+  position,
+  slide_down,
+  slide_up,
+  data,
+  get_val,
+  set_val,
+} from '../core/dom.js';
+import { ajax, param, is_empty } from '../core/ajax.js';
+import {
+  create_floating_slider,
+  destroy_numericbox,
+  get_sliders_ranges,
+  serialize_numeric,
+  inquiry_param,
+} from '../components/sliders.js';
+import { make_sortable } from '../components/tablesort.js';
+
+let db_sorter = null;
+
+wmgui.notify = function (msg) {
+  var delay = 0;
+  if (wmgui.notify_counter) {
+    clearTimeout(wmgui.notify_counter);
+    wmgui.notify_counter = null;
+    delay = 1500;
+  }
+  setTimeout(function () {
+    set_html($('#notifybox'), wmgui.clean(msg));
+    show($('#notifybox'));
+    wmgui.notify_counter = setTimeout(function () {
+      hide($('#notifybox'));
+    }, 4000);
+  }, delay);
+};
+
+// external API function
+wmgui.aug_search_cmd = function (new_fct, new_val) {
+  // Take care of mutually exclusive facets
+  var checks = [
+    ['elements', 'formulae'],
+    ['formulae', 'elements'],
+    ['lattices', 'sgs'],
+    ['sgs', 'lattices'],
+    ['protos', 'sgs'],
+    ['sgs', 'protos'],
+    ['lattices', 'protos'],
+    ['protos', 'lattices'],
+  ];
+  for (var i = 0; i < checks.length; i++) {
+    if (wmgui.search[checks[i][0]] && new_fct == checks[i][1]) {
+      delete wmgui.search[checks[i][0]];
+      break;
+    }
+  }
+
+  var orepr = {};
+
+  wmgui.facets.forEach(function (fct) {
+    if (wmgui.search[fct] && fct == new_fct) {
+      if (wmgui.multi_facets.indexOf(fct) !== -1)
+        orepr[fct] = wmgui.search[fct] + ',' + new_val;
+      else orepr[fct] = new_val;
+    } else if (wmgui.search[fct]) {
+      orepr[fct] = wmgui.search[fct];
+    } else if (fct == new_fct) {
+      orepr[fct] = new_val;
+    }
+  });
+  return '#inquiry/' + inquiry_param(orepr);
+};
+
+// reading the multiselect at the main search input (landing)
+wmgui._selectize_read_main = function () {
+  var result = {},
+    instance = wmgui.multiselects['main'];
+
+  (instance ? instance.items : []).forEach(function (item) {
+    var facet = item.facet;
+
+    if (wmgui.other_facets.indexOf(facet) !== -1 && wmgui.search[facet])
+      result[facet] = wmgui.search[facet];
+    else if (facet == 'numeric') {
+      if (wmgui.search[facet]) {
+        result[facet] = '';
+        wmgui.search[facet].forEach(function (num_item) {
+          result[facet] += serialize_numeric.apply(this, num_item); // unpack
+        });
+        if (result[facet].length)
+          result[facet] = result[facet].substr(0, result[facet].length - 1);
+      } // NB else just skip!
+    } else if (result[facet] && facet == 'elements')
+      result[facet] += '-' + item.label;
+    else if (result[facet] && wmgui.multi_facets.indexOf(facet) !== -1)
+      result[facet] += ', ' + item.label;
+    else if (facet == 'formulae')
+      result[facet] = item.label
+        .replaceAll('<sub>', '')
+        .replaceAll('</sub>', '');
+    else result[facet] = item.label;
+  });
+
+  return result;
+};
+
+// reading the multiselect at the *wmgui.multi_facets* categories
+wmgui._selectize_read_facet = function (fct) {
+  var result = {},
+    instance = wmgui.multiselects[fct];
+
+  (instance ? instance.items : []).forEach(function (item) {
+    var facet = item.facet;
+
+    if (result[facet]) result[facet] += ', ' + item.label;
+    else result[facet] = item.label;
+    return;
+  });
+
+  return result;
+};
+
+wmgui._selectize_write = function (multiselect, name, search_obj) {
+  wmgui.selectize_emit = false;
+
+  var given_search = {};
+  Object.assign(given_search, search_obj);
+
+  if (name == 'main') {
+    name = ['formulae', 'props', 'elements', 'classes', 'lattices', 'aetypes'];
+
+    for (var i = 0; i < wmgui.other_facets.length; i++) {
+      if (given_search[wmgui.other_facets[i]]) {
+        wmgui._selectize_display(
+          multiselect,
+          wmgui.other_facets[i],
+          wmgui.facet_names[wmgui.other_facets[i]].toLowerCase(),
+        ); // stub display
+      }
+    }
+
+    if (given_search.numeric)
+      wmgui._selectize_display(multiselect, 'numeric', 'range search');
+  } else name = [name];
+
+  name.forEach(function (facet) {
+    // facets supported for multiselect autocomplete
+    if (!given_search[facet]) return;
+    else if (facet == 'elements' && given_search[facet].indexOf('-') > 0) {
+      given_search[facet].split('-').forEach(function (part) {
+        wmgui._selectize_display(multiselect, facet, part);
+      });
+    } else if (
+      wmgui.multi_facets.indexOf(facet) !== -1 &&
+      given_search[facet].indexOf(',') > 0
+    ) {
+      given_search[facet].split(',').forEach(function (part) {
+        wmgui._selectize_display(multiselect, facet, part);
+      });
+    } else if (facet == 'formulae') {
+      given_search[facet] = wmgui.to_formula(given_search[facet]);
+      wmgui._selectize_display(multiselect, facet, given_search[facet]);
+    } else wmgui._selectize_display(multiselect, facet, given_search[facet]);
+  });
+
+  multiselect.clearOptions();
+  wmgui.selectize_emit = true;
+};
+
+wmgui._selectize_display = function (multiselect, facet, term) {
+  // NB consume one random value, exactly like the old implementation did
+  // (Math.floor(Math.random() * 1000) ids), to keep the global random
+  // sequence aligned between page loads, e.g. for the rotating legends
+  Math.random();
+  const option_data = { facet: facet, label: term };
+  multiselect.addOption(option_data);
+  multiselect.addItem(option_data.id);
+};
+
+export function show_interpretation(search) {
+  // FIXME only allow pre-defined props
+  set_html(
+    $('#interpret'),
+    wmgui.clean(
+      wmgui.get_interpretation(search, wmgui.facet_names, wmgui.numerics),
+    ),
+  );
+}
+
+// re-loading without history affection
+export function re_view_request(search_type) {
+  var caption_items = [];
+  for (var k in wmgui.search) {
+    if (k == 'search_type') continue;
+    caption_items.push(wmgui.search[k]);
+  }
+  if (!caption_items.length) return;
+
+  wmgui.search_type = search_type;
+  wmgui.search.search_type = search_type;
+  request_search(
+    wmgui.search,
+    caption_items.join(' ').replaceAll(',', ' '),
+    true,
+  );
+  $$('#dtypes_phid > ul > li').forEach(function (li) {
+    li.classList.remove('active');
+  });
+}
+
+export function update_databrowser_sort() {
+  if (db_sorter) db_sorter.update();
+}
+
+export async function request_search(search, caption, without_history) {
+  if (manage_visavis(rebuild_history_box, search, caption)) return;
+
+  try {
+    wmgui.active_ajax.abort();
+  } catch (e) {}
+  try {
+    wmgui.quick_ajax.abort();
+  } catch (e) {}
+
+  wmgui.show_preloader();
+  const request = ajax({
+    type: 'GET',
+    url: wmgui.search_endpoint,
+    data: {
+      q: JSON.stringify(search),
+      strict: wmgui.ctx_strict_phases,
+      //subphases: wmgui.ctx_subphases,
+      sid: wmgui.sid,
+    },
+  });
+  wmgui.active_ajax = request;
+
+  let data;
+  try {
+    data = await request;
+  } catch (error) {
+    wmgui.hide_preloader();
+    if (!(error && error.aborted))
+      wmgui.notify(
+        'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+    return;
+  }
+  wmgui.hide_preloader();
+
+  if (data.error) return wmgui.notify(data.error);
+
+  caption = caption.replaceAll('%2F', '/');
+
+  if (!data.out.length) return wmgui.notify('No hits for ' + caption);
+
+  wmgui.fuzzyout = false;
+  if (data.fuzzy_notice) {
+    wmgui.fuzzyout = true;
+    wmgui.notify(data.fuzzy_notice);
+  }
+
+  var res_str = data.estimated_count == 1 ? ' result' : ' results',
+    notice = data.estimated_count > 150 ? 'At least ' : '';
+  document.title = notice + data.estimated_count + res_str; // + ' (' + wmgui.estimate + ')';
+  //console.log('Obtained: '+data.estimated_count+', expected: '+wmgui.estimate);
+  switch_view_mode(2);
+
+  if (!wmgui.chosen_table_browser)
+    // TODO add smarter check?
+    wmgui.thumbed_display = data.out.length > wmgui.ntab_tolerance;
+
+  if (wmgui.thumbed_display) {
+    var db = $('#databrowser');
+    db.className = 'thumbed';
+    // NB the old jQuery .append('<tr>...') put the tr directly under the
+    // table (no tbody wrapper), so the DOM stays identical
+    const tr = document.createElement('tr');
+    tr.innerHTML = '<td>' + build_thumbs(data.out) + '</td>';
+    db.innerHTML = '';
+    db.appendChild(tr);
+    slide_down($('#results'), 250);
+  } else {
+    var db = $('#databrowser');
+    db.className = 'tabled';
+    db.innerHTML = build_cells(data.out, '<tbody>', '</tbody>');
+    slide_down($('#results'), 250);
+
+    if (wmgui.search_type == 2) {
+      db.classList.add('tablesorter');
+      db_sorter = make_sortable(db, {
+        sortMultiSortKey: 'ctrlKey',
+        headers: {
+          0: { sorter: 'doi' },
+          5: { sorter: false },
+        },
+        selectorHeaders: '#dataheader_articles > thead > tr > th',
+      });
+      show($('#header_articles'));
+    } else if (wmgui.search_type == 1) {
+      db.classList.add('tablesorter');
+      db_sorter = make_sortable(db, {
+        sortMultiSortKey: 'ctrlKey',
+        headers: {
+          0: { sorter: 'chemical' },
+          1: { sorter: 'digit' },
+          2: { sorter: 'digit' },
+          3: { sorter: 'digit' },
+          4: { sorter: false },
+        },
+        selectorHeaders: '#dataheader_phases > thead > tr > th',
+      });
+      show($('#header_phases'));
+    } else {
+      db.classList.add('tablesorter');
+      db_sorter = make_sortable(db, {
+        sortMultiSortKey: 'ctrlKey',
+        headers: {
+          0: { sorter: 'chemical' },
+          1: { sorter: false },
+          5: { sorter: 'doi' },
+        },
+        selectorHeaders: '#dataheader_entries > thead > tr > th',
+      });
+      show($('#header_entries'));
+    }
+  }
+
+  // count & show ctx
+  wmgui.unfinished_page = false;
+  if (wmgui.search_type || search.phid) {
+    if (data.estimated_count >= wmgui.quick_page_size * 3) {
+      set_html($('#toomuch span'), 'other');
+      show($('#toomuch'));
+    }
+    show_hints(search.entry || search.interlinkage);
+  } else {
+    if (data.estimated_count > wmgui.quick_page_size + wmgui.fetch_page_size) {
+      set_html(
+        $('#toomuch span'),
+        'nearly ' + (data.estimated_count - wmgui.quick_page_size),
+      );
+      show($('#toomuch'));
+      show_hints(search.entry, data.estimated_count);
+    } else if (data.estimated_count > wmgui.quick_page_size) {
+      show($('#loadscroll'));
+      wmgui.unfinished_page = true;
+    } else show_hints(search.entry, data.estimated_count);
+  }
+
+  // switchers
+  if (wmgui.visavis_terminating) stop_visavis();
+
+  if (
+    wmgui.search_type ||
+    search.phid ||
+    search.bid ||
+    search.entry ||
+    search.interlinkage ||
+    search.doi ||
+    search.numeric
+  ) {
+    if (search.phid || search.bid || search.entry) {
+      switch_control_mode(9, 11, 'a', 'c');
+      show_dunit_info(search.phid, search.bid, search.entry);
+    } else if (search.interlinkage) {
+      switch_control_mode(9, 11, 'a', 'c');
+      show_examples('#examples', true, true);
+      hide($('#dtypes'));
+    } else if (search.numeric) {
+      switch_control_mode(1, 12, 'b', false);
+      //console.log(search.numeric);
+      destroy_numericbox();
+      get_sliders_ranges(search.numeric, wmgui.numerics).forEach(
+        function (item) {
+          create_floating_slider.apply(this, item); // unpack
+        },
+      );
+      show_examples('#examples', true, true);
+    } else {
+      switch_control_mode(1, 10, false, false);
+      show_examples('#examples', true, true);
+    }
+
+    if (search.entry) {
+      var that = document.getElementById('e__' + search.entry);
+      if (search.entry.indexOf('-') == -1 && !that)
+        that = document.getElementById('e__' + search.entry + '-1');
+      if (that && that.getAttribute('data-rank') != 0) {
+        // NB "!=", not "!=="
+        that.classList.remove('busy_entry');
+        open_context(that, true);
+      }
+    }
+  } else {
+    wmgui.fuzzyout
+      ? switch_control_mode(1, 11, 'a', false)
+      : switch_control_mode(0, 10, false, false);
+    request_refinement(search, data.estimated_count > wmgui.quick_page_size);
+  }
+
+  //console.log(search);
+  if (!search.numeric) {
+    destroy_numericbox();
+    delete wmgui.search.numeric;
+  }
+  if (search.props && wmgui.numerics[search.props]) {
+    // making a hint
+    var num_data = wmgui.numerics[search.props],
+      prop_id = num_data[0],
+      units = num_data[1],
+      min = num_data[2],
+      max = num_data[3],
+      step = num_data[4];
+    create_floating_slider(search.props, prop_id, units, min, max, step);
+  }
+  if (!without_history) rebuild_history_box(search, caption);
+  wmgui.search.elements && wmgui.search_type == 1
+    ? show($('#phases_ctx'))
+    : hide($('#phases_ctx'));
+}
+
+function rebuild_history_box(search, caption) {
+  var orepr = {};
+  wmgui.facets.forEach(function (item) {
+    if (search[item]) orepr[item] = search[item];
+  });
+
+  var inquiry = false;
+  for (var m = 0; m < wmgui.inquiries.length; m++) {
+    if (orepr[wmgui.inquiries[m]]) {
+      inquiry = true;
+      break;
+    }
+  }
+
+  var title = [];
+  for (var prop in orepr) {
+    title.push(orepr[prop].toLowerCase());
+  }
+  title.sort();
+  var fingerprint = title.join(' '),
+    search_log = JSON.parse(
+      window.localStorage.getItem(wmgui.store_history_key) || '[]',
+    ),
+    chk_searches = [];
+  if (search_log.length > 8) search_log = search_log.slice(0, 7);
+  search_log.forEach(function (item) {
+    var past_title = [];
+    for (var p in item) {
+      past_title.push(item[p].toLowerCase());
+    }
+    past_title.sort();
+    chk_searches.push(past_title.join(' '));
+  });
+  if (chk_searches.indexOf(fingerprint) == -1) {
+    var item;
+    if (inquiry)
+      item = '<a href="#inquiry/' + inquiry_param(orepr) + '">' + caption + '</a>';
+    else
+      item =
+        '<a href="#search/' +
+        encodeURIComponent(caption) +
+        '">' +
+        caption +
+        '</a>';
+
+    prepend_html($('#history ul'), '<li>' + wmgui.clean(item) + '</li>');
+    search_log.unshift(orepr);
+    window.localStorage.setItem(
+      wmgui.store_history_key,
+      JSON.stringify(search_log),
+    );
+    const history_lis = $$('#history ul li');
+    if (history_lis.length > 8) history_lis[history_lis.length - 1].remove();
+  }
+  wmgui.tooltip_counter++;
+  if (wmgui.tooltip_counter == 1) {
+    setTimeout(function () {
+      show_tooltip(wmgui.tooltips['interpretation']);
+    }, 3000);
+  }
+}
+
+export function rotate_interesting() {
+  set_html(
+    $('#legend'),
+    '<i>e.g.</i> <a href="#">' +
+      wmgui.get_interesting()['text'].replace(/\d/g, '&#x208$&;') +
+      '</a>',
+  );
+}
+
+export function show_examples(box, more_examples, fix_rfn_header) {
+  if (wmgui.cliff_counter === null)
+    wmgui.cliff_counter = Math.floor(Math.random() * wmgui.cliffhangers.length);
+  var html = '';
+  for (var i = 0; i < (more_examples ? 7 : 3); i++) {
+    wmgui.cliff_counter += 1;
+    if (wmgui.cliff_counter > wmgui.cliffhangers.length - 1)
+      wmgui.cliff_counter = 0;
+    html +=
+      '<li><a href="#search/' +
+      wmutils.termify_formulae(wmgui.cliffhangers[wmgui.cliff_counter]) +
+      '">' +
+      wmgui.cliffhangers[wmgui.cliff_counter].charAt(0).toUpperCase() +
+      wmgui.cliffhangers[wmgui.cliff_counter].slice(1) +
+      '</a></li>';
+
+    var legend = wmgui.get_interesting()['text'];
+    html +=
+      '<li><a href="#search/' +
+      encodeURIComponent(legend) +
+      '">' +
+      legend.charAt(0).toUpperCase() +
+      legend.slice(1).replace(/\d/g, '&#x208$&;') +
+      '</a></li>';
+  }
+  empty($(box + ' > ul'));
+  append_html($(box + ' > ul'), html);
+  show($(box));
+
+  if (fix_rfn_header) {
+    hide($$('#refine_col > div.col_title, #refine_col > ul'));
+    show($('#refine_col'));
+  }
+}
+
+export function arrange_menu_collateral() {
+  empty($$('#hintsbox_msg, #tagcloudbox'));
+
+  var links_html = '';
+  for (var i = 0; i < wmgui.collateral_links.length; i++) {
+    var rel = wmgui.collateral_links[i][1],
+      cls = wmgui.collateral_links[i][1] ? 'collateral' : false,
+      target = '',
+      lbr = '';
+    if (i % 2) {
+      cls = cls ? cls + ' violet' : 'violet';
+      lbr = '<br />';
+    }
+    if (wmgui.collateral_links[i][3]) target = ' target="_blank"';
+    links_html +=
+      '<a' +
+      target +
+      ' href="' +
+      wmgui.collateral_links[i][0] +
+      '"' +
+      (cls ? ' class="' + cls + '"' : '') +
+      (rel ? ' rel=' + rel : '') +
+      '>' +
+      wmgui.collateral_links[i][2] +
+      '</a>' +
+      lbr;
+  }
+  append_html($('#tagcloudbox'), links_html);
+
+  append_html($('#hintsbox_msg'), wmgui.get_random_term(wmgui.welcome_msgs));
+}
+
+export function switch_view_mode(mode) {
+  wmgui.view_mode = mode;
+  hide($$('div.autocomplete-suggestions'));
+  hide($$('#results, #header_entries, #header_phases, #header_articles'));
+  hide($$('div.context_msg'));
+  close_vibox();
+
+  if (mode == 1) {
+    stop_visavis();
+    document.title = 'Materials Platform for Data Science';
+    document.body.classList.add('noscroll');
+    $('#search_box').classList.remove('fluid');
+
+    hide($$('div.side_cols'));
+    show($('#legend'));
+
+    $('#search_holder').classList.remove('prolonged');
+    $('#search_area').classList.remove('prolonged');
+    $('#ermac_logo').classList.remove('cornered');
+
+    wmgui.ptable.decide();
+    if (wmgui.ptable.activated)
+      document.getElementById('ptable_dtypes_box').classList.add('resulted');
+  } else if (mode == 2) {
+    hide($('#legend'));
+    hide($('#ctx_col'));
+    if (wmgui.passive_sim_col) hide($('#sim_col'));
+
+    document.body.classList.remove('noscroll');
+    $('#search_box').classList.add('fluid');
+
+    show($('#right_col'));
+    show($('#dtypes'));
+    $('#search_holder').classList.add('prolonged');
+    $('#search_area').classList.add('prolonged');
+    $('#ermac_logo').classList.add('cornered');
+
+    wmgui.ptable.hide();
+    document.getElementById('ptable_dtypes_box').classList.remove('resulted');
+  }
+  // hook back into a parent integration
+  wmgui.mpdsgui.view(mode);
+}
+
+function switch_control_mode(mode, next_mode, active_abf, active_cde) {
+  // NB (0, 10) is the most common 6-button layout
+  if (mode == 0) {
+    // cde, second
+    $$('#control_c, #control_d, #control_e').forEach(function (el) {
+      el.style.width = '33.3%';
+    });
+    show($$('#control_c, #control_d, #control_e'));
+  } else if (mode == 1) {
+    // cde, second
+    hide($('#control_e'));
+    $$('#control_c, #control_d').forEach(function (el) {
+      el.style.width = '50%';
+    });
+    show($$('#control_c, #control_d'));
+  } else if (mode == 9) {
+    // cde, second
+    hide($$('#control_e, #control_d'));
+    $('#control_c').style.width = '100%';
+    show($('#control_c'));
+  } else if (mode == 10) {
+    // abf, first
+    $$('#control_a, #control_b, #control_f').forEach(function (el) {
+      el.style.width = '33.3%';
+    });
+    show($$('#control_a, #control_b, #control_f'));
+  } else if (mode == 11) {
+    // abf, first
+    hide($$('#control_b, #control_f'));
+    $('#control_a').style.width = '100%';
+    show($('#control_a'));
+  } else if (mode == 12) {
+    // abf, first
+    hide($$('#control_a, #control_f'));
+    $('#control_b').style.width = '100%';
+    show($('#control_b'));
+  }
+  if (!next_mode) return;
+
+  if (!active_abf) active_abf = { 0: 'a', 1: 'b', 2: 'f' }[wmgui.search_type];
+  if (!active_cde) active_cde = wmgui.thumbed_display ? 'd' : 'c';
+
+  // NB like the old $('div.controlswitch > div').removeClass(): ALL six
+  // switches lose ALL their classes before the two current ones are set
+  $$('div.controlswitch > div').forEach(function (el) {
+    el.className = '';
+  });
+  $('#control_' + active_abf).classList.add('active');
+  $('#control_' + active_cde).classList.add('active');
+
+  switch_control_mode(next_mode);
+}
+
+export function build_cells(json, header, footer) {
+  var cls_map = {
+      7: 'ml_data',
+      8: 'ab_data',
+      9: 'ab_data',
+      10: 'ab_data',
+      11: 'ab_data',
+      13: 'deactivated',
+    },
+    result_html = '';
+
+  if (header) result_html += header;
+
+  if (wmgui.search_type == 2) {
+    if (json[0].length != 6) {
+      wmgui.notify(
+        'Rendering error, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+      return '';
+    }
+
+    var act_link = '';
+
+    json.forEach(function (row, k) {
+      act_link = '<a class="launch_id" href="#article/' + row[0] + '">Show</a>';
+
+      row[0] = parseInt(row[0]);
+      if (row[0] == 999999) {
+        row[4] = wmgui.mockyear; // special *ref_id*, only handled in GUI
+        act_link = '&nbsp;';
+      }
+      result_html +=
+        '<tr id="e__B' +
+        row[0] +
+        '" class="tcell" data-type="B"><td class=c55>[<a class="resolve_ref' +
+        (wmgui.bid_history.indexOf(row[0]) !== -1 ? ' visited' : '') +
+        '" href="' +
+        wmgui.refs_endpoint +
+        '?ref_id=' +
+        row[0] +
+        '&sid=' +
+        wmgui.sid +
+        '&ed=' +
+        wmgui.edition +
+        '" rel="' +
+        row[0] +
+        '" target="_blank" rel="noopener noreferrer">' +
+        row[0] +
+        '</a>]</td><td class=a1>' +
+        row[1] +
+        '</td><td class=a2 title="' +
+        row[2] +
+        '">' +
+        row[2] +
+        '</td><td class=a5>' +
+        row[5] +
+        '</td><td class=c4>' +
+        row[4] +
+        '</td><td class=a6>' +
+        act_link +
+        '</td></tr>';
+    });
+  } else if (wmgui.search_type == 1) {
+    if (json[0].length != 5) {
+      wmgui.notify(
+        'Rendering error, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+      return '';
+    }
+
+    json.forEach(function (row, k) {
+      result_html +=
+        '<tr id="e__Z' +
+        row[0] +
+        '" class="tcell" data-type="Z"><td class=p1>' +
+        row[1] +
+        '</td><td class=p2>' +
+        row[2] +
+        '</td><td class=p3>' +
+        row[3] +
+        '</td><td class=p4>' +
+        row[4] +
+        '</td><td class=p5><a class="launch_id" href="#phase_id/' +
+        row[0] +
+        '">Show entries</a></td></tr>';
+    });
+  } else {
+    if (json[0].length != 8) {
+      wmgui.notify(
+        'Rendering error, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+      return '';
+    }
+
+    json.forEach(function (row, k) {
+      row[7] = parseInt(row[7]);
+      var dtype = row[0].substr(0, 1),
+        preview =
+          row[3] == 4 ||
+          row[3] == 5 ||
+          row[3] == 6 ||
+          row[3] == 9 ||
+          row[3] == 10 ||
+          row[3] == 12
+            ? '<span class=launch_v>Show</span>'
+            : ' ', // FIXME? w.r.t. open_context
+        biblio_html =
+          row[7] == 999999
+            ? '<td class=cj>&mdash;</td><td class=c4>' +
+              wmgui.mockyear +
+              '</td><td class=c5>&mdash;</td>'
+            : '<td class=cj>' +
+              row[5] +
+              '</td><td class=c4>' +
+              row[6] +
+              '</td><td class=c5>[<a class="resolve_ref' +
+              (wmgui.bid_history.indexOf(row[7]) !== -1 ? ' visited' : '') +
+              '" href="' +
+              wmgui.refs_endpoint +
+              '?ref_id=' +
+              row[7] +
+              '&sid=' +
+              wmgui.sid +
+              '&ed=' +
+              wmgui.edition +
+              '" rel="' +
+              row[7] +
+              '" target="_blank" rel="noopener noreferrer">' +
+              row[7] +
+              '</a>]</td>'; // special *ref_id*, only handled in GUI
+
+      result_html +=
+        '<tr id="e__' +
+        row[0] +
+        '" class="tcell ' +
+        (cls_map[row[3]] || '') +
+        (row[4] ? ' opened' : '') +
+        '" data-type="' +
+        dtype +
+        '" data-rank="' +
+        row[3] +
+        '" title="Click for more info"><td class=c1>' +
+        row[1] +
+        '</td><td class=cp>' +
+        preview +
+        '</td><td class=c2>' +
+        row[2] +
+        '</td>' +
+        biblio_html +
+        '</tr>';
+    });
+  }
+  if (footer) result_html += footer;
+  return result_html;
+}
+
+export function build_thumbs(json) {
+  var cls_map = {
+      6: 'pd_full',
+      7: 'ml_data',
+      8: 'ab_data',
+      9: 'ab_data',
+      10: 'ab_data',
+      11: 'ab_data',
+      13: 'deactivated',
+    },
+    result_html = '';
+
+  if (wmgui.search_type == 2) {
+    if (json[0].length != 6) {
+      wmgui.notify(
+        'Rendering error, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+      return '';
+    }
+
+    json.sort(function (a, b) {
+      return a[4] > b[4] ? 1 : a[4] < b[4] ? -1 : 0; // pubyear
+    });
+
+    var title_html = '',
+      full_display = !!wmgui.sid,
+      act_link = '';
+
+    json.forEach(function (row, k) {
+      act_link =
+        '<a class="launch_id" href="#article/' + row[0] + '">Show entries</a>';
+
+      row[0] = parseInt(row[0]);
+      if (row[0] == 999999) {
+        row[4] = wmgui.mockyear; // special *ref_id*, only handled in GUI
+        act_link = 'Too many to show...';
+      }
+      if (full_display)
+        title_html =
+          (row[1].length > 60 ? row[1].substr(0, 60) + '&hellip;' : row[1]) +
+          ', <span>' +
+          (row[2].length > 80 ? row[2].substr(0, 80) + '&hellip;' : row[2]) +
+          '</span>';
+      else title_html = '<b>&#x1f4d6;</b>'; // book icon
+
+      result_html +=
+        '<div class="gallery_item" id="e__B' +
+        row[0] +
+        '" data-type="B"><div class="gallery_img"><div class="articled">' +
+        title_html +
+        '</div></div><div class="gallery_label">' +
+        act_link +
+        '<br />[<a class="resolve_ref' +
+        (wmgui.bid_history.indexOf(row[0]) !== -1 ? ' visited' : '') +
+        '" href="' +
+        wmgui.refs_endpoint +
+        '?ref_id=' +
+        row[0] +
+        '&sid=' +
+        wmgui.sid +
+        '&ed=' +
+        wmgui.edition +
+        '" rel="' +
+        row[0] +
+        '" target="_blank" rel="noopener noreferrer">' +
+        row[3] +
+        '&rsquo;' +
+        row[4].toString().substr(2, 2) +
+        '</a>]</div></div>';
+    });
+  } else if (wmgui.search_type == 1) {
+    if (json[0].length != 5) {
+      wmgui.notify(
+        'Rendering error, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+      return '';
+    }
+
+    json.sort(function (a, b) {
+      return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
+    });
+    json.forEach(function (row, k) {
+      result_html +=
+        '<div class="gallery_item" id="e__Z' +
+        row[0] +
+        '" data-type="Z"><div class="gallery_img" rel="' +
+        row[0] +
+        '"><div class="phased">' +
+        row[1] +
+        '<br /><br />space group ' +
+        row[2] +
+        '</div></div><div class="gallery_label"><a class="launch_id" href="#phase_id/' +
+        row[0] +
+        '">Show ' +
+        row[3] +
+        (row[3] == 1 ? ' entry' : ' entries') +
+        '</a><br />Publications: ' +
+        row[4] +
+        '</div></div>';
+    });
+  } else {
+    if (json[0].length != 8) {
+      wmgui.notify(
+        'Rendering error, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+      return '';
+    }
+
+    json.sort(function (a, b) {
+      var dtype_a = a[0].substr(0, 1),
+        dtype_b = b[0].substr(0, 1);
+
+      if (dtype_a == 'S') {
+        if (dtype_b == 'S') return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
+        return -1;
+      }
+      if (dtype_a == 'C') {
+        if (dtype_b == 'C') return a[7] > b[7] ? 1 : a[7] < b[7] ? -1 : 0;
+        if (dtype_b == 'S') return 1;
+        if (dtype_b == 'P') return -1;
+      }
+      if (dtype_a == 'P') {
+        if (dtype_b == 'P')
+          return a[2].toUpperCase() > b[2].toUpperCase()
+            ? 1
+            : a[2].toUpperCase() < b[2].toUpperCase()
+              ? -1
+              : 0;
+        return 1;
+      }
+    });
+    json.forEach(function (row, k) {
+      row[7] = parseInt(row[7]);
+      var dtype = row[0].substr(0, 1),
+        content,
+        biblio_html =
+          row[7] == 999999
+            ? '<br />&mdash;'
+            : '<br />[<a class="resolve_ref' +
+              (wmgui.bid_history.indexOf(row[7]) !== -1 ? ' visited' : '') +
+              '" href="' +
+              wmgui.refs_endpoint +
+              '?ref_id=' +
+              row[7] +
+              '&sid=' +
+              wmgui.sid +
+              '&ed=' +
+              wmgui.edition +
+              '" rel="' +
+              row[7] +
+              '" target="_blank" rel="noopener noreferrer">' +
+              row[5] +
+              '&rsquo;' +
+              row[6].toString().substr(2, 2) +
+              '</a>]'; // special *ref_id*, only handled in GUI
+
+      if (dtype == 'P') content = '<div>' + row[2] + '</div>';
+      else if (dtype == 'S')
+        content =
+          '<img loading="lazy" alt="' +
+          row[0] +
+          '" src="' +
+          wmgui.static_host +
+          '/rd_thumbs/' +
+          row[0].split('-')[0] +
+          '.png" />';
+      else {
+        // FIXME
+        row[2] = row[2].split(';')[0];
+        row[2] = row[2].split(' ')[row[2].split(' ').length - 1];
+        var url_dest =
+          row[3] == 12
+            ? row[2].split('-').length == 3
+              ? '/prism'
+              : '/tetrahedron'
+            : '/pd_thumbs/' + row[0].split('-')[0];
+        content =
+          '<img loading="lazy" alt="' +
+          row[0] +
+          '" src="' +
+          wmgui.static_host +
+          url_dest +
+          '.png" /><p>' +
+          row[2] +
+          '</p>';
+      }
+      result_html +=
+        '<div class="gallery_item ' +
+        (cls_map[row[3]] || '') +
+        (row[4] ? ' opened' : '') +
+        '" id="e__' +
+        row[0] +
+        '" data-type="' +
+        dtype +
+        '" data-rank="' +
+        row[3] +
+        '" title="Click for more info"><div class="gallery_img">' +
+        content +
+        '</div><div class="gallery_label">' +
+        row[1] +
+        biblio_html +
+        '</div></div>';
+    });
+  }
+  return result_html;
+}
+
+export async function request_refinement(query_obj, is_heavy) {
+  hide($$('#examples, #ind_col'));
+  empty($('#ind_col > span'));
+  empty($('#refine_col > ul'));
+  show($('#refine_col'));
+  show($('#refine_col > div.col_title'));
+
+  var given_search = { is_heavy: is_heavy };
+  Object.assign(given_search, query_obj);
+  try {
+    wmgui.active_ajax.abort();
+  } catch (e) {}
+
+  //console.log(given_search);
+  show($('#rfn_preloader'));
+  const request = ajax({
+    type: 'GET',
+    url: wmgui.rfn_endpoint,
+    data: { q: JSON.stringify(given_search) },
+  });
+  wmgui.active_ajax = request;
+
+  let data;
+  try {
+    data = await request;
+  } catch (error) {
+    hide($('#rfn_preloader'));
+    if (!(error && error.aborted))
+      wmgui.notify(
+        'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+    return;
+  }
+  hide($('#rfn_preloader'));
+
+  if (data.error) return wmgui.notify(data.error);
+
+  var was_facet = null,
+    refine_html = '',
+    classes_chk = [],
+    num_terms = 0;
+  delete given_search['is_heavy'];
+
+  if (given_search.classes) {
+    // no whitespace in multiple classes
+    classes_chk = given_search.classes.split(',').map(function (x) {
+      return x.trim();
+    });
+    given_search.classes = classes_chk.join(',');
+  }
+
+  var inquiry = false;
+  for (var m = 0; m < wmgui.inquiries.length; m++) {
+    if (given_search[wmgui.inquiries[m]]) {
+      inquiry = true;
+      break;
+    }
+  }
+
+  for (var i = 0; i < data.payload.length; i++) {
+    const found_obj = data.payload[i];
+    if (query_obj.formulae && found_obj.facet == 'elements') continue; // NB no sense to show elements in this context
+
+    var link_base = '',
+      //count_text = ' ('+found_obj.count+')',
+      nested_skip = false,
+      orepr = {};
+
+    for (var key in given_search) {
+      const val = given_search[key];
+      if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
+      else if (
+        found_obj.facet == 'elements' &&
+        (key == 'elements' || key == 'formulae')
+      )
+        continue;
+      else if (found_obj.facet == 'props' && key == 'props') continue;
+
+      link_base += val + ' ';
+
+      if (orepr[key]) orepr[key] += ', ' + val;
+      else orepr[key] = val;
+    }
+    //if (found_obj.facet == 'elements') count_text = '';
+    if (query_obj.classes && found_obj.facet == 'classes') {
+      for (var n = 0; n < classes_chk.length; n++) {
+        if (classes_chk[n] == found_obj.value) {
+          nested_skip = true;
+          break;
+        }
+      }
+    }
+    if (nested_skip) continue;
+
+    if (found_obj.facet != was_facet) {
+      if (was_facet && is_heavy)
+        refine_html +=
+          '<li class="fct_' +
+          was_facet +
+          ' extd_refine"><a class="extd_refine" rel="' +
+          was_facet +
+          '" href="#">Show more&nbsp;</a></li>';
+      refine_html +=
+        '<li class="new_rfn_facet fct_' +
+        found_obj.facet +
+        '">' +
+        wmgui.facet_names[found_obj.facet] +
+        '</li>';
+      was_facet = found_obj.facet;
+    }
+    if (found_obj.facet == 'props') {
+      found_obj.value = found_obj.value
+        .replace(/\(|\)/g, '')
+        .replace(/\/[\w\-]*/g, ''); // FIXME
+    }
+
+    if (orepr[found_obj.facet])
+      orepr[found_obj.facet] += ', ' + found_obj.value;
+    else orepr[found_obj.facet] = found_obj.value;
+
+    if (orepr['elements'])
+      orepr['elements'] = orepr['elements'].replaceAll(', ', '-');
+
+    if (inquiry)
+      refine_html +=
+        '<li class="fct_' +
+        found_obj.facet +
+        '"><a href="#inquiry/' +
+        inquiry_param(orepr) +
+        '">' +
+        found_obj.value +
+        '</a></li>';
+    else
+      refine_html +=
+        '<li class="fct_' +
+        found_obj.facet +
+        '"><a href="#search/' +
+        link_base +
+        found_obj.value +
+        '">' +
+        found_obj.value +
+        '</a></li>';
+    num_terms++;
+  }
+
+  if (is_heavy)
+    refine_html +=
+      '<li class="fct_' +
+      was_facet +
+      ' extd_refine"><a class="extd_refine" rel="' +
+      was_facet +
+      '" href="#">Show more&nbsp;</a></li>';
+
+  if (num_terms == 0) show_examples('#examples', true, true);
+  else {
+    show($('#refine_col > ul'));
+    append_html($('#refine_col > ul'), wmgui.clean(refine_html));
+    if (num_terms <= 10) show_examples('#examples', false, false);
+  }
+}
+
+/**
+ * NB: Ranks legend
+ * 0 - bib-ref (unproc) + P-entries data on
+ * 1 - textual (diagrammatic) P-entry
+ * 2 - scalar (numeric) P-entry
+ * 3 - C-phase
+ * 4 - SD-entry (P-array)
+ * 5 - S-entry
+ * 6 - C-diagram
+ * 7 - ML P-entry
+ * 8 - ab initio entry (scalar)
+ * 9 - ab initio entry (P-array) electron spectra
+ * 10 - ab initio entry (P-array) phonon spectra
+ * 11 - ab initio data in progress (unproc)
+ * 12 - 3d combination of C-diagrams
+ * 13 - deactivated entries
+ */
+export function open_context(el, launch_ext) {
+  close_vibox();
+  if (el.classList.contains('busy_entry')) {
+    el.classList.remove('busy_entry');
+    hide($$('#ctx_col, #sim_col'));
+    try {
+      wmgui.quick_ajax.abort();
+    } catch (e) {}
+  } else {
+    var entry = el.id.substr(3),
+      rank = parseInt(el.getAttribute('data-rank')),
+      entype = entry.substr(0, 1),
+      orig_id = entry.split('-')[0];
+
+    $$('.busy_entry').forEach(function (busy) {
+      busy.classList.remove('busy_entry');
+    });
+    el.classList.add('busy_entry');
+
+    if (entype == 'Z' || entype == 'B') return;
+
+    set_html(
+      $('#entryno'),
+      '<a href="#entry/' + orig_id + '">' + orig_id + '</a>',
+    );
+
+    show($('#ctx_col'));
+    const visualize = $('#visualize');
+    if (visualize) visualize.setAttribute('data-rank', rank);
+    const xrpdize = $('#xrpdize');
+    if (xrpdize) xrpdize.setAttribute('data-rank', 99); // FIXME hack
+    //$('#visualize, #xrpdize, #absolidize, div.spinoff_pane, li.d_icon').hide();
+    hide($$('#visualize, #xrpdize, div.spinoff_pane, li.d_icon'));
+
+    open_sim_col(entry, entype, rank);
+
+    if (rank == 0) {
+      show($('#download_bib'));
+    } else if (rank == 1) {
+      show($$('#download_bib, #download_pdf'));
+      ajax({ type: 'GET', url: wmgui.path_pp_ping + entry })
+        .then(function () {
+          show($$('#visualize, #download_png, #download_json'));
+        })
+        .catch(function () {});
+    } else if (rank == 2) {
+      show($$('#download_bib, #download_pdf, #download_json'));
+    } else if (rank == 3) {
+      show($$('#download_bib, #download_png, #download_cdr'));
+    } else if (rank == 4) {
+      show($$('#download_bib, #download_json, #visualize'));
+    } else if (rank == 5) {
+      //$('#absolidize, #download_bib, #download_pdf, #visualize, #xrpdize, #absolidize, #download_cif, #download_inp, #download_json').show();
+      show(
+        $$(
+          '#download_bib, #download_pdf, #visualize, #xrpdize, #download_cif, #download_inp, #download_json',
+        ),
+      );
+    } else if (rank == 6) {
+      show(
+        $$(
+          '#download_bib, #download_pdf, #visualize, #download_png, #download_cdr, #download_json',
+        ),
+      );
+    } else if (rank == 7) {
+      show($$('#ml_data, #download_pdf, #download_json'));
+    } else if (rank == 8) {
+      show($$('#ab_data, #download_pdf, #download_json, #download_raw'));
+    } else if (rank == 9) {
+      show(
+        $$(
+          '#ab_data, #download_pdf, #download_json, #visualize, #download_png, #download_raw',
+        ),
+      );
+    } else if (rank == 10) {
+      show(
+        $$(
+          '#ab_data, #download_pdf, #download_json, #visualize, #download_raw',
+        ),
+      );
+    } else if (rank == 11) {
+      show($$('#ab_promise, #download_json'));
+    } else if (rank == 12) {
+      show($$('#pd3d_data, #visualize'));
+    } else if (rank == 13) {
+      show($$('#deactivated_data, #download_bib'));
+    }
+    $$('#ctx_col > ul > li.d_icon > a').forEach(function (a) {
+      var fmt = a.getAttribute('rel'),
+        link_add = entype == 'S' ? '&export=1' : '',
+        link_sid = fmt == 'raw' ? 'null' : wmgui.sid,
+        link_url =
+          wmgui.dd_addr_tpl +
+          '/' +
+          entype.toLowerCase() +
+          '?q=' +
+          entry +
+          '&fmt=' +
+          fmt +
+          '&sid=' +
+          link_sid +
+          link_add +
+          '&ed=' +
+          wmgui.edition;
+
+      a.setAttribute('href', link_url);
+    });
+
+    //(wmgui.mydata_history.indexOf(entry) == -1) ? $('#absolidize').addClass('wmbutton') : $('#absolidize').removeClass('wmbutton');
+
+    if (launch_ext) launch_db_iframed(rank);
+  }
+}
+
+async function open_sim_col(entry, entype, rank) {
+  empty($$('#sim_col > ul, #sim_legend'));
+  hide($$('.sim_col_ctx'));
+  show($('#sim_col'));
+
+  var cur_obj = { q: entry },
+    allpurpose = [0, 1, 4, 9].indexOf(rank) !== -1;
+  if (allpurpose) cur_obj.allpurpose = true;
+
+  try {
+    wmgui.quick_ajax.abort();
+  } catch (e) {}
+
+  show($('#sim_preloader'));
+  const request = ajax({
+    type: 'GET',
+    url: wmgui.sim_endpoint,
+    data: cur_obj,
+  });
+  wmgui.quick_ajax = request;
+
+  let data;
+  try {
+    data = await request;
+  } catch (error) {
+    hide($('#sim_preloader'));
+    if (!(error && error.aborted))
+      wmgui.notify(
+        'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+      );
+    return;
+  }
+  hide($('#sim_preloader'));
+
+  if (data.error) return wmgui.notify(data.error);
+  var counter = 0,
+    sim_html = '';
+
+  if (allpurpose) {
+    data.out.sim.forEach(function (row, k) {
+      if (counter == 7) return;
+      if (row[4])
+        sim_html +=
+          '<li><a href="#inquiry/' +
+          param({
+            elements: row[1],
+            years: row[2],
+            codens: row[3],
+            classes: row[4] == 1 ? '' : row[4],
+          }) +
+          '">' +
+          row[0] +
+          '</a></li>';
+      else
+        sim_html +=
+          '<li><a href="#inquiry/' +
+          param({ formulae: row[1], years: row[2], codens: row[3] }) +
+          '">' +
+          row[0] +
+          '</a></li>';
+      counter++;
+    });
+  } else if (entype == 'C' || entype == 'S') {
+    if (rank > 3) {
+      data.out.sim.forEach(function (row, k) {
+        if (counter == 8) return;
+        sim_html +=
+          '<li><a href="#phase_id/' + row[1] + '">' + row[0] + '</a></li>';
+        counter++;
+      });
+      if (entype == 'C') show($('#pd_legend'));
+      else if (counter == 1) counter = 0;
+    }
+  } else {
+    // FIXME this is fragile
+    // NB the selected (busy) entry is in the results (#databrowser), not in
+    // #sim_col; like jQuery's .text(), a missing element gives ''
+    var prop_el = wmgui.thumbed_display
+        ? $('div.busy_entry > div.gallery_img > div')
+        : $('tr.busy_entry > td.c2'),
+      prop = (prop_el ? prop_el.textContent : '').split(';')[0];
+
+    data.out.sim.forEach(function (row, k) {
+      if (counter == 8) return;
+      sim_html +=
+        '<li><a href="#search/' +
+        prop +
+        ' ' +
+        row[1] +
+        '">' +
+        row[0] +
+        '</a></li>';
+      counter++;
+    });
+  }
+
+  if (counter) {
+    $('#sim_legend').classList.remove('apparent');
+
+    if (allpurpose)
+      $('#sim_legend').textContent = 'Also studied by these authors:';
+    else if (entype == 'C')
+      $('#sim_legend').textContent = 'Phases at the diagram:';
+    else if (entype == 'S')
+      $('#sim_legend').textContent = 'The same prototype structures:';
+    else $('#sim_legend').textContent = 'Similar ' + prop + ':';
+
+    if (counter > 7) {
+      //var link = (entype == 'C') ? '#entry/' + $('#entryno').text() : '#interlinkage/' + entry;
+      $('#sim_trigger').setAttribute('href', '#interlinkage/' + entry);
+      show($('#sim_trigger'));
+    }
+    set_html($('#sim_col > ul'), sim_html);
+  } else {
+    if (allpurpose) {
+      $('#sim_legend').classList.add('apparent');
+      $('#sim_legend').textContent = 'No cross-links found';
+    } else if (entype == 'C' && rank == 3) {
+      // FIXME this is fragile
+      var els,
+        html_3d = '';
+
+      if (wmgui.thumbed_display) {
+        els = $('div.busy_entry > div.gallery_img > p').textContent.split('-');
+      } else {
+        els = $('tr.busy_entry > td.c2')
+          .textContent.replace('; ', '')
+          .split(' ');
+        els = els[els.length - 1].split('-');
+      }
+      if (els.length == 3 || els.length == 4)
+        html_3d =
+          '<br /><br /><a href="#inquiry/classes=' +
+          (els.length == 3 ? 'prism' : 'tetrahedron') +
+          '&props=phase%20diagram&elements=' +
+          els.join('-') +
+          '"><img alt="3d" src="' +
+          wmgui.static_host +
+          '/' +
+          (els.length == 3 ? 'prism' : 'tetrahedron') +
+          '.png" /><br /><span>3d phase diagram</span></a>';
+
+      $('#sim_legend').classList.add('apparent');
+      set_html(
+        $('#sim_legend'),
+        '<br /><a href="#entry/' +
+          entry.split('-')[0] +
+          '"><img alt="C-entry" src="' +
+          wmgui.static_host +
+          '/pd_thumbs/' +
+          entry.split('-')[0] +
+          '.png" /><br /><span>Full phase diagram</span></a>' +
+          html_3d,
+      );
+    } else if (entype == 'C' && rank == 5) {
+      $('#sim_legend').classList.add('apparent');
+      $('#sim_legend').textContent = 'No links to other phases found.';
+    } else if (entype == 'C' && rank == 12) {
+      $('#sim_legend').classList.add('apparent');
+      $('#sim_legend').textContent =
+        'Hover the binary or ternary diagrams for more data.';
+    } else if (entype == 'S') {
+      $('#sim_legend').classList.add('apparent');
+      $('#sim_legend').textContent =
+        'No other structures for this prototype found.';
+    } else {
+      $('#sim_legend').classList.add('apparent');
+      $('#sim_legend').textContent = 'No similar values found.';
+    }
+  }
+
+  if (data.out.own.length && !wmgui.search.phid) {
+    set_html(
+      $('#own_phase'),
+      '<a href="#phase_id/' +
+        data.out.own[0][1] +
+        '"><img alt="Phase" src="' +
+        wmgui.static_host +
+        '/rd_thumbs/' +
+        data.out.own[0][0] +
+        '.png" /><br /><span>Linked ' +
+        (entype == 'S' ? 'distinct phase' : 'crystalline structure') +
+        '</span></a>',
+    );
+    show($('#own_phase'));
+  }
+}
+
+export function close_vibox() {
+  const iframe = $('#iframe');
+  if (iframe) {
+    if (wmgui.thumbed_display)
+      slide_up(iframe, 400, function () {
+        iframe.remove();
+      });
+    else iframe.remove();
+    hide($('#vibox'));
+    return true;
+  }
+  return false;
+}
+
+export function launch_db_iframed(rank) {
+  const that = $$('.busy_entry')[0];
+  if (!that) return;
+
+  var entry = that.id.substr(3),
+    entype = entry.substr(0, 1),
+    iframe_src,
+    iframe_height;
+
+  if (entype == 'S') {
+    if (rank == 99) {
+      ((iframe_src =
+        wmgui.engines_addrs['visavis'] + wmgui.path_s_xrpd + entry),
+        (iframe_height = 550));
+    } else
+      ((iframe_src =
+        wmgui.engines_addrs['cifplayer'] + wmgui.path_s_entry + entry),
+        (iframe_height = 650));
+  } else if (entype == 'P') {
+    if (rank == 1) {
+      ((iframe_src =
+        wmgui.engines_addrs['visavis'] + wmgui.path_pp_plot + entry),
+        (iframe_height = 550));
+      wmgui.notify('P-curves are in beta-testing');
+    } else if (rank == 4)
+      ((iframe_src =
+        wmgui.engines_addrs['visavis'] + wmgui.path_sd_plot + entry),
+        (iframe_height = 550));
+    else if (rank == 9)
+      ((iframe_src =
+        wmgui.v_pd_user_addr +
+        wmgui.api_host +
+        '/download/p?fmt=png&q=' +
+        entry),
+        (iframe_height = 600));
+    else if (rank == 10)
+      ((iframe_src = wmgui.v_ab_vis_addr + entry), (iframe_height = 600));
+    else return;
+  } else {
+    if (rank == 12) {
+      var triple = wmgui.thumbed_display
+        ? $('div.busy_entry > div.gallery_img > p').textContent
+        : $('tr.busy_entry > td.c1').textContent.split(' ')[0];
+      ((iframe_src = wmgui.v_pd_3d_addr + triple), (iframe_height = 550));
+    } else if (rank == 6)
+      ((iframe_src =
+        (wmgui.sid
+          ? wmgui.v_pd_user_addr + wmgui.api_host + '/download/c?fmt=png&q='
+          : wmgui.engines_addrs['visavis'] + wmgui.path_c_entry) + entry),
+        (iframe_height = 600));
+    else return;
+
+    if (wmgui.entries_messages[entry])
+      wmgui.notify(wmgui.entries_messages[entry]);
+  }
+
+  if (wmgui.sid) iframe_src += '&sid=' + wmgui.sid;
+
+  var iframe_html =
+    '<iframe frameborder=0 scrolling="no" width="100%" height="' +
+    iframe_height +
+    '" src="' +
+    iframe_src +
+    '"></iframe>';
+  if (wmgui.thumbed_display)
+    iframe_html =
+      '<div id="iframe" style="display:block;width:100%;border:1px solid #ddd;margin:10px 0;">' +
+      iframe_html +
+      '</div>';
+  else
+    iframe_html =
+      '<tr id="iframe"><td colspan="20" style="width:100%;padding:0;border-right:1px solid #eee;border-left:1px solid #eee;">' +
+      iframe_html +
+      '</td></tr>';
+
+  that.insertAdjacentHTML('afterend', iframe_html);
+  window.scrollTo(0, position(that).top - 95);
+}
+
+export function start_visavis(plot_type) {
+  destroy_numericbox();
+  delete wmgui.search.numeric;
+  if (plot_type) wmgui.visavis_curtype = plot_type;
+
+  hide($$('div.ctxpanel'));
+  const toshow = $('#ctxpanel_' + wmgui.visavis_curtype);
+  if (toshow) show(toshow);
+  if (['matrix', 'cube', 'discovery'].indexOf(wmgui.visavis_curtype) !== -1)
+    show($('#cmppanel_plots'));
+
+  if (wmgui.visavis_working) return manage_visavis();
+
+  rebuild_visavis();
+
+  // visavis_col preparation
+  show($('#visavis_col'));
+  show($('#visavis'));
+
+  switch_control_mode(0, 11, 'a', 'e');
+  document.body.classList.add('noscroll');
+
+  wmgui.search_type = 0;
+  wmgui.visavis_working = true;
+
+  var cur_obj = { total_count: 1 };
+  Object.assign(cur_obj, wmgui.search);
+
+  try {
+    document
+      .getElementById('visavis_iframe')
+      .contentWindow.location.replace(get_visavis_url(cur_obj));
+  } catch (e) {
+    console.error('No iframe access');
+  }
+}
+
+function manage_visavis(callback_fn, param_a, param_b) {
+  if (wmgui.visavis_terminating || !wmgui.visavis_working) {
+    return false;
+  }
+
+  if (wmgui.search.numeric) {
+    // not supported for plotting yet!
+    wmgui.visavis_terminating = true;
+    return false;
+  }
+
+  try {
+    wmgui.active_ajax.abort();
+  } catch (e) {}
+  try {
+    wmgui.quick_ajax.abort();
+  } catch (e) {}
+
+  rebuild_visavis();
+
+  var cur_obj = { total_count: 1 };
+  Object.assign(cur_obj, wmgui.search);
+
+  try {
+    document
+      .getElementById('visavis_iframe')
+      .contentWindow.location.replace(get_visavis_url(cur_obj));
+  } catch (e) {
+    console.error('No iframe access');
+  }
+
+  if (callback_fn) callback_fn(param_a, param_b);
+  return true;
+}
+
+function rebuild_visavis() {
+  var extr = window.location.hash.indexOf('search/');
+  if (extr == -1) {
+    var extr = window.location.hash.indexOf('inquiry/');
+    if (extr == -1) return;
+  }
+
+  var query = window.location.hash.substr(extr);
+
+  $$('a.pltcol_links').forEach(function (a) {
+    var plot_type = a.getAttribute('rev');
+    a.setAttribute(
+      'href',
+      wmgui.gui_host +
+        window.location.pathname +
+        '#plot/' +
+        plot_type +
+        '/' +
+        query,
+    );
+  });
+
+  $$('#visavis_col > ul > li').forEach(function (li) {
+    li.classList.remove('embodied');
+  });
+  const pltchoice = $('#pltchoice_' + wmgui.visavis_curtype);
+  if (pltchoice) pltchoice.classList.add('embodied');
+
+  // ctx reset
+  if (['matrix', 'cube', 'discovery'].indexOf(wmgui.visavis_curtype) !== -1)
+    update_dc();
+
+  if (wmgui.visavis_curtype == 'matrix') {
+    $$('#ctxpanel_matrix > ul > li.embodied').forEach(function (li) {
+      li.classList.remove('embodied');
+    });
+    $$('#ctxpanel_matrix > ul > li.ss_y').forEach(function (li) {
+      li.classList.remove('ss_y');
+    });
+    $('#vismatrix_nump').classList.add('embodied'); // set the default sort order, also in Visavis: TODO
+    remove($$('span.sops'));
+  } else if (wmgui.visavis_curtype == 'cube') {
+    $$('#ctxpanel_cube > ul > li.embodied').forEach(function (li) {
+      li.classList.remove('embodied');
+    });
+    $$('#ctxpanel_cube > ul > li.ss_y').forEach(function (li) {
+      li.classList.remove('ss_y');
+    });
+    $$('#ctxpanel_cube > ul > li.ss_z').forEach(function (li) {
+      li.classList.remove('ss_z');
+    });
+    $('#viscube_nump').classList.add('embodied');
+    remove($$('span.sops'));
+  } else if (wmgui.visavis_curtype == 'graph') {
+    $$('#ctxpanel_graph > ul > li.embodied').forEach(function (li) {
+      li.classList.remove('embodied');
+    });
+    $('#visgraph_props').classList.add('embodied');
+  }
+
+  try {
+    document
+      .getElementById('visavis_iframe')
+      .contentWindow.fixel_manage(
+        wmgui.visavis_curtype == 'cube' && wmgui.search.elements,
+      );
+  } catch (e) {
+    console.error('No iframe access');
+  }
+}
+
+function stop_visavis() {
+  hide($$('#visavis, #visavis_col'));
+  wmgui.visavis_working = false;
+  wmgui.visavis_terminating = false;
+}
+
+export function get_visavis_url(request, type, height) {
+  if (wmgui.visavis_curtype == 'pie' && !type)
+    return (
+      wmgui.engines_addrs['visavis'] +
+      '#' +
+      wmgui.rfn_endpoint +
+      '?q=' +
+      encodeURIComponent(JSON.stringify(request))
+    );
+
+  var height_str = height ? '&visavis_height=' + height : '';
+
+  return (
+    wmgui.engines_addrs['visavis'] +
+    '#' +
+    wmgui.vis_endpoint +
+    '/' +
+    (type || wmgui.visavis_curtype) +
+    '?q=' +
+    encodeURIComponent(JSON.stringify(request)) +
+    height_str
+  );
+}
+
+export function describe_perms(perms) {
+  var out_gui = '<h3>Web-browser access = GUI</h3><ul>',
+    out_api = '<h3>Programmatic access = API</h3><ul>';
+
+  if (perms.gui) {
+    if (perms.gui.root) out_gui += '<li>complete access</li>';
+    else {
+      if (!Array.isArray(perms.gui)) perms.gui = [perms.gui];
+      for (var m = 0; m < perms.gui.length; m++) {
+        const ruleset = perms.gui[m];
+        if (m > 3) {
+          out_gui += '<li>and ' + (perms.gui.length - 4) + ' more...</li>';
+          break;
+        }
+        wmgui.facets.forEach(function (item) {
+          if (ruleset[item]) {
+            try {
+              out_gui +=
+                '<li class="perms_view fct_' +
+                item +
+                '"><strong>' +
+                wmgui.facet_names[item] +
+                '</strong>: ' +
+                ruleset[item]
+                  .map(function (x) {
+                    return x.replace(', ', ' &amp; ');
+                  })
+                  .join(', ') +
+                '</li>';
+            } catch (e) {}
+          }
+        });
+        if (ruleset.refs == 'ALL')
+          out_gui += '<li>full access to reference details</li>';
+        else if (ruleset.refs == 'MENTIONED')
+          out_gui += '<li>access to corresponding references</li>';
+        else out_gui += '<li>no access to reference details</li>';
+        out_gui += '<li style="font-size:0.8em;line-height:0.8em;"><br /></li>';
+      }
+    }
+  } else out_gui += '<li>only open data</li>';
+
+  if (perms.api) {
+    if (perms.api.root) out_api += '<li>complete access</li>';
+    else if (perms.api.disabled)
+      out_api += '<li>disabled &mdash; please check on the other device</li>';
+    else {
+      if (!Array.isArray(perms.api)) perms.api = [perms.api];
+      for (var m = 0; m < perms.api.length; m++) {
+        const ruleset = perms.api[m];
+        if (m > 3) {
+          out_api += '<li>and ' + (perms.api.length - 4) + ' more...</li>';
+          break;
+        }
+        wmgui.facets.forEach(function (item) {
+          if (ruleset[item]) {
+            try {
+              out_api +=
+                '<li class="perms_view fct_' +
+                item +
+                '"><strong>' +
+                wmgui.facet_names[item] +
+                '</strong>: ' +
+                ruleset[item]
+                  .map(function (x) {
+                    return x.replace(', ', ' &amp; ');
+                  })
+                  .join(', ') +
+                '</li>';
+            } catch (e) {}
+          }
+        });
+        out_api += '<li style="font-size:0.8em;line-height:0.8em;"><br /></li>';
+      }
+    }
+  } else out_api += '<li>only open data</li>';
+
+  return out_gui + '</ul><div class="divider"></div>' + out_api + '</ul>';
+}
+
+export function show_advsbox() {
+  hide($$('div.modal'));
+  show($$('#advsbox, #overlay'));
+
+  // show typed terms
+  if (!is_empty(wmgui.search)) {
+    wmgui.simple_facets.forEach(function (item) {
+      if (wmgui.search[item]) {
+        var value = wmgui.search[item];
+
+        if (item == 'codens') value = wmgui.journal_converter.c2j(value);
+        else if (item == 'doi') value = value.replaceAll('%2F', '/');
+
+        $('#advs_fct_' + item).value = decodeURIComponent(
+          value.replace(/\+/g, '%20'),
+        );
+      } else $('#advs_fct_' + item).value = '';
+    });
+
+    wmgui.multi_facets.forEach(function (item) {
+      const rest_input = $('#advs_fct_' + item + '-selectized');
+      if (rest_input) rest_input.value = '';
+      wmgui.multiselects[item].clear();
+
+      if (wmgui.search[item]) {
+        var obj = {};
+        obj[item] = wmgui.search[item];
+        wmgui.multiselects[item].write(obj);
+        //wmgui.multiselects[item].write({[item]: wmgui.search[item]});
+        if (item == 'aetypes')
+          show_aetmap(wmgui.search[item].split(',').pop().trim());
+      }
+    });
+  }
+  if (!show_aetmap.cached_aetmap) {
+    show_aetmap.cached_aetmap = new Image();
+    show_aetmap.cached_aetmap.src = wmgui.aetmap_addr;
+  }
+}
+
+export function show_hints(disabled, res_count) {
+  //$('#fdwidget').html('Were you satisfied with the data quality? Did everything work as expected? <span id="fdwidget_yes">Yes</span><span id="fdwidget_no">No</span>').show();
+
+  if (
+    disabled ||
+    wmgui.search.numeric ||
+    wmgui.search.doi ||
+    wmgui.search.phid ||
+    wmgui.search.bid ||
+    wmgui.fuzzyout ||
+    wmgui.search_type == 2
+  )
+    return;
+
+  var cur_obj = {};
+  Object.assign(cur_obj, wmgui.search);
+  delete cur_obj.ignored;
+  delete cur_obj.search_type;
+
+  var hint = JSON.stringify(cur_obj)
+    .replaceAll(' ', '+')
+    .replace('\{', '\\{')
+    .replace('\}', '\\}');
+  set_html($('#apihint kbd'), hint);
+  show($('#apihint'));
+
+  if (wmgui.search_type === 0 && (res_count > 3 || res_count === undefined)) {
+    $$('a.plthint_links').forEach(function (a) {
+      var plot_type = a.getAttribute('rev');
+      a.setAttribute(
+        'href',
+        wmgui.gui_host +
+          window.location.pathname +
+          '#plot/' +
+          plot_type +
+          '/' +
+          window.location.hash.substr(1),
+      );
+    });
+    show($('#plthint'));
+  }
+}
+
+export function show_tooltip(info, forced) {
+  if (
+    info.view_mode != wmgui.view_mode ||
+    (wmgui.visavis_working && !forced) ||
+    $$('.modal').some(isVisible)
+  )
+    return;
+
+  var ref = position($('#' + info.el)),
+    tooltip_el = document.getElementById('tooltip');
+
+  tooltip_el.style.left = ref.left + info.oleft + 'px';
+  tooltip_el.style.top = ref.top + info.otop + 'px';
+  tooltip_el.firstChild.innerHTML = info.text;
+  document.getElementById('tooltip').style.display = 'block';
+}
+
+export function show_modal(which) {
+  if (which == 'login') {
+    if ($('#factor_by_email').value)
+      $('#login_email').value = $('#factor_by_email').value;
+    else $('#login_email').value = '';
+
+    $('#login_password').value = '';
+    show($('#loginbox'));
+    $('#login_email').focus();
+
+    // for OAuth linking redirect only
+    // see email_chain.html
+    var u_email =
+      window.localStorage.getItem(wmgui.store_oauth_email_key) || false;
+    if (u_email) {
+      $('#login_email').value = u_email;
+      window.localStorage.removeItem(wmgui.store_oauth_email_key);
+    }
+  } else if (which == 'factor') {
+    if ($('#login_email').value)
+      $('#factor_by_email').value = $('#login_email').value;
+    else $('#factor_by_email').value = '';
+
+    show($('#factorbox'));
+    $('#factor_by_email').focus();
+  } else if (which == 'restore') {
+    if ($('#login_email').value)
+      $('#restore_by_email').value = $('#login_email').value;
+    else $('#restore_by_email').value = '';
+
+    show($('#restorebox'));
+    $('#restore_by_email').focus();
+  }
+}
+
+export function init_user_login() {
+  // to prevent re-execution
+  var locals = JSON.parse(
+    window.localStorage.getItem(wmgui.store_user_key) || '{}',
+  );
+  if (locals.sid === wmgui.sid) return;
+
+  if (!locals.ipbased && locals.sid && locals.name && locals.acclogin) {
+    user_login(
+      locals.sid,
+      locals.name,
+      locals.acclogin,
+      locals.admin,
+      locals.oauths,
+      false,
+    );
+  } else {
+    // attempt IP-based login
+    ajax({
+      type: 'POST',
+      url: wmgui.ip_endpoint,
+    })
+      .then(function (data) {
+        if (data.sid && data.name && data.acclogin)
+          user_login(
+            data.sid,
+            data.name,
+            data.acclogin,
+            data.admin,
+            data.oauths,
+            true,
+          );
+      })
+      .catch(function () {});
+  }
+}
+
+export function user_login(sid, name, acclogin, admin, oauths, ipbased) {
+  var corner_name = name.length > 40 ? name.substr(0, 37) + '&hellip;' : name;
+  set_html($('#auth_user'), corner_name);
+  set_html($('#account_holder_name'), 'Hello ' + name + ' &#x1f44d;');
+  set_html(
+    $('#account_holder_acclogin > span'),
+    ipbased
+      ? 'location-based'
+      : '<a href="mailto:' + acclogin + '">' + acclogin + '</a>',
+  );
+
+  wmgui.sid = sid;
+  wmgui.oauths = oauths;
+
+  hide($$('div.logged_out'));
+  show($$('div.logged_in'));
+  hide($('#account_pass_change'));
+
+  window.localStorage.setItem(
+    wmgui.store_user_key,
+    JSON.stringify({
+      sid: sid,
+      name: name,
+      acclogin: acclogin,
+      admin: admin,
+      ipbased: ipbased,
+    }),
+  ); // TODO? oauths: oauths
+
+  if (admin && (wmgui.edition == 0 || wmgui.edition == 1)) show($$('li.admin'));
+  else hide($$('li.admin'));
+
+  if (ipbased) {
+    hide($$('.only_regular'));
+    $('#logout_trigger').classList.add('disabled');
+    $('#accpass_trigger').textContent = 'disabled';
+    $('#accpass_trigger').classList.add('disabled');
+  } else {
+    show($$('.only_regular'));
+    $('#logout_trigger').classList.remove('disabled');
+    $('#accpass_trigger').textContent = 'change';
+    $('#accpass_trigger').classList.remove('disabled');
+  }
+
+  try {
+    document.getElementById('visavis_iframe').contentWindow.location.reload();
+  } catch (e) {
+    console.error('No iframe access');
+  }
+  communicate_windows('tab_user_login');
+
+  wmgui.notify('Logged in as ' + name);
+
+  // One-off redirection
+  var redir = window.localStorage.getItem(wmgui.store_redir_key);
+  if (redir) {
+    window.localStorage.removeItem(wmgui.store_redir_key);
+    return window.location.replace(redir); // FIXME? replace vs. href
+  }
+}
+
+export function tab_user_login() {
+  // to prevent re-execution
+  var locals = JSON.parse(
+    window.localStorage.getItem(wmgui.store_user_key) || '{}',
+  );
+  if (locals.sid === wmgui.sid) return;
+
+  window.location.reload();
+}
+
+export function user_logout(silent) {
+  if (!wmgui.sid) return;
+
+  wmgui.sid = null;
+  wmgui.oauths = null;
+  hide($$('li.admin'));
+  hide($$('div.logged_in'));
+  show($$('div.logged_out'));
+
+  window.localStorage.removeItem(wmgui.store_user_key);
+
+  try {
+    document.getElementById('visavis_iframe').contentWindow.location.reload();
+  } catch (e) {
+    console.error('No iframe access');
+  }
+  communicate_windows('user_logout');
+
+  if (!silent) wmgui.notify('You are logged out');
+}
+
+export function force_relogin(show_msg) {
+  ajax({
+    type: 'POST',
+    url: wmgui.logout_endpoint,
+    data: { sid: wmgui.sid },
+  })
+    .then(function () {})
+    .catch(function () {});
+  user_logout(true);
+  window.location.replace('#modal/login');
+  if (show_msg) wmgui.notify(show_msg);
+}
+
+function communicate_windows(runnable_name) {
+  // NB the active window doesn't receive a storage event
+  window.localStorage.setItem(wmgui.store_comm_exec_key, runnable_name);
+  setTimeout(function () {
+    window.localStorage.removeItem(wmgui.store_comm_exec_key);
+  }, 0);
+}
+
+function reset_factor_form() {
+  document.getElementById('factor_trigger').style.display = 'block';
+  document.getElementById('factor_form_step_one').style.display = 'block';
+  document.getElementById('factor_form_step_two').style.display = 'none';
+  var resps = document.getElementsByClassName('factor_form_resp');
+  for (var i = 0; i < resps.length; i++) {
+    resps[i].value = '';
+  }
+}
+
+export function submit_factor_form_resp() {
+  var result = '';
+  var resps = document.getElementsByClassName('factor_form_resp');
+  for (var i = 0; i < resps.length; i++) {
+    result += resps[i].value;
+  }
+  if (result.length !== 6 || !Number.isInteger(parseInt(result))) return false;
+
+  ajax({
+    type: 'POST',
+    url: wmgui.factor_v_endpoint,
+    data: { a: result, ed: wmgui.edition },
+  })
+    .then(function (data) {
+      if (data.error) return wmgui.notify(data.error);
+      if (!data.sid || !data.name || !data.acclogin) {
+        window.location.replace('#start');
+        return wmgui.notify(
+          'Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>',
+        );
+      }
+      user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
+
+      reset_factor_form();
+
+      $('#userbox').click();
+    })
+    .catch(function () {});
+}
+
+function update_dc() {
+  var title = [],
+    orepr = {};
+  for (var key in wmgui.search) {
+    if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
+    orepr[key] = wmgui.search[key];
+    title.push(wmgui.search[key]);
+  }
+  title = title.join(' ');
+
+  var count = 0,
+    cur_str = JSON.stringify(orepr),
+    cmp_html = '<option value="X" selected>To last searches...</option>';
+
+  JSON.parse(
+    window.localStorage.getItem(wmgui.store_history_key) || '[]',
+  ).forEach(function (past) {
+    if (count > 6) return;
+
+    var past_title = [],
+      past_str = JSON.stringify(past);
+    if (cur_str == past_str) return;
+
+    for (var prop in past) {
+      past_title.push(past[prop]);
+    }
+    past_title = past_title.join(' ');
+    cmp_html +=
+      '<option value="' +
+      encodeURIComponent(past_str) +
+      '">' +
+      past_title +
+      '</option>';
+    count++;
+  });
+  cmp_html += '<option value="Y">No comparison</option>';
+  const select_cmp = $('#select_cmp_trigger');
+  select_cmp.innerHTML = '';
+  select_cmp.insertAdjacentHTML('beforeend', cmp_html);
+}
+
+export function show_aetmap(term) {
+  var coords = wmgui.aets[term];
+  if (coords) {
+    const aetmap = $('#aetmap');
+    aetmap.style.height = coords[1] + 'px';
+    aetmap.style.background =
+      'url(' + wmgui.aetmap_addr + ') 0 -' + coords[0] + 'px no-repeat';
+    show(aetmap);
+  } else hide($('#aetmap'));
+}
+
+export function render_all_polyhedra() {
+  const content = $('#all_polyhedra_content');
+  if (content.firstChild) return;
+  var aetypes_html = '',
+    defined_aetypes = Object.keys(wmgui.aets);
+  defined_aetypes.sort(function (a, b) {
+    var partsa = a.split('-vertex')[0].split(' '),
+      va = parseInt(partsa[partsa.length - 1]),
+      partsb = b.split('-vertex')[0].split(' '),
+      vb = parseInt(partsb[partsb.length - 1]);
+    return va > vb
+      ? 1
+      : va < vb
+        ? -1
+        : a.length > b.length
+          ? 1
+          : a.length < b.length
+            ? -1
+            : 0;
+  });
+  defined_aetypes.forEach(function (value) {
+    var coords = wmgui.aets[value];
+    aetypes_html +=
+      '<div class="gallery_item" rel="' +
+      value +
+      '"><div style="width:125px;height:' +
+      coords[1] +
+      'px;margin:10px auto;background:url(' +
+      wmgui.aetmap_addr +
+      ') 0 -' +
+      coords[0] +
+      'px no-repeat;"></div><span>' +
+      value +
+      '</span></div>';
+  });
+  set_html(content, aetypes_html);
+}
+
+function show_dunit_info(phid, bid, entry) {
+  if (phid) {
+    set_html($('#ind_title'), 'Phase ' + phid);
+    const ind_link = $('#ind_link');
+    ind_link.setAttribute('href', 'https://mpds.io/phase_id/' + phid);
+    set_html(ind_link, 'www.mpds.io/phase_id/' + phid);
+  } else if (bid) {
+    set_html($('#ind_title'), 'Publication B' + bid);
+    const ind_link = $('#ind_link');
+    ind_link.setAttribute('href', 'https://mpds.io/article/' + bid);
+    set_html(ind_link, 'www.mpds.io/article/' + bid);
+  } else if (entry) {
+    set_html($('#ind_title'), 'Entry ' + entry);
+    const ind_link = $('#ind_link');
+    ind_link.setAttribute('href', 'https://mpds.io/entry/' + entry);
+    set_html(ind_link, 'www.mpds.io/entry/' + entry);
+  }
+
+  hide($$('#refine_col, #ctx_col'));
+  empty($$('#phase_info, #ind_col > span'));
+
+  if (phid) {
+    set_html(
+      $('#ind_col > span'),
+      '<img src="' + wmgui.static_host + '/phid_thumbs/' + phid + '.png" />',
+    );
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'GET',
+      url: wmgui.phase_endpoint,
+      data: { phid: phid },
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (data) {
+        wmgui.hide_preloader();
+        if (data.error) return wmgui.notify(data.error);
+
+        var html =
+          '<h4>' +
+          data.out.formula_html.split(' ')[0] +
+          ' ' +
+          (data.out.spg || '?') +
+          ' ' +
+          (data.out.pearson || '&mdash;') +
+          '</h4>';
+
+        if (data.out.mpid)
+          html +=
+            '<h4 style="background:#ddd;margin-top:-7px;">Materials Project <a target="_blank" href="https://materialsproject.org/materials/mp-' +
+            data.out.mpid +
+            '">mp-' +
+            data.out.mpid +
+            '</a></h4>';
+
+        html += '<p>';
+        if (data.out.articles_count)
+          html +=
+            'This phase was reported in ' +
+            data.out.articles_count +
+            ' article' +
+            (data.out.articles_count > 1 ? 's' : '') +
+            '.';
+        if (data.out.sim_count > 1)
+          html +=
+            ' There are <a href="#interlinkage/' +
+            phid +
+            '">' +
+            data.out.sim_count +
+            ' structurally similar phases</a> from other articles.';
+        html += '</p>';
+
+        set_html($('#phase_info'), html);
+        show($('#dtypes_phid'));
+      })
+      .catch(function (error) {
+        wmgui.hide_preloader();
+        if (!(error && error.aborted))
+          wmgui.notify('Sorry, a network error occured. Please, try again');
+      });
+  } else if (bid) {
+    set_html($('#ind_col > span'), '<strong>&#x1f4d6;</strong>'); // book icon
+    set_html(
+      $('#phase_info'),
+      '<h4>Ref. ' +
+        bid +
+        '</h4><p>Please make sure you are<br /><a target="_blank" href="#modal/menu">logged in</a> to see all the details.</p>',
+    );
+
+    wmgui.show_preloader();
+    const request = ajax({
+      type: 'GET',
+      url:
+        wmgui.refs_endpoint +
+        '?noredir=1&fmt=bib&ref_id=' +
+        bid +
+        '&sid=' +
+        wmgui.sid,
+      dataType: 'text',
+    });
+    wmgui.active_ajax = request;
+
+    request
+      .then(function (data) {
+        wmgui.hide_preloader();
+        var citation = wmgui.parse_bib(data),
+          citation_html = '',
+          main_author = '',
+          links_html = '';
+
+        if (citation[0].length) {
+          citation[0].split(',').forEach(function (item, index) {
+            var author_name = item.trim().split('.')[0];
+            author_name = author_name
+              .substr(0, author_name.length - 2)
+              .replace("'", '');
+            if (index === 0) main_author = author_name;
+            links_html +=
+              '<a href="#inquiry/authors=' +
+              author_name +
+              '" style="color:#777;border-bottom-color:#777;">' +
+              author_name +
+              '</a> or ';
+          });
+          links_html = links_html.substr(0, links_html.length - 4); // " or "
+          if (citation[0].indexOf(',') !== -1) main_author += ' et al.';
+          citation_html +=
+            ' <a href="' +
+            wmgui.refs_endpoint +
+            '?fmt=bib&ref_id=' +
+            bid +
+            '&sid=' +
+            wmgui.sid +
+            '">' +
+            main_author +
+            ', ' +
+            citation[1] +
+            '. ' +
+            citation[2] +
+            ' <i>(' +
+            citation[3] +
+            ')</i></a>';
+        }
+
+        if (bid == 999999) {
+          set_html(
+            $('#phase_info'),
+            '<h4>In-house data</h4><p>These data were generated automatically on the MPDS platform based on the original peer-reviewed Pauling File data. Please cite as ' +
+              citation_html +
+              '.</p>',
+          );
+        } else {
+          var n_entries = wmgui.thumbed_display
+            ? $$('div.gallery_item').length
+            : $$('tr.tcell').length;
+          if (n_entries == 1000) n_entries = 'more than ' + n_entries;
+          set_html(
+            $('#phase_info'),
+            '<h4>Ref. ' +
+              bid +
+              '</h4><p>We have ' +
+              (n_entries == 1 ? 'one entry' : n_entries + ' entries') +
+              ' from this reference' +
+              citation_html +
+              '.</p>' +
+              (links_html.length
+                ? '<p>Retrieve all data co-authored by ' + links_html + '.</p>'
+                : ''),
+          );
+        }
+      })
+      .catch(function () {
+        wmgui.hide_preloader();
+      });
+  } else {
+    set_html($('#ind_col > span'), '<strong>&#x1f52c;</strong>'); // microscope icon
+  }
+
+  show($('#ind_col'));
+  hide($('#dtypes'));
+}
+
+export function assign_edition() {
+  function run_edition(edition_key) {
+    edition_key = parseInt(edition_key);
+    if (!wmgui.editions[edition_key]) edition_key = 0;
+    wmgui.edition = edition_key;
+    if (wmgui.editions[edition_key].css)
+      wmgui.loadCSS(wmgui.editions[edition_key].css);
+    if (wmgui.editions[edition_key].actions)
+      wmgui.editions[edition_key].actions();
+  }
+
+  for (var key in wmgui.editions) {
+    if (
+      wmgui.gui_host == wmgui.editions[key]['prod_url'] ||
+      wmgui.gui_host == wmgui.editions[key]['dev_url']
+    ) {
+      run_edition(key);
+      break;
+    }
+  }
+
+  // for any unknown domain, ICDD MPDS is assumed
+  if (!wmgui.edition) run_edition(0);
+
+  // for any third-party integrations, id="mpds_native" should not be used
+  wmgui.mpds_native = !!document.getElementById('mpds_native');
+}
diff --git a/src_js/app/startup.js b/src_js/app/startup.js
new file mode 100644
index 0000000..7cea2b4
--- /dev/null
+++ b/src_js/app/startup.js
@@ -0,0 +1,623 @@
+/**
+ * Ermac startup: satisfy_requirements() initializes autocompletes, multiselects,
+ * client-side data features, and triggers the initial route.
+ */
+
+/* global Darkmode */
+
+import wmgui from '../core/settings.js';
+import { wmutils } from '../core/utils.js';
+import { $, $$, hide, set_attr, append_html, isVisible } from '../core/dom.js';
+import { ajax } from '../core/ajax.js';
+import { create_autocomplete } from '../components/autocomplete.js';
+import { create_multiselect } from '../components/multiselect.js';
+import {
+  create_floating_slider,
+  destroy_numericbox,
+  inquiry_param,
+} from '../components/sliders.js';
+import { show_aetmap, init_user_login, rotate_interesting } from './search.js';
+import { url_redraw_react } from './router.js';
+import { read_ptable_html, select_ptable_series } from './ptable.js';
+
+export function satisfy_requirements() {
+  hide($$('#notifybox, #preloader'));
+  //document.title = document.body.clientWidth + ' px';
+  const absolidize_href = $('#absolidize > span.disabled > span.href');
+  if (absolidize_href) set_attr(absolidize_href, 'rel', wmgui.mydata_addr);
+
+  wmgui.ptable.els_data = read_ptable_html();
+
+  init_user_login();
+
+  // building history box
+  var history_html = '';
+  JSON.parse(
+    window.localStorage.getItem(wmgui.store_history_key) || '[]',
+  ).forEach(function (past, n) {
+    wmgui.tooltip_counter++;
+
+    if (n > 5) return;
+
+    var title = [],
+      inquiry = false;
+
+    for (var prop in past) {
+      title.push(past[prop]);
+    }
+    title = title.join(' ');
+    wmgui.inquiries.forEach(function (item) {
+      if (past[item]) {
+        inquiry = true;
+      }
+    });
+
+    if (inquiry)
+      history_html +=
+        '<li><a href="#inquiry/' + inquiry_param(past) + '">' + title + '</a></li>';
+    else
+      history_html +=
+        '<li><a href="#search/' +
+        encodeURIComponent(title) +
+        '">' +
+        title +
+        '</a></li>';
+  });
+  append_html($('#history ul'), history_html);
+
+  JSON.parse(window.localStorage.getItem(wmgui.store_bids_key) || '[]').forEach(
+    function (item) {
+      wmgui.bid_history.push(parseInt(item));
+    },
+  );
+
+  JSON.parse(
+    window.localStorage.getItem(wmgui.store_mydata_key) || '[]',
+  ).forEach(function (item) {
+    wmgui.mydata_history.push(item);
+  });
+
+  // set client-side data features
+  ajax({
+    url: wmgui.wmdata_endpoint,
+    type: 'GET',
+    //data: {nocache: Math.floor(Math.random() * 1000)}
+  })
+    .then(function (answer) {
+      var i = 0,
+        len = answer.props_ref.length;
+      for (i; i < len; i++) {
+        if (!answer.props_ref[i]) answer.props_ref[i] = answer.props[i];
+      }
+
+      // local search algo
+      // #1
+      ['props', 'lattices', 'sgs', 'protos', 'codens', 'geos', 'orgs'].forEach(
+        function (fct) {
+          create_autocomplete({
+            custom_type: fct,
+            selector: 'advs_fct_' + fct,
+            minChars: 1,
+            cache: 1,
+            source: function (term, fct_type, suggest) {
+              // other names are used, define them first here
+              var fct_src = fct_type,
+                fct_chk = fct_type,
+                anypos = false;
+
+              if (fct_type !== 'lattices') {
+                anypos = true;
+                if (fct_type == 'props') fct_src = 'props_ref';
+                else if (fct_type == 'codens') {
+                  fct_src = 'jfull';
+                  fct_chk = 'jfull';
+                }
+              }
+
+              var suggestions = [],
+                cnt = 0,
+                checks = [],
+                i = 0,
+                len = answer[fct_chk].length;
+
+              term = term.toLowerCase();
+              for (i; i < len; i++) {
+                if (answer[fct_chk][i].toLowerCase().startswith(term)) {
+                  suggestions.push(answer[fct_src][i]);
+                  if (anypos) checks.push(answer[fct_src][i]);
+                  cnt++;
+                  if (cnt > 12) break;
+                }
+              }
+              if (anypos && suggestions.length < 6) {
+                for (i = 0; i < len; i++) {
+                  if (
+                    answer[fct_chk][i].toLowerCase().indexOf(term) != -1 &&
+                    checks.indexOf(answer[fct_src][i]) == -1
+                  ) {
+                    suggestions.push(answer[fct_src][i]);
+                    cnt++;
+                    if (cnt > 12) break;
+                  }
+                }
+              }
+              suggest(suggestions);
+            },
+            renderItem: function (item, search) {
+              return (
+                '<div class="autocomplete-suggestion" data-val="' +
+                item +
+                '">' +
+                item +
+                '</div>'
+              );
+            },
+          });
+        },
+      );
+
+      // local search algo
+      // #2
+      wmgui.multi_facets.forEach(function (fct) {
+        wmgui.multiselects[fct] = create_multiselect($('#advs_fct_' + fct), {
+          plugins: ['remove_button', 'preserve_on_blur'],
+          valueField: 'id',
+          labelField: 'label',
+          searchField: 'label',
+          create: false,
+          highlight: false,
+          maxItems: 5,
+          closeAfterSelect: true,
+          diacritics: false,
+          options: [],
+          onChange: function (value) {
+            if (fct == 'aetypes') {
+              var term = (wmgui.multiselects['aetypes'].read()['aetypes'] || '')
+                .split(', ')
+                .pop();
+              show_aetmap(term);
+              if ($('#aet_limit').checked) $('#aet_limit').click();
+            } else if (fct == 'wyckoff') {
+              var terms = (
+                wmgui.multiselects['wyckoff'].read()['wyckoff'] || ''
+              )
+                .split(',')
+                .map(function (x) {
+                  return x.trim();
+                });
+              if (terms && terms[0] && terms.length > 1) {
+                var cmp = wmgui.is_wyckoff_position(terms[0]);
+                if (
+                  !terms.every(function (x) {
+                    return cmp === wmgui.is_wyckoff_position(x);
+                  })
+                )
+                  wmgui.notify(
+                    'Wyckoff sequence and positions are mutually exclusive',
+                  );
+              }
+            }
+          },
+          onItemRemove: function (value) {
+            var input = this;
+            setTimeout(function () {
+              input.close();
+            }, 750);
+          },
+          load: function (term, callback) {
+            this.clearOptions();
+            if (!term.length) return callback();
+
+            var suggestions = [],
+              cnt = 0,
+              checks = [],
+              i = 0,
+              len = answer[fct].length;
+
+            term = term.toLowerCase();
+            for (i; i < len; i++) {
+              if (answer[fct][i].toLowerCase().startswith(term)) {
+                suggestions.push({
+                  facet: fct,
+                  label: answer[fct][i],
+                  id: fct + i,
+                });
+                checks.push(answer[fct][i]);
+                cnt++;
+                if (cnt > 12) break;
+              }
+            }
+            if (suggestions.length < 6) {
+              for (i = 0; i < len; i++) {
+                if (
+                  answer[fct][i].toLowerCase().indexOf(term) != -1 &&
+                  checks.indexOf(answer[fct][i]) == -1
+                ) {
+                  suggestions.push({
+                    facet: fct,
+                    label: answer[fct][i],
+                    id: fct + i,
+                  });
+                  cnt++;
+                  if (cnt > 12) break;
+                }
+              }
+            }
+            callback(suggestions);
+          },
+          score: function () {
+            return function () {
+              return 1;
+            };
+          }, // no client scoring
+          render: {
+            option: function (item, escape) {
+              return (
+                '<div class="fct_' + item.facet + '">' + item.label + '</div>'
+              );
+            },
+            item: function (item, escape) {
+              return (
+                '<div class="fct_' +
+                item.facet +
+                '" data-facet="' +
+                item.facet +
+                '" data-term="' +
+                item.label +
+                '">' +
+                item.label +
+                '</div>'
+              );
+            },
+          },
+        });
+
+        wmgui.multiselects[fct].read = function () {
+          return wmgui._selectize_read_facet(fct);
+        };
+        wmgui.multiselects[fct].write = function (search_obj) {
+          wmgui._selectize_write(wmgui.multiselects[fct], fct, search_obj);
+        };
+        wmgui.multiselects[fct].display = function (facet, term) {
+          wmgui._selectize_display(wmgui.multiselects[fct], facet, term);
+        };
+      });
+
+      wmgui.journal_converter.j2c = function (x) {
+        var fi = answer.jfull.indexOf(x);
+        if (fi == -1) {
+          wmgui.notify('Sorry, unknown journal: ' + x);
+          return x;
+        }
+        return answer.codens[fi];
+      };
+      wmgui.journal_converter.c2j = function (x) {
+        var fi = answer.codens.indexOf(x);
+        if (fi == -1) {
+          wmgui.notify('Sorry, unknown CODEN: ' + x);
+          return x;
+        }
+        return answer.jfull[fi];
+      };
+
+      var html_scalars = '',
+        html_complex = '',
+        html_arrays = '',
+        counter = 0;
+
+      (function () {
+        for (var term in answer.hy_scalars) {
+          const content = answer.hy_scalars[term];
+          term = parseInt(term);
+          //console.log(term);
+          term = answer.props_ref[term]
+            ? answer.props_ref[term]
+            : answer.props[term];
+          //console.log(term);
+          counter += 1;
+          html_scalars +=
+            '<li><a class="dynprop" data-val="' +
+            term +
+            '" href="#inquiry/props=' +
+            term.replace(/ /g, '+') +
+            '">' +
+            term +
+            '</a> (<span class="hy' +
+            counter +
+            '">expand</span>)<ul style="display:none;">';
+          (function () {
+            for (var sub_term in content) {
+              const sub_content = content[sub_term];
+              sub_term = parseInt(sub_term);
+              //console.log(sub_term);
+              sub_term = answer.props_ref[sub_term]
+                ? answer.props_ref[sub_term]
+                : answer.props[sub_term];
+              //console.log('----' + sub_term);
+              html_scalars +=
+                '<li><a class="dynprop" data-val="' +
+                sub_term +
+                '" href="#inquiry/props=' +
+                sub_term.replace(/ /g, '+') +
+                '">' +
+                sub_term +
+                '</a><ul style="display:none;">';
+              sub_content.forEach(function (item, n) {
+                item = parseInt(item);
+                var prop = answer.props_ref[item]
+                    ? answer.props_ref[item]
+                    : answer.props[item],
+                  specs = answer.numerics[item]; // NB object vs. array
+                //console.log('---------' + item + ' ' + prop);
+                html_scalars +=
+                  '<li><a class="dynprop" data-val="' +
+                  prop +
+                  '" href="#inquiry/props=' +
+                  prop.replace(/ /g, '+') +
+                  '">' +
+                  prop +
+                  '</a>';
+                if (specs) {
+                  html_scalars +=
+                    '<strong class="numeric" title="Numeric search" rel="' +
+                    prop +
+                    '">' +
+                    (specs[0] || '') +
+                    ' &nbsp;[' +
+                    specs[1] +
+                    ' &#8596; ' +
+                    specs[2] +
+                    ']&nbsp;&#x1F50D;</strong>';
+                  wmgui.numerics[prop] = [
+                    item,
+                    specs[0],
+                    specs[1],
+                    specs[2],
+                    specs[3],
+                  ]; // prop_name: [client_prop_id, units, min, max, ?step, ?origname]
+                }
+                html_scalars += '</li>';
+              });
+              html_scalars += '</ul></li>';
+            }
+          })();
+          html_scalars += '</ul></li>';
+        }
+      })();
+      append_html($('#hy_scalars > ul'), html_scalars);
+
+      wmgui.hy_complex.forEach(function (item) {
+        // FIXME cannot process with optimade NLP parser
+        html_complex +=
+          '<li><a class="dynprop" data-val="' +
+          item +
+          '" href="#search/' +
+          item +
+          '">' +
+          item +
+          '</a></li>';
+      });
+      append_html($('#hy_complex > ul'), html_complex);
+
+      (function () {
+        for (var term in answer.hy_textual) {
+          const content = answer.hy_textual[term];
+          term = parseInt(term);
+          term = answer.props_ref[term]
+            ? answer.props_ref[term]
+            : answer.props[term];
+          counter += 1;
+          html_arrays +=
+            '<li><a class="dynprop" data-val="' +
+            term +
+            '" href="#inquiry/props=' +
+            term.replace(/ /g, '+') +
+            '">' +
+            term +
+            '</a> (<span class="hy' +
+            counter +
+            '">expand</span>)<ul style="display:none;">';
+          (function () {
+            for (var sub_term in content) {
+              const sub_content = content[sub_term];
+              sub_term = parseInt(sub_term);
+              sub_term = answer.props_ref[sub_term]
+                ? answer.props_ref[sub_term]
+                : answer.props[sub_term];
+              html_arrays +=
+                '<li><a class="dynprop" data-val="' +
+                sub_term +
+                '" href="#inquiry/props=' +
+                sub_term.replace(/ /g, '+') +
+                '">' +
+                sub_term +
+                '</a><ul style="display:none;">';
+              sub_content.forEach(function (item) {
+                item = parseInt(item);
+                item = answer.props_ref[item]
+                  ? answer.props_ref[item]
+                  : answer.props[item];
+                html_arrays +=
+                  '<li><a class="dynprop" data-val="' +
+                  item +
+                  '" href="#inquiry/props=' +
+                  item.replace(/ /g, '+') +
+                  '">' +
+                  item +
+                  '</a></li>';
+              });
+              html_arrays += '</ul></li>';
+            }
+          })();
+          html_arrays += '</ul></li>';
+        }
+      })();
+      append_html($('#hy_arrays > ul'), html_arrays);
+
+      create_autocomplete({
+        selector: 'hy_suggest',
+        minChars: 1,
+        cache: 1,
+        source: function (term, fct_type, suggest) {
+          var fct_src = 'props_ref',
+            term = term.toLowerCase(),
+            suggestions = [],
+            cnt = 0,
+            checks = [],
+            i = 0,
+            len = answer[fct_type].length;
+          for (i; i < len; i++) {
+            if (answer[fct_type][i].startswith(term)) {
+              suggestions.push(answer[fct_src][i]);
+              checks.push(answer[fct_src][i]);
+              cnt++;
+              if (cnt > 18) break;
+            }
+          }
+          if (suggestions.length < 12) {
+            for (i = 0; i < len; i++) {
+              if (
+                answer[fct_type][i].indexOf(term) != -1 &&
+                checks.indexOf(answer[fct_src][i]) == -1
+              ) {
+                suggestions.push(answer[fct_src][i]);
+                cnt++;
+                if (cnt > 18) break;
+              }
+            }
+          }
+          suggest(suggestions);
+        },
+        renderItem: function (item, search) {
+          return (
+            '<div class="autocomplete-suggestion" style="' +
+            (wmgui.numerics[item] ? 'color:#c00' : '') +
+            '" data-val="' +
+            item +
+            '">' +
+            item +
+            '</div>'
+          );
+        },
+        onSelect: function (e, term, item) {
+          var numerics = wmgui.numerics[term];
+
+          if (isVisible($('#numericbox')) && numerics)
+            create_floating_slider(
+              term,
+              numerics[0],
+              numerics[1],
+              numerics[2],
+              numerics[3],
+              numerics[4],
+            );
+          else window.location.hash = wmgui.aug_search_cmd('props', term);
+
+          $('#hy_suggest').value = '';
+        },
+      });
+
+      rotate_interesting();
+      setInterval(rotate_interesting, 2000);
+
+      window.location.hash
+        ? url_redraw_react()
+        : window.location.replace('#start');
+    })
+    .catch(function (errorThrown) {
+      console.error(errorThrown);
+      throw new Error('Failed to load GUI');
+    });
+
+  // set server-side data features
+  wmgui.multiselects['main'] = create_multiselect($('#search_field'), {
+    plugins: ['remove_button', 'preserve_on_blur'],
+    valueField: 'id',
+    labelField: 'label',
+    searchField: 'label',
+    create: false,
+    highlight: false,
+    maxItems: 10,
+    closeAfterSelect: true,
+    diacritics: false,
+    options: [],
+    onInitialize: function () {
+      $('#search_field-selectized').focus();
+    },
+    onItemAdd: function () {
+      if (wmgui.selectize_emit) {
+        var check = wmgui.multiselects['main'].read();
+        select_ptable_series(check.elements);
+      }
+    },
+    onItemRemove: function () {
+      var check = wmgui.multiselects['main'].read(),
+        input = this;
+      if (!check.numeric) {
+        destroy_numericbox();
+        delete wmgui.search.numeric;
+        if (wmgui.selectize_emit) select_ptable_series(check.elements);
+      }
+      setTimeout(function () {
+        input.close();
+      }, 750);
+    },
+    load: function (query, callback) {
+      this.clearOptions();
+      if (!query.length) return callback();
+      ajax({
+        url: wmgui.auto_endpoint + '?q=' + encodeURIComponent(query),
+        type: 'GET',
+      })
+        .then(function (res) {
+          if (!res.length) {
+            return;
+          }
+          callback(res);
+        })
+        .catch(function () {
+          callback();
+        });
+    },
+    score: function () {
+      return function () {
+        return 1;
+      };
+    }, // no client scoring
+    render: {
+      option: function (item, escape) {
+        return '<div class="fct_' + item.facet + '">' + item.label + '</div>';
+      },
+      item: function (item, escape) {
+        return (
+          '<div class="fct_' +
+          item.facet +
+          '" data-facet="' +
+          item.facet +
+          '" data-term="' +
+          item.label +
+          '">' +
+          item.label +
+          '</div>'
+        );
+      },
+    },
+  });
+
+  wmgui.multiselects['main'].read = function () {
+    return wmgui._selectize_read_main();
+  };
+  wmgui.multiselects['main'].write = function (search_obj) {
+    wmgui._selectize_write(wmgui.multiselects['main'], 'main', search_obj);
+  };
+  wmgui.multiselects['main'].display = function (facet, term) {
+    wmgui._selectize_display(wmgui.multiselects['main'], facet, term);
+  };
+
+  wmgui.darkmode = new Darkmode({ saveInCookies: false });
+  document.getElementById('darkmode_trigger').innerHTML =
+    wmgui.darkmode.isActivated() ? 'enabled' : 'disabled';
+
+  //create_floating_slider('density', 42, 'Mg/m<sup>3</sup>', 10, 900, 10);
+  // EOF satisfy_requirements
+}
diff --git a/src_js/components/autocomplete.js b/src_js/components/autocomplete.js
new file mode 100644
index 0000000..61aec21
--- /dev/null
+++ b/src_js/components/autocomplete.js
@@ -0,0 +1,269 @@
+// spin-off from https://github.com/Pixabay/JavaScript-autoComplete
+// converted to an ES module
+
+
+export const create_autocomplete = (function () {
+  function autoComplete(options) {
+    if (!document.querySelector) return;
+
+    // helpers
+    function hasClass(el, className) {
+      return el.classList
+        ? el.classList.contains(className)
+        : new RegExp('\\b' + className + '\\b').test(el.className);
+    }
+
+    function addEvent(el, type, handler) {
+      el.addEventListener(type, handler);
+    }
+    function removeEvent(el, type, handler) {
+      el.removeEventListener(type, handler);
+    }
+    function live(elClass, event, cb, context) {
+      addEvent(context || document, event, function (e) {
+        var found,
+          el = e.target || e.srcElement;
+        while (el && !(found = hasClass(el, elClass))) el = el.parentElement;
+        if (found) cb.call(el, e);
+      });
+    }
+
+    var o = {
+      selector: 0,
+      source: 0,
+      minChars: 3,
+      delay: 150,
+      offsetLeft: 0,
+      offsetTop: 1,
+      cache: 1,
+      menuClass: '',
+      renderItem: function (item, search) {},
+      onSelect: function (e, term, item) {},
+      // NB app hooks are injected by the caller: components do not import app/
+      onHover: function (term, item) {},
+      arrow_pressed: false,
+      custom_type: false,
+    };
+    for (var k in options) {
+      if (options.hasOwnProperty(k)) o[k] = options[k];
+    }
+
+    // init
+    var that = document.getElementById(o.selector),
+      fct_type = that.getAttribute('rel');
+
+    // create suggestions container "sc"
+    that.sc = document.createElement('div');
+    that.sc.className = 'autocomplete-suggestions ' + o.menuClass;
+
+    that.autocompleteAttr = that.getAttribute('autocomplete');
+    that.setAttribute('autocomplete', 'off');
+    that.cache = {};
+    that.last_val = '';
+
+    that.updateSC = function (resize, next) {
+      var rect = that.getBoundingClientRect();
+      that.sc.style.left =
+        Math.round(
+          rect.left +
+            (window.pageXOffset || document.documentElement.scrollLeft) +
+            o.offsetLeft,
+        ) + 'px';
+      that.sc.style.top =
+        Math.round(
+          rect.bottom +
+            (window.pageYOffset || document.documentElement.scrollTop) +
+            o.offsetTop,
+        ) + 'px';
+      that.sc.style.width = Math.round(rect.right - rect.left) + 'px'; // outerWidth
+      if (!resize) {
+        that.sc.style.display = 'block';
+        if (!that.sc.maxHeight) {
+          that.sc.maxHeight = parseInt(
+            (window.getComputedStyle
+              ? getComputedStyle(that.sc, null)
+              : that.sc.currentStyle
+            ).maxHeight,
+          );
+        }
+        if (!that.sc.suggestionHeight)
+          that.sc.suggestionHeight = that.sc.querySelector(
+            '.autocomplete-suggestion',
+          ).offsetHeight;
+        if (that.sc.suggestionHeight)
+          if (!next) that.sc.scrollTop = 0;
+          else {
+            var scrTop = that.sc.scrollTop,
+              selTop =
+                next.getBoundingClientRect().top -
+                that.sc.getBoundingClientRect().top;
+            if (selTop + that.sc.suggestionHeight - that.sc.maxHeight > 0)
+              that.sc.scrollTop =
+                selTop + that.sc.suggestionHeight + scrTop - that.sc.maxHeight;
+            else if (selTop < 0) that.sc.scrollTop = selTop + scrTop;
+          }
+      }
+    };
+    addEvent(window, 'resize', that.updateSC);
+    document.body.appendChild(that.sc);
+
+    live(
+      'autocomplete-suggestion',
+      'mouseleave',
+      function (e) {
+        var sel = that.sc.querySelector('.autocomplete-suggestion.selected');
+        if (sel)
+          setTimeout(function () {
+            sel.className = sel.className.replace('selected', '');
+          }, 20);
+      },
+      that.sc,
+    );
+
+    live(
+      'autocomplete-suggestion',
+      'mouseover',
+      function (e) {
+        var sel = that.sc.querySelector('.autocomplete-suggestion.selected');
+        if (sel) sel.className = sel.className.replace('selected', '');
+        this.className += ' selected';
+
+        o.onHover(this.innerText, this);
+      },
+      that.sc,
+    );
+
+    live(
+      'autocomplete-suggestion',
+      'mousedown',
+      function (e) {
+        if (hasClass(this, 'autocomplete-suggestion')) {
+          // else outside click
+          var v = this.getAttribute('data-val');
+          that.value = v;
+          o.onSelect(e, v, this);
+          that.sc.style.display = 'none';
+        }
+      },
+      that.sc,
+    );
+
+    that.blurHandler = function () {
+      try {
+        var over_sb = document.querySelector('.autocomplete-suggestions:hover');
+      } catch (e) {
+        var over_sb = 0;
+      }
+      if (!over_sb) {
+        that.last_val = that.value;
+        that.sc.style.display = 'none';
+        setTimeout(function () {
+          that.sc.style.display = 'none';
+        }, 350); // hide suggestions on fast input
+      } else if (that !== document.activeElement)
+        setTimeout(function () {
+          that.focus();
+        }, 20);
+    };
+    addEvent(that, 'blur', that.blurHandler);
+
+    var suggest = function (data) {
+      o.arrow_pressed = false;
+      var val = that.value;
+      that.cache[val] = data;
+      if (data.length && val.length >= o.minChars) {
+        var s = '';
+        for (var i = 0; i < data.length; i++) s += o.renderItem(data[i], val);
+        that.sc.innerHTML = s;
+        that.updateSC(0);
+      } else that.sc.style.display = 'none';
+    };
+
+    that.keydownHandler = function (e) {
+      var key = window.event ? e.keyCode : e.which;
+      // down (40), up (38)
+      if ((key == 40 || key == 38) && that.sc.innerHTML) {
+        o.arrow_pressed = true;
+        var next,
+          sel = that.sc.querySelector('.autocomplete-suggestion.selected');
+        if (!sel) {
+          next =
+            key == 40
+              ? that.sc.querySelector('.autocomplete-suggestion')
+              : that.sc.childNodes[that.sc.childNodes.length - 1]; // first : last
+          next.className += ' selected';
+          that.value = next.getAttribute('data-val');
+        } else {
+          next = key == 40 ? sel.nextSibling : sel.previousSibling;
+          if (next) {
+            sel.className = sel.className.replace('selected', '');
+            next.className += ' selected';
+            that.value = next.getAttribute('data-val');
+          } else {
+            sel.className = sel.className.replace('selected', '');
+            that.value = that.last_val;
+            next = 0;
+          }
+        }
+        that.updateSC(0, next);
+        return false;
+      }
+      // esc
+      else if (key == 27) {
+        that.value = that.last_val;
+        that.sc.style.display = 'none';
+      }
+      // enter
+      else if (key == 13 || key == 9) {
+        var sel = that.sc.querySelector('.autocomplete-suggestion.selected');
+        if (sel && that.sc.style.display != 'none' && o.arrow_pressed) {
+          o.onSelect(e, sel.getAttribute('data-val'), sel);
+          that.sc.style.display = 'none';
+          //setTimeout(function(){ that.sc.style.display = 'none'; }, 20);
+        }
+      }
+    };
+    addEvent(that, 'keydown', that.keydownHandler);
+
+    that.keyupHandler = function (e) {
+      var key = window.event ? e.keyCode : e.which;
+      if (!key || ((key < 35 || key > 40) && key != 13 && key != 27)) {
+        var val = that.value;
+        if (val.length >= o.minChars) {
+          if (val != that.last_val) {
+            that.last_val = val;
+            clearTimeout(that.timer);
+            if (o.cache) {
+              if (val in that.cache) {
+                suggest(that.cache[val]);
+                return;
+              }
+              // no requests if previous suggestions were empty
+              for (var i = 1; i < val.length - o.minChars; i++) {
+                var part = val.slice(0, val.length - i);
+                if (part in that.cache && !that.cache[part].length) {
+                  suggest([]);
+                  return;
+                }
+              }
+            }
+            that.timer = setTimeout(function () {
+              o.source(val, fct_type, suggest);
+            }, o.delay);
+          }
+        } else {
+          that.last_val = val;
+          that.sc.style.display = 'none';
+        }
+      }
+    };
+    addEvent(that, 'keyup', that.keyupHandler);
+
+    that.focusHandler = function (e) {
+      that.last_val = '\n';
+      that.keyupHandler(e);
+    };
+    if (!o.minChars) addEvent(that, 'focus', that.focusHandler);
+  }
+  return autoComplete;
+})();
diff --git a/src_js/components/multiselect.js b/src_js/components/multiselect.js
new file mode 100644
index 0000000..d3269b9
--- /dev/null
+++ b/src_js/components/multiselect.js
@@ -0,0 +1,746 @@
+/**
+ * Ermac multiselect: a vanilla replacement for the selectize jQuery plugin.
+ *
+ * This is a port of the *vendored* selectize 0.12 subset the app uses (not
+ * of the upstream documentation), preserving the observable UX contract:
+ * the DOM structure and CSS class names (.selectize-control / .selectize-input /
+ * .selectize-dropdown, see webassets/ermac.css), the item DOM contract
+ * (data-facet / data-term), the input id convention (<id>-selectized) with
+ * the input of type="select-multiple", the hidden original <select multiple
+ * class="selectized"> mirroring the chips, option selection on MOUSEDOWN,
+ * item activation (.active) with the hidden-input mode, the caret movement
+ * and deleteSelection() of the arrows/Backspace keys, ctrl/cmd+A select all,
+ * the input auto-grow measurement, and the full state-class set of
+ * selectize's refreshClasses().
+ *
+ * NB Enter is NOT handled: the vendored selectize has its Enter handler
+ * commented out, so Enter bubbles to the #search_holder and document
+ * handlers, which run the search with the chips and the raw typed text.
+ */
+
+/* module-scoped measurement span, shared by all instances like Selectize.$testInput */
+var measure_span = null;
+
+function measure_string(str, parent_el) {
+  if (!str) return 0;
+  if (!measure_span) {
+    measure_span = document.createElement('span');
+    var style = measure_span.style;
+    style.position = 'absolute';
+    style.top = '-99999px';
+    style.left = '-99999px';
+    style.width = 'auto';
+    style.padding = '0';
+    style.whiteSpace = 'pre';
+    document.body.appendChild(measure_span);
+  }
+  measure_span.textContent = str;
+  var parent_style = window.getComputedStyle(parent_el);
+  [
+    'letterSpacing',
+    'fontSize',
+    'fontFamily',
+    'fontWeight',
+    'textTransform',
+  ].forEach(function (property) {
+    measure_span.style[property] = parent_style[property];
+  });
+  return measure_span.getBoundingClientRect().width;
+}
+
+export function create_multiselect(select_el, settings) {
+  const self = {
+    settings: settings || {},
+    options: {}, // id -> {facet, label, id}
+    items: [], // ordered option data, like selectize's items
+    caret_pos: 0,
+    opened: false,
+    has_options: false,
+    is_focused: false,
+    is_input_hidden: false,
+    active_option_id: null,
+    active_item_els: [],
+    counter: 0,
+    load_timer: null,
+    last_value: '',
+    loaded_searches: {}, // NB like the old loadedSearches: a query loads once
+  };
+
+  const render_item =
+    (settings.render && settings.render.item) ||
+    function (item) {
+      return (
+        '<div class="fct_' +
+        item.facet +
+        '" data-facet="' +
+        item.facet +
+        '" data-term="' +
+        item.label +
+        '">' +
+        item.label +
+        '</div>'
+      );
+    };
+
+  const render_option =
+    (settings.render && settings.render.option) ||
+    function (item) {
+      return '<div class="fct_' + item.facet + '">' + item.label + '</div>';
+    };
+
+  const max_items = settings.maxItems || Infinity;
+
+  // DOM structure mirroring selectize:
+
+  const control = document.createElement('div');
+  control.className =
+    'selectize-control multi plugin-remove_button plugin-preserve_on_blur';
+
+  const input_holder = document.createElement('div');
+  input_holder.className = 'selectize-input items not-full';
+  control.appendChild(input_holder);
+
+  const text_input = document.createElement('input');
+  // NB the vendored selectize input type, part of the DOM contract
+  text_input.type = 'select-multiple';
+  text_input.autocomplete = 'off';
+  text_input.id = (select_el.id ? select_el.id : '') + '-selectized';
+  input_holder.appendChild(text_input);
+
+  const dropdown = document.createElement('div');
+  dropdown.className = 'selectize-dropdown multi plugin-remove_button';
+  dropdown.style.display = 'none';
+  const dropdown_content = document.createElement('div');
+  dropdown_content.className = 'selectize-dropdown-content';
+  dropdown.appendChild(dropdown_content);
+  control.appendChild(dropdown);
+
+  // NB the original <select> becomes the hidden mirror, part of the contract
+  select_el.style.display = 'none';
+  select_el.setAttribute('multiple', 'multiple');
+  select_el.classList.add('selectized');
+  select_el.insertAdjacentElement('afterend', control);
+
+  /**
+   * State classes: the full contract of selectize refreshClasses()
+   */
+
+  function refresh_classes() {
+    const is_full = self.items.length >= max_items;
+    input_holder.classList.toggle('focus', self.is_focused);
+    input_holder.classList.toggle('full', is_full);
+    input_holder.classList.toggle('not-full', !is_full);
+    input_holder.classList.toggle(
+      'input-active',
+      self.is_focused && !self.is_input_hidden,
+    );
+    input_holder.classList.toggle('dropdown-active', self.opened);
+    input_holder.classList.toggle('has-options', self.has_options);
+    input_holder.classList.toggle('has-items', self.items.length > 0);
+  }
+
+  /**
+   * The original <select> mirrors the items, like selectize updateOriginalInput()
+   */
+
+  function update_original_input() {
+    select_el.innerHTML = '';
+    self.items.forEach(function (item) {
+      const option = document.createElement('option');
+      option.selected = true;
+      option.value = String(item.id);
+      option.textContent = item.label;
+      select_el.appendChild(option);
+    });
+  }
+
+  /**
+   * The input auto-grow: like selectize's autoGrow(), the width follows
+   * the typed text (measured), 4px for the empty input
+   */
+
+  function auto_grow() {
+    var value = text_input.value;
+    var width = measure_string(value, text_input) + 4;
+    if (width !== text_input.style.width) text_input.style.width = width + 'px';
+  }
+
+  function set_textbox_value(value) {
+    text_input.value = value;
+    auto_grow();
+  }
+
+  /**
+   * The caret: like selectize setCaret(), the input stays in place and the
+   * item elements move around it
+   */
+
+  function item_elements() {
+    return Array.prototype.slice.call(
+      input_holder.querySelectorAll('div[data-value]'),
+    );
+  }
+
+  function set_caret(index) {
+    index = Math.max(0, Math.min(self.items.length, index));
+    const elements = item_elements();
+    for (var j = 0; j < elements.length; j++) {
+      const el = elements[j];
+      input_holder.removeChild(el);
+      if (j < index) input_holder.insertBefore(el, text_input);
+      else input_holder.appendChild(el);
+    }
+    self.caret_pos = index;
+  }
+
+  /**
+   * Options dropdown management
+   */
+
+  function is_selected(id) {
+    return self.items.some(function (item) {
+      return String(item.id) === String(id);
+    });
+  }
+
+  function render_dropdown() {
+    dropdown_content.innerHTML = '';
+    // NB like refreshOptions() with hideSelected (multi mode): the options
+    // belonging to the existing items are not offered again
+    for (const id in self.options) {
+      if (is_selected(id)) continue;
+      const option_data = self.options[id];
+      const tpl = document.createElement('template');
+      tpl.innerHTML = render_option(option_data).trim();
+      const option_el = tpl.content.firstElementChild;
+      if (!option_el) continue;
+      option_el.setAttribute('data-selectable', '');
+      option_el.setAttribute('data-value', id);
+      if (self.active_option_id === id) option_el.classList.add('active');
+      dropdown_content.appendChild(option_el);
+    }
+    self.has_options = !!dropdown_content.children.length;
+  }
+
+  function position_dropdown() {
+    // NB like selectize positionDropdown(): $control is the INPUT HOLDER,
+    // and jQuery position() EXCLUDES the holder's own margins (border-box
+    // offset minus marginTop/marginLeft), while outerHeight(true) adds
+    // them back. The wrapper-relative coordinates follow.
+    const holder_rect = input_holder.getBoundingClientRect();
+    const control_rect = control.getBoundingClientRect();
+    const holder_style = getComputedStyle(input_holder);
+    const pos_top =
+      holder_rect.top -
+      control_rect.top -
+      parseFloat(getComputedStyle(control).borderTopWidth || '0') -
+      parseFloat(holder_style.marginTop || '0');
+    const pos_left =
+      holder_rect.left -
+      control_rect.left -
+      parseFloat(getComputedStyle(control).borderLeftWidth || '0') -
+      parseFloat(holder_style.marginLeft || '0');
+    const outer =
+      input_holder.offsetHeight +
+      parseFloat(holder_style.marginTop) +
+      parseFloat(holder_style.marginBottom);
+    dropdown.style.width = holder_rect.width + 'px';
+    dropdown.style.top = pos_top + outer + 'px';
+    dropdown.style.left = pos_left + 'px';
+  }
+
+  function open() {
+    if (self.opened) return;
+    if (!self.has_options) return; // NB like selectize: nothing to show
+    self.opened = true;
+    dropdown.style.display = 'block';
+    position_dropdown();
+    refresh_classes();
+  }
+
+  self.open = open;
+
+  self.close = function () {
+    if (!self.opened) return;
+    self.opened = false;
+    self.active_option_id = null;
+    dropdown.style.display = 'none';
+    refresh_classes();
+  };
+
+  function set_active_option(id) {
+    self.active_option_id = id;
+    dropdown_content
+      .querySelectorAll('[data-selectable]')
+      .forEach(function (el) {
+        el.classList.toggle('active', el.getAttribute('data-value') === id);
+      });
+  }
+
+  /**
+   * Items management
+   */
+
+  function trigger(event_name, a, b) {
+    const callback = self.settings[event_name];
+    if (typeof callback === 'function') callback.apply(self, [a, b]);
+    if (
+      event_name === 'onItemAdd' ||
+      event_name === 'onItemRemove' ||
+      event_name === 'clear'
+    ) {
+      if (typeof self.settings.onChange === 'function')
+        self.settings.onChange.call(
+          self,
+          self.items
+            .map(function (item) {
+              return item.label;
+            })
+            .join(','),
+        );
+    }
+  }
+
+  function build_item_el(option_data) {
+    const tpl = document.createElement('template');
+    tpl.innerHTML = render_item(option_data).trim();
+    const item_el = tpl.content.firstElementChild;
+    if (!item_el) return null;
+
+    // remove_button plugin behavior
+    const remove_anchor = document.createElement('a');
+    remove_anchor.href = 'javascript:void(0)';
+    remove_anchor.className = 'remove';
+    remove_anchor.tabIndex = -1;
+    remove_anchor.title = 'Remove';
+    remove_anchor.innerHTML = '&times;';
+    item_el.appendChild(remove_anchor);
+    return item_el;
+  }
+
+  self.addOption = function (data) {
+    if (Array.isArray(data)) {
+      data.forEach(function (d) {
+        self.addOption(d);
+      });
+      return;
+    }
+    self.counter += 1;
+    if (data.id === undefined) data.id = self.counter;
+    self.options[data.id] = data;
+    self.has_options = true;
+    refresh_classes();
+  };
+
+  // NB the vendored clearOptions() keeps the options belonging to the
+  // current items (only the others are deleted), which is why the input
+  // holder keeps the has-options class after a write()
+  self.clearOptions = function () {
+    for (const id in self.options) {
+      if (!is_selected(id)) delete self.options[id];
+    }
+    self.active_option_id = null;
+    self.loaded_searches = {};
+    self.has_options = !!Object.keys(self.options).length;
+    // NB like the vendored clearOptions(): the dropdown is NOT closed here,
+    // the app's load handler clears options on every keystroke while the
+    // dropdown stays open
+    refresh_classes();
+  };
+
+  self.addItem = function (id) {
+    const option_data = self.options[id];
+    if (!option_data) return;
+    if (
+      self.items.some(function (item) {
+        return String(item.id) === String(id);
+      })
+    )
+      return;
+    if (self.items.length >= max_items) return;
+
+    const item_el = build_item_el(option_data);
+    if (!item_el) return;
+
+    // NB like selectize addItem(): the item enters at the caret
+    item_el.setAttribute('data-value', String(id));
+    input_holder.insertBefore(item_el, text_input);
+    self.items.splice(self.caret_pos, 0, option_data);
+    self.caret_pos += 1;
+
+    refresh_classes();
+    update_original_input();
+
+    if (self.settings.closeAfterSelect !== false) self.close();
+    set_textbox_value('');
+    set_active_option(null);
+
+    trigger('onItemAdd', id, item_el);
+  };
+
+  function remove_item_el(item_el) {
+    if (item_el && item_el.parentNode === input_holder)
+      input_holder.removeChild(item_el);
+  }
+
+  self.removeItem = function (id, item_el) {
+    const index = self.items.findIndex(function (item) {
+      return String(item.id) === String(id);
+    });
+    if (index === -1) return;
+    if (!item_el)
+      item_el = input_holder.querySelector('[data-value="' + id + '"]');
+    remove_item_el(item_el);
+    const active_index = self.active_item_els.indexOf(item_el);
+    if (active_index !== -1) self.active_item_els.splice(active_index, 1);
+    self.items.splice(index, 1);
+    if (index < self.caret_pos)
+      self.caret_pos = Math.max(0, self.caret_pos - 1);
+    refresh_classes();
+    update_original_input();
+    trigger('onItemRemove', id, item_el);
+  };
+
+  self.clear = function () {
+    const previous = self.items;
+    self.items = [];
+    self.caret_pos = 0;
+    self.active_item_els = [];
+    input_holder.querySelectorAll('div[data-value]').forEach(remove_item_el);
+    refresh_classes();
+    update_original_input();
+    if (previous.length) trigger('clear');
+  };
+
+  /**
+   * Item activation: the plain-click part of selectize setActiveItem():
+   * the clicked item is marked .active and the text input is hidden
+   */
+
+  function show_input() {
+    text_input.style.opacity = '1';
+    text_input.style.position = 'relative';
+    text_input.style.left = '0';
+    self.is_input_hidden = false;
+    refresh_classes();
+  }
+
+  function hide_input() {
+    set_textbox_value('');
+    text_input.style.opacity = '0';
+    text_input.style.position = 'absolute';
+    text_input.style.left = '-10000px';
+    self.is_input_hidden = true;
+    refresh_classes();
+  }
+
+  function set_active_item(item_el) {
+    if (!item_el) {
+      self.active_item_els.forEach(function (el) {
+        el.classList.remove('active');
+      });
+      self.active_item_els = [];
+      if (self.is_focused) show_input();
+      return;
+    }
+    self.active_item_els.forEach(function (el) {
+      el.classList.remove('active');
+    });
+    self.active_item_els = [item_el];
+    item_el.classList.add('active');
+    hide_input(); // NB like selectize: no text editing with a selected item
+    if (!self.is_focused) text_input.focus();
+  }
+
+  // NB like selectize selectAll(), bound to ctrl/cmd+A
+  function select_all() {
+    self.active_item_els = item_elements();
+    self.active_item_els.forEach(function (el) {
+      el.classList.add('active');
+    });
+    if (self.active_item_els.length) {
+      hide_input();
+      self.close();
+    }
+    text_input.focus();
+  }
+
+  /**
+   * deleteSelection: a faithful port of the vendored function
+   */
+
+  function delete_selection(event) {
+    if (self.active_item_els.length) {
+      self.active_item_els.slice().forEach(function (el) {
+        self.removeItem(el.getAttribute('data-value'), el);
+      });
+      set_active_item(null);
+      if (event) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      return;
+    }
+    // NB direction -1 is Backspace: remove the item before the caret,
+    // when the cursor is at the very start of the empty input
+    const selection_start = text_input.selectionStart;
+    if (self.items.length && !text_input.value && selection_start === 0) {
+      const doomed = self.items[self.caret_pos - 1];
+      if (doomed) {
+        const item_el = item_elements()[self.caret_pos - 1];
+        self.removeItem(doomed.id, item_el);
+        if (event) event.preventDefault();
+      }
+    }
+  }
+
+  /**
+   * onOptionSelect: NB selectize binds MOUSEDOWN (not click), and prevents
+   * the default so the text input keeps its focus
+   */
+
+  function on_option_select(option_el) {
+    if (!option_el) return;
+    self.addItem(option_el.getAttribute('data-value'));
+  }
+
+  /**
+   * Event wiring
+   */
+
+  control.addEventListener('mousedown', function (event) {
+    // NB the vendored selectize onMouseDown: when focused, prevent the
+    // default everywhere except on the input itself (text selection!)
+    const target_is_input = event.target === text_input;
+    if (self.is_focused) {
+      if (!target_is_input) {
+        set_active_item(null);
+        event.preventDefault();
+        event.stopPropagation();
+      }
+    } else {
+      event.preventDefault();
+      event.stopPropagation();
+      window.setTimeout(function () {
+        text_input.focus();
+      }, 0);
+    }
+  });
+
+  control.addEventListener('click', function (event) {
+    // NB remove_button anchor click: remove the item
+    const remove_button = event.target.closest('a.remove');
+    if (remove_button) {
+      event.preventDefault();
+      event.stopPropagation();
+      const item_el = remove_button.parentNode;
+      const data_term = item_el.getAttribute('data-term');
+      const found = self.items.find(function (item) {
+        return item.label === data_term;
+      });
+      if (found) self.removeItem(found.id, item_el);
+      text_input.focus();
+      return;
+    }
+
+    // NB selectize onClick: focus back (and reopen the dropdown) after a
+    // closeAfterSelect, or give the control focus from an outside click
+    if (!self.is_focused || !self.opened) {
+      event.preventDefault();
+      text_input.focus();
+    }
+  });
+
+  dropdown_content.addEventListener('mouseover', function (event) {
+    const option_el = event.target.closest('[data-selectable]');
+    if (option_el) set_active_option(option_el.getAttribute('data-value'));
+  });
+
+  dropdown_content.addEventListener('mousedown', function (event) {
+    const option_el = event.target.closest('[data-selectable]');
+    if (!option_el || !dropdown_content.contains(option_el)) return;
+    event.preventDefault();
+    event.stopPropagation();
+    on_option_select(option_el);
+  });
+
+  input_holder.addEventListener('mousedown', function (event) {
+    // NB item mousedown (like watchChildEvent($control, 'mousedown', '*:not(input)')):
+    // the clicked item becomes active; not on the remove anchor
+    if (event.target === text_input) return;
+    if (event.target.closest('a.remove')) return;
+    const item_el = event.target.closest('div[data-value]');
+    if (item_el && input_holder.contains(item_el)) {
+      event.preventDefault();
+      event.stopPropagation();
+      set_active_item(item_el);
+    }
+  });
+
+  function load_suggestions(query) {
+    clearTimeout(self.load_timer);
+    if (typeof self.settings.load !== 'function') return;
+    // NB like the old debounced onSearchChange + loadedSearches:
+    // a query value loads at most once, and a later call cancels the
+    // pending debounce (e.g. the Enter keyup with the cleared value)
+    if (self.loaded_searches.hasOwnProperty(query)) return;
+    self.loaded_searches[query] = true;
+    self.load_timer = setTimeout(function () {
+      self.settings.load.call(self, query, function (suggestions) {
+        if (!suggestions || !suggestions.length) {
+          // NB like the old load() with no results: nothing rendered,
+          // nothing opened
+          return;
+        }
+        self.addOption(suggestions);
+        render_dropdown();
+        // NB like refreshOptions: highlight the first option, unless the
+        // prior one survived; the dropdown only opens when the input is
+        // still focused (the old triggerDropdown: isFocused && !isInputHidden)
+        if (
+          self.active_option_id === null ||
+          !self.options[self.active_option_id]
+        )
+          set_active_option(
+            dropdown_content
+              .querySelector('[data-selectable]')
+              .getAttribute('data-value'),
+          );
+        if (self.is_focused && !self.is_input_hidden) open();
+        refresh_classes();
+      });
+    }, 300); // mimicking selectize default loadThrottle
+  }
+
+  text_input.addEventListener('input', function () {
+    auto_grow();
+  });
+
+  document.addEventListener('mousedown', function (event) {
+    // NB like the old $document.on('mousedown') handler: blur on click
+    // outside the control (except the dropdown itself)
+    if (!self.is_focused) return;
+    if (
+      event.target === dropdown ||
+      event.target.parentNode === dropdown
+    )
+      return;
+    if (!control.contains(event.target)) text_input.blur();
+  });
+
+  window.addEventListener('scroll', function () {
+    if (self.opened) position_dropdown();
+  });
+
+  text_input.addEventListener('keydown', function (event) {
+    const is_mac = /Mac/.test(navigator.userAgent);
+
+    if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+      const selectable = dropdown_content.querySelectorAll('[data-selectable]');
+      const active_el = dropdown_content.querySelector(
+        '[data-selectable].active',
+      );
+      if (!selectable.length) return;
+      event.preventDefault();
+      if (!self.opened) {
+        open();
+        if (self.active_option_id === null)
+          set_active_option(selectable[0].getAttribute('data-value'));
+        return;
+      }
+      let next;
+      if (!active_el) {
+        next =
+          event.key === 'ArrowDown'
+            ? selectable[0]
+            : selectable[selectable.length - 1];
+      } else {
+        next =
+          event.key === 'ArrowDown'
+            ? active_el.nextElementSibling
+            : active_el.previousElementSibling;
+      }
+      if (next) set_active_option(next.getAttribute('data-value'));
+      return;
+    }
+
+    if (event.key === 'ArrowLeft' || event.key === 'ArrowRight') {
+      // NB like advanceSelection(): the caret moves among the items when
+      // the input is empty and the cursor is at its edge
+      if (self.is_focused && !self.is_input_hidden && !text_input.value) {
+        const direction = event.key === 'ArrowLeft' ? -1 : 1;
+        const at_edge =
+          direction < 0
+            ? text_input.selectionStart === 0
+            : text_input.selectionStart === 0; // empty input: both edges are 0
+        if (at_edge) set_caret(self.caret_pos + direction);
+      }
+      return;
+    }
+
+    if (event.key === 'Escape') {
+      if (self.opened) event.stopPropagation();
+      self.close();
+      return;
+    }
+
+    if (event.key === 'Backspace' || event.key === 'Delete') {
+      delete_selection(event);
+      return;
+    }
+
+    if (
+      (is_mac ? event.metaKey : event.ctrlKey) &&
+      (event.key === 'a' || event.key === 'A')
+    ) {
+      select_all();
+      return;
+    }
+
+    // NB Enter is NOT consumed (see the header comment): it bubbles to
+    // the #search_holder and document handlers, which run the search
+
+    // NB like the vendored onKeyDown tail: with a hidden input or a full
+    // box, plain typing is prevented
+    if (
+      (self.items.length >= max_items || self.is_input_hidden) &&
+      !event.ctrlKey
+    ) {
+      event.preventDefault();
+    }
+  });
+
+  text_input.addEventListener('keyup', function () {
+    auto_grow();
+    const value = text_input.value;
+    if (self.last_value !== value) {
+      self.last_value = value;
+      load_suggestions(value);
+    }
+  });
+
+  text_input.addEventListener('focus', function () {
+    self.is_focused = true;
+    refresh_classes();
+    if (self.has_options) open(); // NB like selectize onFocus
+  });
+
+  text_input.addEventListener('blur', function () {
+    self.is_focused = false;
+    // NB preserve_on_blur plugin behavior: keep the typed text
+    self.close();
+    refresh_classes();
+  });
+
+  // the "rest input" is read by the app via the id convention
+  self.input_el = text_input;
+
+  set_textbox_value(''); // sets the initial 4px width, like selectize's autoGrow()
+  show_input(); // NB the initial opacity/position/left inline styles, as in selectize
+  refresh_classes();
+  update_original_input();
+  if (typeof self.settings.onInitialize === 'function')
+    self.settings.onInitialize();
+
+  return self;
+}
diff --git a/src_js/components/sliders.js b/src_js/components/sliders.js
new file mode 100644
index 0000000..b4d5412
--- /dev/null
+++ b/src_js/components/sliders.js
@@ -0,0 +1,170 @@
+/**
+ * Ermac numeric range sliders, based on the vendored vanilla noUiSlider.
+ */
+
+/* global noUiSlider, wNumb */
+
+import wmgui from '../core/settings.js';
+import { $, $$, show, hide, isVisible } from '../core/dom.js';
+import { param } from '../core/ajax.js';
+
+export function create_floating_slider(
+  prop_name,
+  prop_id,
+  units,
+  p_min,
+  p_max,
+  p_step,
+  p_start,
+  p_end,
+) {
+  // FIXME compatibilize with *wmgui.numerics*
+
+  if (document.getElementById('slider_' + prop_id)) {
+    console.log('Attempted to create an existing slider id' + prop_id);
+    return;
+  }
+
+  var html = '<li>';
+  html += '<div class="slider_title">';
+  html +=
+    (wmgui.numerics[prop_name][5] || prop_name) +
+    (units ? ',&nbsp;<em>' + units + '</em>' : '');
+  html += '</div>';
+  html += '<div class="cross slider_close"></div>';
+  html += '<div class="slider">'; // #numericbox > ul > li > div.slider
+  html +=
+    '<img src="' +
+    wmgui.pdist_endpoint +
+    '?pdist=' +
+    encodeURIComponent(prop_name);
+  html +=
+    '&q=' +
+    encodeURIComponent(JSON.stringify(wmgui.search)) +
+    '" width="530" height="25" />';
+  html +=
+    '<div id="slider_' +
+    prop_id +
+    '" class="slider_numerics" rel="' +
+    prop_name +
+    '"></div></div>';
+  html += '</li>';
+
+  show($('#numericbox'));
+  $('#numericbox > ul').insertAdjacentHTML('afterbegin', html);
+
+  var decimals = p_step
+    ? Math.abs(Math.log10(p_step))
+    : Math.max(p_min.count_decimals(), p_max.count_decimals());
+  //console.log('decimals = ', decimals);
+
+  noUiSlider.create(document.getElementById('slider_' + prop_id), {
+    start: [p_start || p_min, p_end || p_max],
+    step: p_step || (p_max - p_min) / 250,
+    tooltips: [wNumb({ decimals: decimals }), wNumb({ decimals: decimals })],
+    connect: true,
+    behaviour: 'drag',
+    range: { min: p_min, max: p_max },
+    format: {
+      to: function (value) {
+        return value;
+      },
+      from: function (value) {
+        return Number(value);
+      },
+    },
+  });
+  // NB noUiSlider 14 handles are focusable and keyboard-operable (arrows),
+  // but unnamed; version 14 has no handleAttributes option
+  document
+    .querySelectorAll('#slider_' + prop_id + ' .noUi-handle')
+    .forEach(function (handle, index) {
+      handle.setAttribute('aria-label', prop_name + (index ? ', upper bound' : ', lower bound'));
+    });
+}
+
+export function destroy_numericbox() {
+  const numericbox = $('#numericbox');
+  if (isVisible(numericbox)) {
+    $$('#numericbox > ul > li').forEach(function (li) {
+      const slider = li.querySelector('div.slider_numerics');
+      if (slider && slider.noUiSlider) slider.noUiSlider.destroy();
+      li.remove();
+    });
+    hide(numericbox);
+  }
+}
+
+export function get_sliders_ranges(url_num_obj, num_database) {
+  // given by:
+  // (1.) wmutils.guess, or
+  // (2.) from re-inventing serialization for numeric nested arrays, or
+  // (3.) by the user
+  var props = {},
+    output = [];
+
+  for (var i = 0; i < url_num_obj.length; i++) {
+    if (url_num_obj[i][1] !== '>' && url_num_obj[i][1] !== '<') continue;
+
+    var prop = url_num_obj[i][1] == '>' ? 'start' : 'end';
+
+    if (!props[url_num_obj[i][0]]) props[url_num_obj[i][0]] = {};
+
+    props[url_num_obj[i][0]][prop] = parseFloat(url_num_obj[i][2]); // TODO? consequent series like > 100, > 200, etc.
+  }
+  //console.log(props);
+  for (var key in props) {
+    if (!num_database[key]) {
+      console.log('Unsupported key: ' + key);
+      continue;
+    }
+
+    if (!props[key]['start'])
+      props[key]['start'] = num_database[key][2]; // min
+    else if (!props[key]['end']) props[key]['end'] = num_database[key][3]; // max
+
+    if (props[key]['end'] < props[key]['start'])
+      throw new Error('The end of range is lower than the start of range!');
+    output.push([
+      key,
+      num_database[key][0],
+      num_database[key][1],
+      num_database[key][2],
+      num_database[key][3],
+      num_database[key][4],
+      props[key]['start'],
+      props[key]['end'],
+    ]);
+  }
+  output.sort(function (a, b) {
+    return a[1] > b[1] ? 1 : -1; // prop_id
+  });
+  return output;
+}
+
+export function serialize_numeric(prop, sign, value) {
+  // re-inventing serialization for numeric nested arrays
+  return prop + ',' + sign + ',' + value + ';';
+}
+
+/**
+ * #inquiry hash serialization: param(), except that a numeric search kept as
+ * the nested [prop, sign, value] arrays (as given by wmutils.guess() or kept
+ * in wmgui.search) is written in the router's own "prop,sign,value;..." form,
+ * like the sliders path does via serialize_numeric().
+ * NB intentional fix: the old GUI passed the arrays to $.param() as is, which
+ * produced numeric[0][]=... keys the router cannot read ("Unrecognized
+ * input"; parity scenario search_numeric_text, approved via xfail).
+ */
+export function inquiry_param(query) {
+  if (!query || !Array.isArray(query.numeric)) return param(query);
+  var copy = {};
+  for (var key in query) copy[key] = query[key]; // NB keeps the key order
+  copy.numeric = query.numeric
+    .map(function (item) {
+      return serialize_numeric.apply(this, item); // unpack
+    })
+    .join('');
+  if (copy.numeric.slice(-1) == ';') copy.numeric = copy.numeric.slice(0, -1);
+  return param(copy);
+}
diff --git a/src_js/components/tablesort.js b/src_js/components/tablesort.js
new file mode 100644
index 0000000..0a4748f
--- /dev/null
+++ b/src_js/components/tablesort.js
@@ -0,0 +1,231 @@
+/**
+ * Ermac table sorter: a vanilla replacement for the jquery.tablesorter plugin.
+ *
+ * This is a port of the *vendored* tablesorter 2.0 subset the app uses (not
+ * of the upstream documentation), preserving the observable contract:
+ * the CSS class names (th.header, headerSortUp, headerSortDown, see
+ * webassets/ermac.css), the custom chemical/doi parsers added in the
+ * vendored file, the locale-aware text comparison (sortLocaleCompare),
+ * and the mousedown text-selection cancellation (cancelSelection).
+ *
+ * The data table body and the header cells live in two separate tables
+ * (the old tablesorter 'selectorHeaders' / 'selectorHeaderParent' use case).
+ * Ctrl-click appends a column to the current multi-sort.
+ */
+
+/*
+ * The parsers of the vendored tablesorter, formats verbatim:
+ *
+ *   text     trim(s.toLocaleLowerCase())                 type text
+ *   chemical trim(s.replace('[', '').replace('(', ''))   type text
+ *   digit    parseFloat(s) || 0                         type numeric
+ *   doi      parseInt(s.replace('[', '').replace(']', '')) || 0  type numeric
+ */
+
+var PARSERS = {
+  text: {
+    type: 'text',
+    format: function (s) {
+      return s.trim().toLocaleLowerCase();
+    },
+  },
+  chemical: {
+    type: 'text',
+    format: function (s) {
+      return s.trim().replace('[', '').replace('(', '');
+    },
+  },
+  digit: {
+    type: 'numeric',
+    format: function (s) {
+      var value = parseFloat(s);
+      return isNaN(value) ? 0 : value;
+    },
+  },
+  doi: {
+    type: 'numeric',
+    format: function (s) {
+      var value = parseInt(s.replace('[', '').replace(']', ''));
+      return isNaN(value) ? 0 : value;
+    },
+  },
+};
+
+function cell_text(row, col) {
+  const cell = row.cells[col];
+  return cell ? cell.textContent.trim() : '';
+}
+
+export function make_sortable(data_table, options) {
+  options = options || {};
+  const header_cells = document.querySelectorAll(options.selectorHeaders);
+  const headers_conf = options.headers || {};
+  const tbody = data_table.tBodies[0];
+
+  let sortlist = []; // [{col, dir}] where dir 0 = asc, 1 = desc
+  var counts = {}; // per-column click counter, like the old this.count
+  var parsers = null; // NB detected once like the old buildParserCache()
+  // NB the old comparator ends with the orgOrderCol tie-break: equal values
+  // fall back to the position in the cache built at init/update time, NOT
+  // to the browser sort stability
+  var original_index = new WeakMap();
+
+  function parser_for(index) {
+    const conf = headers_conf[index];
+    if (conf !== undefined && conf.sorter === false) return false;
+    const name = conf && conf.sorter !== undefined ? conf.sorter : undefined;
+    if (name !== undefined && PARSERS[name]) return PARSERS[name];
+    // NB like the old detectParserForColumn: auto-detect digits, else text
+    for (var row_index = 0; row_index < tbody.rows.length; row_index++) {
+      const value = cell_text(tbody.rows[row_index], index);
+      if (value !== '') {
+        return /^[-+]?\d*$/.test(value.replace(/[,.']/g, ''))
+          ? PARSERS.digit
+          : PARSERS.text;
+      }
+    }
+    return PARSERS.text;
+  }
+
+  function detect_parsers() {
+    parsers = [];
+    const first_row = tbody.rows[0];
+    for (var col = 0; col < (first_row ? first_row.cells.length : 0); col++)
+      parsers.push(parser_for(col));
+    for (var i = 0; i < tbody.rows.length; i++)
+      original_index.set(tbody.rows[i], i);
+  }
+
+  // NB like the old buildCache(): every cell formatted once per sort
+  function apply() {
+    if (!sortlist.length || !tbody) return;
+    const rows = Array.prototype.slice.call(tbody.rows);
+
+    const keyed = rows.map(function (row) {
+      const values = [];
+      for (var col = 0; col < row.cells.length; col++) {
+        values.push(
+          parsers[col] ? parsers[col].format(cell_text(row, col)) : '',
+        );
+      }
+      return { row: row, values: values };
+    });
+
+    // NB the vendored makeSortFunction() builds RAW codepoint comparisons,
+    // the localeCompare branch is dead code in that version
+    const comparators = [];
+    sortlist.forEach(function (entry) {
+      const col = entry.col;
+      const parser = parsers[col];
+      const a = function (x) { return x.values[col]; };
+      if (parser && parser.type === 'text') {
+        comparators.push(
+          entry.dir === 0
+            ? function (x, y) {
+                const va = a(x), vb = a(y);
+                return va === vb
+                  ? 0
+                  : va === null
+                    ? Number.POSITIVE_INFINITY
+                    : vb === null
+                      ? Number.NEGATIVE_INFINITY
+                      : va < vb
+                        ? -1
+                        : 1;
+              }
+            : function (x, y) {
+                const va = a(x), vb = a(y);
+                return va === vb
+                  ? 0
+                  : va === null
+                    ? Number.POSITIVE_INFINITY
+                    : vb === null
+                      ? Number.NEGATIVE_INFINITY
+                      : vb < va
+                        ? -1
+                        : 1;
+              },
+        );
+      } else {
+        comparators.push(
+          entry.dir === 0
+            ? function (x, y) { return a(x) - a(y); }
+            : function (x, y) { return a(y) - a(x); },
+        );
+      }
+    });
+
+    keyed.sort(function (a, b) {
+      for (var i = 0; i < comparators.length; i++) {
+        const result = comparators[i](a, b);
+        if (result !== 0) return result;
+      }
+      // NB the orgOrderCol tie-break of the old comparator
+      const oa = original_index.get(a.row), ob = original_index.get(b.row);
+      return oa === undefined || ob === undefined ? 0 : oa - ob;
+    });
+    keyed.forEach(function (entry) {
+      tbody.appendChild(entry.row);
+    });
+  }
+
+  function refresh_header_classes() {
+    header_cells.forEach(function (th, index) {
+      th.classList.remove('headerSortUp', 'headerSortDown');
+      const found = sortlist.find(function (entry) {
+        return entry.col === index;
+      });
+      // NB parity with the old vendored plugin: it applied
+      // sortCSS = [cssDesc, cssAsc], i.e. ascending order was marked
+      // with the headerSortDown class, and vice versa
+      if (found)
+        th.classList.add(found.dir === 1 ? 'headerSortUp' : 'headerSortDown');
+    });
+  }
+
+  header_cells.forEach(function (th, index) {
+    // NB cancelSelection is bound to ALL header cells in the old plugin,
+    // the unsortable ones too: a click on them must not move the focus
+    th.addEventListener('mousedown', function (event) {
+      event.preventDefault();
+      event.stopPropagation();
+    });
+    if (parser_for(index) === false) return; // unsortable column
+    th.classList.add('header');
+    th.style.cursor = 'pointer';
+    th.addEventListener('click', function (event) {
+      const existing = sortlist.find(function (entry) {
+        return entry.col === index;
+      });
+
+      if (event.ctrlKey && options.sortMultiSortKey === 'ctrlKey') {
+        if (existing) existing.dir = existing.dir === 0 ? 1 : 0;
+        else sortlist.push({ col: index, dir: 0 });
+      } else {
+        if (existing && sortlist.length === 1)
+          existing.dir = existing.dir === 0 ? 1 : 0;
+        else sortlist = [{ col: index, dir: 0 }];
+      }
+      counts[index] = (counts[index] || 0) + 1;
+      refresh_header_classes();
+      apply();
+    });
+  });
+
+  detect_parsers();
+
+  return {
+    // NB like the old 'update' event: the parsers are re-detected,
+    // the current sort is re-applied to the appended rows
+    update: function () {
+      detect_parsers();
+      apply();
+    },
+    destroy: function () {
+      sortlist = [];
+      header_cells.forEach(function (th) {
+        th.classList.remove('header', 'headerSortUp', 'headerSortDown');
+      });
+    },
+  };
+}
diff --git a/src_js/core/a11y.js b/src_js/core/a11y.js
new file mode 100644
index 0000000..840bba3
--- /dev/null
+++ b/src_js/core/a11y.js
@@ -0,0 +1,356 @@
+/**
+ * Ermac keyboard and assistive-technology support (VPAT / WCAG 2.1.1
+ * Keyboard), see the accessibility plan. Everything here is declarative:
+ *
+ *  - A11Y_CONTROLS: which existing elements are controls (role, name, state
+ *    derived from the classes the app already toggles). A MutationObserver
+ *    applies them to static and dynamically rendered markup alike, so the
+ *    app code that renders rows, chips, crosses etc. stays unchanged.
+ *  - Enter / Space activate a non-native control by clicking it, so the
+ *    existing click handlers do the work.
+ *  - A11Y_ROVING: composite widgets (periodic table, results, thumbnails,
+ *    tabs, VIEW switches) are one Tab stop each, arrow keys move inside.
+ *  - Dialogs (div.modal.user_dialogue): when one becomes visible, focus moves
+ *    into it and the rest of the page is made inert; when none is visible,
+ *    focus returns to the control that was focused before.
+ *
+ * NB the bundle is one shared scope: every top-level name is a11y_-prefixed.
+ */
+
+import { $, $$, isVisible } from './dom.js';
+
+const A11Y_NATIVE = 'a[href], button, input, select, textarea, label';
+const A11Y_ACTIVATABLE = '[role=button], [role=tab], [role=radio], [role=link], [data-a11y-activate]';
+
+function a11y_text(el) {
+  return (el.textContent || '').replace(/\s+/g, ' ').trim();
+}
+
+// selector -> {role, label (string or function), state (function -> {attr: value})}
+const A11Y_CONTROLS = [
+  { selector: 'div.cross', role: 'button', label: 'Close' },
+  { selector: 'div.slider_close', role: 'button', label: 'Remove this range' },
+  { selector: 'div.wmbutton', role: 'button', label: function (el) { return el.getAttribute('title') || a11y_text(el); } },
+  {
+    selector: '#userbox',
+    role: 'button',
+    label: function () {
+      const inside = $('#userbox div.logged_in');
+      return inside && isVisible(inside) ? 'Account menu' : 'Log in';
+    },
+    attrs: { 'aria-haspopup': 'dialog' },
+  },
+  { selector: '#darkmode_trigger', role: 'button', label: function (el) { return 'Dark mode: ' + a11y_text(el); } },
+  { selector: 'span.href[rel]', role: 'link' },
+  { selector: '#notifybox span.relogin', role: 'button' },
+  { selector: 'strong.numeric', role: 'button', label: function (el) { return 'Numeric search: ' + (el.parentNode ? a11y_text(el.parentNode) : a11y_text(el)); } },
+  { selector: '#hy_box span[class^="hy"]', role: 'button', state: function (el) { return { 'aria-expanded': String(a11y_text(el) === 'collapse') }; } },
+  { selector: '#hy_box a.dynprop', role: 'button' },
+  {
+    selector: '#ptable_area > ul > li[data-pos]',
+    role: 'button',
+    label: function (el) {
+      const name = el.querySelector('span');
+      const symbol = el.firstChild && el.firstChild.nodeType === 3 ? el.firstChild.nodeValue.trim() : '';
+      return (name ? a11y_text(name) : '') + (symbol ? ' (' + symbol + ')' : '');
+    },
+    state: function (el) { return { 'aria-pressed': String(/\bselected_[abc]\b/.test(el.className)) }; },
+    roving: true,
+  },
+  { selector: '#ptable_area > ul', role: 'group', label: 'Periodic table', tabindex: null },
+  { selector: '#dtypes > ul > li, #dtypes_phid > ul > li', role: 'button', state: function (el) { return { 'aria-pressed': String(el.classList.contains('active')) }; } },
+  { selector: '#interpret > li', role: 'button' },
+  // NB the chips keep the multiselect's own keyboard model (Backspace in the
+  // empty search field removes the last one, the arrows move between them)
+  { selector: '#search_holder div.selectize-input > div[data-term]', role: null, tabindex: null,
+    label: function (el) { return a11y_text(el).replace(/×$/, '') + ', press Backspace in the search field to remove'; },
+    attrs: { 'data-a11y-keyboard': 'Backspace in the search field' } },
+  { selector: 'div.controlswitch', role: 'radiogroup', tabindex: null, label: function (el) { return el.querySelector('#control_a') ? 'Results' : 'Display'; } },
+  { selector: 'div.controlswitch > div', role: 'radio', state: function (el) { return { 'aria-checked': String(el.classList.contains('active')) }; }, roving: true },
+  { selector: '#advstab_options, #hy_options, #tab_links', role: 'tablist', tabindex: null },
+  {
+    selector: '#advstab_options > li, #hy_options > li, #tab_links > li',
+    role: 'tab',
+    state: function (el) {
+      const state = { 'aria-selected': String(el.classList.contains('working')) };
+      if (el.getAttribute('rev')) state['aria-controls'] = el.getAttribute('rev');
+      return state;
+    },
+    roving: true,
+  },
+  { selector: 'div.advstab, #hy_box div.hy_tabs, div.menu_tabs', role: 'tabpanel', tabindex: null },
+  { selector: 'th.header', role: null, state: function (el) {
+      const sort = el.classList.contains('headerSortDown') ? 'ascending' : el.classList.contains('headerSortUp') ? 'descending' : 'none';
+      return { 'aria-sort': sort };
+    }, activate: true },
+  { selector: '#databrowser span.launch_v', role: 'button', label: 'Preview' },
+  { selector: '#visualize, #xrpdize', role: 'button' },
+  { selector: '#ctxpanel_matrix > ul > li, #ctxpanel_cube > ul > li, #ctxpanel_graph > ul > li, li.discovery_custom', role: 'button' },
+  { selector: '#ss_gear_matrix, #ss_gear_cube', role: 'button', label: 'Settings' },
+  { selector: '#discovery_custom_box div.rearrange', role: 'button' },
+  { selector: '#tooltip span', role: 'button' },
+  { selector: '#ctx_col span.extd', role: 'button' },
+  // composite widgets: the items get data-a11y-activate (Enter / Space click them)
+  { selector: '#databrowser tr.tcell, #databrowser div.gallery_item', role: null, roving: true, activate: true },
+  { selector: '#all_polyhedra_content div.gallery_item', role: 'button', roving: true, label: function (el) { return a11y_text(el); } },
+];
+
+// container -> item selector; columns: a number, 'auto' (items per visual row) or 'grid'
+const A11Y_ROVING = [
+  { container: '#ptable_area > ul', items: 'li[data-pos]', columns: 'grid', grid_cells: 'li', grid_width: 18 },
+  { container: '#databrowser', items: 'tr.tcell, div.gallery_item', columns: 'auto' },
+  { container: '#all_polyhedra_content', items: 'div.gallery_item', columns: 'auto' },
+  { container: '#advstab_options', items: 'li', columns: 0 },
+  { container: '#hy_options', items: 'li', columns: 0 },
+  { container: '#tab_links', items: 'li', columns: 0 },
+  { container: 'div.controlswitch', items: 'div', columns: 0 },
+];
+
+function a11y_set(el, name, value) {
+  if (value === null || value === undefined) return;
+  if (el.getAttribute(name) !== value) el.setAttribute(name, value);
+}
+
+function a11y_apply(spec, el) {
+  if (spec.role && !el.hasAttribute('role')) el.setAttribute('role', spec.role);
+  // NB roving items get their tabindex from a11y_roving_sync()
+  if (spec.tabindex !== null && !spec.roving && !el.matches(A11Y_NATIVE) && !el.hasAttribute('tabindex'))
+    el.setAttribute('tabindex', '0');
+  if (spec.activate) a11y_set(el, 'data-a11y-activate', '');
+  if (spec.label) a11y_set(el, 'aria-label', typeof spec.label === 'function' ? spec.label(el) : spec.label);
+  for (const name in spec.attrs || {}) a11y_set(el, name, spec.attrs[name]);
+  if (spec.state) {
+    const state = spec.state(el);
+    for (const name in state) a11y_set(el, name, state[name]);
+  }
+}
+
+function a11y_columns(spec, items) {
+  if (typeof spec.columns === 'number') return spec.columns;
+  // 'auto': the number of items on the first visual row
+  const top = items.length ? items[0].offsetTop : 0;
+  let n = 0;
+  while (n < items.length && items[n].offsetTop === top) n++;
+  return Math.max(n, 1);
+}
+
+function a11y_roving_items(spec, container) {
+  return Array.prototype.filter.call(container.querySelectorAll(spec.items), function (el) {
+    return el.parentNode === container || container.contains(el);
+  }).filter(isVisible);
+}
+
+function a11y_roving_sync(spec, container) {
+  const items = a11y_roving_items(spec, container);
+  if (!items.length) return;
+  // the focused item, else the selected tab / checked radio, else the previous stop, else the first
+  const chosen = function (el) {
+    return el.getAttribute('aria-selected') === 'true' || el.getAttribute('aria-checked') === 'true';
+  };
+  const current = items.indexOf(document.activeElement) !== -1 ? document.activeElement :
+    items.filter(chosen)[0] ||
+    items.filter(function (el) { return el.getAttribute('tabindex') === '0'; })[0] ||
+    items[0];
+  items.forEach(function (el) {
+    a11y_set(el, 'tabindex', el === current ? '0' : '-1');
+  });
+}
+
+function a11y_roving_key(spec, container, event) {
+  const keys = ['ArrowRight', 'ArrowLeft', 'ArrowDown', 'ArrowUp', 'Home', 'End'];
+  if (keys.indexOf(event.key) === -1) return;
+  const items = a11y_roving_items(spec, container);
+  const index = items.indexOf(event.target);
+  if (index === -1) return;
+  let target = null;
+  if (event.key === 'Home') target = items[0];
+  else if (event.key === 'End') target = items[items.length - 1];
+  else if (spec.columns === 'grid') {
+    // NB the periodic table: a fixed grid that includes empty spacer cells
+    const cells = Array.prototype.slice.call(container.querySelectorAll(':scope > ' + spec.grid_cells));
+    const step = { ArrowRight: 1, ArrowLeft: -1, ArrowDown: spec.grid_width, ArrowUp: -spec.grid_width }[event.key];
+    let at = cells.indexOf(event.target) + step;
+    while (at >= 0 && at < cells.length && items.indexOf(cells[at]) === -1) at += step;
+    target = cells[at] || null;
+  } else {
+    const columns = a11y_columns(spec, items);
+    const step = columns === 0
+      ? { ArrowRight: 1, ArrowLeft: -1 }[event.key] // NB tabs and switches: horizontal only
+      : { ArrowRight: 1, ArrowLeft: -1, ArrowDown: columns, ArrowUp: -columns }[event.key];
+    if (step) target = items[index + step] || null;
+  }
+  if (!target) return;
+  event.preventDefault();
+  items.forEach(function (el) { a11y_set(el, 'tabindex', el === target ? '0' : '-1'); });
+  target.focus();
+  if (target.scrollIntoView) target.scrollIntoView({ block: 'nearest' });
+}
+
+function a11y_sync() {
+  A11Y_CONTROLS.forEach(function (spec) {
+    $$(spec.selector).forEach(function (el) { a11y_apply(spec, el); });
+  });
+  A11Y_ROVING.forEach(function (spec) {
+    $$(spec.container).forEach(function (container) { a11y_roving_sync(spec, container); });
+  });
+}
+
+// -- dialogs ----------------------------------------------------------------
+
+const A11Y_DIALOG = 'div.modal.user_dialogue';
+// shown together with dialogs: must stay usable
+// NB #numericbox: the sliders opened from the advanced search, next to it;
+// #userbox stays above the overlay and toggles the login / account dialogs;
+// div.autocomplete-suggestions: appended to <body>, used by dialog fields
+const A11Y_NOT_INERT = ['#overlay', '#notifybox', '#aetmap', '#numericbox', '#userbox', 'div.menu_collateral',
+  'div.autocomplete-suggestions', '#tooltip', '#preloader'];
+let a11y_dialog_state = null; // {box, opener}
+let a11y_last_outside = null; // the last focused element outside any dialog
+
+function a11y_visible_dialog() {
+  return $$(A11Y_DIALOG).filter(isVisible).pop() || null;
+}
+
+export function open_dialog(box, initial) {
+  const opener = a11y_dialog_state ? a11y_dialog_state.opener : a11y_last_outside;
+  release_dialog(false);
+  a11y_set(box, 'role', 'dialog');
+  a11y_set(box, 'aria-modal', 'true');
+  Array.prototype.forEach.call(document.body.children, function (el) {
+    if (el === box || el.contains(box) || el.inert) return;
+    if (A11Y_NOT_INERT.some(function (selector) { return el.matches(selector); })) return;
+    el.inert = true;
+    el.setAttribute('data-a11y-inert', '');
+  });
+  // NB code that shows a dialog may already have focused a field in it;
+  // otherwise the dialog itself takes focus (no focus ring for mouse users),
+  // and the next Tab reaches its first control
+  if (!box.contains(document.activeElement)) {
+    const target = (initial && box.querySelector(initial)) || box;
+    if (target === box) a11y_set(box, 'tabindex', '-1');
+    target.focus({ preventScroll: true });
+  }
+  a11y_dialog_state = { box: box, opener: opener };
+}
+
+export function release_dialog(restore) {
+  $$('[data-a11y-inert]').forEach(function (el) {
+    el.inert = false;
+    el.removeAttribute('data-a11y-inert');
+  });
+  const state = a11y_dialog_state;
+  a11y_dialog_state = null;
+  if (restore !== false && state && state.opener && state.opener.isConnected && isVisible(state.opener)) {
+    const focus = document.activeElement;
+    if (!focus || focus === document.body || state.box.contains(focus)) state.opener.focus();
+  }
+}
+
+function a11y_dialog_check() {
+  const box = a11y_visible_dialog();
+  if (box && (!a11y_dialog_state || a11y_dialog_state.box !== box)) open_dialog(box);
+  else if (!box && a11y_dialog_state) release_dialog();
+}
+
+// -- entry columns: focus in on keyboard activation, back to the row on close --
+
+let a11y_context_row = null;
+
+export function a11y_context_opened(row, by_keyboard) {
+  a11y_context_row = row;
+  const title = $('#ctx_col div.col_title');
+  if (!by_keyboard || !title || !isVisible($('#ctx_col'))) return;
+  title.setAttribute('tabindex', '-1');
+  title.focus();
+}
+
+export function a11y_context_closed() {
+  const row = a11y_context_row;
+  a11y_context_row = null;
+  const focus = document.activeElement;
+  if (row && row.isConnected && isVisible(row) &&
+      (!focus || focus === document.body || focus.closest('#ctx_col, #sim_col'))) row.focus();
+}
+
+// -- non-modal popups: focus back to the opener on close -------------------------
+
+// NB #numericbox (the sliders of a numeric property) opens next to a dialog;
+// hiding it with the focus inside would drop the focus to <body>
+const A11Y_POPUPS = ['#numericbox'];
+const a11y_popup_state = {}; // selector -> the element focused when it opened
+
+function a11y_popup_check() {
+  A11Y_POPUPS.forEach(function (selector) {
+    const box = $(selector);
+    if (!box) return;
+    const shown = isVisible(box);
+    if (shown && !(selector in a11y_popup_state)) {
+      a11y_popup_state[selector] = box.contains(document.activeElement) ? null : document.activeElement;
+    } else if (!shown && selector in a11y_popup_state) {
+      const opener = a11y_popup_state[selector];
+      delete a11y_popup_state[selector];
+      const focus = document.activeElement;
+      if (opener && opener.isConnected && isVisible(opener) &&
+          (!focus || focus === document.body || box.contains(focus))) opener.focus({ preventScroll: true });
+    }
+  });
+}
+
+// -- skip control --------------------------------------------------------------
+
+function a11y_skip() {
+  const targets = ['#databrowser [tabindex="0"]', '#ptable_area [tabindex="0"]', '#databrowser'];
+  for (let i = 0; i < targets.length; i++) {
+    const el = $(targets[i]);
+    if (el && isVisible(el)) {
+      if (!el.hasAttribute('tabindex')) el.setAttribute('tabindex', '-1');
+      el.focus();
+      return;
+    }
+  }
+}
+
+// -- installation ---------------------------------------------------------------
+
+export function install_a11y() {
+  a11y_sync();
+
+  document.addEventListener('keydown', function (event) {
+    const el = event.target;
+    if ((event.key === 'Enter' || event.key === ' ') && el && el.matches &&
+        el.matches(A11Y_ACTIVATABLE) && !el.matches(A11Y_NATIVE)) {
+      event.preventDefault(); // NB Space must not scroll the page
+      el.click();
+      return;
+    }
+    for (let i = 0; i < A11Y_ROVING.length; i++) {
+      const spec = A11Y_ROVING[i];
+      const container = el && el.closest ? el.closest(spec.container) : null;
+      if (container) return a11y_roving_key(spec, container, event);
+    }
+  });
+
+  document.addEventListener('focusin', function (event) {
+    if (!event.target.closest || !event.target.closest(A11Y_DIALOG)) a11y_last_outside = event.target;
+  });
+
+  const skip = $('#a11y_skip');
+  if (skip) skip.addEventListener('click', a11y_skip);
+
+  // NB microtask-driven, no timers: deterministic under the parity fake clock
+  new MutationObserver(function (mutations) {
+    let dialogs = false,
+      popups = false,
+      content = false;
+    for (let i = 0; i < mutations.length; i++) {
+      const m = mutations[i];
+      if (m.type !== 'attributes' || m.attributeName === 'class') content = true;
+      if (m.target.nodeType === 1 && m.target.matches(A11Y_DIALOG)) dialogs = true;
+      if (m.target.nodeType === 1 && A11Y_POPUPS.some(function (s) { return m.target.matches(s); })) popups = true;
+    }
+    // NB style-only changes (animations, show/hide) need no new attributes
+    if (content) a11y_sync();
+    if (dialogs) a11y_dialog_check();
+    if (popups) a11y_popup_check();
+  }).observe(document.body, { subtree: true, childList: true, characterData: true, attributes: true, attributeFilter: ['class', 'style'] });
+}
diff --git a/src_js/core/ajax.js b/src_js/core/ajax.js
new file mode 100644
index 0000000..0da4774
--- /dev/null
+++ b/src_js/core/ajax.js
@@ -0,0 +1,131 @@
+/**
+ * Ermac AJAX: a minimal promise-based XMLHttpRequest wrapper,
+ * keeping cross-domain credentials and abortability of the old jQuery $.ajax calls.
+ *
+ * Returns a promise, additionally fitted with an .abort() method.
+ * The promise resolves with the parsed response, or rejects with
+ * {aborted: true} for requests cancelled via .abort(), or {status: N}
+ * otherwise; NB a network failure (offline, refused, CORS) is status 0
+ * but NOT an abort: like jQuery's textStatus 'error' vs 'abort'.
+ */
+
+export function ajax(settings) {
+  const xhr = new XMLHttpRequest();
+  let aborted = false;
+  let url = settings.url;
+  const type = (settings.type || 'GET').toUpperCase();
+  let query = null;
+
+  if (settings.data) {
+    if (type === 'GET') {
+      url += (url.indexOf('?') === -1 ? '?' : '&') + param(settings.data);
+    } else {
+      query = param(settings.data);
+    }
+  }
+
+  const promise = new Promise(function (resolve, reject) {
+    xhr.onreadystatechange = function () {
+      if (xhr.readyState !== 4) return;
+      if (xhr.status === 0) return reject({ aborted: aborted, status: 0, xhr: xhr });
+      if (xhr.status >= 200 && xhr.status < 300) {
+        let answer = xhr.responseText;
+        if (
+          settings.dataType === 'json' ||
+          (settings.dataType !== 'text' &&
+            (xhr.getResponseHeader('Content-Type') || '').indexOf('json') !==
+              -1)
+        ) {
+          try {
+            answer = JSON.parse(answer);
+          } catch (e) {
+            /* keep raw text */
+          }
+        }
+        resolve(answer);
+      } else {
+        reject({ status: xhr.status, xhr: xhr });
+      }
+    };
+    xhr.open(type, url);
+    xhr.withCredentials = true;
+    if (type === 'POST' && query) {
+      xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+    }
+    xhr.send(query);
+  });
+
+  promise.abort = function () {
+    aborted = true;
+    try {
+      xhr.abort();
+    } catch (e) {}
+  };
+  return promise;
+}
+
+/**
+ * URL query serialization, mimicking the vendored jQuery 3.7.1 $.param()
+ * (traditional = false) exactly: encodeURIComponent per key/value, null and
+ * undefined emitted as "key=", function values called, nested values
+ * expanded like jQuery's buildParams(): arrays as key[]= (key[i]= for
+ * object/array members), objects as key[name]=, a top-level array as
+ * {name, value} pairs.
+ * NB spaces stay as %20 (the vendored jQuery does NOT convert them to '+').
+ * NB #inquiry hashes with a numeric search need inquiry_param() instead.
+ */
+
+const PARAM_RBRACKET = /\[\]$/;
+const PARAM_NON_OBJECT_TAGS = [
+  'Boolean', 'Number', 'String', 'Function', 'Array', 'Date', 'RegExp', 'Error', 'Symbol',
+];
+
+function param_is_object(value) {
+  // jQuery's toType(value) === 'object'
+  if (value == null || (typeof value !== 'object' && typeof value !== 'function')) return false;
+  const tag = Object.prototype.toString.call(value).slice(8, -1);
+  return PARAM_NON_OBJECT_TAGS.indexOf(tag) === -1;
+}
+
+function param_build(prefix, value, add) {
+  if (Array.isArray(value)) {
+    value.forEach(function (member, index) {
+      if (PARAM_RBRACKET.test(prefix)) add(prefix, member);
+      else
+        param_build(
+          prefix + '[' + (typeof member === 'object' && member != null ? index : '') + ']',
+          member,
+          add,
+        );
+    });
+  } else if (!param_is_object(value)) {
+    add(prefix, value);
+  } else {
+    for (const name in value) param_build(prefix + '[' + name + ']', value[name], add);
+  }
+}
+
+export function param(obj) {
+  const parts = [];
+  const add = function (key, value) {
+    const resolved = typeof value === 'function' ? value() : value;
+    parts.push(encodeURIComponent(key) + '=' + encodeURIComponent(resolved == null ? '' : resolved));
+  };
+  if (obj == null) return '';
+  if (Array.isArray(obj)) {
+    obj.forEach(function (item) {
+      add(item.name, item.value);
+    });
+  } else {
+    for (const key in obj) param_build(key, obj[key], add);
+  }
+  return parts.join('&');
+}
+
+export function is_empty(obj) {
+  if (!obj) return true;
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) return false;
+  }
+  return true;
+}
diff --git a/src_js/core/dom.js b/src_js/core/dom.js
new file mode 100644
index 0000000..ed3fbef
--- /dev/null
+++ b/src_js/core/dom.js
@@ -0,0 +1,325 @@
+/**
+ * Ermac DOM helpers: a minimal vanilla replacement for the jQuery idioms used in this codebase.
+ */
+
+export function $(selector, root) {
+  return (root || document).querySelector(selector);
+}
+
+export function $$(selector, root) {
+  return Array.prototype.slice.call(
+    (root || document).querySelectorAll(selector),
+  );
+}
+
+/**
+ * Element data store, mimicking jQuery .data(key, value)
+ */
+
+const data_store = new WeakMap();
+
+export function data(el, key, value) {
+  if (value !== undefined) {
+    if (!data_store.has(el)) data_store.set(el, {});
+    data_store.get(el)[key] = value;
+    return value;
+  }
+  const stored = data_store.get(el);
+  return stored && stored[key] !== undefined ? stored[key] : undefined;
+}
+
+/**
+ * Display control, with the jQuery 3 .show() / .hide() / .toggle() semantics:
+ * hide() remembers the inline display it overrides, show() restores it, or
+ * clears the inline value and, if the stylesheet still hides the element,
+ * uses the default display of its tag (block for div, list-item for li...).
+ * NB only the element itself is considered, not its ancestors.
+ */
+
+const olddisplay = new WeakMap();
+const default_displays = {};
+
+function default_display(el) {
+  const name = el.nodeName;
+  if (default_displays[name]) return default_displays[name];
+  const temp = document.body.appendChild(document.createElement(name));
+  let display = window.getComputedStyle(temp).display;
+  temp.parentNode.removeChild(temp);
+  if (display === 'none') display = 'block';
+  default_displays[name] = display;
+  return display;
+}
+
+function hidden_within_tree(el) {
+  return (
+    el.style.display === 'none' ||
+    (el.style.display === '' &&
+      el.isConnected &&
+      window.getComputedStyle(el).display === 'none')
+  );
+}
+
+function show_one(el) {
+  let value = null;
+  if (el.style.display === 'none') {
+    value = olddisplay.get(el) || null;
+    if (!value) el.style.display = '';
+  }
+  if (el.style.display === '' && hidden_within_tree(el)) value = default_display(el);
+  if (value !== null) el.style.display = value;
+}
+
+function hide_one(el) {
+  const display = el.style.display;
+  if (display !== 'none') {
+    olddisplay.set(el, display);
+    el.style.display = 'none';
+  }
+}
+
+export function show(els) {
+  if (!els) return;
+  if (!Array.isArray(els)) els = [els];
+  els.forEach(function (el) {
+    if (el) show_one(el);
+  });
+}
+
+export function hide(els) {
+  if (!els) return;
+  if (!Array.isArray(els)) els = [els];
+  els.forEach(function (el) {
+    if (el) hide_one(el);
+  });
+}
+
+// NB jQuery .toggle(): the display argument is kept for the call sites, but
+// like jQuery the shown state is the restored/default display
+export function toggle_display(els) {
+  if (!els) return;
+  if (!Array.isArray(els)) els = [els];
+  els.forEach(function (el) {
+    if (!el) return;
+    if (hidden_within_tree(el)) show_one(el);
+    else hide_one(el);
+  });
+}
+
+export function isVisible(el) {
+  return !!(
+    el &&
+    (el.offsetParent ||
+      el.offsetWidth ||
+      el.offsetHeight ||
+      el.getClientRects().length)
+  );
+}
+
+/**
+ * Content manipulation
+ */
+
+export function set_html(el, markup) {
+  if (el) el.innerHTML = markup;
+}
+
+export function append_html(el, markup) {
+  if (el) el.insertAdjacentHTML('beforeend', markup);
+}
+
+export function prepend_html(el, markup) {
+  if (el) el.insertAdjacentHTML('afterbegin', markup);
+}
+
+export function after_html(el, markup) {
+  if (el) el.insertAdjacentHTML('afterend', markup);
+}
+
+export function empty(els) {
+  if (!Array.isArray(els)) els = [els];
+  els.forEach(function (el) {
+    if (el) while (el.firstChild) el.removeChild(el.firstChild);
+  });
+}
+
+export function remove(els) {
+  if (!Array.isArray(els)) els = [els];
+  els.forEach(function (el) {
+    if (el && el.parentNode) el.parentNode.removeChild(el);
+  });
+}
+
+/**
+ * Attributes, values, classes
+ */
+
+export function get_attr(el, name) {
+  return el ? el.getAttribute(name) : null;
+}
+
+export function set_attr(el, name, value) {
+  if (el) el.setAttribute(name, value);
+}
+
+export function get_val(el) {
+  return el ? el.value : '';
+}
+
+export function set_val(el, value) {
+  if (el) el.value = value;
+}
+
+export function get_text(el) {
+  return el ? el.textContent : '';
+}
+
+/**
+ * Geometry, mimicking jQuery .offset() and .position()
+ */
+
+export function offset(el) {
+  if (!el) return { left: 0, top: 0 };
+  const rect = el.getBoundingClientRect();
+  return {
+    left: rect.left + window.scrollX,
+    top: rect.top + window.scrollY,
+  };
+}
+
+export function position(el) {
+  if (!el) return { left: 0, top: 0 };
+  const rect = el.getBoundingClientRect();
+  if (!el.offsetParent) return { left: rect.left, top: rect.top };
+  const parent = el.offsetParent.getBoundingClientRect();
+  return {
+    left: rect.left - parent.left - el.offsetParent.clientLeft,
+    top: rect.top - parent.top - el.offsetParent.clientTop,
+  };
+}
+
+export function scroll_top() {
+  return window.scrollY || document.documentElement.scrollTop;
+}
+
+export function window_height() {
+  return window.innerHeight || document.documentElement.clientHeight;
+}
+
+/**
+ * Simple animations, mimicking jQuery slideUp/slideDown/fadeOut.
+ * NB the ticks are setTimeout-driven (like the old jQuery fx loop), NOT
+ * requestAnimationFrame: compositor-driven frames do not advance while a
+ * headless virtual-time budget runs, freezing rAF animations mid-flight.
+ */
+
+function animate(el, from, to, duration, on_finish) {
+  const start = performance.now();
+  el.style.overflow = 'hidden';
+  function step() {
+    const progress = Math.min((performance.now() - start) / duration, 1);
+    el.style.height = from + (to - from) * progress + 'px';
+    if (progress < 1) setTimeout(step, 16);
+    else {
+      el.style.overflow = '';
+      el.style.height = '';
+      if (on_finish) on_finish();
+    }
+  }
+  setTimeout(step, 16);
+}
+
+export function slide_up(el, duration, on_finish) {
+  if (!el || !isVisible(el)) {
+    if (on_finish) on_finish();
+    return;
+  }
+  const h = el.offsetHeight;
+  animate(el, h, 0, duration || 250, function () {
+    el.style.display = 'none';
+    if (on_finish) on_finish();
+  });
+}
+
+export function slide_down(el, duration) {
+  if (!el) return;
+  el.style.display = ''; // NB let the natural display apply, mimicking jQuery
+  if (!isVisible(el)) el.style.display = 'block';
+  const h = el.offsetHeight;
+  animate(el, 0, h, duration || 250);
+}
+
+export function fade_out(el, duration, on_finish) {
+  if (!el) {
+    if (on_finish) on_finish();
+    return;
+  }
+  const start_opacity = parseFloat(el.style.opacity || '1');
+  const start = performance.now();
+  function step() {
+    const progress = Math.min((performance.now() - start) / (duration || 250), 1);
+    el.style.opacity = String(start_opacity * (1 - progress));
+    if (progress < 1) setTimeout(step, 16);
+    else if (on_finish) on_finish();
+  }
+  setTimeout(step, 16);
+}
+
+/**
+ * Delegated events with the jQuery .on(event, selector, handler) semantics:
+ *  - all delegated handlers of a root run from ONE native listener, the
+ *    deepest matching element first (registration order within a level);
+ *  - stopPropagation() in a handler stops the handlers of the outer
+ *    matching elements of the same root (e.g. a button inside a row);
+ *  - a handler returning false means preventDefault() + stopPropagation();
+ *  - delegated clicks ignore non-primary mouse buttons.
+ */
+
+const delegations = new WeakMap(); // root -> {type: [{selector, handler}]}
+
+export function on(root, selector, type, handler) {
+  root = root || document;
+  let types = delegations.get(root);
+  if (!types) {
+    types = {};
+    delegations.set(root, types);
+  }
+  if (!types[type]) {
+    types[type] = [];
+    const entries = types[type];
+    root.addEventListener(type, function (event) {
+      if (type === 'click' && event.button >= 1) return;
+      const queue = [];
+      for (let cur = event.target; cur && cur !== root; cur = cur.parentNode) {
+        if (cur.nodeType !== 1) continue;
+        const matched = entries.filter(function (entry) {
+          return cur.matches(entry.selector);
+        });
+        if (matched.length) queue.push({ el: cur, entries: matched });
+      }
+      let immediate_stop = false;
+      const native_stop_immediate = event.stopImmediatePropagation;
+      event.stopImmediatePropagation = function () {
+        immediate_stop = true;
+        return native_stop_immediate.call(event);
+      };
+      try {
+        for (let i = 0; i < queue.length; i++) {
+          if (event.cancelBubble) break;
+          const level = queue[i];
+          for (let j = 0; j < level.entries.length; j++) {
+            const result = level.entries[j].handler.call(level.el, event, level.el);
+            if (result === false) {
+              event.preventDefault();
+              event.stopPropagation();
+            }
+            if (immediate_stop) break;
+          }
+          if (immediate_stop) break;
+        }
+      } finally {
+        event.stopImmediatePropagation = native_stop_immediate;
+      }
+    });
+  }
+  types[type].push({ selector: selector, handler: handler });
+}
diff --git a/src_js/core/settings.js b/src_js/core/settings.js
new file mode 100644
index 0000000..b3c83a5
--- /dev/null
+++ b/src_js/core/settings.js
@@ -0,0 +1,541 @@
+/**
+ * Ermac global state, constants, API endpoint URLs, edition configs.
+ * The state object is exposed as window.wmgui for embeddability (external host apps
+ * may override wmgui.mpdsgui hooks or call wmgui.notify), while remaining
+ * a regular ES module export internally.
+ */
+
+import { $, $$, hide, show, set_html } from './dom.js';
+
+const wmgui = {};
+window.wmgui = wmgui;
+export default wmgui;
+
+wmgui.search = {}; // the main object containing the app state synced to the server
+wmgui.search_type = 0; // 0 = entries, 1 = phases, or 2 = articles (NB copied into the main state object, defines *without_history*)
+wmgui.view_mode = 1; // 1 = intro screen, 2 = results screen
+wmgui.thumbed_display = false;
+wmgui.ctx_strict_phases = ''; // empty string or anything (bool)
+//wmgui.ctx_subphases = ''; // empty string or anything (bool)
+wmgui.ntab_tolerance = 100;
+wmgui.chosen_table_browser = false;
+wmgui.fuzzyout = false;
+wmgui.passive_sim_col = true;
+
+wmgui.active_ajax = null;
+wmgui.quick_ajax = null;
+
+// these are all usual search categories
+wmgui.facets = [
+  'formulae',
+  'props',
+  'elements',
+  'classes',
+  'lattices',
+  'sgs',
+  'protos',
+  'authors',
+  'years',
+  'codens',
+  'doi',
+  'aeatoms',
+  'aetypes',
+  'geos',
+  'orgs',
+  'wyckoff',
+];
+
+// these are those categories only accessible from the advanced search menu
+wmgui.inquiries = [
+  'sgs',
+  'protos',
+  'authors',
+  'years',
+  'codens',
+  'doi',
+  'aeatoms',
+  'aetypes',
+  'geos',
+  'orgs',
+  'wyckoff',
+];
+wmgui.other_facets = wmgui.inquiries.filter(function (item) {
+  return item !== 'aetypes';
+}); // NOT main search field or NLP-handled
+wmgui.simple_facets = [
+  'formulae',
+  'props',
+  'elements',
+  'lattices',
+  'sgs',
+  'protos',
+  'years',
+  'codens',
+  'doi',
+  'aeatoms',
+  'geos',
+  'orgs',
+];
+wmgui.multi_facets = ['classes', 'authors', 'aetypes', 'wyckoff'];
+wmgui.facet_names = {
+  props: 'Physical properties',
+  elements: 'Chemical elements',
+  classes: 'Materials classes',
+  lattices: 'Crystal systems',
+  formulae: 'Chemical formulae',
+  protos: 'Prototypes',
+  sgs: 'Space groups',
+  numeric: 'Numerical search', // NB not a real facet
+  authors: 'Authors',
+  years: 'Years',
+  codens: 'Journal codes',
+  doi: 'DOI',
+  aeatoms: 'Polyhedron atoms',
+  aetypes: 'Polyhedral types',
+  geos: 'Geography',
+  orgs: 'Organization',
+  wyckoff: 'Wyckoff search', // also positions and sequence
+};
+wmgui.multiselects = {}; // multiselect component instances, for *wmgui.multi_facets* and *main*
+wmgui.selectize_emit = true;
+wmgui.unfinished_page = false;
+wmgui.quick_page_size = 150;
+wmgui.fetch_page_size = 850;
+wmgui.notify_counter = null;
+wmgui.cliff_counter = null;
+wmgui.sid = null;
+wmgui.oauths = null;
+wmgui.prod = window.location.host.indexOf('localhost') === -1;
+wmgui.darkmode = null;
+
+wmgui.cliffhangers = [
+  'binary compounds with negative thermal expansion',
+  'band gap of hexagonal ZnO',
+  'ternary oxides of indium',
+  //"microhardness < 0.05",
+  //"temperature for metal-nonmetal transition < 10",
+  //"thermoelectric figure of merit > 0.5",
+  'electronic properties for semiconductor carbides',
+  //"c/a > 3, a/b > 3, density < 4",
+  'noble gases superconductivity',
+  'W-Mo ternary phase diagram',
+  //"density < 3 and temperature for congruent melting > 2000",
+  'tetragonal SrTiO&#x2083; phonons',
+  'radioactive elements conductivity',
+  'O&#x2083;Al&#x2082; elastic properties',
+  //"refractive index > 5", // FIXME
+  'sidorenkite crystal cell',
+  //"birefringence < 0.005 and static permittivity > 7.5",
+  'phase diagrams from ab initio literature',
+  //"adiabatic bulk modulus > 250 and isothermal bulk modulus > 250",
+  'magnetic properties of binary compounds',
+  'radioactive binary compounds',
+  'binary frank-kasper type',
+  'liquidus projection phase diagrams',
+];
+wmgui.welcome_msgs = [
+  "The distinct phases is the central concept at the MPDS. Thanks to it, the crystal structures are linked to the phase diagrams and physical properties. Any distinct phase is uniquely determined by its chemical formula, space group, and Pearson symbol <i>e.g.</i> <a href='/#phase/CuAl2/140/tI12'>CuAl2 140 tI12</a>.",
+  "Our data back up such products as Springer Materials, ICDD PDF-5+, ASM Alloy Phase Diagrams, Pearson's Crystal Data, MedeA Materials Design, and AtomWork Advanced.",
+  'Each peer-reviewed crystal structure, phase diagram, or physical property at the MPDS originates from a particular publication.',
+  'There are two search modes, simple and advanced. The simple one presents one "smart" input field, the advanced one offers many various search fields.',
+  'The MPDS includes the data extracted from the rare USSR and Japanese journals from 60-es, 70-es, and 80-es. These journals were never online.',
+  "A unique feature of the MPDS is the support of the <a href='/#polyhedra'>polyhedral type searches</a>, taking into account the atomic environments.",
+];
+// NB this is used also in legacy Ermac detection (FIXME)
+wmgui.api_msg =
+  'Try to run <i>e.g.</i> the command given below in a terminal. As finished, do not forget to revoke your API key. See the <a href="https://developer.mpds.io">manual</a> for more details and the <a href="/#formal/api">license</a> for open data listing. <pre style="overflow-x:scroll;margin:1em 0;">curl -H Key:YOUR_API_KEY \'https://api.mpds.io/v0/download/facet?q=&bsol;{"elements":"Ag-K"&bsol;}\'</pre><div class="wmbutton" style="background:#999;border-color:#999;width:150px;margin:0 auto;font-size:0.9em;">Copy to clipboard</div>';
+
+wmgui.bid_history = [];
+wmgui.mydata_history = [];
+wmgui.journal_converter = { j2c: function () {}, c2j: function () {} };
+wmgui.hy_complex = [
+  'crystalline structure',
+  'phase diagram',
+  'electron energy band structure',
+  'electron density of states',
+  'vibrational spectra',
+]; // NB check exact match in "props" p2i FIXME 'electron density of states - ab initio calculations'
+
+wmgui.visavis_curtype = 'pie'; // pie, graph, discovery, matrix, cube, qproj, lit, TODO heuristic plot type detection
+wmgui.visavis_ready = false;
+wmgui.visavis_working = false;
+wmgui.visavis_terminating = false;
+wmgui.visavis_starting = false; // only used by an old engine, to delete TODO
+
+wmgui.numerics = {
+  // these first 8 below are *pseudo_numerics*, client_prop_id > 5000
+  volume: [5001, '&#8491;<sup>3</sup>', 3, 10000, 1],
+  density: [5002, 'Mg/m<sup>3</sup>', 0.1, 30, 0.1],
+  'a--b': [5003, false, 0.1, 10, false, '<i>a/b</i>'],
+  'b--c': [5004, false, 0.1, 10, false, '<i>b/c</i>'],
+  'c--a': [5005, false, 0.1, 10, false, '<i>c/a</i>'],
+  alat: [5006, '&#8491;', 1.5, 20, 0.1, '<i>a<sub>lat</sub></i>'],
+  blat: [5007, '&#8491;', 1.5, 20, 0.1, '<i>b<sub>lat</sub></i>'],
+  clat: [5008, '&#8491;', 1.5, 20, 0.1, '<i>c<sub>lat</sub></i>'],
+}; // client data *numerics*: prop_name: [client_prop_id, units, min, max, ?step, ?origname]
+
+// NB all URLs follow below
+wmgui.gui_host = window.location.protocol + '//' + window.location.host;
+wmgui.api_host = wmgui.prod
+  ? 'https://api.mpds.io/v0'
+  : 'http://localhost:7070';
+wmgui.static_host = 'https://mpds.io';
+wmgui.app_folder = window.location.pathname.slice(
+  0,
+  window.location.pathname.lastIndexOf('/'),
+);
+
+// below are the main MPDS API endpoints
+wmgui.login_endpoint = wmgui.api_host + '/users/login';
+wmgui.logout_endpoint = wmgui.api_host + '/users/logout';
+wmgui.factor_endpoint = wmgui.api_host + '/users/factor';
+wmgui.factor_v_endpoint = wmgui.api_host + '/users/factor_v';
+wmgui.restore_endpoint = wmgui.api_host + '/users/lost_password';
+wmgui.password_endpoint = wmgui.api_host + '/users/new_password';
+wmgui.access_endpoint = wmgui.api_host + '/users/access';
+wmgui.ip_endpoint = wmgui.api_host + '/users/ip';
+wmgui.ratify_endpoint = wmgui.api_host + '/users/ratify';
+wmgui.api_key_endpoint = wmgui.api_host + '/users/api_key';
+wmgui.perms_endpoint = wmgui.api_host + '/users/perms';
+wmgui.ip_perms_endpoint = wmgui.api_host + '/users/ip_perms';
+wmgui.funnel_endpoint = wmgui.api_host + '/users/funnel';
+//wmgui.fd_endpoint =       wmgui.api_host + '/users/feedback';
+wmgui.search_endpoint = wmgui.api_host + '/search/facet';
+wmgui.rfn_endpoint = wmgui.api_host + '/search/refinement';
+wmgui.sim_endpoint = wmgui.api_host + '/search/interlinkage';
+wmgui.phase_endpoint = wmgui.api_host + '/search/phase';
+wmgui.phph_endpoint = wmgui.api_host + '/search/phase_phid';
+wmgui.auto_endpoint = wmgui.api_host + '/search/selectize';
+wmgui.refs_endpoint = wmgui.api_host + '/download/bib';
+wmgui.wmdata_endpoint = wmgui.api_host + '/download/wmdata';
+wmgui.vis_endpoint = wmgui.api_host + '/visavis';
+wmgui.pdist_endpoint = wmgui.api_host + '/visavis/pdistribs';
+wmgui.mydata_endpoint = wmgui.api_host + '/extension/mydata';
+
+wmgui.dd_addr_tpl = wmgui.api_host + '/download';
+wmgui.mydata_addr = wmgui.prod
+  ? 'https://app.absolidix.com'
+  : 'http://localhost:5000';
+
+wmgui.path_c_entry = '#' + wmgui.api_host + '/download/c?fmt=json&q=';
+wmgui.path_s_entry = '#' + wmgui.api_host + '/download/s?fmt=cif&q=';
+wmgui.path_s_xrpd = '#' + wmgui.api_host + '/download/s?fmt=xrpd&q=';
+wmgui.path_sd_plot = '#' + wmgui.api_host + '/download/p?fmt=json&q=';
+wmgui.path_pp_plot = '#https://data.mpds.io/export?fmt=json&q='; // TODO
+wmgui.path_pp_ping = wmgui.prod
+  ? 'https://data.mpds.io/ping?q='
+  : 'http://localhost:8080/ping?q=';
+
+wmgui.engines_addrs = {
+  cifplayer: wmgui.app_folder + '/webassets/iframe_cifplayer.html',
+  visavis: wmgui.app_folder + '/webassets/iframe_visavis.html',
+};
+
+wmgui.v_pd_user_addr = wmgui.app_folder + '/webassets/pd_stub.html#';
+wmgui.v_ab_vis_addr =
+  wmgui.app_folder +
+  '/labs/view-phonons/#' +
+  wmgui.api_host +
+  '/download/p?fmt=json&q=';
+wmgui.v_pd_3d_addr = wmgui.app_folder + '/labs/pd3d/?';
+wmgui.aetmap_addr = wmgui.static_host + '/aets.jpg';
+
+wmgui.mpds_native = false; // TODO relate to wmgui.edition
+wmgui.edition = null; // NB edition ID (e.g. 0, 1) is determined by a domain
+
+wmgui.editions = {
+  0: {
+    name: 'Materials Platform for Data Science',
+    prod_url: 'https://mpds.io',
+    dev_url: 'http://localhost:8070',
+    css: wmgui.static_host + '/editions/wm/style.css?220923',
+    actions: function () {
+      const logo = $('#logo_l');
+      if (logo) logo.textContent = 'MPDS';
+      $$('.only_asm').forEach(hide);
+      $$('.only_mpds').forEach(function (el) {
+        el.style.display = 'inline-block';
+      });
+    },
+  },
+  1: {
+    name: 'ASM International Materials Platform',
+    prod_url: 'https://asm.mpds.io',
+    dev_url: 'http://localhost:8075',
+    css: wmgui.static_host + '/editions/asm/style.css?150125',
+    actions: function () {
+      $$('.only_mpds').forEach(hide);
+      $$('.only_asm').forEach(function (el) {
+        el.style.display = 'inline-block';
+      });
+      // custom favicon
+      var link =
+        document.querySelector("link[rel*='icon']") ||
+        document.createElement('link');
+      link.type = 'image/x-icon';
+      link.rel = 'shortcut icon';
+      link.href = wmgui.static_host + '/editions/asm/asm.ico';
+      document.getElementsByTagName('head')[0].appendChild(link);
+    },
+  },
+};
+// NB all URLs are above
+
+wmgui.elemental_names = {
+  num: 'atomic number',
+  nump: 'periodic number',
+  size: 'atomic size',
+  rea: 'atomic reactivity',
+  rpp: 'pseudopotential radii',
+  rion: 'ionic radii',
+  rcov: 'covalent radii',
+  rmet: 'metallic radii',
+  tmelt: 'melting temperature',
+  eneg: 'electronegativity',
+};
+
+wmgui.collateral_links = [
+  // [link_href, link_rel_attr, link_value, _blank]
+  ['#', 'my', 'search my publications'],
+  ['#', 'adv', 'try advanced search'],
+  ['#polyhedra', false, 'explore polyhedra'],
+  ['#hierarchy', false, 'browse physical properties'],
+  [
+    wmgui.static_host + '/labs/mpds-ml-labs/design.html',
+    false,
+    'design new material',
+    true,
+  ],
+  [
+    wmgui.static_host + '/labs/mpds-ml-labs/props.html',
+    false,
+    'predict properties for crystal',
+    true,
+  ],
+  ['#', 'idea', 'get inspired'],
+  ['#', 'sod', 'show structure of the day'],
+  ['oauth/asm.html', false, 'connect ASM profile', true],
+  ['oauth/github.html', false, 'connect GitHub profile', true],
+  ['oauth/orcid.html', false, 'connect ORCID profile', true],
+  ['oauth/linkedin.html', false, 'connect LinkedIn profile', true],
+];
+
+wmgui.aets = {
+  'single atom 1-vertex': [0, 83],
+  '4-capped trigonal prism 10-vertex': [85, 102],
+  'bicapped square prism 10-vertex': [189, 123],
+  'bicapped square antiprism 10-vertex': [314, 125],
+  'triangle-pentagon faced polyhedron 10-vertex': [441, 125],
+  'distorted equatorial 4-capped trigonal prism 10-vertex': [568, 113],
+  'truncated hexagonal bipyramid 10-vertex': [683, 111],
+  'polar bicapped square prism 10-vertex': [796, 125],
+  'pentagonal prism 10-vertex': [923, 121],
+  'octagonal bipyramid 10-vertex': [1046, 122],
+  '5-capped trigonal prism 11-vertex': [1170, 119],
+  'pseudo Frank-Kasper 11-vertex': [1291, 125],
+  'monotruncated icosahedron 11-vertex': [1418, 102],
+  'tricapped cube same plane 11-vertex': [1522, 87],
+  'tricapped cube different plane 11-vertex': [1611, 123],
+  'icosahedron 12-vertex': [1736, 125],
+  'cuboctahedron 12-vertex': [1863, 117],
+  'bicapped pentagonal prism 12-vertex': [1982, 125],
+  'anticuboctahedron 12-vertex': [2109, 109],
+  'hexagonal prism 12-vertex': [2220, 90],
+  'triangle-hexagon faced polyhedron 12-vertex': [2312, 112],
+  'double-bicapped cube 12-vertex': [2426, 114],
+  'pseudo Frank-Kasper 13-vertex': [2542, 125],
+  'tricapped pentagonal prism 13-vertex': [2669, 114],
+  'monocapped cuboctahedron-a 13-vertex': [2785, 111],
+  'monocapped cuboctahedron-b 13-vertex': [2898, 120],
+  '14-vertex Frank-Kasper': [3020, 116],
+  'rhombic dodecahedron 14-vertex': [3138, 121],
+  'distorted rhombic dodecahedron 14-vertex': [3261, 123],
+  'bicapped hexagonal prism 14-vertex': [3386, 122],
+  '6-capped hexagonal bipyramid 14-vertex': [3510, 125],
+  'double-bicapped hexagonal prism 14-vertex': [3637, 111],
+  '15-vertex Frank-Kasper': [3750, 125],
+  'equatorial 5-capped pentagonal-prism 15-vertex': [3877, 97],
+  'polar equatorial tricapped pentagonal-prism 15-vertex': [3976, 125],
+  'monotruncated 16-vertex Frank-Kasper': [4103, 107],
+  '16-vertex Frank-Kasper': [4212, 125],
+  'defective 8-equatorial capped pentagonal prism 16-vertex': [4339, 92],
+  'octagonal prism 16-vertex': [4433, 119],
+  '7-capped pentagonal prism 17-vertex': [4554, 125],
+  '8-equatorial capped pentagonal prism 18-vertex': [4681, 125],
+  'pseudo Frank-Kasper 18-vertex': [4808, 125],
+  '6-capped hexagonal prism 18-vertex': [4935, 108],
+  'double-bicapped heptagonal prism 18-vertex': [5045, 110],
+  'distorted pseudo Frank-Kasper 19-vertex': [5157, 125],
+  'pseudo Frank-Kasper 19-vertex': [5284, 122],
+  'non-collinear atoms 2-vertex': [5408, 41],
+  'collinear atoms 2-vertex': [5451, 111],
+  'pseudo Frank-Kasper 20-vertex': [5564, 125],
+  '20-pentagonal faced polyhedron 20-vertex': [5691, 114],
+  'pseudo Frank-Kasper 21-vertex': [5807, 125],
+  'polar 8-equatorial capped hexagonal prism 22-vertex': [5934, 125],
+  'pseudo Frank-Kasper 23-vertex': [6061, 118],
+  '6-square 8-hexagonal faced polyhedron 24-vertex': [6181, 118],
+  'pseudo Frank-Kasper 24-vertex': [6301, 125],
+  'truncated cube dice 24-vertex': [6428, 118],
+  'triangle-square-hexagon faced polyhedron 24-vertex': [6548, 97],
+  'triangle-square faced polyhedron 24-vertex': [6647, 125],
+  'pseudo Frank-Kasper 26-vertex': [6774, 125],
+  'pseudo Frank-Kasper 28-vertex': [6901, 123],
+  'non-coplanar triangle 3-vertex': [7026, 75],
+  'coplanar triangle 3-vertex': [7103, 64],
+  '32-vertex': [7169, 122],
+  'tetrahedron central atom outside 4-vertex': [7293, 99],
+  'coplanar square 4-vertex': [7394, 68],
+  'non-coplanar square 4-vertex': [7464, 69],
+  'tetrahedron 4-vertex': [7535, 120],
+  'square pyramid central atom outside of base plane 5-vertex': [7657, 81],
+  'coplanar pentagon 5-vertex': [7740, 67],
+  'square pyramid 5-vertex': [7809, 125],
+  'trigonal bipyramid 5-vertex': [7936, 107],
+  'coplanar hexagon 6-vertex': [8045, 49],
+  'non-coplanar hexagon 6-vertex': [8096, 80],
+  'octahedron 6-vertex': [8178, 125],
+  'trigonal prism 6-vertex': [8305, 120],
+  'pentagonal pyramid 6-vertex': [8427, 116],
+  'distorted prism 6-vertex': [8545, 110],
+  'monocapped octahedron 7-vertex': [8657, 125],
+  'top-monocapped trigonal prism 7-vertex': [8784, 125],
+  'bicapped hexagon 7-vertex': [8911, 108],
+  'hexagonal pyramid 7-vertex': [9021, 96],
+  'monocapped trigonal prism 7-vertex': [9119, 125],
+  'pentagonal bipyramid 7-vertex': [9246, 122],
+  'square prism cube 8-vertex': [9370, 115],
+  'square antiprism 8-vertex': [9487, 103],
+  'hexagonal bipyramid 8-vertex': [9592, 125],
+  'distorted square anti-prism-a 8-vertex': [9719, 123],
+  'double anti-trigonal prism 8-vertex': [9844, 99],
+  'side-bicapped trigonal prism 8-vertex': [9945, 107],
+  'distorted square anti-prism-b 8-vertex': [10054, 125],
+  'tricapped trigonal prism 9-vertex': [10181, 119],
+  'monocapped square prism 9-vertex': [10302, 125],
+  'monocapped double anti-trigonal prism 9-vertex': [10429, 113],
+  'truncated hexagonal pyramid 9-vertex': [10544, 75],
+  'bicapped hexagonal pyramid 9-vertex': [10621, 116],
+};
+
+//wmgui.contact_html = '<textarea id="fdwidget_msg" placeholder="Please tell us why, anonymously"></textarea><select id="fdwidget_msgtype"><option value="No reason" selected>Please select reason...</option><option value="Data missing">Data missing</option><option value="Error in data">Error in data</option><option value="Other">Other</option></select><div id="fdwidget_trigger" class="wmbutton">Send</div>';
+
+wmgui.s_examples = [
+  251737, 261485, 301194, 458778, 525194, 533193, 1005414, 1030546, 1122968,
+  1215422, 1232477, 1321212, 1406036, 1613664, 1638591, 1640622, 1707997,
+  1711681, 1722027, 1819191, 1928624, 1933647, 1940797,
+];
+wmgui.mockyear = '2022'; // used for the in-house generated data, TODO switch to 2024
+
+wmgui.store_history_key = 'wm_search_log_v5';
+wmgui.store_user_key = 'wm';
+wmgui.store_bids_key = 'bid_history'; // TODO rename to wm_bid_history
+wmgui.store_mydata_key = 'absolidix_v1';
+wmgui.store_oauth_email_key = 'wm_u_email';
+wmgui.store_comm_exec_key = 'wm_reload_v1';
+wmgui.store_redir_key = 'wm_redir_v1';
+
+wmgui.tooltips = {
+  //'advsearch': {el: 'advsearch_init_trigger', oleft: -90, otop: 60, view_mode: 1, text: 'Use the &#9776; button for the detailed search by 15+ categories.<br /><span rel="userbox">Next</span>'},
+  //'hierarchy': {el: 'advsearch_init_trigger', oleft: -50, otop: 60, view_mode: 1, text: 'Use the <i>&mu;</i> button to select physical properties from the curated hierarchy.<br /><span rel="userbox">Next</span>'},
+  userbox: {
+    el: 'userbox',
+    oleft: -105,
+    otop: 60,
+    view_mode: 1,
+    text: 'Check your full access<br />with your account here.<br /><span rel="close_tooltip">OK</span>',
+  },
+  interpretation: {
+    el: 'right_col',
+    oleft: -70,
+    otop: 99,
+    view_mode: 2,
+    text: 'The entries are grouped in the phases.<br /><span rel="databrowser">Next</span>',
+  },
+  databrowser: {
+    el: 'databrowser',
+    oleft: 0,
+    otop: 200,
+    view_mode: 2,
+    text: 'Click the particular entry to get more info. Opened lock means open access.<br /><span rel="close_tooltip">OK</span>',
+  },
+  //'plots': {el: 'databrowser', oleft: 0, otop: 500, view_mode: 2, text: 'Use the graph chart buttons in the footer (at the very bottom of the page).<br /><span rel="close_tooltip">OK</span>'},
+  ss_axes: {
+    el: 'ctxpanel_plots',
+    oleft: 60,
+    otop: 114,
+    view_mode: 2,
+    text: 'Click gear icon to sort axes differently.<br /><span rel="visavis" class="forced">Next</span>',
+  },
+  visavis: {
+    el: 'right_col',
+    oleft: -150,
+    otop: 500,
+    view_mode: 2,
+    text: 'Fine-tune visualizations with the commands here.<br /><span rel="close_tooltip">OK</span>',
+  },
+};
+wmgui.tooltip_counter = 0;
+wmgui.tooltip_landing = 'userbox';
+
+wmgui.poly_limits = {
+  1: 'isopolyhedral',
+  2: 'dipolyhedral',
+  3: 'tripolyhedral',
+};
+
+// external integrations
+// TODO account contentWindow iframe calls here
+
+wmgui.mpdsgui = {};
+wmgui.mpdsgui.view = function () {};
+wmgui.mpdsgui.ptable_activate = function () {};
+wmgui.mpdsgui.ptable_deactivate = function () {};
+
+wmgui.entries_messages = {
+  C900500: 'This system is stable (dashed metastable)',
+  C904090: 'This system is metastable (dashed stable)',
+  C904091: 'This system is metastable',
+  C904092: 'This system is metastable (dashed stable)',
+  C904124: 'This system is metastable (dashed stable)',
+  C904221: 'This system is stable; allotropic transition of Fe is not shown',
+  C904222: 'This system is stable',
+  C904223: 'This system is stable',
+  C904313: 'This system is stable',
+  C904322: 'This system is stable',
+  C904329: 'This system is stable',
+  C904330: 'This system is metastable (dashed stable)',
+  C904331: 'This system is metastable (dashed stable)',
+  C904332: 'This system is stable',
+  C904343: 'This system is stable',
+  C904344: 'This system is stable',
+  C904345: 'This system is stable (dashed metastable)',
+  C904354: 'This system is metastable (dashed stable)',
+  C904366: 'This system is metastable',
+  C904376: 'This system is metastable (dashed stable)',
+  C904437: 'This system is stable',
+  C904478: 'This system is stable',
+  C905006: 'This system is metastable',
+  C905621: 'This system is metastable',
+  C905635: 'This system is stable (dashed metastable)',
+  C905636: 'This system is stable',
+  C905637: 'This system is stable (dashed metastable)',
+  C905638: 'This system is stable (dashed metastable)',
+  C905985: 'This system is metastable (dashed stable)',
+  C906635: 'This system is stable',
+  C906931: 'This system is stable',
+  C908341: 'This system is stable; p = 8.0 GPa',
+  C908342: 'This system is metastable',
+  C908343: 'This system is metastable',
+  C979860: 'This system is stable',
+  C979861: 'This system is stable',
+  C979862: 'This system is stable',
+  C979863: 'This system is metastable',
+  C979864: 'This system is stable',
+  C979865: 'This system is stable',
+  C102059: 'This system is metastable',
+  C103150: 'This system is stable',
+  C104069: 'This system is metastable',
+  C105034: 'This system is metastable',
+  C105035: 'This system is metastable',
+};
diff --git a/src_js/core/utils.js b/src_js/core/utils.js
new file mode 100644
index 0000000..d25e8fa
--- /dev/null
+++ b/src_js/core/utils.js
@@ -0,0 +1,1536 @@
+/**
+ * Ermac core utilities: base-type extensions, DOM-adjacent helpers,
+ * domain data and methods ported from the old wmcore.js.
+ */
+
+import wmgui from './settings.js';
+import { $, show, hide } from './dom.js';
+import { is_empty } from './ajax.js';
+
+/**
+ * Vendored NLP parser (src_js/third_party/optimade_mpds_nlp.js) defines the window global.
+ */
+/* global OptimadeNLP */
+
+if (typeof OptimadeNLP === 'undefined') {
+  throw new Error('Failed to load OptimadeNLP');
+}
+
+export const wmutils = OptimadeNLP();
+
+/**
+ * Extending base types with the utilities
+ */
+
+Array.prototype.extend = function (other_array) {
+  other_array.forEach(function (v) {
+    this.push(v);
+  }, this);
+};
+
+String.prototype.startswith = function (prefix) {
+  return this.indexOf(prefix) === 0;
+};
+
+Number.prototype.count_decimals = function () {
+  if (isFinite(this) && Math.floor(this) === this) return 0; // is integer
+  var repr = this.toString();
+  if (repr.indexOf('.') == -1) return 0;
+  return repr.split('.')[1].length || 0;
+};
+
+/**
+ * Auxiliary methods relevant for DOM
+ */
+
+// NB notifications interpolate server-provided text (e.g. data.error):
+// besides <script>, drop the other auto-executing vectors (event handler
+// attributes, embedded documents) and javascript: URLs, except the one the
+// app itself uses in its messages ("please try to reload")
+const UNSAFE_ELEMENTS = 'script, iframe, frame, frameset, object, embed, base, meta, link';
+const ALLOWED_JS_URL = 'javascript:location.reload()';
+
+wmgui.clean = function (str) {
+  const tpl = document.createElement('template');
+  tpl.innerHTML = (str || '').bold();
+  tpl.content.querySelectorAll(UNSAFE_ELEMENTS).forEach(function (el) {
+    el.remove();
+  });
+  tpl.content.querySelectorAll('*').forEach(function (el) {
+    Array.prototype.slice.call(el.attributes).forEach(function (attr) {
+      const name = attr.name.toLowerCase();
+      const value = attr.value.replace(/[\s\u0000-\u001f]+/g, '').toLowerCase();
+      if (
+        name.startsWith('on') ||
+        ((name === 'href' || name === 'src' || name === 'action' ||
+          name === 'formaction' || name === 'xlink:href') &&
+          value.startsWith('javascript:') &&
+          attr.value.trim() !== ALLOWED_JS_URL)
+      )
+        el.removeAttribute(attr.name);
+    });
+  });
+  const first = tpl.content.firstElementChild;
+  return first ? first.innerHTML : tpl.innerHTML;
+};
+
+wmgui.cancel_event = function (evt) {
+  evt = evt || window.event;
+  if (evt.cancelBubble) evt.cancelBubble = true;
+  else {
+    if (evt.stopPropagation) evt.stopPropagation();
+    if (evt.preventDefault) evt.preventDefault();
+  }
+};
+
+wmgui.debounce = function (func, wait, immediate) {
+  var timeout;
+
+  return function () {
+    var context = this,
+      args = arguments;
+    var later = function () {
+      timeout = null;
+      if (!immediate) func.apply(context, args);
+    };
+    var callNow = immediate && !timeout;
+    clearTimeout(timeout);
+    timeout = setTimeout(later, wait);
+    if (callNow) func.apply(context, args);
+  };
+};
+
+wmgui.is_inview = function (element) {
+  if (!element) return false;
+
+  var pageTop = window.scrollY,
+    pageBottom = pageTop + window.innerHeight,
+    elementTop = element.getBoundingClientRect().top + pageTop,
+    elementBottom = elementTop + element.offsetHeight;
+
+  return elementTop <= pageBottom && elementBottom >= pageTop;
+};
+
+wmgui.show_preloader = function () {
+  show($('#preloader'));
+};
+
+wmgui.hide_preloader = function () {
+  hide($('#preloader'));
+};
+
+wmgui.loadCSS = function (href, before, media, attributes) {
+  // Arguments:
+  // `href` [REQUIRED] is the URL for your CSS file.
+  // `before` [OPTIONAL] is the element the script should use as a reference for injecting our stylesheet <link> before
+  // By default, loadCSS attempts to inject the link after the last stylesheet or script in the DOM. However, you might desire a more specific location in your document.
+  // `media` [OPTIONAL] is the media type or query of the stylesheet. By default it will be 'all'
+  // `attributes` [OPTIONAL] is the Object of attribute name/attribute value pairs to set on the stylesheet's DOM Element.
+  var ss = document.createElement('link');
+  var ref;
+
+  if (before) {
+    ref = before;
+  } else {
+    var refs = (document.body || document.getElementsByTagName('head')[0])
+      .childNodes;
+    ref = refs[refs.length - 1];
+  }
+
+  var sheets = document.styleSheets;
+  // Set any of the provided attributes to the stylesheet DOM Element.
+  if (attributes) {
+    for (var attributeName in attributes) {
+      if (attributes.hasOwnProperty(attributeName)) {
+        ss.setAttribute(attributeName, attributes[attributeName]);
+      }
+    }
+  }
+  ss.rel = 'stylesheet';
+  ss.href = href;
+  // temporarily set media to something inapplicable to ensure it'll fetch without blocking render
+  ss.media = 'only x';
+
+  // wait until body is defined before injecting link. This ensures a non-blocking load in IE11.
+  function ready(cb) {
+    if (document.body) {
+      return cb();
+    }
+    setTimeout(function () {
+      ready(cb);
+    });
+  }
+  // Inject link
+  // Note: the ternary preserves the existing behavior of "before" argument, but we could choose to change the argument to "after" in a later release and standardize on ref.nextSibling for all refs
+  // Note: `insertBefore` is used instead of `appendChild`, for safety re: http://www.paulirish.com/2011/surefire-dom-element-insertion/
+  ready(function () {
+    ref.parentNode.insertBefore(ss, before ? ref : ref.nextSibling);
+  });
+
+  // A method (exposed on return object for external use) that mimics onload by polling document.styleSheets until it includes the new sheet.
+  var onloadcssdefined = function (cb) {
+    var resolvedHref = ss.href;
+    var i = sheets.length;
+    while (i--) {
+      if (sheets[i].href === resolvedHref) {
+        return cb();
+      }
+    }
+    setTimeout(function () {
+      onloadcssdefined(cb);
+    });
+  };
+
+  function loadCB() {
+    if (ss.addEventListener) {
+      ss.removeEventListener('load', loadCB);
+    }
+    ss.media = media || 'all';
+  }
+
+  // once loaded, set link's media back to `all` so that the stylesheet applies once it loads
+  if (ss.addEventListener) {
+    ss.addEventListener('load', loadCB);
+  }
+  ss.onloadcssdefined = onloadcssdefined;
+  onloadcssdefined(loadCB);
+  return ss;
+};
+
+/**
+ * Domain subject definitions
+ */
+
+wmgui.most_frequent_els = [
+  'O',
+  'Si',
+  'Al',
+  'Fe',
+  'Ca',
+  'Na',
+  'Mg',
+  'K',
+  'Ti',
+  'H',
+  'Cl',
+  'S',
+  'Br',
+  'C',
+];
+
+// just less probable than the *most_frequent_els*
+wmgui.probable_els = wmutils.periodic_elements_cased.slice(0, 55);
+wmgui.probable_els.splice(53, 1); // Xe
+wmgui.probable_els.splice(42, 1); // Tc
+wmgui.probable_els.splice(35, 1); // Kr
+wmgui.probable_els.splice(17, 1); // Ar
+wmgui.probable_els.splice(9, 1); // Ne
+wmgui.probable_els.splice(1, 1); // He
+
+wmgui.classes_groups = [
+  'transitional',
+  'chalcogen',
+  'rare earth',
+  'lanthanoid',
+  'metalloid',
+  'alkaline',
+  'halogen',
+  'pnictogen',
+  'alkali',
+  'actinoid',
+]; // NB noble gas
+
+wmgui.classes_families = [
+  'metal',
+  'intermetallic',
+  'oxide',
+  'conductor',
+  'nonmetal',
+  'antiferromagnet',
+  'ferromagnet',
+  'semiconductor',
+  'intermediate valence',
+  'superconductor',
+  'close-packed',
+  'perovskite',
+  'scheelite',
+  'high-tc superconductor',
+  'silicide',
+  'diamagnetic',
+  'cuprate',
+  'ferrimagnet',
+  'sulfide',
+  'spin glass',
+  'rocksalt',
+  'ferroelectric',
+  'frank-kasper',
+  'selenide',
+  'adamantane',
+  'paramagnet',
+  'friauf-laves',
+  'boride',
+  'semimetal',
+  'pauli paramagnet',
+  'fluoride',
+  'telluride',
+  'hydrate',
+  'carbide',
+  'ionic conductor',
+  'chloride',
+  'spinel',
+  'intercalation',
+  'fluorite',
+  'hard magnet',
+  'arsenide',
+  'ferroelastic',
+  'orthophosphate',
+  'phosphide',
+  'nitride',
+  'piezoelectric',
+  'antiferroelectric',
+  'hydroxide',
+  'silicate',
+  'organic',
+  'hydride',
+  'iodide',
+  'bromide',
+  'charge-density wave state',
+  'spin-density wave state',
+  'ruddlesden-popper',
+  'sulfate',
+  'superionic conductor',
+  'pyrochlore',
+  'orthosilicate',
+  'borocarbide',
+  'molybdate',
+  'borate',
+  'garnet',
+  'cyanide',
+  'thermoelectric',
+  'helimagnet',
+  'vanadate',
+  'zeolite',
+  'birefringent',
+  'deuteride',
+  'orthoborate',
+  'van vleck paramagnet',
+  'mictomagnet',
+  'carbonate',
+  'phosphate',
+  'chevrel',
+  'gamma-brass',
+  'polaron conductor',
+  'nasicon',
+  'luminescent',
+  'tungstate',
+  'arsenate',
+  'nitrate',
+  'radioactive',
+];
+
+wmgui.most_frequent_classes = [
+  'metal',
+  'oxide',
+  'conductor',
+  'nonmetal',
+  'antiferromagnet',
+  'semiconductor',
+  'perovskite',
+  'scheelite',
+  'sulfide',
+  'paramagnet',
+  'ab initio literature',
+  'hydrate',
+  'chloride',
+  'spinel',
+  'fluorite',
+  'orthophosphate',
+  'silicate',
+  'machine learning',
+  'ab initio calculations',
+];
+
+wmgui.most_frequent_props = [
+  'magnetism',
+  'crystal structure',
+  'electronic properties',
+  'mechanical properties',
+  'thermodynamics',
+  'phase transitions',
+  'optical properties',
+  'superconductivity',
+  'enthalpy of formation',
+  'heat capacity',
+  'thermal expansion',
+  'Seebeck coefficient',
+]; // TODO cell parameters
+
+wmgui.most_frequent_lats = [
+  'cubic',
+  'tetragonal',
+  'orthorhombic',
+  'monoclinic',
+];
+
+wmgui.most_frequent_formulae = [
+  'Ag2S',
+  'Ag2Se',
+  'Ag2Te',
+  'Ag3Sn',
+  'AgBr',
+  'AgCe',
+  'AgCl',
+  'AgCu4Yb',
+  'AgGaS2',
+  'AgGaSe2',
+  'AgI',
+  'AgYbGe',
+  'Al2O3',
+  'Al4C3',
+  'AlAs',
+  'AlF3',
+  'AlN',
+  'AlP',
+  'AlSb',
+  'Al[PO4]',
+  'As2S3',
+  'As2Se3',
+  'As2Te3',
+  'AsS',
+  'AuSn',
+  'AuTe2',
+  'B13C2',
+  'Ba2Cu2YFeO7',
+  'Ba2Cu3DyO7',
+  'Ba2Cu3ErO7',
+  'Ba2Cu3EuO7',
+  'Ba2Cu3GdO7',
+  'Ba2Cu3HoO7',
+  'Ba2Cu3LaO7',
+  'Ba2Cu3NdO7',
+  'Ba2Cu3PrO7',
+  'Ba2Cu3SmO7',
+  'Ba2Cu3TmO7',
+  'Ba2Cu3YO6',
+  'Ba2Cu3YO7',
+  'Ba2Cu3YbO7',
+  'Ba2Cu4YO8',
+  'Ba2CuTl2O6',
+  'Ba2MoFeO6',
+  'Ba4Ga8Ge15',
+  'Ba4Ga8Sn15',
+  'BaBiO3',
+  'BaCl2',
+  'BaF2',
+  'BaFe12O19',
+  'BaFe2As2',
+  'BaIrO3',
+  'BaLaMn2O6',
+  'BaMnF4',
+  'BaO',
+  'BaPbO3',
+  'BaRuO3',
+  'BaTiO3',
+  'BaVS3',
+  'BaYCo4O7',
+  'BaZrO3',
+  'Be13U',
+  'BeO',
+  'Bi2O3',
+  'Bi2S3',
+  'Bi2Se3',
+  'Bi2Te3',
+  'C60',
+  'Ca2ReFeO6',
+  'Ca2RuO4',
+  'Ca3Co2O6',
+  'Ca3Co4O9',
+  'CaAl2',
+  'CaAlSi',
+  'CaCu3Ti4O12',
+  'CaF2',
+  'CaFe2As2',
+  'CaIrO3',
+  'CaMnO3',
+  'CaO',
+  'CaRuO3',
+  'CaS',
+  'CaSi2',
+  'CaTiO3',
+  'Ca[CO3]',
+  'Ca[WO4]',
+  'Cd2Nb2O7',
+  'Cd3As2',
+  'CdAs2',
+  'CdCr2S4',
+  'CdCr2Se4',
+  'CdF2',
+  'CdI2',
+  'CdO',
+  'CdS',
+  'CdSb',
+  'CdSe',
+  'CdTe',
+  'Ce2Fe17',
+  'Ce3Al11',
+  'Ce3Sn',
+  'CeAl2',
+  'CeAl3',
+  'CeB6',
+  'CeBi',
+  'CeCo2',
+  'CeCo5',
+  'CeCoGe3',
+  'CeCoIn5',
+  'CeFe2',
+  'CeFe4Sb12',
+  'CeIn3',
+  'CeIrSi3',
+  'CeMn2Si2',
+  'CeNi',
+  'CeNi2Ge2',
+  'CeNi2Si2',
+  'CeNi2Sn2',
+  'CeNiGe2',
+  'CeNiSn',
+  'CeO2',
+  'CeP',
+  'CePd2Al3',
+  'CePd2Si2',
+  'CePd3',
+  'CePdSn',
+  'CePt2Si2',
+  'CePt3Si',
+  'CePtSn',
+  'CeRh2Si2',
+  'CeRh3B2',
+  'CeRhAs',
+  'CeRhGe',
+  'CeRhIn5',
+  'CeRhSb',
+  'CeRhSn',
+  'CeRu2',
+  'CeRu2Ge2',
+  'CeRu2Si2',
+  'CeRuRhSi2',
+  'CeSb',
+  'CeSi2',
+  'Co2Al9',
+  'Co2B',
+  'Co2Si',
+  'Co3O4',
+  'Co3[VO4]2',
+  'CoAl',
+  'CoGa',
+  'CoO',
+  'CoPt',
+  'CoS2',
+  'CoSb3',
+  'CoSi',
+  'CoSi2',
+  'Cr23C6',
+  'Cr2FeS4',
+  'Cr2O3',
+  'Cr2S3',
+  'Cr3C2',
+  'Cr3Si',
+  'Cr7Al45',
+  'Cr7C3',
+  'CrAs',
+  'CrB2',
+  'CrN',
+  'CrO2',
+  'CrSi2',
+  'CrTe',
+  'Cs2ZnI4',
+  'CsBr',
+  'CsC8',
+  'CsCl',
+  'CsI',
+  'Cu2Ce',
+  'Cu2CeSi2',
+  'Cu2GdSi2',
+  'Cu2Nd',
+  'Cu2O',
+  'Cu2S',
+  'Cu2Se',
+  'Cu2Te',
+  'Cu2UGe2',
+  'Cu2USi2',
+  'Cu2Y',
+  'Cu2Y2O5',
+  'Cu2YbSi2',
+  'Cu2ZnSnS4',
+  'Cu33Al17',
+  'Cu3As',
+  'Cu3Au',
+  'Cu3Sb',
+  'Cu3Sn',
+  'Cu41Sn11',
+  'Cu4CeAl',
+  'Cu4YbIn',
+  'Cu5U',
+  'Cu5Zn8',
+  'Cu6Ce',
+  'Cu9Al4',
+  'CuAl',
+  'CuAl2',
+  'CuAu',
+  'CuBr',
+  'CuCl',
+  'CuCr2Se4',
+  'CuCrO2',
+  'CuFe2O4',
+  'CuFeO2',
+  'CuGaS2',
+  'CuGaSe2',
+  'CuGd2O4',
+  'CuGeO3',
+  'CuI',
+  'CuInS2',
+  'CuInSe2',
+  'CuInTe2',
+  'CuIr2S4',
+  'CuLa2O4',
+  'CuNd2O4',
+  'CuO',
+  'CuPr2O4',
+  'CuS',
+  'CuTi2',
+  'CuV2S4',
+  'CuZn',
+  'Dy2Fe14B',
+  'Dy2Fe17',
+  'DyAl2',
+  'DyCo2',
+  'DyFe2',
+  'DyFe4Al8',
+  'DyMn2',
+  'DyMn2O5',
+  'DyMo2Fe10',
+  'DyTiFe11',
+  'Dy[VO4]',
+  'Er2Fe14B',
+  'Er2Fe17',
+  'Er2Fe17C3',
+  'Er5Si4',
+  'ErAl2',
+  'ErCo2',
+  'ErFe2',
+  'ErFeO3',
+  'ErMn2O5',
+  'ErNi2B2C',
+  'ErRh4B4',
+  'ErTiFe11',
+  'Eu2O3',
+  'Eu4Ga8Ge15',
+  'EuB6',
+  'EuFe2As2',
+  'EuFe4Sb12',
+  'EuMo6S8',
+  'EuO',
+  'EuS',
+  'EuSe',
+  'EuTe',
+  'Fe2As',
+  'Fe2B',
+  'Fe2CoO4',
+  'Fe2NiO4',
+  'Fe2O3',
+  'Fe2P',
+  'Fe3Al',
+  'Fe3C',
+  'Fe3Ga',
+  'Fe3O4',
+  'Fe3P',
+  'Fe3Si',
+  'Fe4Al13',
+  'Fe4N',
+  'Fe5Si3',
+  'FeAl',
+  'FeAs',
+  'FeB',
+  'FeBiO3',
+  'FeCl2',
+  'FeCo',
+  'FeCo2Si',
+  'FeGaO3',
+  'FeGe',
+  'FeGe2',
+  'FeNi3',
+  'FeO',
+  'FeP',
+  'FePt3',
+  'FeRh',
+  'FeS',
+  'FeS2',
+  'FeSb2',
+  'FeSe',
+  'FeSi',
+  'FeSi2',
+  'Ga2O3',
+  'GaAs',
+  'GaN',
+  'GaP',
+  'GaS',
+  'GaSb',
+  'GaSe',
+  'GaTe',
+  'Ga[PO4]',
+  'Gd2Fe14B',
+  'Gd2Fe17',
+  'Gd2O3',
+  'Gd2[MoO4]3',
+  'Gd3Co',
+  'Gd5Ge4',
+  'GdAl2',
+  'GdB6',
+  'GdCo2',
+  'GdCo5',
+  'GdFe2',
+  'GdFe3[BO3]4',
+  'GdMn2',
+  'GdMn2Ge2',
+  'GdMnO3',
+  'GdN',
+  'GdNi2',
+  'GdSi2',
+  'GdTiFe11',
+  'GeO2',
+  'GeS',
+  'GeSe',
+  'GeSe2',
+  'GeTe',
+  'H2',
+  'H2Cs[PO4]',
+  'H2K[PO4]',
+  'H2O',
+  'H2Rb[PO4]',
+  'H3Na[SeO3]2',
+  'HK[CO3]',
+  'HfB2',
+  'HfC',
+  'HfO2',
+  'HgCr2S4',
+  'HgCr2Se4',
+  'HgI2',
+  'HgS',
+  'HgSe',
+  'HgTe',
+  'Ho2Fe14B',
+  'HoAl2',
+  'HoCo2',
+  'HoFe2',
+  'HoMn2O5',
+  'HoMnO3',
+  'HoNi2',
+  'HoNi2B2C',
+  'In2O3',
+  'In2S3',
+  'In2Se3',
+  'InAs',
+  'InBi',
+  'InN',
+  'InP',
+  'InSb',
+  'InSe',
+  'InTe',
+  'K2[SeO4]',
+  'K3Mo10O30',
+  'K3Na[SeO4]2',
+  'K3[C60]',
+  'KBr',
+  'KC24',
+  'KC8',
+  'KCl',
+  'KLi[SO4]',
+  'KMnF3',
+  'KNbO3',
+  'KOs2O6',
+  'KTaO3',
+  'KTi[PO4]O',
+  'K[CN]',
+  'La2NiO4',
+  'La2O3',
+  'La3Ga5SiO14',
+  'La3S4',
+  'LaAl2',
+  'LaAlO3',
+  'LaB6',
+  'LaCoO3',
+  'LaCrO3',
+  'LaF3',
+  'LaFe11Si2',
+  'LaFe4Sb12',
+  'LaFeAsO',
+  'LaFeO3',
+  'LaGaO3',
+  'LaH3',
+  'LaMn2Ge2',
+  'LaMnO3',
+  'LaNi5',
+  'LaNiO3',
+  'LaTiO3',
+  'LaVO3',
+  'Li2Pd3B',
+  'Li2S',
+  'Li3N',
+  'LiAl',
+  'LiBr',
+  'LiCl',
+  'LiCoO2',
+  'LiF',
+  'LiFe[PO4]',
+  'LiH',
+  'LiMn2O4',
+  'LiNbO3',
+  'LiNiO2',
+  'LiTaO3',
+  'LiTi2O4',
+  'LiV2O5',
+  'LiVO2',
+  'LiYF4',
+  'Lu2Fe17',
+  'Lu5Ir4Si10',
+  'LuNi2B2C',
+  'Mg17Al12',
+  'Mg24Y5',
+  'Mg28Al45',
+  'Mg2Si',
+  'Mg2Sn',
+  'Mg2TiO4',
+  'Mg2[SiO4]',
+  'MgAl2O4',
+  'MgB2',
+  'MgCu2',
+  'MgF2',
+  'MgFe2O4',
+  'MgFeAlO4',
+  'MgFe[SiO4]',
+  'MgO',
+  'MgSiO3',
+  'MgZn2',
+  'Mn11Al15',
+  'Mn3C',
+  'Mn3O4',
+  'Mn5Si3',
+  'MnAl6',
+  'MnAs',
+  'MnBi',
+  'MnF2',
+  'MnFe2O4',
+  'MnNi2Ga',
+  'MnNi2In',
+  'MnNi2Sb',
+  'MnNi2Sn',
+  'MnNiSb',
+  'MnO',
+  'MnO2',
+  'MnP',
+  'MnS',
+  'MnSi',
+  'MnTe',
+  'Mo2S3',
+  'Mo3Al8',
+  'Mo4O11',
+  'Mo6PbS8',
+  'Mo7Ni7',
+  'MoB2',
+  'MoO3',
+  'MoS2',
+  'MoSi2',
+  'NaBr',
+  'NaCl',
+  'NaF',
+  'NaI',
+  'NaNbO3',
+  'Na[NO2]',
+  'Na[NO3]',
+  'Nb2Al',
+  'Nb3FeSe6',
+  'Nb3Ge',
+  'Nb3Si',
+  'Nb3Sn',
+  'Nb5Si3',
+  'Nb7Ni6',
+  'NbAl3',
+  'NbB2',
+  'NbC',
+  'NbCr2',
+  'NbFe2',
+  'NbH',
+  'NbN',
+  'NbNi3',
+  'NbO2',
+  'NbSe2',
+  'NbSe3',
+  'NbSi2',
+  'Nd2Co14B',
+  'Nd2Fe13CoB',
+  'Nd2Fe14B',
+  'Nd2Fe17',
+  'Nd2O3',
+  'Nd6Fe11Al3',
+  'NdAl2',
+  'NdB6',
+  'NdCo2',
+  'NdCo5',
+  'NdFeAsO',
+  'NdFeO3',
+  'NdMn2Ge2',
+  'NdMnFeGe2',
+  'NdMnO3',
+  'NdMo2Fe10',
+  'NdNiO3',
+  'NdTiFe11',
+  'NdTiO3',
+  'NdV2Fe10',
+  'Ni2Al3',
+  'Ni2B',
+  'Ni2Si',
+  'Ni31Si12',
+  'Ni3Al',
+  'Ni3B',
+  'Ni3Si',
+  'Ni3[VO4]2',
+  'Ni4B3',
+  'NiAl',
+  'NiAl3',
+  'NiO',
+  'NiS',
+  'NiS2',
+  'NiSb',
+  'NiSi',
+  'NiSi2',
+  'NpPd5Al2',
+  'O2',
+  'PbF2',
+  'PbI2',
+  'PbO',
+  'PbO2',
+  'PbS',
+  'PbSe',
+  'PbTe',
+  'Pb[WO4]',
+  'Pd2Si',
+  'PdAl',
+  'PdH',
+  'Pr2Fe14B',
+  'Pr2O3',
+  'PrAl2',
+  'PrB6',
+  'PrCo5',
+  'PrFe2Ge2',
+  'PrFe4P12',
+  'PrFeAsO',
+  'PrMn2Ge2',
+  'PrMnO3',
+  'PrNi2Si2',
+  'PrNi5',
+  'PrOs4Sb12',
+  'Rb2ZnBr4',
+  'Rb2ZnCl4',
+  'Rb3[C60]',
+  'RbBr',
+  'RbCl',
+  'RbF',
+  'RbI',
+  'RbLi[SO4]',
+  'Rb[C60]',
+  'ReO3',
+  'RuAl2',
+  'Sb2S3',
+  'Sb2Se3',
+  'Sb2Te3',
+  'SbSI',
+  'Sc2[WO4]3',
+  'ScAl3',
+  'Si3N4',
+  'SiC',
+  'SiO2',
+  'Sm2Co17',
+  'Sm2Fe17',
+  'Sm2Fe17N3',
+  'Sm2O3',
+  'SmB6',
+  'SmCo5',
+  'SmFeAsO',
+  'SmMn2Ge2',
+  'SmS',
+  'SmTiFe11',
+  'SnO2',
+  'SnS',
+  'SnS2',
+  'SnSe',
+  'SnSe2',
+  'SnTe',
+  'Sr14Cu24O41',
+  'Sr2CuBi2O6',
+  'Sr2LaMn2O7',
+  'Sr2MoFeO6',
+  'Sr2RuO4',
+  'SrAl4',
+  'SrCoO3',
+  'SrCuLaO4',
+  'SrF2',
+  'SrFe12O19',
+  'SrFe2As2',
+  'SrFeO3',
+  'SrLaMnO4',
+  'SrLaNiO4',
+  'SrMnO3',
+  'SrNb2Bi2O9',
+  'SrO',
+  'SrRuO3',
+  'SrTa2Bi2O9',
+  'SrTiO3',
+  'SrZrO3',
+  'TaC',
+  'TaS2',
+  'TaS3',
+  'TaSe2',
+  'Tb3Fe5O12',
+  'TbFe2',
+  'TbMn2',
+  'TbMn2O5',
+  'TbMnO3',
+  'TbNi2Si2',
+  'TbRh2Si2',
+  'TbTiFe11',
+  'TeO2',
+  'ThO2',
+  'Ti2Ni',
+  'Ti2O3',
+  'Ti3Al',
+  'Ti3Bi4O12',
+  'Ti5Si3',
+  'TiAl',
+  'TiAl2',
+  'TiAl3',
+  'TiB2',
+  'TiC',
+  'TiCo',
+  'TiCo2Al',
+  'TiCo2Sn',
+  'TiCoSb',
+  'TiCr2',
+  'TiFe',
+  'TiFe2',
+  'TiFeO3',
+  'TiH2',
+  'TiN',
+  'TiNi',
+  'TiNi3',
+  'TiO',
+  'TiO2',
+  'TiPbO3',
+  'TiS2',
+  'TiSe2',
+  'TiSi2',
+  'TiVO3',
+  'Tl2S',
+  'Tl5Se3',
+  'Tl5Te3',
+  'TlBr',
+  'TlCl',
+  'TlGaSe2',
+  'TlI',
+  'TlInS2',
+  'TlS',
+  'TlSe',
+  'TlTe',
+  'Tm2Fe14B',
+  'TmSe',
+  'TmTe',
+  'U2C3',
+  'U2Ni2Sn',
+  'U2Pt2In',
+  'U6Fe',
+  'UAl2',
+  'UAs',
+  'UC2',
+  'UCo2Ge2',
+  'UCoAl',
+  'UFe10Si2',
+  'UFe2',
+  'UFe4Al8',
+  'UGe2',
+  'UMn2',
+  'UNi2Al3',
+  'UNiAl',
+  'UNiGa',
+  'UNiSn',
+  'UO2',
+  'UPd2Al3',
+  'UPd3',
+  'UPdSn',
+  'UPt3',
+  'UPtGe',
+  'URu2Si2',
+  'USb',
+  'UTe',
+  'V2MnO4',
+  'V2O3',
+  'V2O5',
+  'V3Ga',
+  'V3Ge',
+  'V3O5',
+  'V3Si',
+  'V4O7',
+  'V5Al8',
+  'V5O9',
+  'V6O11',
+  'V6O13',
+  'V7O13',
+  'VAl3',
+  'VFe2Al',
+  'VO2',
+  'VSe2',
+  'W2C',
+  'WBi2O6',
+  'WMnO4',
+  'WO3',
+  'WSi2',
+  'Y2Co17',
+  'Y2Fe14B',
+  'Y2Fe17',
+  'Y2O3',
+  'Y3Al5O12',
+  'Y3Fe5O12',
+  'YAl2',
+  'YAl3',
+  'YB6',
+  'YCo2',
+  'YCo3',
+  'YCo4B',
+  'YCo5',
+  'YFe2',
+  'YFe4Al8',
+  'YH3',
+  'YMn2',
+  'YMnO3',
+  'YMo2Fe10',
+  'YNi2B2C',
+  'YTiFe11',
+  'YTiO3',
+  'YV2Fe10',
+  'YVO3',
+  'Yb2O3',
+  'Yb4As3',
+  'YbAl3',
+  'YbFe4Sb12',
+  'YbMnO3',
+  'YbRh2Si2',
+  'Zn10Fe3',
+  'Zn2Zr',
+  'Zn3As2',
+  'Zn3P2',
+  'ZnCr2O4',
+  'ZnCr2Se4',
+  'ZnF2',
+  'ZnFe2O4',
+  'ZnGeP2',
+  'ZnO',
+  'ZnS',
+  'ZnSe',
+  'ZnSiP2',
+  'ZnTe',
+  'Zr2Ni',
+  'ZrAl2',
+  'ZrAl3',
+  'ZrB2',
+  'ZrC',
+  'ZrCo2',
+  'ZrCr2',
+  'ZrFe2',
+  'ZrMn2',
+  'ZrMo2',
+  'ZrN',
+  'ZrNiSn',
+  'ZrO2',
+  'ZrPbO3',
+  'ZrV2',
+  'Zr[WO4]2',
+  '[NH4]2ZnCl4',
+];
+
+wmgui.most_frequent_anonymous = [
+  'AB',
+  'AB2',
+  'ABC3',
+  'ABC',
+  'ABC2',
+  'ABCD3',
+  'AB3',
+  'AB2C4',
+  'AB2C2',
+  'ABC4',
+  'ABC2D6',
+  'ABCD4',
+  'A2B3',
+  'ABC2D4',
+  'ABCD',
+  'ABCD2',
+  'AB2C3',
+  'AB2C6',
+  'AB2C5',
+  'AB2C3D7',
+  'A3B4',
+  'A3B5',
+  'ABC2D2',
+  'A2B2C7',
+  'AB3C5',
+  'ABC2D5',
+  'ABC2D7',
+  'AB5',
+  'AB3C6',
+  'AB3C4',
+  'ABC5',
+  'ABC2D8',
+  'AB3C3',
+  'AB4',
+  'AB6',
+  'AB2C2D7',
+  'AB4C12',
+  'A2B17',
+  'AB3C4D12',
+  'ABCD5',
+  'ABCD6',
+  'A2B3C4',
+  'ABC3D7',
+  'A2B3C5',
+  'AB2C10',
+  'A2B2C5',
+  'AB2C2D6',
+  'AB2C3D8',
+  'AB2C8',
+  'ABC2D3',
+  'A2B5',
+  'AB2C3D6',
+  'AB4C8',
+  'ABC6',
+  'AB2C2D8',
+  'AB6C6',
+  'AB3C7',
+  'A4B5',
+];
+
+// FIXME? this concerns MPDS S-numerics:
+//if (props_fgrs) props_fgrs.extend(['c--a', 'a--b', 'b--c', 'volume', 'density', 'alat', 'blat', 'clat']);
+//if (props_ref) props_ref.extend(  ['c--a', 'a--b', 'b--c', 'volume', 'density', 'alat', 'blat', 'clat']);
+
+/**
+ * Methods
+ */
+
+wmgui.get_random_term = function (sequence) {
+  return sequence[Math.floor(Math.random() * sequence.length)];
+};
+
+wmgui.is_wyckoff_position = function (input) {
+  return /^[1-9]/.test(input.trim());
+};
+
+/**
+ * Generate random sequences
+ */
+
+wmgui.get_realistic = function (facet, cur_nlen) {
+  var term;
+
+  if (facet == 'elements') {
+    var i = 0,
+      els = [],
+      prob_arity = [2, 3], // 4 is improbable
+      cur_nlen = cur_nlen || wmgui.get_random_term(prob_arity);
+
+    while (i < cur_nlen) {
+      var el;
+      if (i < 2) el = wmgui.get_random_term(wmgui.probable_els);
+      else el = wmgui.get_random_term(wmgui.most_frequent_els);
+      if (els.indexOf(el) > -1) continue;
+      els.push(el);
+      i++;
+    }
+    term = els.join('-');
+  } else if (facet == 'formulae') {
+    term = wmgui.get_random_term(wmgui.most_frequent_formulae);
+  } else if (facet == 'anonymous') {
+    term = wmgui.get_random_term(wmgui.most_frequent_anonymous);
+  } else if (facet == 'props') {
+    term = wmgui.get_random_term(wmgui.most_frequent_props);
+  } else if (facet == 'classes') {
+    term = wmgui.get_random_term(wmgui.classes_families);
+  } else if (facet == 'lattices') {
+    term = wmgui.get_random_term(wmgui.most_frequent_lats);
+  } else
+    return wmgui.get_realistic(
+      ['elements', 'formulae', 'props', 'classes', 'lattices'][
+        Math.floor(Math.random() * 5)
+      ],
+    );
+
+  return term;
+};
+
+/**
+ * Generate random sequences
+ */
+
+wmgui.get_interesting = function (scene) {
+  var scenarios = [1, 2, 3, 4, 5, 6, 7, 8],
+    scene = scene || wmgui.get_random_term(scenarios),
+    result = { text: '', terms: [], facets: [] };
+
+  if (scene == 1) {
+    // classes-elements, 4% fails
+    result['facets'].extend(['classes', 'elements']);
+    result['terms'].extend([
+      wmgui.get_random_term(wmgui.most_frequent_classes),
+      wmgui.get_realistic('elements', 2),
+    ]);
+    result['text'] += result['terms'][0] + ' ' + result['terms'][1];
+  } else if (scene == 2) {
+    // classes-classes, 4.5% fails
+    result['facets'].extend(['classes', 'classes']);
+    result['terms'].extend([
+      wmgui.get_random_term(wmgui.classes_groups),
+      wmgui.get_realistic('classes'),
+    ]);
+    result['text'] += result['terms'][0] + ' group, ' + result['terms'][1];
+  } else if (scene == 3) {
+    // formulae-lattices, 1% fails
+    result['facets'].extend(['formulae', 'lattices']);
+    result['terms'].extend([
+      wmgui.get_realistic('formulae'),
+      wmgui.get_realistic('lattices'),
+    ]);
+    result['text'] +=
+      result['terms'][0] + ' ' + result['terms'][1] + ' crystal';
+  } else if (scene == 4) {
+    // props-classes, always correct
+    result['facets'].extend(['props', 'classes']);
+    result['terms'].extend([
+      wmgui.get_realistic('props'),
+      wmgui.get_realistic('classes'),
+    ]);
+    result['text'] += result['terms'][0] + ' for ' + result['terms'][1];
+    if (!result['text'].endsWith('d') && !result['text'].endsWith('s'))
+      result['text'] += 's';
+  } else if (scene == 5) {
+    // classes-lattices, 3% fails
+    result['facets'].extend(['classes', 'lattices']);
+    result['terms'].extend([
+      wmgui.get_realistic('classes'),
+      wmgui.get_realistic('lattices'),
+    ]);
+    result['text'] +=
+      result['terms'][0] + ', ' + result['terms'][1] + ' crystal';
+  } else if (scene == 6) {
+    // elements-lattices, 3% fails
+    result['facets'].extend(['elements', 'lattices']);
+    result['terms'].extend([
+      wmgui.get_realistic('elements'),
+      wmgui.get_realistic('lattices'),
+    ]);
+    result['text'] +=
+      result['terms'][0] + ', ' + result['terms'][1] + ' crystal';
+  } else if (scene == 7) {
+    // props and anonymous formulae
+    result['facets'].extend(['props', 'formulae']);
+    result['terms'].extend([
+      wmgui.get_realistic('props'),
+      wmgui.get_realistic('anonymous'),
+    ]);
+    result['text'] += result['terms'][0] + ' ' + result['terms'][1];
+  } else {
+    // props-formulae, 4% fails
+    result['facets'].extend(['props', 'formulae']);
+    result['terms'].extend([
+      wmgui.get_realistic('props'),
+      wmgui.get_realistic('formulae'),
+    ]);
+    result['text'] += result['terms'][0] + ' of ' + result['terms'][1];
+  }
+  return result;
+};
+
+/**
+ * Convert formula to HTML
+ */
+
+wmgui.to_formula = function (input) {
+  return input.replace(/\d/g, '<sub>$&</sub>');
+};
+
+/**
+ * Display processing results in HTML
+ */
+
+wmgui.get_interpretation = function (search, facet_names, num_database) {
+  if (!search) search = {};
+
+  var interpret_html = '',
+    cur_nlen = 0;
+
+  for (var k in search) {
+    var val = search[k];
+    if (!facet_names[k] || !val) continue;
+    else if (k == 'formulae') val = wmgui.to_formula(val);
+    else if (k == 'doi' || k == 'sgs') val = decodeURIComponent(val);
+    else if (k == 'elements') {
+      var els = val.split('-');
+      cur_nlen = els.length;
+      val = els
+        .map(function (x) {
+          return x.charAt(0).toUpperCase() + x.slice(1).toLowerCase();
+        })
+        .join(', ');
+    } else if (k == 'classes') {
+      val = val
+        .split(',')
+        .map(function (x) {
+          return x.trim();
+        })
+        .join(', ');
+    } else if (k == 'authors') {
+      val = val
+        .split(',')
+        .map(function (surname) {
+          return surname
+            .trim()
+            .split(' ')
+            .map(function (part) {
+              return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+            })
+            .join(' ');
+        })
+        .join(', ');
+    } else if (k == 'aeatoms') {
+      val = wmutils.parse_aeatoms(val);
+      val = val[0] + '&nbsp;center and ' + val[1] + '&nbsp;as ligands';
+    } else if (k == 'aetypes') {
+      val = val
+        .split(',')
+        .map(function (x) {
+          var parts = x.trim().split('-vertex')[0].split(' '),
+            va = parseInt(parts[parts.length - 1]);
+          return x.replace(/\d{1,2}\-vertex/, 'CN&nbsp;=&nbsp;' + va);
+        })
+        .join(', ');
+    } else if (k == 'wyckoff') {
+      if (wmgui.is_wyckoff_position(val)) {
+        facet_names[k] = 'Wyckoff positions';
+      } else {
+        facet_names[k] = 'Wyckoff sequence';
+        val = val.replace(/\d/g, function (x) {
+          return [
+            '&#x2070;',
+            '&#x00B9;',
+            '&#x00B2;',
+            '&#x00B3;',
+            '&#x2074;',
+            '&#x2075;',
+            '&#x2076;',
+            '&#x2077;',
+            '&#x2078;',
+            '&#x2079;',
+          ][x];
+        });
+      }
+    } else if (k == 'numeric') {
+      var out = '';
+      val.forEach(function (member) {
+        var repr = member[0],
+          units = '';
+
+        if (num_database[repr]) {
+          var decimals = num_database[repr][4]
+            ? Math.abs(Math.log10(num_database[repr][4]))
+            : Math.max(
+                num_database[repr][2].count_decimals(),
+                num_database[repr][3].count_decimals(),
+              );
+          member[2] = Number(member[2]).toFixed(decimals);
+
+          if (num_database[repr][1]) units = '&nbsp;' + num_database[repr][1]; // units
+
+          if (num_database[repr][5]) repr = num_database[repr][5]; // origname
+        }
+        out += repr + ' ' + member[1] + ' ' + member[2] + units + '<br />';
+      });
+      val = out;
+    }
+
+    interpret_html +=
+      '<li class="fct_' +
+      k +
+      '"><span>' +
+      facet_names[k] +
+      '</span><br />' +
+      val +
+      '</li>';
+  }
+
+  if (!search.formulae && !is_empty(search)) {
+    var add_arity_helper = true,
+      arity_helper_html = '',
+      arity_keys = wmutils.arity_keys.slice(1);
+
+    for (var num = 0; num < arity_keys.length; num++) {
+      var value = arity_keys[num];
+
+      if (search.classes && search.classes.indexOf(value) !== -1) {
+        add_arity_helper = false;
+        break;
+      }
+
+      if (cur_nlen - 1 > num) continue;
+
+      if ((cur_nlen < 4 && num > 3) || num > 4) break;
+
+      if (window.location.hash.indexOf('inquiry') > -1) {
+        if (window.location.hash.indexOf('classes=') > -1)
+          var addr = window.location.hash.replace(
+            'classes=',
+            'classes=' + value + ',',
+          );
+        else
+          var addr = window.location.hash.replace(
+            'inquiry/',
+            'inquiry/classes=' + value + '&',
+          );
+      } else var addr = window.location.hash + ' ' + value;
+
+      arity_helper_html +=
+        '<li class="fct_classes" rel="' +
+        addr +
+        '" style="letter-spacing:0.5px;">Show only ' +
+        value.substr(0, value.length - 1) +
+        'ies</li>';
+    }
+    if (add_arity_helper) interpret_html += arity_helper_html;
+  }
+
+  return interpret_html;
+};
+
+/**
+ * Parse MPDS BIBTEX
+ */
+
+wmgui.parse_bib = function (string) {
+  try {
+    var title = string.split('title={')[1].split('},')[0].trim(),
+      authors = string.split('author={')[1].split('},')[0].trim(),
+      journal = string.split('journal={')[1].split('},')[0].trim(),
+      pubyear = string.split('year={')[1].split('},')[0].trim();
+  } catch (error) {
+    console.error('Misformatted BIB, terminating...');
+    var title = '',
+      authors = '',
+      journal = '',
+      pubyear = '';
+  }
+  return [authors, title, journal, pubyear];
+};
diff --git a/src_js/events.js b/src_js/events.js
deleted file mode 100755
index 3fe6e57..0000000
--- a/src_js/events.js
+++ /dev/null
@@ -1,1571 +0,0 @@
-"use strict";
-
-var wmgui = window.wmgui || {};
-
-function register_events(){
-
-    document.querySelector('#ptable_area > ul').addEventListener('click', function(event){
-        var that = event.target;
-        if (!that.hasAttribute('data-pos'))
-            return;
-
-        wmgui.ptable.update_selectize = true;
-        var selected_el = wmgui.ptable.elements[that.getAttribute('data-pos')];
-        select_ptable_el(selected_el, that);
-    });
-
-    var radios = document.querySelectorAll('input[name="ptable_dtypes"]');
-    for (var i = 0; i < radios.length; i++){
-        radios[i].addEventListener('change', function(){
-            if (!this.checked) return;
-            wmgui.ptable.dtypes = this.value;
-            var check = wmgui.multiselects['main'].read();
-            select_ptable_series(check.elements);
-        });
-    }
-
-    $('#search_trigger').click(function(){
-
-        var query = wmgui.multiselects['main'].read(),
-            val = $('#search_field-selectized').val();
-
-        if (val){
-            if (val.endsWith(" ") || val.endsWith(",")) val = val.substr(0, val.length - 1);
-            var parsed = wmutils.guess(val);
-
-            for (var key in parsed){
-                if (key == 'ignored')
-                    continue;
-                else if (query[key] && key == 'elements')
-                    query[key] += '-' + parsed[key];
-                else if (query[key] && key == 'classes')
-                    query[key] += ', ' + parsed[key];
-                else
-                    query[key] = parsed[key];
-            }
-        }
-
-        if (wmgui.search.numeric && !query.numeric){
-            query.numeric = '';
-            wmgui.search.numeric.forEach(function(item){
-                query.numeric += serialize_numeric.apply(this, item); // unpack
-            });
-            delete query.props; // NB to make the numeric results "more clear"
-        }
-
-        if ($.isEmptyObject(query)){
-            wmgui.notify('Sorry, unrecognized input');
-            return false;
-        }
-
-        wmgui.ctx_strict_phases = '';
-        $('#ctx_strict_phases_trigger').prop('checked', true);
-
-        var urlstr = $.param(query);
-        if (window.location.hash == '#inquiry/' + urlstr){
-            // hash-hack FIXME?
-            if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
-            else                         urlstr += '=';
-        }
-        window.location.hash = '#inquiry/' + urlstr;
-        return false;
-    });
-
-    $('#advsearch_do_trigger').click(function(){
-        var curval = '',
-            rest_input = '',
-            query = {};
-
-        $.each(wmgui.simple_facets, function(n, item){
-            curval = $('#advs_fct_' + item).val();
-            if (curval){
-                if (item == "formulae") curval = wmutils.termify_formulae(curval);
-                else if (item == "elements") curval = curval.replaceAll(',', '').replaceAll(' ', '-');
-                else if (item == "doi") curval = curval.replace('http:\/\/dx\.doi\.org\/', '').replace('http:\/\/doi\.org\/', '').trim();
-                else if (item == "codens") curval = wmgui.journal_converter.j2c(curval);
-                query[item] = curval;
-            }
-        });
-
-        $.each(wmgui.multi_facets, function(n, item){
-            curval = wmgui.multiselects[item].read();
-
-            if (curval[item]){
-                curval = curval[item];
-                if (item == "authors") curval = curval.replace(/'/g, '').replaceAll('\\.', ' ').replaceAll('\\b\\w{1}\\b', '').trim();
-                query[item] = curval;
-            }
-            rest_input = $('#advs_fct_' + item + '-selectized').val();
-            if (rest_input){
-                if (query[item])
-                    query[item] += ', ' + rest_input;
-                else
-                    query[item] = rest_input;
-            }
-        });
-
-        if (wmgui.search.numeric){
-            query.numeric = '';
-            wmgui.search.numeric.forEach(function(item){
-                query.numeric += serialize_numeric.apply(this, item); // unpack
-            });
-            delete query.props; // NB to make the numeric results "more clear"
-        }
-
-        if ($.isEmptyObject(query)) return wmgui.notify('Sorry, search is empty');
-
-        wmgui.ctx_strict_phases = '';
-        $('#ctx_strict_phases_trigger').prop('checked', true);
-
-        var urlstr = $.param(query);
-        if (window.location.hash == '#inquiry/' + urlstr){
-            // hash-hack FIXME?
-            if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
-            else                         urlstr += '=';
-        }
-        window.location.hash = '#inquiry/' + urlstr;
-    });
-
-    $('#advsearch_drop_trigger').click(function(){
-
-        $('input.advs_input').val('');
-
-        $.each(wmgui.multi_facets, function(n, item){
-            $('#advs_fct_' + item + '-selectized').val('');
-            wmgui.multiselects[item].clear();
-        });
-
-        $('#aetmap').hide();
-        $('#aet_limit').prop('checked', false);
-
-        destroy_numericbox();
-        delete wmgui.search.numeric;
-        // TODO? delete wmgui.search
-    });
-
-    $('#advsearch_init_trigger').click(function(){
-        $('#advstab_options li').removeClass('working');
-        $('#advstab_options li[rev=advstab_cry]').addClass('working');
-        $('#advstab_cry').show();
-        $('#advstab_main, #advstab_bib').hide();
-        show_advsbox();
-        return false;
-    });
-
-    $('#search_box').on('click', '#legend a', function(){
-        var legend = $(this).text();
-        window.location.hash = '#search/' + encodeURIComponent(legend);
-        return false;
-    });
-
-    $('div.advs_legend > a').click(function(){
-        var that = $(this),
-            legend = that.attr('rel') || that.text(),
-            multiselects = that.parent().data('multiselects');
-
-        if (multiselects){
-            $('#advs_fct_' + multiselects + '-selectized').val('');
-            wmgui.multiselects[multiselects].clear();
-            var obj = {};
-            obj[multiselects] = legend;
-            wmgui.multiselects[multiselects].write(obj);
-            //wmgui.multiselects[multiselects].write({[multiselects]: legend});
-        } else {
-            that.parent().parent().children('input').val(legend).focus();
-        }
-        //if (legend.indexOf('-vertex') !== -1) show_aetmap(legend);
-
-        return false;
-    });
-
-    $('#databrowser, #ptable_results').on('click', 'div.gallery_img', function(){
-        var that = $(this);
-        if (that.attr('rel')){
-            if (wmgui.view_mode === 1 && wmgui.ptable.dtypes > 1){
-                var phid = that.attr('rel');
-
-                wmgui.ptable.dtypes == 2 ?
-                document.querySelector('#ptable_vis > iframe').contentWindow.location.hash = '#' + wmgui.phase_endpoint + '?phid=' + phid + '&struct=1' :
-                document.querySelector('#ptable_vis > iframe').contentWindow.location.replace(get_visavis_url({phid: phid}, 'graph', window.innerHeight - 50));
-
-                $('div.gallery_item.active').removeClass('active');
-                that.parent().addClass('active');
-
-            } else {
-                var path = that.attr('data-path') || "phase_id";
-                window.location.hash = '#' + path + '/' + that.attr('rel');
-            }
-        }
-    });
-
-    $('#databrowser').on('mousedown', 'a.resolve_ref', function(e){
-        var that = $(this),
-            bid = that.attr('rel');
-        $('a.resolve_ref[rel=' + bid + ']').addClass('visited'); // :visited
-        wmgui.bid_history.push(parseInt(bid));
-        window.localStorage.setItem(wmgui.store_bids_key, JSON.stringify(wmgui.bid_history));
-        return true;
-    });
-
-    $('#databrowser').on('click', 'tr.tcell, div.gallery_item', function(){
-        open_context($(this), false);
-    });
-
-    $('#databrowser').on('click', 'span.launch_v', function(e){
-        wmgui.cancel_event(e);
-        var parent_row = $(this).parent().parent();
-        parent_row.removeClass('busy_entry');
-        open_context(parent_row, true);
-    });
-
-    $('#databrowser').on('click', 'a.launch_id', function(e){
-        wmgui.cancel_event(e);
-        var phid_link = $(this).attr('href');
-        if (window.location.hash == phid_link){
-            // hash-hack FIXME?
-            phid_link += '.';
-        }
-        window.location.hash = phid_link;
-        return false;
-    });
-
-    $('#all_polyhedra_content').on('click', 'div.gallery_item', function(){
-        $('#advstab_options li').removeClass('working');
-        $('#advstab_options li[rev=advstab_cry]').addClass('working');
-        $('div.advstab').hide();
-        $('#advstab_cry').show();
-        $('div.modal').hide();
-        $('#advsbox, #overlay').show();
-
-        var term = $(this).attr('rel'),
-            selected_aetypes = (wmgui.multiselects['aetypes'].read()['aetypes'] || "").split(', ');
-        if (selected_aetypes.indexOf(term) == -1)
-            wmgui.multiselects['aetypes'].write({'aetypes': term});
-        show_aetmap(term);
-    });
-
-    $('#aet_limit').click(function(e){
-        var selected_classes = (wmgui.multiselects['classes'].read()['classes'] || "").split(', ');
-
-        if (this.checked){
-            var selected_aetypes = (wmgui.multiselects['aetypes'].read()['aetypes'] || "").split(', ').filter(function(x){ return x }),
-                limit_kwd = wmgui.poly_limits[selected_aetypes.length];
-
-            if (!limit_kwd){
-                wmgui.cancel_event(e);
-                wmgui.notify('Sorry, only up to 3 supported');
-                return false;
-            }
-            if (selected_classes.indexOf(limit_kwd) == -1){
-                wmgui.multiselects['classes'].write({'classes': limit_kwd});
-            }
-
-        } else {
-            var poly_limits = Object.values(wmgui.poly_limits);
-            wmgui.multiselects['classes'].clear();
-            wmgui.multiselects['classes'].write({'classes': selected_classes.filter(function(x){ return poly_limits.indexOf(x) == -1 }).join(', ')});
-        }
-        return true;
-    });
-
-    $('#visualize, #xrpdize').click(function(){
-        close_vibox();
-        launch_db_iframed(this.getAttribute('data-rank'));
-    });
-
-    /*$('#absolidize').click(function(){
-
-        if (!$(this).hasClass('wmbutton')) return false;
-
-        if (!wmgui.sid){
-            window.localStorage.setItem(window.store_redir_key, '/' + window.location.hash);
-            return window.location.replace('#modal/login');
-        }
-
-        var entry = $('#entryno > a').text();
-
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        $.ajax({
-            type: 'GET',
-            url: wmgui.mydata_endpoint,
-            data: {q: entry, sid: wmgui.sid},
-            beforeSend: wmgui.show_preloader
-
-        }).always(wmgui.hide_preloader).done(function(data){
-
-            if (data.error) return wmgui.notify(data.error);
-
-            wmgui.mydata_history.push(entry);
-            window.localStorage.setItem(wmgui.store_mydata_key, JSON.stringify(wmgui.mydata_history));
-            $('#absolidize').removeClass('wmbutton');
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Please, make sure <a href="#junction">your access works</a> <br /> and try again');
-        });
-    });*/
-
-    $('#refine_col').on('click', 'a.extd_refine', function(){
-        var facet = $(this).attr('rel');
-        if ($('#refine_col > ul > li.extd_rfns.fct_' + facet).length){
-            $('#refine_col > ul > li:not(.fct_' + facet + ')').addClass('hidden_rfns').slideUp();
-            $('#refine_col > ul > li.extd_rfns.fct_' + facet).show();
-            $('a.extd_refine[rel=' + facet + ']').parent().hide();
-            return false;
-        }
-        var given_search = {extd_refine: facet};
-        $.extend(given_search, wmgui.search);
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        wmgui.active_ajax = $.ajax({
-            type: 'GET',
-            url: wmgui.rfn_endpoint,
-            data: {q: JSON.stringify(given_search)}
-
-        }).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            var html = '';
-            delete given_search['numeric'];
-            delete given_search['extd_refine'];
-            //if (given_search.classes) given_search.classes = given_search.classes.split(',').join(' ');
-
-            var inquiry = false;
-            $.each(wmgui.inquiries, function(n, i){ if (given_search[i]){ inquiry = true; return false; } });
-
-            $.each(data.payload, function(i, found){
-                // FIXME: duplicating
-                var link_base = '',
-                    orepr = {};
-                    //count_text = ' ('+found[1]+')';
-
-                $.each(given_search, function(key, val){
-                    if (key == 'search_type')
-                        return true;
-                    else if (facet == 'elements' && (key == 'elements' || key == 'formulae'))
-                        return true;
-                    else if (facet == 'props' && key == 'props')
-                        return true;
-
-                    link_base += val + ' ';
-
-                    if (orepr[key]) orepr[key] += ', ' + val;
-                    else            orepr[key] = val;
-                });
-
-                //if (facet == 'elements') count_text = '';
-                if (facet == 'props'){
-                    found[0] = found[0].replace(/\(|\)/g, "").replace(/\/[\w\-]*/g, ""); // FIXME
-                }
-
-                if (orepr[facet]) orepr[facet] += ', ' + found[0];
-                else              orepr[facet] = found[0];
-
-                if (orepr['elements']) orepr['elements'] = orepr['elements'].replaceAll(', ', '-');
-
-                if (inquiry) html += '<li class="extd_rfns fct_' + facet + '"><a href="#inquiry/' + $.param(orepr) + '">' + found[0] + '</a></li>';
-                else         html += '<li class="extd_rfns fct_' + facet + '"><a href="#search/' + link_base + found[0] + '">' + found[0] + '</a></li>';
-            });
-
-            html += '<li class="extd_rfns fct_' + facet + ' collapse_refine"><a class="collapse_refine" rel="' + facet + '" href="#">Show less&nbsp;</a></li>';
-            $('#refine_col > ul > li:not(.fct_' + facet + ')').addClass('hidden_rfns').slideUp();
-            $('a.extd_refine[rel=' + facet + ']').parent().hide().after(wmgui.clean(html));
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-        });
-        return false;
-    });
-
-    $('#refine_col').on('click', 'a.collapse_refine', function(){
-        var facet = $(this).attr('rel');
-        $('a.extd_refine[rel=' + facet + ']').parent().show();
-        $('#refine_col > ul > li.hidden_rfns').removeClass('hidden_rfns').slideDown(250);
-        $('#refine_col > ul > li.extd_rfns').hide();
-        return false;
-    });
-
-    /*$('#fdwidget').on('click', 'span', function(){
-        var what = $(this).attr('id');
-        if (what == 'fdwidget_yes'){
-            $('#fdwidget').html('We appreciate your feedback!');
-        } else {
-            $('#fdwidget').html(wmgui.contact_html);
-            $('#fdwidget_msg').focus();
-        }
-    });*/
-
-    /*$('#fdwidget').on('click', 'div.wmbutton', function(){
-        if ($(this).data('busy')) return;
-        $(this).data('busy', true);
-        $.ajax({
-            type: 'POST',
-            url: wmgui.fd_endpoint,
-            data: {fdwidget_msg: $('#fdwidget_msg').val(), fdwidget_msgtype: $('#fdwidget_msgtype').val(), fdwidget_url: window.location.href},
-            beforeSend: wmgui.show_preloader
-
-        }).always(wmgui.hide_preloader).done(function(data){
-            $('#fdwidget_trigger').data('busy', false);
-            if (data.error) return wmgui.notify(data.error);
-            $('#fdwidget').html('We appreciate your feedback!');
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            wmgui.notify("Sorry, cannot process your input");
-        });
-    });*/
-
-    $('#tagcloudbox').on('click', 'a.collateral', function(){
-        $('#userbox').data('saved_hash', false)
-        var act = $(this).attr('rel');
-        if (act == 'adv'){
-            $('#advsearch_init_trigger').trigger('click');
-            $('div.menu_collateral').hide();
-
-        } else if (act == 'idea'){
-            window.location.hash = '#plot/' + wmgui.get_random_term(['pie', 'lit', 'graph']) + '/search/' + wmgui.get_interesting()['text'];
-
-        } else if (act == 'sod'){
-            var now = new Date(),
-                pick = now.getDate() % wmgui.s_examples.length,
-                start = new Date(now.getFullYear(), 0, 0),
-                diff = (now - start) + ((start.getTimezoneOffset() - now.getTimezoneOffset()) * 60 * 1000),
-                nday = Math.floor(diff / (1000 * 60 * 60 * 24)),
-                sod = wmgui.s_examples[pick] + nday;
-            window.location.hash = '#entry/S' + sod;
-
-        } else if (act == 'my'){
-            var locals = JSON.parse(window.localStorage.getItem(wmgui.store_user_key) || '{}');
-            if (locals.ipbased){
-                window.location.hash = '#inquiry/orgs=' + locals.name;
-
-            } else if (locals.name){
-                var names = locals.name.split(' ');
-                window.location.hash = '#inquiry/authors=' + encodeURIComponent(names[names.length - 1]);
-            }
-        }
-        return false;
-    });
-
-    $('#hintsbox_msg').on('click', 'div.wmbutton', function(){
-        // copy to clipbox functionality
-        var range = document.createRange();
-        range.selectNode($('#hintsbox_msg > pre').get(0));
-        window.getSelection().removeAllRanges();
-        window.getSelection().addRange(range);
-        document.execCommand('copy');
-        wmgui.notify('Copied');
-    });
-
-    $('#tooltip').on('click', 'span', function(){
-        var that = $(this),
-            act = that.attr('rel'),
-            forced = that.hasClass('forced');
-        document.getElementById('tooltip').style.display = 'none';
-        if (act && wmgui.tooltips[act]) show_tooltip(wmgui.tooltips[act], forced);
-    });
-
-    $('#sim_col').on('click', 'li > a', function(){
-        $('#sim_col > ul > li').removeClass('selected');
-        $(this).parent().addClass('selected');
-        wmgui.passive_sim_col = false;
-        return true;
-    });
-
-    $('div.close_user_dialogue').click(function(){
-        $('#userbox').trigger('click');
-    });
-
-    $('div.close_advs_dialogue').click(function(){
-        $('#advsbox, #overlay, #aetmap').hide();
-    });
-
-    $('#close_inquiry_dialogue').click(function(){
-        $('#inquirybox').hide();
-    });
-
-    $('#close_ss_dialogue').click(function(){
-
-        var x_sort = $('#ss_x > ul > li.ss_x').attr('rel').split('_')[1],
-            y_sort = $('#ss_y > ul > li.ss_y').attr('rel').split('_')[1],
-            x_op = $('#sops_x > ul > li.sops_x').text(),
-            y_op = $('#sops_y > ul > li.sops_y').text(),
-            x_op = (x_op == 'none') ? false : x_op,
-            y_op = (y_op == 'none') ? false : y_op;
-
-        if ($('#ss_z').is(':visible')){
-            var z_sort = $('#ss_z > ul > li.ss_z').attr('rel').split('_')[1],
-                z_op = $('#sops_z > ul > li.sops_z').text(),
-                z_op = (z_op == 'none') ? false : z_op;
-
-            $('#ctxpanel_cube > ul > li.embodied').removeClass('embodied');
-            $('#viscube_' + x_sort).addClass('embodied');
-            $('#ctxpanel_cube > ul > li.ss_y').removeClass('ss_y');
-            $('#viscube_' + y_sort).addClass('ss_y');
-            $('#ctxpanel_cube > ul > li.ss_z').removeClass('ss_z');
-            $('#viscube_' + z_sort).addClass('ss_z');
-
-            $('span.sops').remove();
-            if (x_op) $('<span class="sops" rel="x">' + x_op + '</span>').appendTo('#viscube_' + x_sort);
-            if (y_op) $('<span class="sops" rel="y">' + y_op + '</span>').appendTo('#viscube_' + y_sort);
-            if (z_op) $('<span class="sops" rel="z">' + z_op + '</span>').appendTo('#viscube_' + z_sort);
-
-            if (document.getElementById('visavis_iframe').contentWindow.location.hash.indexOf('fixel=1') !== -1)
-                document.getElementById('visavis_iframe').contentWindow.matrix_order(x_sort, y_sort, x_op, y_op);
-            else
-                document.getElementById('visavis_iframe').contentWindow.cube_order(x_sort, y_sort, z_sort, x_op, y_op, z_op);
-
-        } else {
-            if ((x_op && x_sort == 'count') || (y_op && y_sort == 'count')) return wmgui.notify('Sorry, data counts are not supported');
-
-            $('#ctxpanel_matrix > ul > li.embodied').removeClass('embodied');
-            $('#vismatrix_' + x_sort).addClass('embodied');
-            $('#ctxpanel_matrix > ul > li.ss_y').removeClass('ss_y');
-            $('#vismatrix_' + y_sort).addClass('ss_y');
-
-            $('span.sops').remove();
-            if (x_op) $('<span class="sops" rel="x">' + x_op + '</span>').appendTo('#vismatrix_' + x_sort);
-            if (y_op) $('<span class="sops" rel="y">' + y_op + '</span>').appendTo('#vismatrix_' + y_sort);
-
-            document.getElementById('visavis_iframe').contentWindow.matrix_order(x_sort, y_sort, x_op, y_op);
-        }
-
-        $('#ss_custom_box, #overlay').hide();
-        $('div.ss_col > ul').empty();
-    });
-
-    $('#close_dc_dialogue').click(function(){
-        $('#discovery_custom_box, #overlay').hide();
-        $('#discovery_enabled, #discovery_disabled').empty();
-        document.getElementById('visavis_iframe').contentWindow.discovery_rerun();
-        $('#select_cmp_trigger').val('X');
-    });
-
-    // not handled by ermac?
-    $('#close_formal_dialogue').click(function(){
-        window.location.hash = '#start';
-    });
-
-    // not handled by ermac?
-    $('#close_ph_dialogue, div.close_hy_dialogue, div.close_product_dialogue').click(function(){
-        if (document.referrer.indexOf(window.location.host) == -1) window.location.hash = '#start'; // FIXME: empty referrer
-        else {
-            var prev = window.location.href;
-            window.history.go(-1);
-            setTimeout(function(){ if (window.location.href == prev) window.location.hash = '#start' }, 500);
-        }
-    });
-
-    /** $('#overlay').click(function(){
-        $('div.modal:visible').each(function(){
-            $(this).find('div.cross').trigger('click');
-        });
-    }); **/
-
-    $('div._close_ctx').click(function(){
-        try { wmgui.quick_ajax.abort() } catch(e){}
-        $('.busy_entry').removeClass('busy_entry');
-        $('#ctx_col, #sim_col').hide();
-        wmgui.passive_sim_col = true;
-        close_vibox();
-    });
-
-    $('#hy_box').on('click', 'span', function(){
-        var hyid = $(this).attr('class');
-        $('span.' + hyid).each(function(){
-            var that = $(this);
-            that.parent().find('ul').toggle();
-            that.text() == 'expand' ? that.text('collapse') : that.text('expand');
-        });
-    });
-
-    $('#hy_box').on('click', 'a.dynprop', function(){
-        // FIXME cannot process with the optimade NLP parser
-        //if (wmgui.view_mode == 1)
-        //    return true;
-
-        var value = $(this).attr('data-val');
-        window.location.hash = wmgui.aug_search_cmd("props", value);
-        return false;
-    });
-
-    // numeric search
-    $('#hy_box').on('click', 'strong.numeric', function(){
-        var prop = $(this).attr('rel'),
-            data = wmgui.numerics[prop],
-            prop_id = data[0],
-            units = data[1],
-            min = data[2],
-            max = data[3],
-            step = data[4];
-        var nblocks = $('div.slider_numerics').length;
-        if (nblocks >= 2) wmgui.notify('Too little phases have all these properties reported &mdash; expect no results');
-        if (nblocks >= 8)
-            return;
-        create_floating_slider(prop, prop_id, units, min, max, step);
-    });
-
-    $('strong.numeric').click(function(){
-        var prop = $(this).attr('rel'),
-            data = wmgui.numerics[prop],
-            prop_id = data[0],
-            units = data[1],
-            min = data[2],
-            max = data[3],
-            step = data[4];
-        create_floating_slider(prop, prop_id, units, min, max, step);
-    });
-
-    $('#hy_options > li').click(function(){
-        var that = $(this),
-            desttab = that.attr('rev');
-        if (desttab == 'hy_vis'){
-            window.open(wmgui.static_host + '/labs/ontology');
-            return;
-        }
-        that.addClass('working').siblings().removeClass('working');
-        $('div.hy_tabs').hide();
-        $('#' + desttab).show();
-    });
-
-    $('#dtypes > ul > li').click(function(){
-        var that = $(this),
-            facet = that.data('facet'),
-            term = that.data('term');
-
-        if (facet == 'classes'){
-            if (wmgui.search.classes) // FIXME?
-                wmgui.search.classes = wmgui.search.classes.replace('peer-reviewed', '').replace('peer-review', '').replace('machine-learning', '').replace('machine learning', '').replace('ab initio calculations', '').split(',').map(function(x){ return x.trim() }).filter(function(x){ return x }).join(', ');
-            //wmgui.inquiries.forEach(function(item){
-            //    if (wmgui.search[item]) delete wmgui.search[item];
-            //});
-        }
-        window.location.hash = wmgui.aug_search_cmd(facet, term);
-    });
-
-    $('#dtypes_phid > ul > li').click(function(){
-        var that = $(this),
-            rankfilter = that.data('rankfilter'),
-            active = that.hasClass('active'),
-            legend = that.text();
-        request_search({'phid': wmgui.search.phid, 'rankfilter': active ? null : rankfilter}, legend + ' of phase ' + wmgui.search.phid, true);
-        $('#dtypes_phid > ul > li').removeClass('active');
-        active ? this.classList.remove('active') : this.classList.add('active');
-    });
-
-    $(window).scroll(wmgui.debounce(function(){
-        if (wmgui.view_mode == 2){
-            if (wmgui.unfinished_page){
-                if ($('#footer').offset().top - $(window).scrollTop() - $(window).height() < 50){ // footer pos - scrolling - window height
-
-                    wmgui.unfinished_page = false;
-                    var cur_search = {offset: wmgui.quick_page_size};
-                    $.extend(cur_search, wmgui.search);
-
-                    // NB no abort of the other requests!
-                    wmgui.active_ajax = $.ajax({
-                        type: 'GET',
-                        url: wmgui.search_endpoint,
-                        data: {
-                            q: JSON.stringify(cur_search),
-                            strict: wmgui.ctx_strict_phases,
-                            //subphases: wmgui.ctx_subphases,
-                            sid: wmgui.sid
-                        },
-                        beforeSend: wmgui.show_preloader
-
-                    }).always(wmgui.hide_preloader).done(function(data){
-                        if (data.error) return wmgui.notify(data.error);
-                        $('div.context_msg').hide();
-                        show_hints();
-                        if (!data.out.length)
-                            return;
-                        if (wmgui.thumbed_display){
-                            $('#databrowser tr td').append(build_thumbs(data.out));
-                        } else {
-                            $('#databrowser tbody').append(build_cells(data.out));
-                            $('#databrowser').trigger('update');
-                        }
-                    }).fail(function(xhr, textStatus, errorThrown){
-                        if (textStatus != 'abort')
-                            wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-                    });
-                }
-            }
-            var iframe = $('#iframe');
-            if (iframe.length && !wmgui.is_inview(iframe)) close_vibox();
-
-        } else if (wmgui.ptable.activated){
-
-            var scroll_pos = window.scrollY;
-            //console.log(scroll_pos);
-
-            if (scroll_pos > 40){
-                document.getElementById('ptable_dtypes_box').classList.remove('resulted');
-                document.getElementById('legend').style.display = 'none';
-
-                (wmgui.ptable.vis_fixed && scroll_pos > 550) ? document.getElementById('ptable_vis').classList.add('fixed') :
-                    document.getElementById('ptable_vis').classList.remove('fixed');
-
-            } else {
-                document.getElementById('ptable_dtypes_box').classList.add('resulted');
-                document.getElementById('legend').style.display = 'block';
-                document.getElementById('ptable_vis').classList.remove('fixed');
-            }
-        }
-    }, 300));
-
-    $('#userbox').click(function(){
-        var that = $(this);
-        if (window.location.hash == that.data('saved_hash'))
-            that.data('saved_hash', false);
-
-        if (that.data('saved_hash')){
-            window.location.replace(that.data('saved_hash'));
-            that.data('saved_hash', false);
-
-        } else {
-            if (window.location.hash.indexOf('modal') !== -1){
-                window.location.replace('#start');
-            } else {
-                that.data('saved_hash', window.location.hash);
-
-                if (wmgui.sid) window.location.replace('#modal/menu');
-                else window.location.replace('#modal/login');
-            }
-        }
-    });
-
-    $('span.href[rel]').click(function(){
-        window.location.replace($(this).attr('rel'));
-    });
-
-    $('div.spinoff_pane').on('click', 'span.extd', function(){
-        var that = $(this);
-        that.siblings('span.legend').toggle();
-        that.text() == 'Show more info...' ? that.text('Hide more info...') : that.text('Show more info...');
-    });
-
-    $('#interpret').on('click', 'li', function(){
-        var that = $(this),
-            link = that.attr('rel');
-        if (!!link){ // search only ... arity
-            window.location.hash = link;
-            return;
-        }
-
-        var csscls = that.attr('class');
-
-        if (csscls.indexOf('numeric') !== -1){
-            window.location.hash = '#hierarchy';
-
-        } else if (csscls.indexOf('authors') !== -1 || csscls.indexOf('years') !== -1 || csscls.indexOf('codens') !== -1 || csscls.indexOf('doi') !== -1 || csscls.indexOf('geos') !== -1 || csscls.indexOf('orgs') !== -1){
-            $('#advstab_options li').removeClass('working');
-            $('#advstab_options li[rev=advstab_bib]').addClass('working');
-            $('div.advstab').hide();
-            $('#advstab_bib').show();
-            show_advsbox();
-
-        } else if (csscls.indexOf('formulae') !== -1 || csscls.indexOf('props') !== -1 || csscls.indexOf('elements') !== -1 || csscls.indexOf('classes') !== -1) {
-            $('#advstab_options li').removeClass('working');
-            $('#advstab_options li[rev=advstab_main]').addClass('working');
-            $('div.advstab').hide();
-            $('#advstab_main').show();
-            show_advsbox();
-
-        } else {
-            $('#advstab_options li').removeClass('working');
-            $('#advstab_options li[rev=advstab_cry]').addClass('working');
-            $('div.advstab').hide();
-            $('#advstab_cry').show();
-            show_advsbox();
-            if (wmgui.search.aetypes) show_aetmap(wmgui.search.aetypes);
-        }
-    });
-
-    $('#tab_links > li').click(function(){
-        try { wmgui.active_ajax.abort() } catch(e){}
-        try { wmgui.quick_ajax.abort() } catch(e){}
-
-        var that = $(this),
-            desttab = that.attr('rev');
-
-        that.addClass('working').siblings().removeClass('working');
-        $('div.menu_tabs').hide();
-        $('#' + desttab).show();
-
-        if (desttab == 'usr_tab_api_key'){
-            $('#hintsbox_msg').html(wmgui.api_msg);
-
-            wmgui.active_ajax = $.ajax({
-                type: 'POST',
-                url: wmgui.api_key_endpoint,
-                data: {sid: wmgui.sid},
-                beforeSend: wmgui.show_preloader
-
-            }).always(wmgui.hide_preloader).done(function(data){
-                if (data.error) return wmgui.notify(data.error);
-                $('#usr_api_key').html(data.msg);
-                if (data.revokable)      $('#revoke_usr_api_key_holder').show();
-                else if (data.creatable) $('#create_usr_api_key_holder').show();
-                else return wmgui.notify('Your session ended: please, <span class="href relogin">log in again</span>');
-
-            }).fail(function(xhr, textStatus, errorThrown){
-                if (textStatus != 'abort')
-                    wmgui.notify('Your session ended: please, <span class="href relogin">log in again</span>');
-                $('#usr_api_key').html('authentication error');
-            });
-
-        } else if (desttab == 'usr_tab_perms'){
-            $('#hintsbox_msg').html(wmgui.get_random_term(wmgui.welcome_msgs));
-
-            var locals = JSON.parse(window.localStorage.getItem(wmgui.store_user_key) || '{}');
-
-            wmgui.active_ajax = $.ajax({
-                type: 'POST',
-                url: locals.ipbased ? wmgui.ip_perms_endpoint : wmgui.perms_endpoint,
-                data: {sid: wmgui.sid},
-                beforeSend: wmgui.show_preloader
-
-            }).always(wmgui.hide_preloader).done(function(data){
-                if (data.error) return wmgui.notify(data.error);
-                if (!data.hasOwnProperty('gui') || !data.hasOwnProperty('api')) return wmgui.notify('Your session ended: please, <span class="href relogin">log in again</span>');
-                $('#perms_view').html(describe_perms(data));
-
-            }).fail(function(xhr, textStatus, errorThrown){
-                if (textStatus != 'abort')
-                    wmgui.notify('Your session ended: please, <span class="href relogin">log in again</span>');
-                $('#perms_view').html('authentication error');
-            });
-
-        } else if (desttab == 'usr_tab_ctrl'){ // redirect to an external app
-            window.location.href = '/ctrl/?' + Math.floor(Math.random() * 1000);
-
-        } else if (desttab == 'usr_tab_absolidix'){ // redirect to an external app
-            window.location.href = wmgui.mydata_addr;
-
-        } else if (desttab == 'usr_tab_account'){
-            $('#hintsbox_msg').html(wmgui.get_random_term(wmgui.welcome_msgs));
-        }
-    });
-
-    $('#advstab_options > li').click(function(){
-        var that = $(this),
-            desttab = that.attr('rev');
-
-        that.addClass('working').siblings().removeClass('working');
-
-        $('div.advstab').hide();
-        $('#' + desttab).show();
-    });
-
-    $('a.link_adjuster').click(function(){
-        // hash-hack FIXME?
-        if (window.location.hash == '#polyhedra'){ window.location.hash = '#polyhedra/'; return false; }
-        else if (window.location.hash == '#polyhedra/'){ window.location.hash = '#polyhedra'; return false; }
-        else return true;
-    });
-
-    $('#create_usr_api_key').click(function(){
-        $(this).parent().hide();
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        wmgui.active_ajax = $.ajax({
-            type: 'POST',
-            url: wmgui.api_key_endpoint,
-            data: {sid: wmgui.sid, create: true},
-            beforeSend: wmgui.show_preloader
-
-        }).always(wmgui.hide_preloader).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            $('#usr_api_key').html(data.msg);
-            $('#revoke_usr_api_key_holder').show();
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Your session ended: please, <span class="href relogin">log in again</span>');
-        });
-    });
-    $('#revoke_usr_api_key').click(function(){
-        $(this).parent().hide();
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        wmgui.active_ajax = $.ajax({
-            type: 'POST',
-            url: wmgui.api_key_endpoint,
-            data: {sid: wmgui.sid, revoke: true},
-            beforeSend: wmgui.show_preloader
-
-        }).always(wmgui.hide_preloader).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            $('#usr_api_key').html('Successfully revoked');
-            $('#create_usr_api_key_holder').show();
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Your session ended: please, <span class="href relogin">log in again</span>');
-        });
-    });
-
-    $('#login_trigger').click(function(){
-        if ($(this).data('busy')) return;
-        $(this).data('busy', true);
-        $(this).text('In process...');
-
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        wmgui.active_ajax = $.ajax({
-            type: 'POST',
-            url: wmgui.login_endpoint,
-            data: {login: $('#login_email').val().trim(), pass: $('#login_password').val(), ed: wmgui.edition},
-            beforeSend: wmgui.show_preloader
-
-        }).always(function(){
-            $('#login_trigger').data('busy', false);
-            $('#login_trigger').text('Login');
-            wmgui.hide_preloader();
-
-        }).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            if (!data.sid || !data.name || !data.acclogin) return wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-            user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
-            $('#userbox').trigger('click');
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            wmgui.notify("Login unsuccessful");
-        });
-    });
-
-    $('#factor_trigger').click(function(){
-        if ($(this).data('busy')) return;
-        $(this).data('busy', true);
-        $(this).text('Sending...');
-
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        wmgui.active_ajax = $.ajax({
-            type: 'POST',
-            url: wmgui.factor_endpoint,
-            data: {login: $('#factor_by_email').val().trim()},
-            beforeSend: wmgui.show_preloader
-
-        }).always(function(){
-            $('#factor_trigger').data('busy', false);
-            $('#factor_trigger').text('Send code');
-            wmgui.hide_preloader();
-
-        }).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            wmgui.notify('Please, check your inbox (and spam)');
-
-            // handle factor log in step two...
-            document.getElementById('factor_trigger').style.display = 'none';
-            document.getElementById('factor_form_step_one').style.display = 'none';
-            document.getElementById('factor_form_step_two').style.display = 'block';
-            document.getElementById('factor_form_resp_0').focus();
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Sorry, a network error occured. Please, try again');
-        });
-    });
-
-    $('#restore_trigger').click(function(){
-        if ($(this).data('busy')) return;
-        $(this).data('busy', true);
-        $(this).text('Sending...');
-
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        wmgui.active_ajax = $.ajax({
-            type: 'POST',
-            url: wmgui.restore_endpoint,
-            data: {login: $('#restore_by_email').val().trim(), ed: wmgui.edition},
-            beforeSend: wmgui.show_preloader
-
-        }).always(function(){
-            $('#restore_trigger').data('busy', false);
-            $('#restore_trigger').text('Send link');
-            wmgui.hide_preloader();
-
-        }).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            wmgui.notify('Please, check your inbox (and spam)');
-            $('#userbox').trigger('click');
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Sorry, a network error occured. Please, try again');
-        });
-    });
-
-    $('#accpass_trigger').click(function(){
-
-        if ($(this).hasClass('disabled')) return false;
-
-        $('#account_pass_change').toggle();
-    });
-
-    $('#password_trigger').click(function(){
-        var p1 = $("#new_password_1").val(),
-            p2 = $("#new_password_2").val();
-        if (!p1 || !p2) return wmgui.notify("Please, type your new password in both fields");
-        if (p1 !== p2) return wmgui.notify("Passwords do not match (typo?)");
-
-        if ($(this).data('busy')) return;
-        $(this).data('busy', true);
-        $(this).text('Changing...');
-
-        try { wmgui.active_ajax.abort() } catch(e){}
-
-        wmgui.active_ajax = $.ajax({
-            type: 'POST',
-            url: wmgui.password_endpoint,
-            data: {new_password: p2, sid: wmgui.sid, ed: wmgui.edition},
-            beforeSend: wmgui.show_preloader
-
-        }).always(function(){
-            $('#password_trigger').data('busy', false);
-            $('#password_trigger').text('Change');
-            wmgui.hide_preloader();
-
-        }).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
-            window.location.replace('#start');
-            $('#account_pass_change').hide();
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Your session ended: please, <span class="href relogin">log in again</span>');
-        });
-    });
-
-    $('#logout_trigger').click(function(){
-
-        if ($(this).hasClass('disabled')) return false;
-
-        $.ajax({
-            type: 'POST',
-            url: wmgui.logout_endpoint,
-            data: {sid: wmgui.sid}
-
-        }).done(function(data){}).fail(function(xhr, textStatus, errorThrown){});
-        user_logout();
-        $('#userbox').trigger('click');
-    });
-    $('#notifybox').on('click', 'span.relogin', force_relogin);
-
-    var resps = document.getElementsByClassName('factor_form_resp');
-    for (var i = 0; i < resps.length; i++) {
-
-        resps[i].addEventListener('keyup', function(evt) {
-
-            // back, left arrow
-            if (evt.keyCode == 8 || evt.keyCode == 37) {
-                var prev = this.previousElementSibling;
-                if (prev) {
-                    prev.focus();
-                    prev.select();
-                }
-
-            } else if (evt.keyCode > 47 && evt.keyCode < 58) {
-
-                submit_factor_form_resp();
-
-                var next = this.nextElementSibling;
-                if (next) {
-                    next.focus();
-                    next.select();
-                }
-            }
-        });
-
-        resps[i].addEventListener('paste', function(evt) {
-            var pasted = (evt.clipboardData || window.clipboardData).getData("text");
-            if (!pasted || !pasted.length)
-                return false;
-
-            for (var i = 0; i < 6; i++) {
-                document.getElementById('factor_form_resp_' + i).value = pasted.charAt(i);
-            }
-            submit_factor_form_resp();
-        });
-    }
-
-    $('#search_holder').keydown(function(e){
-        var key = window.event ? e.keyCode : e.which;
-        if (key == 13) $('#search_trigger').trigger('click');
-    });
-
-    // switch sliders: first row abf
-    $('#control_a').click(function(){ // entries
-        ///re_view_request(0);
-        var orepr = {};
-        for (var key in wmgui.search){
-            if (['search_type', 'phid'].indexOf(key) !== -1) continue;
-            orepr[key] = wmgui.search[key];
-        }
-
-        wmgui.search_type = 0;
-        wmgui.search.search_type = wmgui.search_type;
-
-        var urlstr = $.param(orepr);
-        if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
-        else                         urlstr += '=';
-
-        window.location.hash = '#inquiry_entries/' + urlstr;
-    });
-    $('#control_b').click(function(){ // phases
-        ///re_view_request(1);
-        var orepr = {};
-        for (var key in wmgui.search){
-            if (['search_type', 'phid'].indexOf(key) !== -1) continue;
-            orepr[key] = wmgui.search[key];
-        }
-
-        wmgui.search_type = 1;
-        wmgui.search.search_type = wmgui.search_type;
-
-        var urlstr = $.param(orepr);
-        if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
-        else                         urlstr += '=';
-
-        window.location.hash = '#inquiry_phases/' + urlstr;
-    });
-    $('#control_f').click(function(){ // articles
-        ///re_view_request(2);
-        var orepr = {};
-        for (var key in wmgui.search){
-            if (['search_type', 'phid'].indexOf(key) !== -1) continue;
-            orepr[key] = wmgui.search[key];
-        }
-
-        wmgui.search_type = 2;
-        wmgui.search.search_type = wmgui.search_type;
-
-        var urlstr = $.param(orepr);
-        if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
-        else                         urlstr += '=';
-
-        window.location.hash = '#inquiry_articles/' + urlstr;
-    });
-
-    // switch sliders: second row cde
-    $('#control_c').click(function(){ // table
-        wmgui.visavis_terminating = true;
-        wmgui.thumbed_display = false;
-        if (wmgui.visavis_working){
-            var orepr = {};
-            for (var key in wmgui.search){
-                if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
-                orepr[key] = wmgui.search[key];
-            }
-            var urlstr = $.param(orepr);
-            if (window.location.hash == '#inquiry/' + urlstr){
-                // hash-hack FIXME?
-                if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
-                else                         urlstr += '=';
-            }
-            window.location.hash = '#inquiry/' + urlstr;
-
-        } else re_view_request(wmgui.search_type);
-        wmgui.chosen_table_browser = true;
-    });
-    $('#control_d').click(function(){ // previews
-        wmgui.visavis_terminating = true;
-        wmgui.thumbed_display = true;
-        if (wmgui.visavis_working){
-            var orepr = {};
-            for (var key in wmgui.search){
-                if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
-                orepr[key] = wmgui.search[key];
-            }
-            var urlstr = $.param(orepr);
-            if (window.location.hash == '#inquiry/' + urlstr){
-                // hash-hack FIXME?
-                if (urlstr.slice(-1) == '=') urlstr = urlstr.substr(0, urlstr.length - 1);
-                else                         urlstr += '=';
-            }
-            window.location.hash = '#inquiry/' + urlstr;
-
-        } else re_view_request(wmgui.search_type);
-        wmgui.chosen_table_browser = true;
-    });
-    $('#control_e').click(function(){ // plotting
-        var orepr = {};
-        for (var key in wmgui.search){
-            if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
-            orepr[key] = wmgui.search[key];
-        }
-        while (true){
-            var plot_type = wmgui.get_random_term(['matrix', 'cube']); // the most interesting visualization types
-            if (plot_type != wmgui.visavis_curtype) break;
-        }
-        window.location.hash = '#plot/' + plot_type + '/inquiry/' + $.param(orepr);
-    });
-
-    $('#ctx_strict_phases_trigger').change(function(e){
-        //$('#ctx_subphases_trigger').prop('checked', false);
-
-        if (!wmgui.search.elements){
-            wmgui.cancel_event(e);
-            return false;
-        }
-
-        var arity_kwd = wmutils.arity_keys[wmgui.search.elements.split('-').length],
-            kwd_exists = false;
-
-        if (wmgui.search.classes){
-            $.each(wmutils.arity_keys.slice(1), function(num, value){
-
-                if (num == 6)
-                    return false;
-
-                if (wmgui.search.classes.indexOf(value) !== -1){
-                    kwd_exists = true;
-                    return false;
-                }
-            });
-
-            if (!kwd_exists){
-                wmgui.search.classes += ', ' + arity_kwd;
-                wmgui.multiselects['main'].write({'classes': arity_kwd});
-            }
-
-        } else {
-            wmgui.search.classes = arity_kwd;
-            wmgui.multiselects['main'].write({'classes': arity_kwd});
-        }
-
-        wmgui.ctx_strict_phases = $('#ctx_strict_phases_trigger').is(':checked') ? '' : '1';
-        re_view_request(wmgui.search_type);
-    });
-    /*$('#ctx_subphases_trigger').change(function(){
-        //$('#ctx_strict_phases_trigger').prop('checked', false);
-        wmgui.ctx_subphases = wmgui.search.elements && $('#ctx_subphases_trigger').is(':checked') ? '1' : '';
-        re_view_request(wmgui.search_type);
-    });*/
-
-    // visavis ctx
-    $('#ctxpanel_matrix > ul > li').click(function(){
-        var that = $(this);
-        if (that.hasClass('embodied') || that.hasClass('ss_y')) return;
-        var type = that.attr('id').split('_')[1],
-            y_id = $('#ctxpanel_matrix > ul > li.ss_y');
-        $('#ctxpanel_matrix > ul > li.embodied').removeClass('embodied');
-        if (y_id.length) y_id.removeClass('ss_y');
-        that.addClass('embodied');
-        $('span.sops').remove();
-
-        document.getElementById('visavis_iframe').contentWindow.matrix_order(type);
-    });
-    $('#ctxpanel_cube > ul > li').click(function(){
-        var that = $(this);
-        if (that.hasClass('embodied') || that.hasClass('ss_y') || that.hasClass('ss_z')) return;
-        var type = that.attr('id').split('_')[1],
-            y_id = $('#ctxpanel_cube > ul > li.ss_y'),
-            z_id = $('#ctxpanel_cube > ul > li.ss_z');
-        $('#ctxpanel_cube > ul > li.embodied').removeClass('embodied');
-        if (y_id.length) y_id.removeClass('ss_y');
-        if (z_id.length) z_id.removeClass('ss_z');
-        that.addClass('embodied');
-        $('span.sops').remove();
-
-        if (document.getElementById('visavis_iframe').contentWindow.location.hash.indexOf('fixel=1') !== -1)
-            document.getElementById('visavis_iframe').contentWindow.matrix_order(type);
-        else
-            document.getElementById('visavis_iframe').contentWindow.cube_order(type, type, type);
-    });
-    $('#ctxpanel_graph > ul > li').click(function(){
-        var that = $(this);
-        if (that.hasClass('embodied')) return;
-        var type = that.attr('id').split('_')[1];
-        $('#ctxpanel_graph > ul > li.embodied').removeClass('embodied');
-        that.addClass('embodied');
-
-        document.getElementById('visavis_iframe').contentWindow.graph_rebuild(type);
-    });
-    $('#select_cmp_trigger').change(function(){
-        var value = $(this).val(),
-            selected = $('#select_cmp_trigger option:selected'),
-            title = selected.text();
-
-        wmgui.dc_ctrl_flag = true;
-
-        if (value == 'X')
-            return;
-        else if (value == 'Y'){
-            document.getElementById('visavis_iframe').contentWindow.cmp_discard(wmgui.visavis_curtype);
-            return;
-        }
-
-        if (['matrix', 'cube', 'discovery'].indexOf(wmgui.visavis_curtype) == -1)
-            return;
-
-        var url = wmgui.vis_endpoint + '/' + wmgui.visavis_curtype + '?q=' + value;
-        document.getElementById('visavis_iframe').contentWindow.cmp_download(url, wmgui.visavis_curtype);
-    });
-    $('li.discovery_custom').click(function(){
-        if (!document.getElementById('visavis_iframe') || !document.getElementById('visavis_iframe').contentWindow)
-            return false;
-
-        var list = document.getElementById('visavis_iframe').contentWindow.visavis.elementals_on,
-            html_list_on = '',
-            html_list_off = '';
-
-        for (var prop in wmgui.elemental_names){
-            if (list.indexOf(prop) !== -1)
-                html_list_on += '<div class="rearrange" rel="' + prop + '">' + wmgui.elemental_names[prop] + ' (&minus;)</div>';
-            else
-                html_list_off += '<div class="rearrange" rel="' + prop + '">' + wmgui.elemental_names[prop] + ' (+)</div>';
-        }
-        if (html_list_off) $('#discovery_disabled').html(html_list_off);
-
-        $('#discovery_enabled').html(html_list_on);
-        $('#discovery_custom_box, #overlay').show();
-    });
-    $('#discovery_custom_box').on('click', 'div.rearrange', function(){
-        var that = $(this),
-            prop = that.attr('rel'),
-            idx = document.getElementById('visavis_iframe').contentWindow.visavis.elementals_on.indexOf(prop);
-        if (that.parent().attr('id') == 'discovery_enabled'){
-            if ($('#discovery_enabled div.rearrange').length == 1)
-                return false;
-            if (idx !== -1) document.getElementById('visavis_iframe').contentWindow.visavis.elementals_on.splice(idx, 1);
-            $('#discovery_disabled').append('<div class="rearrange" rel="' + prop + '">' + wmgui.elemental_names[prop] + ' (+)</div>');
-            $('#dc_' + prop).hide();
-        } else {
-            if (idx == -1) document.getElementById('visavis_iframe').contentWindow.visavis.elementals_on.push(prop);
-            $('#discovery_enabled').append('<div class="rearrange" rel="' + prop + '">' + wmgui.elemental_names[prop] + ' (&minus;)</div>');
-            $('#dc_' + prop).show();
-        }
-        that.remove();
-    });
-    $('#ss_gear_matrix, #ss_gear_cube').click(function(){
-        var domain = $(this).attr('id').substr(8); // ss_gear_
-        if (domain == 'matrix'){
-            $('#ss_z, #sops_z').hide();
-            $('#ss_x, #ss_y, #sops_x, #sops_y').css('width', '50%');
-        } else {
-            $('#ss_x, #ss_y, #ss_z, #sops_x, #sops_y, #sops_z').css('width', '33%');
-            $('#ss_z, #sops_z').show();
-        }
-
-        // ss_ logic
-        var common_type = $('#ctxpanel_' + domain + ' > ul > li.embodied').attr('id').split('_')[1], // NB embodied, not ss_x
-            y_id = $('#ctxpanel_' + domain + ' > ul > li.ss_y'),
-            z_id = $('#ctxpanel_' + domain + ' > ul > li.ss_z'),
-            x_type = common_type,
-            y_type = y_id.length ? y_id.attr('id').split('_')[1] : common_type,
-            z_type = z_id.length ? z_id.attr('id').split('_')[1] : common_type,
-            x_orders_html = '', y_orders_html = '', z_orders_html = '';
-
-        $('#ctxpanel_' + domain + ' > ul > li').each(function(){
-            var that = $(this),
-                type = that.attr('id').split('_')[1],
-                label = that.contents().filter(function(){ return this.nodeType !== 1 })[0].data.substr(3), // filter text only, then cut "by "
-                cls_html = (type == x_type) ? ' class="ss_x"' : '';
-            x_orders_html += '<li rev="ss_x" rel="x_' + type + '"' + cls_html + '>' + label + '</li>';
-            cls_html = (type == y_type) ? ' class="ss_y"' : '';
-            y_orders_html += '<li rev="ss_y" rel="y_' + type + '"' + cls_html + '>' + label + '</li>';
-            if (domain == 'matrix')
-                return true;
-            cls_html = (type == z_type) ? ' class="ss_z"' : '';
-            z_orders_html += '<li rev="ss_z" rel="z_' + type + '"' + cls_html + '>' + label + '</li>';
-        });
-
-        $('#ss_x > ul').html(x_orders_html);
-        $('#ss_y > ul').html(y_orders_html);
-        if (domain == 'cube') $('#ss_z > ul').html(z_orders_html);
-
-        // sops_ logic
-        $('li.sops_x').removeClass('sops_x');
-        $('li.sops_y').removeClass('sops_y');
-        $('li.sops_z').removeClass('sops_z');
-
-        var sops_types = ['x', 'y', 'z'];
-        $('span.sops').each(function(){
-            var that = $(this),
-                op = that.text(),
-                type = that.attr('rel');
-            $('#sops_' + type + ' > ul > li:contains("' + op + '")').addClass('sops_' + type);
-            sops_types = sops_types.filter(function(x){ return x !== type });
-        });
-        sops_types.forEach(function(item){
-            $('#sops_' + item + ' > ul > li:contains("none")').addClass('sops_' + item);
-        });
-
-        $('#ss_custom_box, #overlay').show();
-    });
-    $('div.ss_col').on('click', 'li', function(){
-        var that = $(this),
-            rowid = that.attr('rev'),
-            rel_dat = that.attr('rel').split('_'),
-            axis = rel_dat[0],
-            clsname = (axis == 'x') ? 'ss_x' : ((axis == 'y') ? 'ss_y' : 'ss_z');
-        $('#' + rowid + ' > ul > li.' + clsname).removeClass(clsname);
-        that.addClass(clsname);
-    });
-    $('div.sops_col').on('click', 'li', function(){
-        var that = $(this),
-            rowid = that.parent().parent().attr('id'),
-            axis = rowid.split('_')[1],
-            clsname = (axis == 'x') ? 'sops_x' : ((axis == 'y') ? 'sops_y' : 'sops_z');
-        $('#' + rowid + ' > ul > li.' + clsname).removeClass(clsname);
-        that.addClass(clsname);
-    });
-
-    $('#tips_trigger').click(function(){
-        wmgui.tooltip_counter = 0;
-        show_tooltip(wmgui.tooltips[wmgui.tooltip_landing]);
-        return false;
-    });
-
-     // numeric search
-    $('#numericbox').on('click', 'div.slider_close', function(){
-        if ($('div.slider_numerics').length == 1){
-            destroy_numericbox();
-            delete wmgui.search.numeric;
-            $('#search_field-selectized').val('');
-            wmgui.multiselects['main'].clear();
-            wmgui.multiselects['main'].write(wmgui.search);
-            return false;
-        }
-        var that = $(this);
-        that.siblings('div.slider').children('div.slider_numerics')[0].noUiSlider.destroy();
-        that.parent('li').fadeOut(250, function(){ $(this).remove() });
-    });
-
-    $('#numericbox_do_trigger').click(function(){
-
-        var sliders_numerics = document.getElementsByClassName('slider_numerics'),
-            numeric = [];
-
-        for (var i = 0; i < sliders_numerics.length; i++){
-            var sdata = sliders_numerics[i].noUiSlider.get(),
-                srange = sliders_numerics[i].noUiSlider.options.range,
-                srange = [srange.min, srange.max];
-            //if (sdata[0] == srange[0] && sdata[1] == srange[1]) continue;
-            //console.log(sdata);
-
-            var prop = sliders_numerics[i].getAttribute('rel');
-            numeric.push([prop, '>', sdata[0]]);
-            numeric.push([prop, '<', sdata[1]]);
-        }
-
-        if (numeric.length) wmgui.search.numeric = numeric;
-
-        if ($('#advsbox').is(':visible'))
-            $('#advsearch_do_trigger').trigger('click');
-        else
-            $('#search_trigger').trigger('click');
-    });
-
-    $('#numericbox_drop_trigger').click(function(){
-
-        var sliders_numerics = document.getElementsByClassName('slider_numerics');
-
-        //console.log(sliders_numerics);
-
-        for (var i = 0; i < sliders_numerics.length; i++){
-            var srange = sliders_numerics[i].noUiSlider.options.range;
-            sliders_numerics[i].noUiSlider.set([srange.min, srange.max]);
-        }
-    });
-
-    $('#close_numericbox').click(function(){
-        destroy_numericbox();
-        delete wmgui.search.numeric;
-        $('#search_field-selectized').val('');
-        wmgui.multiselects['main'].clear();
-        wmgui.multiselects['main'].write(wmgui.search);
-    });
-
-    // mobile version switching
-    /*$('#mobilebox span').click(function(){
-        window.location.href = '/m/' + window.location.hash;
-    });
-    $('#mobilebox a').click(function(){
-        $('#mobilebox').remove();
-        return false;
-    });*/
-
-    // keys press
-    $(document).keydown(function(e){
-        var key = window.event ? e.keyCode : e.which;
-        if (key == 13){ // ENTER: input must trigger submit button via two parent divs!
-            var focused = $(':focus');
-            //console.log(focused);
-
-            if (focused.hasClass('submitter')){
-                focused.parent().parent().find('div.def_submittable').trigger('click');
-
-            } else if (focused.hasClass('advs_input') || (focused.attr('id') || "").startswith('advs_fct_')){
-                $('#advsearch_do_trigger').trigger('click');
-            }
-        } else if (key == 27){ // ESC
-            var target = $('div.cross:visible');
-            if (target.length) target.trigger('click');
-        }
-    });
-
-    $(window).bind('hashchange', url_redraw_react);
-
-    // execute a command in all the active GUI windows (except the current) e.g. setting a new state
-    $(window).bind('storage', function(ev){
-        if (ev.originalEvent.key != wmgui.store_comm_exec_key)
-            return;
-
-        var runnable_name = ev.originalEvent.newValue;
-        if (runnable_name && window[runnable_name]) window[runnable_name]();
-    });
-
-    /*$(window).resize(function(){
-        //document.title = document.body.clientWidth + ' px';
-        if (document.body.clientWidth < 1000) $('#mobilebox').show();
-        else                                  $('#mobilebox').hide();
-    });*/
-
-    document.querySelector('#ptable_previews').addEventListener('click', function(event){
-        if (event.target.classList.contains('subphases_trigger')){
-            var state = parseInt(event.target.getAttribute('data-state')),
-                req = Object.assign({}, wmgui.ptable.query),
-                param;
-
-            if (state === 1){
-                param = 'strict=1';
-
-            } else {
-                param = 'subphases=1';
-                delete req.classes;
-            }
-            ajax_download(wmgui.ptable.active_ajax, wmgui.search_endpoint + '?q=' + JSON.stringify(req) + '&' + param, render_left);
-            wmgui.ptable.subphases_set(state);
-        }
-    });
-
-    // theme switcher
-    document.getElementById('darkmode_trigger').onclick = function(){
-        wmgui.darkmode.toggle();
-        document.getElementById('darkmode_trigger').innerHTML = wmgui.darkmode.isActivated() ? 'enabled' : 'disabled';
-        document.getElementById('comms').contentWindow.postMessage(JSON.stringify({darkmode: wmgui.darkmode.isActivated() ? 1 : 2}), '*');
-    }
-
-    // cross-site comms
-    window.addEventListener('message', function(message){
-        //if (message.origin === 'https://trusted.com') {
-        var received = {};
-        try {
-            received = JSON.parse(message.data);
-        } catch (ignore){}
-        var darkmode = received.darkmode;
-        if (darkmode !== undefined){
-            darkmode = (darkmode === 1);
-            if (darkmode !== wmgui.darkmode.isActivated()) wmgui.darkmode.toggle();
-            document.getElementById('darkmode_trigger').innerHTML = wmgui.darkmode.isActivated() ? 'enabled' : 'disabled';
-        }
-        //}
-    });
-    // EOF register_events
-}
diff --git a/src_js/main_logic.js b/src_js/main_logic.js
deleted file mode 100755
index 7f6cc64..0000000
--- a/src_js/main_logic.js
+++ /dev/null
@@ -1,1634 +0,0 @@
-"use strict";
-
-var wmgui = window.wmgui || {};
-
-wmgui.notify = function(msg){
-    var delay = 0;
-    if (wmgui.notify_counter){
-        clearInterval(wmgui.notify_counter);
-        wmgui.notify_counter = null;
-        delay = 1500;
-    }
-    setTimeout(function(){
-        $('#notifybox').html(wmgui.clean(msg)).show();
-        wmgui.notify_counter = setTimeout(function(){ $('#notifybox').hide() }, 4000);
-    }, delay);
-}
-
-// external API function
-wmgui.aug_search_cmd = function(new_fct, new_val){
-
-    // Take care of mutually exclusive facets
-    var checks = [['elements', 'formulae'], ['formulae', 'elements'], ['lattices', 'sgs'], ['sgs', 'lattices'], ['protos', 'sgs'], ['sgs', 'protos'], ['lattices', 'protos'], ['protos', 'lattices']];
-    for (var i = 0; i < checks.length; i++){
-        if (wmgui.search[checks[i][0]] && new_fct == checks[i][1]){ delete wmgui.search[checks[i][0]]; break; }
-    }
-
-    var orepr = {};
-
-    $.each(wmgui.facets, function(n, fct){
-        if (wmgui.search[fct] && fct == new_fct){
-            if (wmgui.multi_facets.indexOf(fct) !== -1)
-                orepr[fct] = wmgui.search[fct] + ',' + new_val;
-            else
-                orepr[fct] = new_val;
-
-        } else if (wmgui.search[fct]){
-            orepr[fct] = wmgui.search[fct];
-
-        } else if (fct == new_fct){
-            orepr[fct] = new_val;
-        }
-    });
-    return '#inquiry/' + $.param(orepr);
-}
-
-// reading the selectize at the main search input (landing)
-wmgui._selectize_read_main = function(){
-    var result = {};
-
-    $('#search_holder div.selectize-input.items').children().each(function(){
-        if (this.tagName !== 'DIV')
-            return;
-
-        var facet = this.getAttribute('data-facet');
-
-        if (wmgui.other_facets.indexOf(facet) !== -1 && wmgui.search[facet])
-            result[facet] = wmgui.search[facet];
-
-        else if (facet == 'numeric'){
-            if (wmgui.search[facet]){
-                result[facet] = '';
-                wmgui.search[facet].forEach(function(item){
-                    result[facet] += serialize_numeric.apply(this, item); // unpack
-                });
-                if (result[facet].length) result[facet] = result[facet].substr(0, result[facet].length - 1);
-            } // NB else just skip!
-        }
-
-        else if (result[facet] && facet == 'elements')
-            result[facet] += '-' + this.getAttribute('data-term');
-
-        else if (result[facet] && wmgui.multi_facets.indexOf(facet) !== -1)
-            result[facet] += ', ' + this.getAttribute('data-term');
-
-        else if (facet == 'formulae')
-            result[facet] = this.getAttribute('data-term').replaceAll('<sub>', '').replaceAll('</sub>', '');
-
-        else
-            result[facet] = this.getAttribute('data-term');
-    });
-
-    return result;
-}
-
-// reading the selectize at the *wmgui.multi_facets* categories
-wmgui._selectize_read_facet = function(fct){
-    var result = {},
-        selector = 'div.advs_' + fct;
-
-    $(selector + ' div.selectize-input.items').children().each(function(){
-        if (this.tagName !== 'DIV')
-            return;
-
-        var facet = this.getAttribute('data-facet');
-
-        if (result[facet])
-            result[facet] += ', ' + this.getAttribute('data-term');
-        else
-            result[facet] = this.getAttribute('data-term');
-        return;
-    });
-
-    return result;
-}
-
-wmgui._selectize_write = function($this, name, search_obj){
-
-    wmgui.selectize_emit = false;
-
-    var given_search = {};
-    $.extend(given_search, search_obj);
-
-    if (name == 'main'){
-        name = ['formulae', 'props', 'elements', 'classes', 'lattices', 'aetypes'];
-
-        for (var i = 0; i < wmgui.other_facets.length; i++){
-            if (given_search[wmgui.other_facets[i]]){
-                $this.display(wmgui.other_facets[i], wmgui.facet_names[wmgui.other_facets[i]].toLowerCase()); // stub display
-            }
-        }
-
-        if (given_search.numeric) $this.display('numeric', 'range search');
-
-    } else name = [name];
-
-    name.forEach(function(facet){
-        // facets supported for multiselect autocomplete
-        if (!given_search[facet])
-            return;
-
-        else if (facet == 'elements' && given_search[facet].indexOf('-') > 0){
-            given_search[facet].split('-').forEach(function(part){
-                $this.display(facet, part);
-            });
-        } else if (wmgui.multi_facets.indexOf(facet) !== -1 && given_search[facet].indexOf(',') > 0){
-            given_search[facet].split(',').forEach(function(part){
-                $this.display(facet, part);
-            });
-        } else if (facet == 'formulae'){
-            given_search[facet] = wmgui.to_formula(given_search[facet]);
-            $this.display(facet, given_search[facet]);
-
-        } else $this.display(facet, given_search[facet]);
-    });
-
-    $this.clearOptions();
-    wmgui.selectize_emit = true;
-}
-
-wmgui._selectize_display = function($this, facet, term){
-    var random_id = Math.floor((Math.random() * 1000));
-    $this.addOption({facet: facet, label: term, id: random_id});
-    $this.addItem(random_id);
-}
-
-function show_interpretation(search){
-    // FIXME only allow pre-defined props
-    $('#interpret').html(
-        wmgui.clean(wmgui.get_interpretation(search, wmgui.facet_names, wmgui.numerics))
-    );
-}
-
-// re-loading without history affection
-function re_view_request(search_type){
-    var caption_items = [];
-    $.each(wmgui.search, function(k, v){
-        if (k == 'search_type') return true;
-        caption_items.push(v);
-    });
-    if (!caption_items.length) return;
-
-    wmgui.search_type = search_type;
-    wmgui.search.search_type = search_type;
-    request_search(wmgui.search, caption_items.join(" ").replaceAll(",", " "), true);
-    $('#dtypes_phid > ul > li').removeClass('active');
-}
-
-function request_search(search, caption, without_history){
-    if (manage_visavis(rebuild_history_box, search, caption)) return;
-
-    try { wmgui.active_ajax.abort() } catch(e){}
-    try { wmgui.quick_ajax.abort() } catch(e){}
-
-    wmgui.active_ajax = $.ajax({
-        type: 'GET',
-        url: wmgui.search_endpoint,
-        data: {
-            q: JSON.stringify(search),
-            strict: wmgui.ctx_strict_phases,
-            //subphases: wmgui.ctx_subphases,
-            sid: wmgui.sid
-        },
-        beforeSend: wmgui.show_preloader
-
-    }).always(wmgui.hide_preloader).done(function(data){
-        if (data.error)
-            return wmgui.notify(data.error);
-
-        caption = caption.replaceAll('%2F', '/');
-
-        if (!data.out.length)
-            return wmgui.notify('No hits for ' + caption);
-
-        wmgui.fuzzyout = false;
-        if (data.fuzzy_notice){
-            wmgui.fuzzyout = true;
-            wmgui.notify(data.fuzzy_notice);
-        }
-
-        var res_str = (data.estimated_count == 1) ? ' result' : ' results',
-            notice = (data.estimated_count > 150) ? 'At least ' : '';
-        document.title = notice + data.estimated_count + res_str; // + ' (' + wmgui.estimate + ')';
-        //console.log('Obtained: '+data.estimated_count+', expected: '+wmgui.estimate);
-        switch_view_mode(2);
-
-        if (!wmgui.chosen_table_browser) // TODO add smarter check?
-            wmgui.thumbed_display = (data.out.length > wmgui.ntab_tolerance);
-
-        if (wmgui.thumbed_display){
-            var $db = $('#databrowser');
-            $db.removeClass().addClass('thumbed').empty().append('<tr><td>' + build_thumbs(data.out) + '</td></tr>');
-            $('#results').slideDown(250);
-
-        } else {
-            var $db = $('#databrowser');
-            $db.removeClass().addClass('tabled').empty().append(build_cells(data.out, '<tbody>', '</tbody>'));
-            $('#results').slideDown(250);
-
-            if (wmgui.search_type == 2){
-                $db.addClass('tablesorter').tablesorter({ sortMultiSortKey: 'ctrlKey', headers: {
-                    0: {sorter: 'doi'},
-                    5: {sorter: false}
-                }, selectorHeaders: '#dataheader_articles > thead > tr > th', selectorHeaderParent: 'dataheader_articles' });
-                $('#header_articles').show();
-
-            } else if (wmgui.search_type == 1){
-                $db.addClass('tablesorter').tablesorter({ sortMultiSortKey: 'ctrlKey', headers: {
-                    0: {sorter: 'chemical'},
-                    1: {sorter: 'digit'},
-                    2: {sorter: 'digit'},
-                    3: {sorter: 'digit'},
-                    4: {sorter: false}
-                }, selectorHeaders: '#dataheader_phases > thead > tr > th', selectorHeaderParent: 'dataheader_phases' });
-                $('#header_phases').show();
-
-            } else {
-                $db.addClass('tablesorter').tablesorter({ sortMultiSortKey: 'ctrlKey', headers: {
-                    0: {sorter: 'chemical'},
-                    1: {sorter: false},
-                    5: {sorter: 'doi'}
-                }, selectorHeaders: '#dataheader_entries > thead > tr > th', selectorHeaderParent: 'dataheader_entries' });
-                $('#header_entries').show();
-            }
-        }
-
-        // count & show ctx
-        wmgui.unfinished_page = false;
-        if (wmgui.search_type || search.phid){
-            if (data.estimated_count >= wmgui.quick_page_size * 3) $('#toomuch span').html('other').parent().show();
-            show_hints(search.entry || search.interlinkage);
-
-        } else {
-            if (data.estimated_count > wmgui.quick_page_size + wmgui.fetch_page_size){
-                $('#toomuch span').html('nearly ' + (data.estimated_count - wmgui.quick_page_size)).parent().show();
-                show_hints(search.entry, data.estimated_count);
-
-            } else if (data.estimated_count > wmgui.quick_page_size){
-                $('#loadscroll').show();
-                wmgui.unfinished_page = true;
-
-            } else show_hints(search.entry, data.estimated_count);
-        }
-
-        // switchers
-        if (wmgui.visavis_terminating) stop_visavis();
-
-        if (wmgui.search_type || search.phid || search.bid || search.entry || search.interlinkage || search.doi || search.numeric){
-
-            if (search.phid || search.bid || search.entry){
-                switch_control_mode(9, 11, 'a', 'c');
-                show_dunit_info(search.phid, search.bid, search.entry);
-
-            } else if (search.interlinkage){
-                switch_control_mode(9, 11, 'a', 'c');
-                show_examples('#examples', true, true);
-                $('#dtypes').hide();
-
-            } else if (search.numeric){
-                switch_control_mode(1, 12, 'b', false);
-                //console.log(search.numeric);
-                destroy_numericbox();
-                $.each(get_sliders_ranges(search.numeric, wmgui.numerics), function(n, item){ create_floating_slider.apply(this, item) }); // unpack
-                show_examples('#examples', true, true);
-
-            } else {
-                switch_control_mode(1, 10, false, false);
-                show_examples('#examples', true, true);
-            }
-
-            if (search.entry){
-                var that = $('#e__' + search.entry);
-                if (search.entry.indexOf('-') == -1 && !that.length) that = $('#e__' + search.entry + '-1');
-                if (that.length && that.attr('data-rank') != 0){ // NB "!=", not "!=="
-                    that.removeClass('busy_entry');
-                    open_context(that, true);
-                }
-            }
-
-        } else {
-            wmgui.fuzzyout ? switch_control_mode(1, 11, 'a', false) : switch_control_mode(0, 10, false, false);
-            request_refinement(search, (data.estimated_count > wmgui.quick_page_size));
-        }
-
-        //console.log(search);
-        if (!search.numeric){
-            destroy_numericbox();
-            delete wmgui.search.numeric;
-        }
-        if (search.props && wmgui.numerics[search.props]){ // making a hint
-            var data = wmgui.numerics[search.props],
-                prop_id = data[0],
-                units = data[1],
-                min = data[2],
-                max = data[3],
-                step = data[4];
-            create_floating_slider(search.props, prop_id, units, min, max, step);
-        }
-        if (!without_history) rebuild_history_box(search, caption);
-        wmgui.search.elements && wmgui.search_type == 1 ? $('#phases_ctx').show() : $('#phases_ctx').hide();
-
-    }).fail(function(xhr, textStatus, errorThrown){
-        if (textStatus != 'abort')
-            wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-    });
-}
-
-function rebuild_history_box(search, caption){
-    var orepr = {};
-    wmgui.facets.forEach(function(item){
-        if (search[item]) orepr[item] = search[item];
-    });
-
-    var inquiry = false;
-    $.each(wmgui.inquiries, function(m, i){ if (orepr[i]){ inquiry = true; return false; } });
-
-    var title = [];
-    for (var prop in orepr){ title.push(orepr[prop].toLowerCase()) }
-    title.sort();
-    var fingerprint = title.join(" "),
-        search_log = JSON.parse(window.localStorage.getItem(wmgui.store_history_key) || '[]'),
-        chk_searches = [];
-    if (search_log.length > 8) search_log = search_log.slice(0, 7);
-    $.each(search_log, function(n, item){
-        var title = [];
-        for (var p in item){ title.push(item[p].toLowerCase()) }
-        title.sort();
-        chk_searches.push(title.join(" "));
-    });
-    if (chk_searches.indexOf(fingerprint) == -1){
-        var item;
-        if (inquiry) item = '<a href="#inquiry/' + $.param(orepr) + '">' + caption + '</a>';
-        else         item = '<a href="#search/' + encodeURIComponent(caption) + '">' + caption + '</a>';
-
-        $('#history ul').prepend('<li>' + wmgui.clean(item) + '</li>');
-        search_log.unshift(orepr);
-        window.localStorage.setItem(wmgui.store_history_key, JSON.stringify(search_log));
-        if ($('#history ul li').length > 8) $('#history ul li:last').remove();
-    }
-    wmgui.tooltip_counter++;
-    if (wmgui.tooltip_counter == 1){
-        setTimeout(function(){ show_tooltip(wmgui.tooltips['interpretation']) }, 3000);
-    }
-}
-
-function rotate_interesting(){
-    $('#legend').html('<i>e.g.</i> <a href="#">' + wmgui.get_interesting()['text'].replace(/\d/g, "&#x208$&;") + '</a>');
-}
-
-function show_examples(box, more_examples, fix_rfn_header){
-    if (wmgui.cliff_counter === null) wmgui.cliff_counter = Math.floor(Math.random() * wmgui.cliffhangers.length);
-    var html = '';
-    for (var i = 0; i < (more_examples ? 7 : 3); i++){
-        wmgui.cliff_counter += 1;
-        if (wmgui.cliff_counter > wmgui.cliffhangers.length-1) wmgui.cliff_counter = 0;
-        html += '<li><a href="#search/' + wmutils.termify_formulae(wmgui.cliffhangers[wmgui.cliff_counter]) + '">' + wmgui.cliffhangers[wmgui.cliff_counter].charAt(0).toUpperCase() + wmgui.cliffhangers[wmgui.cliff_counter].slice(1) + '</a></li>';
-
-        var legend = wmgui.get_interesting()['text'];
-        html += '<li><a href="#search/' + encodeURIComponent(legend) + '">' + legend.charAt(0).toUpperCase() + legend.slice(1).replace(/\d/g, "&#x208$&;") + '</a></li>';
-    }
-    $(box + ' > ul').empty().append(html);
-    $(box).show();
-
-    if (fix_rfn_header){
-        $('#refine_col > div.col_title, #refine_col > ul').hide();
-        $('#refine_col').show();
-    }
-}
-
-function arrange_menu_collateral(){
-    $('#hintsbox_msg, #tagcloudbox').empty();
-
-    var links_html = '';
-    for (var i = 0; i < wmgui.collateral_links.length; i++){
-        var rel = wmgui.collateral_links[i][1],
-            cls = wmgui.collateral_links[i][1] ? 'collateral' : false,
-            target = '',
-            lbr = '';
-        if (i % 2){
-            cls = cls ? cls + ' violet' : 'violet';
-            lbr = '<br />';
-        }
-        if (wmgui.collateral_links[i][3]) target = ' target="_blank"';
-        links_html += '<a' + target + ' href="' + wmgui.collateral_links[i][0] + '"' + (cls ? ' class="' + cls + '"' : '') + (rel ? ' rel=' + rel : '') + '>' + wmgui.collateral_links[i][2] + '</a>' + lbr;
-    };
-    $('#tagcloudbox').append(links_html);
-
-    $('#hintsbox_msg').append(wmgui.get_random_term(wmgui.welcome_msgs));
-}
-
-function switch_view_mode(mode){
-    wmgui.view_mode = mode;
-    $('div.autocomplete-suggestions').hide();
-    $('#results, #header_entries, #header_phases, #header_articles').hide();
-    $('div.context_msg').hide();
-    close_vibox();
-
-    if (mode == 1){
-        stop_visavis();
-        document.title = 'Materials Platform for Data Science';
-        $('body').addClass('noscroll');
-        $('#search_box').removeClass('fluid');
-
-        $('div.side_cols').hide();
-        $('#legend').show();
-
-        $('#search_holder').removeClass('prolonged').focus();
-        $('#search_area').removeClass('prolonged');
-        $('#ermac_logo').removeClass('cornered');
-
-        wmgui.ptable.decide();
-        if (wmgui.ptable.activated) document.getElementById('ptable_dtypes_box').classList.add('resulted');
-
-    } else if (mode == 2){
-
-        $('#legend').hide();
-        $('#ctx_col').hide();
-        if (wmgui.passive_sim_col) $('#sim_col').hide();
-
-        $('body').removeClass('noscroll');
-        $('#search_box').addClass('fluid');
-
-        $('#right_col').show();
-        $('#dtypes').show();
-        $('#search_holder, #search_area').addClass('prolonged');
-        $('#ermac_logo').addClass('cornered');
-
-        wmgui.ptable.hide();
-        document.getElementById('ptable_dtypes_box').classList.remove('resulted');
-    }
-    // hook back into a parent integration
-    wmgui.mpdsgui.view(mode);
-}
-
-function switch_control_mode(mode, next_mode, active_abf, active_cde){ // NB (0, 10) is the most common 6-button layout
-    if (mode == 0){ // cde, second
-        $('#control_c, #control_d, #control_e').css('width', '33.3%').show();
-
-    } else if (mode == 1){ // cde, second
-        $('#control_e').hide();
-        $('#control_c, #control_d').css('width', '50%').show();
-
-    } else if (mode == 9){ // cde, second
-        $('#control_e, #control_d').hide();
-        $('#control_c').css('width', '100%').show();
-
-    } else if (mode == 10){ // abf, first
-        $('#control_a, #control_b, #control_f').css('width', '33.3%').show();
-
-    } else if (mode == 11){ // abf, first
-        $('#control_b, #control_f').hide();
-        $('#control_a').css('width', '100%').show();
-
-    } else if (mode == 12){ // abf, first
-        $('#control_a, #control_f').hide();
-        $('#control_b').css('width', '100%').show();
-    }
-    if (!next_mode) return;
-
-    if (!active_abf) active_abf = ({0: 'a', 1: 'b', 2: 'f'})[wmgui.search_type];
-    if (!active_cde) active_cde = wmgui.thumbed_display ? 'd' : 'c';
-
-    $('div.controlswitch > div').removeClass();
-    $('#control_' + active_abf + ', #control_' + active_cde).addClass('active');
-
-    switch_control_mode(next_mode);
-}
-
-function build_cells(json, header, footer){
-    var cls_map = {7: 'ml_data', 8: 'ab_data', 9: 'ab_data', 10: 'ab_data', 11: 'ab_data', 13: 'deactivated'},
-        result_html = '';
-
-    if (header) result_html += header;
-
-    if (wmgui.search_type == 2){
-        if (json[0].length != 6){ wmgui.notify('Rendering error, please try to <a href=javascript:location.reload()>reload</a>'); return ''; }
-
-        var act_link = '';
-
-        $.each(json, function(k, row){
-
-            act_link = '<a class="launch_id" href="#article/' + row[0] + '">Show</a>';
-
-            row[0] = parseInt(row[0]);
-            if (row[0] == 999999){
-                row[4] = wmgui.mockyear; // special *ref_id*, only handled in GUI
-                act_link = '&nbsp;';
-            }
-            result_html += '<tr id="e__B' + row[0] + '" class="tcell" data-type="B"><td class=c55>[<a class="resolve_ref' + ((wmgui.bid_history.indexOf(row[0]) !== -1) ? ' visited' : '') + '" href="' + wmgui.refs_endpoint + '?ref_id=' + row[0] + '&sid=' + wmgui.sid + '&ed=' + wmgui.edition + '" rel="' + row[0] + '" target="_blank" rel="noopener noreferrer">' + row[0] + '</a>]</td><td class=a1>' + row[1] + '</td><td class=a2 title="' + row[2] + '">' + row[2] + '</td><td class=a5>' + row[5] + '</td><td class=c4>' + row[4] + '</td><td class=a6>' + act_link + '</td></tr>';
-        });
-    } else if (wmgui.search_type == 1){
-        if (json[0].length != 5){ wmgui.notify('Rendering error, please try to <a href=javascript:location.reload()>reload</a>'); return ''; }
-
-        $.each(json, function(k, row){
-            result_html += '<tr id="e__Z' + row[0] + '" class="tcell" data-type="Z"><td class=p1>' + row[1] + '</td><td class=p2>' + row[2] + '</td><td class=p3>' + row[3] + '</td><td class=p4>' + row[4] + '</td><td class=p5><a class="launch_id" href="#phase_id/' + row[0] + '">Show entries</a></td></tr>';
-        });
-    } else {
-        if (json[0].length != 8){ wmgui.notify('Rendering error, please try to <a href=javascript:location.reload()>reload</a>'); return ''; }
-
-        $.each(json, function(k, row){
-            row[7] = parseInt(row[7]);
-            var dtype = row[0].substr(0, 1),
-                preview = (row[3] == 4 || row[3] == 5 || row[3] == 6 || row[3] == 9 || row[3] == 10 || row[3] == 12) ? '<span class=launch_v>Show</span>' : ' ', // FIXME? w.r.t. open_context
-                biblio_html = (row[7] == 999999) ? '<td class=cj>&mdash;</td><td class=c4>' + wmgui.mockyear + '</td><td class=c5>&mdash;</td>' :
-                '<td class=cj>' + row[5] + '</td><td class=c4>' + row[6] + '</td><td class=c5>[<a class="resolve_ref' + ((wmgui.bid_history.indexOf(row[7]) !== -1) ? ' visited' : '') + '" href="' + wmgui.refs_endpoint + '?ref_id=' + row[7] + '&sid=' + wmgui.sid + '&ed=' + wmgui.edition + '" rel="' + row[7] + '" target="_blank" rel="noopener noreferrer">' + row[7] + '</a>]</td>'; // special *ref_id*, only handled in GUI
-
-            result_html += '<tr id="e__' + row[0] + '" class="tcell ' + (cls_map[row[3]] || '') + (row[4] ? ' opened' : '') + '" data-type="' + dtype + '" data-rank="' + row[3] + '" title="Click for more info"><td class=c1>' + row[1] + '</td><td class=cp>' + preview + '</td><td class=c2>' + row[2] + '</td>' + biblio_html + '</tr>';
-        });
-    }
-    if (footer) result_html += footer;
-    return result_html;
-}
-
-function build_thumbs(json){
-    var cls_map = {6: 'pd_full', 7: 'ml_data', 8: 'ab_data', 9: 'ab_data', 10: 'ab_data', 11: 'ab_data', 13: 'deactivated'},
-        result_html = '';
-
-    if (wmgui.search_type == 2){
-        if (json[0].length != 6){ wmgui.notify('Rendering error, please try to <a href=javascript:location.reload()>reload</a>'); return ''; }
-
-        json.sort(function(a, b){
-            return a[4] > b[4] ? 1 : a[4] < b[4] ? -1 : 0; // pubyear
-        });
-
-        var title_html = '',
-            full_display = !!wmgui.sid,
-            act_link = '';
-
-        $.each(json, function(k, row){
-
-            act_link = '<a class="launch_id" href="#article/' + row[0] + '">Show entries</a>';
-
-            row[0] = parseInt(row[0]);
-            if (row[0] == 999999){
-                row[4] = wmgui.mockyear; // special *ref_id*, only handled in GUI
-                act_link = 'Too many to show...';
-            }
-            if (full_display) title_html = (row[1].length > 60 ? row[1].substr(0, 60) + '&hellip;' : row[1]) + ', <span>' + (row[2].length > 80 ? row[2].substr(0, 80) + '&hellip;' : row[2]) + '</span>';
-            else title_html = '<b>&#x1f4d6;</b>'; // book icon
-
-            result_html += '<div class="gallery_item" id="e__B' + row[0] + '" data-type="B"><div class="gallery_img"><div class="articled">' + title_html + '</div></div><div class="gallery_label">' + act_link + '<br />[<a class="resolve_ref' + ((wmgui.bid_history.indexOf(row[0]) !== -1) ? ' visited' : '') + '" href="' + wmgui.refs_endpoint + '?ref_id=' + row[0] + '&sid=' + wmgui.sid + '&ed=' + wmgui.edition + '" rel="' + row[0] + '" target="_blank" rel="noopener noreferrer">' + row[3] + '&rsquo;' + row[4].toString().substr(2, 2) + '</a>]</div></div>';
-        });
-    } else if (wmgui.search_type == 1){
-        if (json[0].length != 5){ wmgui.notify('Rendering error, please try to <a href=javascript:location.reload()>reload</a>'); return ''; }
-
-        json.sort(function(a, b){
-            return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
-        });
-        $.each(json, function(k, row){
-            result_html += '<div class="gallery_item" id="e__Z' + row[0] + '" data-type="Z"><div class="gallery_img" rel="' + row[0] + '"><div class="phased">' + row[1] + '<br /><br />space group ' + row[2] + '</div></div><div class="gallery_label"><a class="launch_id" href="#phase_id/' + row[0] + '">Show ' + row[3] + (row[3] == 1 ? ' entry' : ' entries') + '</a><br />Publications: ' + row[4] + '</div></div>';
-        });
-    } else {
-        if (json[0].length != 8){ wmgui.notify('Rendering error, please try to <a href=javascript:location.reload()>reload</a>'); return ''; }
-
-        json.sort(function(a, b){
-            var dtype_a = a[0].substr(0, 1),
-                dtype_b = b[0].substr(0, 1);
-
-            if (dtype_a == 'S'){
-                if (dtype_b == 'S') return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
-                return -1;
-            }
-            if (dtype_a == 'C'){
-                if (dtype_b == 'C') return a[7] > b[7] ? 1 : a[7] < b[7] ? -1 : 0;
-                if (dtype_b == 'S') return 1;
-                if (dtype_b == 'P') return -1;
-            }
-            if (dtype_a == 'P'){
-                if (dtype_b == 'P') return a[2].toUpperCase() > b[2].toUpperCase() ? 1 : a[2].toUpperCase() < b[2].toUpperCase() ? -1 : 0;
-                return 1;
-            }
-        });
-        $.each(json, function(k, row){
-            row[7] = parseInt(row[7]);
-            var dtype = row[0].substr(0, 1),
-                content,
-                biblio_html = (row[7] == 999999) ? '<br />&mdash;' :
-                '<br />[<a class="resolve_ref' + ((wmgui.bid_history.indexOf(row[7]) !== -1) ? ' visited' : '') + '" href="' + wmgui.refs_endpoint + '?ref_id=' + row[7] + '&sid=' + wmgui.sid + '&ed=' + wmgui.edition + '" rel="' + row[7] + '" target="_blank" rel="noopener noreferrer">' + row[5] + '&rsquo;' + row[6].toString().substr(2, 2) + '</a>]'; // special *ref_id*, only handled in GUI
-
-            if (dtype == 'P')
-                content = '<div>' + row[2] + '</div>';
-            else if (dtype == 'S')
-                content = '<img loading="lazy" alt="' + row[0] + '" src="' + wmgui.static_host + '/rd_thumbs/' + row[0].split('-')[0] + '.png" />';
-            else {
-                // FIXME
-                row[2] = row[2].split(';')[0];
-                row[2] = row[2].split(' ')[row[2].split(' ').length - 1];
-                var url_dest = (row[3] == 12) ? (row[2].split('-').length == 3 ? '/prism' : '/tetrahedron') : '/pd_thumbs/' + row[0].split('-')[0];
-                content = '<img loading="lazy" alt="' + row[0] + '" src="' + wmgui.static_host + url_dest + '.png" /><p>' + row[2] + '</p>';
-            }
-            result_html += '<div class="gallery_item ' + (cls_map[row[3]] || '') + (row[4] ? ' opened' : '') + '" id="e__' + row[0] + '" data-type="' + dtype + '" data-rank="' + row[3] + '" title="Click for more info"><div class="gallery_img">' + content + '</div><div class="gallery_label">' + row[1] + biblio_html + '</div></div>';
-        });
-    }
-    return result_html;
-}
-
-function request_refinement(query_obj, is_heavy){
-    $('#examples, #ind_col').hide();
-    $('#ind_col > span').empty();
-    $('#refine_col > ul').empty().parent().show();
-    $('#refine_col > div.col_title').show();
-
-    var given_search = {is_heavy: is_heavy};
-    $.extend(given_search, query_obj);
-    try { wmgui.active_ajax.abort() } catch(e){}
-
-    //console.log(given_search);
-    wmgui.active_ajax = $.ajax({
-        type: 'GET',
-        url: wmgui.rfn_endpoint,
-        data: {q: JSON.stringify(given_search)},
-        beforeSend: function(){ $('#rfn_preloader').show() }
-
-    }).always(function(){ $('#rfn_preloader').hide() }).done(function(data){
-        if (data.error) return wmgui.notify(data.error);
-
-        var was_facet = null,
-            refine_html = '',
-            classes_chk = [],
-            num_terms = 0;
-        delete given_search['is_heavy'];
-
-        if (given_search.classes){ // no whitespace in multiple classes
-            classes_chk = given_search.classes.split(',').map(function(x){ return x.trim() });
-            given_search.classes = classes_chk.join(',');
-        }
-
-        var inquiry = false;
-        $.each(wmgui.inquiries, function(n, i){ if (given_search[i]){ inquiry = true; return false; } });
-
-        $.each(data.payload, function(i, found_obj){
-            if (query_obj.formulae && found_obj.facet == 'elements') return true; // NB no sense to show elements in this context
-
-            var link_base = '',
-                //count_text = ' ('+found_obj.count+')',
-                nested_skip = false,
-                orepr = {};
-
-            $.each(given_search, function(key, val){
-                if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1)
-                    return true;
-                else if (found_obj.facet == 'elements' && (key == 'elements' || key == 'formulae'))
-                    return true;
-                else if (found_obj.facet == 'props' && key == 'props')
-                    return true;
-
-                link_base += val + ' ';
-
-                if (orepr[key]) orepr[key] += ', ' + val;
-                else            orepr[key] = val;
-            });
-            //if (found_obj.facet == 'elements') count_text = '';
-            if (query_obj.classes && found_obj.facet == 'classes'){
-                $.each(classes_chk, function(n, cls){
-                    if (cls == found_obj.value){ nested_skip = true; return false; }
-                });
-            }
-            if (nested_skip) return true;
-
-            if (found_obj.facet != was_facet){
-                if (was_facet && is_heavy) refine_html += '<li class="fct_' + was_facet + ' extd_refine"><a class="extd_refine" rel="' + was_facet + '" href="#">Show more&nbsp;</a></li>';
-                refine_html += '<li class="new_rfn_facet fct_' + found_obj.facet + '">' + wmgui.facet_names[found_obj.facet] + '</li>';
-                was_facet = found_obj.facet;
-            }
-            if (found_obj.facet == 'props'){
-                found_obj.value = found_obj.value.replace(/\(|\)/g, "").replace(/\/[\w\-]*/g, ""); // FIXME
-            }
-
-            if (orepr[found_obj.facet]) orepr[found_obj.facet] += ', ' + found_obj.value;
-            else                        orepr[found_obj.facet] = found_obj.value;
-
-            if (orepr['elements']) orepr['elements'] = orepr['elements'].replaceAll(', ', '-');
-
-            if (inquiry) refine_html += '<li class="fct_' + found_obj.facet + '"><a href="#inquiry/' + $.param(orepr) + '">' + found_obj.value + '</a></li>';
-            else         refine_html += '<li class="fct_' + found_obj.facet + '"><a href="#search/' + link_base + found_obj.value + '">' + found_obj.value + '</a></li>';
-            num_terms++;
-        });
-
-        if (is_heavy) refine_html += '<li class="fct_' + was_facet + ' extd_refine"><a class="extd_refine" rel="' + was_facet + '" href="#">Show more&nbsp;</a></li>';
-
-        if (num_terms == 0) show_examples('#examples', true, true);
-        else {
-            $('#refine_col > ul').show().append(wmgui.clean(refine_html));
-            if (num_terms <= 10) show_examples('#examples', false, false);
-        }
-
-    }).fail(function(xhr, textStatus, errorThrown){
-        if (textStatus != 'abort')
-            wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-    });
-}
-
-/**
- * NB: Ranks legend
- * 0 - bib-ref (unproc) + P-entries data on
- * 1 - textual (diagrammatic) P-entry
- * 2 - scalar (numeric) P-entry
- * 3 - C-phase
- * 4 - SD-entry (P-array)
- * 5 - S-entry
- * 6 - C-diagram
- * 7 - ML P-entry
- * 8 - ab initio entry (scalar)
- * 9 - ab initio entry (P-array) electron spectra
- * 10 - ab initio entry (P-array) phonon spectra
- * 11 - ab initio data in progress (unproc)
- * 12 - 3d combination of C-diagrams
- * 13 - deactivated entries
- */
-function open_context(el, launch_ext){
-    close_vibox();
-    if (el.hasClass('busy_entry')){
-        el.removeClass('busy_entry');
-        $('#ctx_col, #sim_col').hide();
-        try { wmgui.quick_ajax.abort() } catch(e){}
-
-    } else {
-        var entry = el.attr('id').substr(3),
-            rank = parseInt(el.attr('data-rank')),
-            entype = entry.substr(0, 1),
-            orig_id = entry.split('-')[0];
-
-        $('.busy_entry').removeClass('busy_entry');
-        el.addClass('busy_entry');
-
-        if (entype == 'Z' || entype == 'B') return;
-
-        $('#entryno').html('<a href="#entry/' + orig_id + '">' + orig_id + '</a>');
-
-        $('#ctx_col').show();
-        $('#visualize').attr('data-rank', rank);
-        $('#xrpdize').attr('data-rank', 99); // FIXME hack
-        //$('#visualize, #xrpdize, #absolidize, div.spinoff_pane, li.d_icon').hide();
-        $('#visualize, #xrpdize, div.spinoff_pane, li.d_icon').hide();
-
-        open_sim_col(entry, entype, rank);
-
-        if (rank == 0){
-            $('#download_bib').show();
-
-        } else if (rank == 1){
-            $('#download_bib, #download_pdf').show();
-            $.ajax({
-                type: 'GET',
-                url: wmgui.path_pp_ping + entry,
-            }).done(function(data){
-                $('#visualize, #download_png, #download_json').show();
-            }).fail(function(xhr, textStatus, errorThrown){});
-
-        } else if (rank == 2){
-            $('#download_bib, #download_pdf, #download_json').show();
-
-        } else if (rank == 3){
-            $('#download_bib, #download_png, #download_cdr').show();
-
-        } else if (rank == 4){
-            $('#download_bib, #download_json, #visualize').show();
-
-        } else if (rank == 5){
-            //$('#absolidize, #download_bib, #download_pdf, #visualize, #xrpdize, #absolidize, #download_cif, #download_inp, #download_json').show();
-            $('#download_bib, #download_pdf, #visualize, #xrpdize, #absolidize, #download_cif, #download_inp, #download_json').show();
-
-        } else if (rank == 6){
-            $('#download_bib, #download_pdf, #visualize, #download_png, #download_cdr, #download_json').show();
-
-        } else if (rank == 7){
-            $('#ml_data, #download_pdf, #download_json').show();
-
-        } else if (rank == 8){
-            $('#ab_data, #download_pdf, #download_json, #download_raw').show();
-
-        } else if (rank == 9){
-            $('#ab_data, #download_pdf, #download_json, #visualize, #download_png, #download_raw').show();
-
-        } else if (rank == 10){
-            $('#ab_data, #download_pdf, #download_json, #visualize, #download_raw').show();
-
-        } else if (rank == 11){
-            $('#ab_promise, #download_json').show();
-
-        } else if (rank == 12){
-            $('#pd3d_data, #visualize').show();
-
-        } else if (rank == 13){
-            $('#deactivated_data, #download_bib').show();
-        }
-        $('#ctx_col > ul > li.d_icon > a').each(function(){
-            var fmt = $(this).attr('rel'),
-                link_add = (entype == 'S') ? '&export=1' : '',
-                link_sid = (fmt == 'raw') ? 'null' : wmgui.sid,
-                link_url = wmgui.dd_addr_tpl + '/' + entype.toLowerCase() + '?q=' + entry + '&fmt=' + fmt + '&sid=' + link_sid + link_add + '&ed=' + wmgui.edition;
-
-            $(this).attr('href', link_url);
-        });
-
-        //(wmgui.mydata_history.indexOf(entry) == -1) ? $('#absolidize').addClass('wmbutton') : $('#absolidize').removeClass('wmbutton');
-
-        if (launch_ext) launch_db_iframed(rank);
-    }
-}
-
-function open_sim_col(entry, entype, rank){
-    $('#sim_col > ul, #sim_legend').empty();
-    $('.sim_col_ctx').hide();
-    $('#sim_col').show();
-
-    var cur_obj = {q: entry},
-        allpurpose = ([0, 1, 4, 9].indexOf(rank) !== -1);
-    if (allpurpose) cur_obj.allpurpose = true;
-
-    try { wmgui.quick_ajax.abort() } catch(e){}
-
-    wmgui.quick_ajax = $.ajax({
-        type: 'GET',
-        url: wmgui.sim_endpoint,
-        data: cur_obj,
-        beforeSend: function(){ $('#sim_preloader').show() }
-
-    }).always(function(){ $('#sim_preloader').hide() }).done(function(data){
-        if (data.error) return wmgui.notify(data.error);
-        var counter = 0,
-            sim_html = '';
-
-        if (allpurpose){
-            $.each(data.out.sim, function(k, row){
-                if (counter == 7) return false;
-                if (row[4]) sim_html += '<li><a href="#inquiry/' + $.param({'elements': row[1], 'years': row[2], 'codens': row[3], 'classes': (row[4] == 1) ? '' : row[4]}) + '">' + row[0] + '</a></li>';
-                else        sim_html += '<li><a href="#inquiry/' + $.param({'formulae': row[1], 'years': row[2], 'codens': row[3]}) + '">' + row[0] + '</a></li>';
-                counter++;
-            });
-
-        } else if (entype == 'C' || entype == 'S'){
-            if (rank > 3){
-                $.each(data.out.sim, function(k, row){
-                    if (counter == 8) return false;
-                    sim_html += '<li><a href="#phase_id/' + row[1] + '">' + row[0] + '</a></li>';
-                    counter++;
-                });
-                if (entype == 'C') $('#pd_legend').show();
-                else if (counter == 1) counter = 0;
-            }
-        } else {
-            // FIXME this is fragile
-            var prop = wmgui.thumbed_display ? $('div.busy_entry > div.gallery_img > div').text().split(';')[0] : $('tr.busy_entry > td.c2').text().split(';')[0];
-
-            $.each(data.out.sim, function(k, row){
-                if (counter == 8) return false;
-                sim_html += '<li><a href="#search/' + prop + ' ' + row[1] + '">' + row[0] + '</a></li>';
-                counter++;
-            });
-        }
-
-        if (counter){
-            if (allpurpose)         $('#sim_legend').removeClass('apparent').text('Also studied by these authors:');
-            else if (entype == 'C') $('#sim_legend').removeClass('apparent').text('Phases at the diagram:');
-            else if (entype == 'S') $('#sim_legend').removeClass('apparent').text('The same prototype structures:');
-            else                    $('#sim_legend').removeClass('apparent').text('Similar ' + prop + ':');
-
-            if (counter > 7){
-                //var link = (entype == 'C') ? '#entry/' + $('#entryno').text() : '#interlinkage/' + entry;
-                $('#sim_trigger').attr('href', '#interlinkage/' + entry).show();
-            }
-            $('#sim_col > ul').html(sim_html);
-
-        } else {
-            if (allpurpose)
-                $('#sim_legend').addClass('apparent').text('No cross-links found');
-
-            else if (entype == 'C' && rank == 3){
-                // FIXME this is fragile
-                var els,
-                    html_3d = '';
-
-                if (wmgui.thumbed_display){
-                    els = $('div.busy_entry > div.gallery_img > p').text().split('-');
-                } else {
-                    els = $('tr.busy_entry > td.c2').text().replace('; ', '').split(' ');
-                    els = els[els.length - 1].split('-');
-                }
-                if (els.length == 3 || els.length == 4)
-                    html_3d = '<br /><br /><a href="#inquiry/classes=' + (els.length == 3 ? 'prism' : 'tetrahedron') + '&props=phase%20diagram&elements=' + els.join('-') + '"><img alt="3d" src="' + wmgui.static_host + '/' + (els.length == 3 ? 'prism' : 'tetrahedron') + '.png" /><br /><span>3d phase diagram</span></a>';
-
-                $('#sim_legend').addClass('apparent').html('<br /><a href="#entry/' + entry.split('-')[0] + '"><img alt="C-entry" src="' + wmgui.static_host + '/pd_thumbs/' + entry.split('-')[0] + '.png" /><br /><span>Full phase diagram</span></a>' + html_3d);
-
-            } else if (entype == 'C' && rank == 5)
-                $('#sim_legend').addClass('apparent').text('No links to other phases found.');
-
-            else if (entype == 'C' && rank == 12)
-                $('#sim_legend').addClass('apparent').text('Hover the binary or ternary diagrams for more data.');
-
-            else if (entype == 'S')
-                $('#sim_legend').addClass('apparent').text('No other structures for this prototype found.');
-
-            else
-                $('#sim_legend').addClass('apparent').text('No similar values found.');
-        }
-
-        if (data.out.own.length && !wmgui.search.phid)
-            $('#own_phase').html('<a href="#phase_id/' + data.out.own[0][1] + '"><img alt="Phase" src="' + wmgui.static_host + '/rd_thumbs/' + data.out.own[0][0] + '.png" /><br /><span>Linked ' + (entype == 'S' ? 'distinct phase' : 'crystalline structure') + '</span></a>').show();
-
-    }).fail(function(xhr, textStatus, errorThrown){
-        if (textStatus != 'abort')
-            wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-    });
-}
-
-function close_vibox(){
-    var iframe = $('#iframe');
-    if (iframe.length){
-        if (wmgui.thumbed_display) $('#iframe').slideUp(function(){ $('#iframe').remove() });
-        else                       $('#iframe').remove();
-        $('#vibox').hide();
-        return true;
-    }
-    return false;
-}
-
-function launch_db_iframed(rank){
-    var that = $('.busy_entry');
-    if (!that.length) return;
-
-    var entry = that.attr('id').substr(3),
-        entype = entry.substr(0, 1),
-        iframe_src,
-        iframe_height;
-
-    if (entype == 'S'){
-        if (rank == 99){
-            iframe_src = wmgui.engines_addrs['visavis'] + wmgui.path_s_xrpd + entry, iframe_height = 550;
-
-        } else
-            iframe_src = wmgui.engines_addrs['cifplayer'] + wmgui.path_s_entry + entry, iframe_height = 650;
-
-    } else if (entype == 'P'){
-        if (rank == 1){
-            iframe_src = wmgui.engines_addrs['visavis'] + wmgui.path_pp_plot + entry, iframe_height = 550;
-            wmgui.notify('P-curves are in beta-testing');
-
-        } else if (rank == 4)
-            iframe_src = wmgui.engines_addrs['visavis'] + wmgui.path_sd_plot + entry, iframe_height = 550;
-
-        else if (rank == 9)
-            iframe_src = wmgui.v_pd_user_addr + wmgui.api_host + '/download/p?fmt=png&q=' + entry, iframe_height = 600;
-
-        else if (rank == 10)
-            iframe_src = wmgui.v_ab_vis_addr + entry, iframe_height = 600;
-
-        else return;
-
-    } else {
-        if (rank == 12){
-            var triple = wmgui.thumbed_display ? $('div.busy_entry > div.gallery_img > p').text() : $('tr.busy_entry > td.c1').text().split(' ')[0];
-            iframe_src = wmgui.v_pd_3d_addr + triple, iframe_height = 550;
-
-        } else if (rank == 6)
-            iframe_src = (wmgui.sid ? wmgui.v_pd_user_addr + wmgui.api_host + '/download/c?fmt=png&q=' : wmgui.engines_addrs['visavis'] + wmgui.path_c_entry) + entry, iframe_height = 600;
-
-        else return;
-
-        if (wmgui.entries_messages[entry])
-            wmgui.notify(wmgui.entries_messages[entry]);
-    }
-
-    if (wmgui.sid) iframe_src += '&sid=' + wmgui.sid;
-
-    var iframe_html = '<iframe frameborder=0 scrolling="no" width="100%" height="' + iframe_height + '" src="' + iframe_src + '"></iframe>';
-    if (wmgui.thumbed_display) iframe_html = '<div id="iframe" style="display:block;width:100%;border:1px solid #ddd;margin:10px 0;">' + iframe_html + '</div>';
-    else                       iframe_html = '<tr id="iframe"><td colspan="20" style="width:100%;padding:0;border-right:1px solid #eee;border-left:1px solid #eee;">' + iframe_html + '</td></tr>';
-
-    that.after(iframe_html);
-    $(window).scrollTop(that.position().top - 95);
-}
-
-function start_visavis(plot_type){
-
-    destroy_numericbox();
-    delete wmgui.search.numeric;
-    if (plot_type) wmgui.visavis_curtype = plot_type;
-
-    $('div.ctxpanel').hide();
-    var toshow = $('#ctxpanel_' + wmgui.visavis_curtype);
-    if (toshow.length) toshow.show();
-    if (['matrix', 'cube', 'discovery'].indexOf(wmgui.visavis_curtype) !== -1) $('#cmppanel_plots').show();
-
-    if (wmgui.visavis_working)
-        return manage_visavis();
-
-    rebuild_visavis();
-
-    // visavis_col preparation
-    $('#visavis_col').show();
-    $('#visavis').show();
-
-    switch_control_mode(0, 11, 'a', 'e');
-    $('body').addClass('noscroll');
-
-    wmgui.search_type = 0;
-    wmgui.visavis_working = true;
-
-    var cur_obj = {total_count: 1};
-    $.extend(cur_obj, wmgui.search);
-
-    try {
-        document.getElementById('visavis_iframe').contentWindow.location.replace(get_visavis_url(cur_obj));
-    } catch (e){
-        console.error('No iframe access');
-    }
-}
-
-function manage_visavis(callback_fn, param_a, param_b){
-    if (wmgui.visavis_terminating || !wmgui.visavis_working){
-        return false;
-    }
-
-    if (wmgui.search.numeric){ // not supported for plotting yet!
-        wmgui.visavis_terminating = true;
-        return false;
-    }
-
-    try { wmgui.active_ajax.abort() } catch(e){}
-    try { wmgui.quick_ajax.abort() } catch(e){}
-
-    rebuild_visavis();
-
-    var cur_obj = {total_count: 1};
-    $.extend(cur_obj, wmgui.search);
-
-    try {
-        document.getElementById('visavis_iframe').contentWindow.location.replace(get_visavis_url(cur_obj));
-    } catch (e){
-        console.error('No iframe access');
-    }
-
-    if (callback_fn) callback_fn(param_a, param_b);
-    return true;
-}
-
-function rebuild_visavis(){
-    var extr = window.location.hash.indexOf('search/');
-    if (extr == -1){
-        var extr = window.location.hash.indexOf('inquiry/');
-        if (extr == -1) return;
-    }
-
-    var query = window.location.hash.substr(extr);
-
-    $('a.pltcol_links').each(function(){
-        var that = $(this),
-            plot_type = that.attr('rev');
-        that.attr('href', wmgui.gui_host + window.location.pathname + '#plot/' + plot_type + '/' + query);
-    });
-
-    $('#visavis_col > ul > li').removeClass('embodied');
-    $('#pltchoice_' + wmgui.visavis_curtype).addClass('embodied');
-
-    // ctx reset
-    if (['matrix', 'cube', 'discovery'].indexOf(wmgui.visavis_curtype) !== -1)
-        update_dc();
-
-    if (wmgui.visavis_curtype == 'matrix'){
-        $('#ctxpanel_matrix > ul > li.embodied').removeClass('embodied');
-        var y_id = $('#ctxpanel_matrix > ul > li.ss_y');
-        if (y_id.length) y_id.removeClass('ss_y');
-        $('#vismatrix_nump').addClass('embodied'); // set the default sort order, also in Visavis: TODO
-        $('span.sops').remove();
-
-    } else if (wmgui.visavis_curtype == 'cube'){
-        $('#ctxpanel_cube > ul > li.embodied').removeClass('embodied');
-        var y_id = $('#ctxpanel_cube > ul > li.ss_y'),
-            z_id = $('#ctxpanel_cube > ul > li.ss_z');
-        if (y_id.length) y_id.removeClass('ss_y');
-        if (z_id.length) z_id.removeClass('ss_z');
-        $('#viscube_nump').addClass('embodied');
-        $('span.sops').remove();
-
-    } else if (wmgui.visavis_curtype == 'graph'){
-        $('#ctxpanel_graph > ul > li.embodied').removeClass('embodied');
-        $('#visgraph_props').addClass('embodied');
-    }
-
-    try {
-        document.getElementById('visavis_iframe').contentWindow.fixel_manage(wmgui.visavis_curtype == 'cube' && wmgui.search.elements);
-    } catch (e){
-        console.error('No iframe access');
-    }
-}
-
-function stop_visavis(){
-    $('#visavis, #visavis_col').hide();
-    wmgui.visavis_working = false;
-    wmgui.visavis_terminating = false;
-}
-
-function get_visavis_url(request, type, height){
-    if (wmgui.visavis_curtype == 'pie' && !type)
-        return wmgui.engines_addrs['visavis'] + '#' + wmgui.rfn_endpoint + '?q=' + encodeURIComponent(JSON.stringify(request));
-
-    var height_str = height ? ('&visavis_height=' + height) : '';
-
-    return wmgui.engines_addrs['visavis'] + '#' + wmgui.vis_endpoint + '/' + (type || wmgui.visavis_curtype) + '?q=' + encodeURIComponent(JSON.stringify(request)) + height_str;
-}
-
-function describe_perms(perms){
-    var out_gui = '<h3>Web-browser access = GUI</h3><ul>',
-        out_api = '<h3>Programmatic access = API</h3><ul>';
-
-    if (perms.gui){
-        if (perms.gui.root) out_gui += '<li>complete access</li>';
-        else {
-            if (!$.isArray(perms.gui)) perms.gui = [perms.gui];
-            $.each(perms.gui, function(m, ruleset){
-                if (m > 3){
-                    out_gui += '<li>and ' + (perms.gui.length - 4) + ' more...</li>';
-                    return false;
-                }
-                $.each(wmgui.facets, function(n, item){
-                    if (ruleset[item]){
-                        try {
-                            out_gui += '<li class="perms_view fct_' + item + '"><strong>' + wmgui.facet_names[item] + '</strong>: ' + ruleset[item].map(function(x){return x.replace(', ', ' &amp; ')}).join(', ') + '</li>';
-                        } catch(e){ return false }
-                    }
-                });
-                if (ruleset.refs == 'ALL')            out_gui += '<li>full access to reference details</li>';
-                else if (ruleset.refs == 'MENTIONED') out_gui += '<li>access to corresponding references</li>';
-                else                                  out_gui += '<li>no access to reference details</li>';
-                out_gui += '<li style="font-size:0.8em;line-height:0.8em;"><br /></li>';
-            });
-        }
-    } else out_gui += '<li>only open data</li>';
-
-    if (perms.api){
-        if (perms.api.root) out_api += '<li>complete access</li>';
-        else if (perms.api.disabled) out_api += '<li>disabled &mdash; please check on the other device</li>';
-        else {
-            if (!$.isArray(perms.api)) perms.api = [perms.api];
-            $.each(perms.api, function(m, ruleset){
-                if (m > 3){
-                    out_api += '<li>and ' + (perms.api.length - 4) + ' more...</li>';
-                    return false;
-                }
-                $.each(wmgui.facets, function(n, item){
-                    if (ruleset[item]){
-                        try {
-                            out_api += '<li class="perms_view fct_' + item + '"><strong>' + wmgui.facet_names[item] + '</strong>: ' + ruleset[item].map(function(x){ return x.replace(', ', ' &amp; ') }).join(', ') + '</li>';
-                        } catch(e){ return false }
-                    }
-                });
-                out_api += '<li style="font-size:0.8em;line-height:0.8em;"><br /></li>';
-            });
-        }
-    } else out_api += '<li>only open data</li>';
-
-    return out_gui + '</ul><div class="divider"></div>' + out_api + '</ul>';
-}
-
-function show_advsbox(){
-
-    $('div.modal').hide();
-    $('#advsbox, #overlay').show();
-
-    // show typed terms
-    if (!$.isEmptyObject(wmgui.search)){
-
-        $.each(wmgui.simple_facets, function(n, item){
-            if (wmgui.search[item]){
-                var value = wmgui.search[item];
-
-                if (item == "codens") value = wmgui.journal_converter.c2j(value);
-                else if (item == "doi") value = value.replaceAll('%2F', '/');
-
-                $('#advs_fct_' + item).val(decodeURIComponent(value.replace(/\+/g, "%20")));
-            } else $('#advs_fct_' + item).val('');
-        });
-
-        $.each(wmgui.multi_facets, function(n, item){
-
-            $('#advs_fct_' + item + '-selectized').val('');
-            wmgui.multiselects[item].clear();
-
-            if (wmgui.search[item]){
-                var obj = {};
-                obj[item] = wmgui.search[item];
-                wmgui.multiselects[item].write(obj);
-                //wmgui.multiselects[item].write({[item]: wmgui.search[item]});
-                if (item == 'aetypes') show_aetmap(wmgui.search[item].split(',').pop().trim());
-            }
-        });
-    }
-    if (!show_advsbox.cached_aetmap){
-        show_advsbox.cached_aetmap = new Image();
-        show_advsbox.cached_aetmap.src = wmgui.aetmap_addr;
-    }
-}
-
-function show_hints(disabled, res_count){
-
-    //$('#fdwidget').html('Were you satisfied with the data quality? Did everything work as expected? <span id="fdwidget_yes">Yes</span><span id="fdwidget_no">No</span>').show();
-
-    if (disabled || wmgui.search.numeric || wmgui.search.doi || wmgui.search.phid || wmgui.search.bid || wmgui.fuzzyout || wmgui.search_type == 2)
-        return;
-
-    var cur_obj = {};
-    $.extend(cur_obj, wmgui.search);
-    delete cur_obj.ignored;
-    delete cur_obj.search_type;
-
-    var hint = JSON.stringify(cur_obj).replaceAll(' ', '+').replace('\{', '\\{').replace('\}', '\\}');
-    $('#apihint kbd').html(hint).parent().show();
-
-    if (wmgui.search_type === 0 && (res_count > 3 || res_count === undefined)){
-        $('a.plthint_links').each(function(){
-            var that = $(this),
-                plot_type = that.attr('rev');
-            that.attr('href', wmgui.gui_host + window.location.pathname + '#plot/' + plot_type + '/' + window.location.hash.substr(1));
-        });
-        $('#plthint').show();
-    }
-}
-
-function show_tooltip(info, forced){
-    if (info.view_mode != wmgui.view_mode || (wmgui.visavis_working && !forced) || $('div.modal').is(':visible'))
-        return;
-
-    var ref = $('#' + info.el).position(),
-        tooltip_el = document.getElementById('tooltip');
-
-    tooltip_el.style.left = (ref.left + info.oleft) + 'px';
-    tooltip_el.style.top = (ref.top + info.otop) + 'px';
-    tooltip_el.firstChild.innerHTML = info.text;
-    document.getElementById('tooltip').style.display = 'block';
-}
-
-function show_modal(which){
-
-    if (which == 'login'){
-
-        if ($("#factor_by_email").val()) $("#login_email").val($("#factor_by_email").val());
-        else $("#login_email").val('');
-
-        $("#login_password").val('');
-        $('#loginbox').show();
-        $("#login_email").focus();
-
-        // for OAuth linking redirect only
-        // see email_chain.html
-        var u_email = window.localStorage.getItem(wmgui.store_oauth_email_key) || false;
-        if (u_email){
-            $("#login_email").val(u_email);
-            window.localStorage.removeItem(wmgui.store_oauth_email_key);
-        }
-
-    } else if (which == 'factor'){
-
-        if ($("#login_email").val()) $("#factor_by_email").val($("#login_email").val());
-        else $("#factor_by_email").val('');
-
-        $('#factorbox').show();
-        $("#factor_by_email").focus();
-
-    } else if (which == 'restore'){
-
-        if ($("#login_email").val()) $("#restore_by_email").val($("#login_email").val());
-        else $("#restore_by_email").val('');
-
-        $('#restorebox').show();
-        $("#restore_by_email").focus();
-    }
-}
-
-function init_user_login(){
-
-    // to prevent re-execution
-    var locals = JSON.parse(window.localStorage.getItem(wmgui.store_user_key) || '{}');
-    if (locals.sid === wmgui.sid)
-        return;
-
-    if (!locals.ipbased && locals.sid && locals.name && locals.acclogin){
-        user_login(locals.sid, locals.name, locals.acclogin, locals.admin, locals.oauths, false);
-
-    } else {
-        // attempt IP-based login
-        $.ajax({
-            type: 'POST',
-            url: wmgui.ip_endpoint,
-
-        }).done(function(data){
-            if (data.sid && data.name && data.acclogin)
-                user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths, true);
-        });
-    }
-}
-
-function user_login(sid, name, acclogin, admin, oauths, ipbased){
-
-    var corner_name = (name.length > 40) ? name.substr(0, 37) + '&hellip;' : name;
-    $('#auth_user').html(corner_name);
-    $('#account_holder_name').html('Hello ' + name + ' &#x1f44d;');
-    $('#account_holder_acclogin > span').html(ipbased ? 'location-based' : '<a href="mailto:' + acclogin + '">' + acclogin + '</a>');
-
-    wmgui.sid = sid;
-    wmgui.oauths = oauths;
-
-    $('div.logged_out').hide();
-    $('div.logged_in').show();
-    $('#account_pass_change').hide();
-
-    window.localStorage.setItem(wmgui.store_user_key, JSON.stringify({
-        sid: sid,
-        name: name,
-        acclogin: acclogin,
-        admin: admin,
-        ipbased: ipbased
-    })); // TODO? oauths: oauths
-
-    (admin && (wmgui.edition == 0 || wmgui.edition == 1)) ? $('li.admin').show() : $('li.admin').hide();
-
-    if (ipbased){
-        $('.only_regular').hide();
-        $('#logout_trigger').addClass('disabled');
-        $('#accpass_trigger').text('disabled').addClass('disabled');
-
-    } else {
-        $('.only_regular').show();
-        $('#logout_trigger').removeClass('disabled');
-        $('#accpass_trigger').text('change').removeClass('disabled');
-    }
-
-    try {
-        document.getElementById('visavis_iframe').contentWindow.location.reload();
-    } catch (e){
-        console.error('No iframe access');
-    }
-    communicate_windows('tab_user_login');
-
-    wmgui.notify('Logged in as ' + name);
-
-    // One-off redirection
-    var redir = window.localStorage.getItem(wmgui.store_redir_key);
-    if (redir){
-        window.localStorage.removeItem(wmgui.store_redir_key);
-        return window.location.replace(redir); // FIXME? replace vs. href
-    }
-}
-
-function tab_user_login(){
-
-    // to prevent re-execution
-    var locals = JSON.parse(window.localStorage.getItem(wmgui.store_user_key) || '{}');
-    if (locals.sid === wmgui.sid)
-        return;
-
-    window.location.reload();
-}
-
-function user_logout(silent){
-    if (!wmgui.sid)
-        return;
-
-    wmgui.sid = null;
-    wmgui.oauths = null;
-    $('li.admin').hide();
-    $('div.logged_in').hide();
-    $('div.logged_out').show();
-
-    window.localStorage.removeItem(wmgui.store_user_key);
-
-    try {
-        document.getElementById('visavis_iframe').contentWindow.location.reload();
-    } catch (e){
-        console.error('No iframe access');
-    }
-    communicate_windows('user_logout');
-
-    if (!silent) wmgui.notify('You are logged out');
-}
-
-function force_relogin(show_msg){
-    $.ajax({
-        type: 'POST',
-        url: wmgui.logout_endpoint,
-        data: {sid: wmgui.sid}
-
-    }).done(function(data){}).fail(function(xhr, textStatus, errorThrown){});
-    user_logout(true);
-    window.location.replace('#modal/login');
-    if (show_msg) wmgui.notify(show_msg);
-}
-
-function communicate_windows(runnable_name){
-    // NB the active window doesn't receive a storage event
-    window.localStorage.setItem(wmgui.store_comm_exec_key, runnable_name);
-    setTimeout(function(){
-        window.localStorage.removeItem(wmgui.store_comm_exec_key)
-    }, 0);
-}
-
-function reset_factor_form() {
-    document.getElementById('factor_trigger').style.display = 'block';
-    document.getElementById('factor_form_step_one').style.display = 'block';
-    document.getElementById('factor_form_step_two').style.display = 'none';
-    var resps = document.getElementsByClassName('factor_form_resp');
-    for (var i = 0; i < resps.length; i++) {
-        resps[i].value = "";
-    }
-}
-
-function submit_factor_form_resp() {
-    var result = "";
-    var resps = document.getElementsByClassName('factor_form_resp');
-    for (var i = 0; i < resps.length; i++) {
-        result += resps[i].value;
-    }
-    if (result.length !== 6 || !Number.isInteger(parseInt(result))) return false;
-
-    $.ajax({
-        type: 'POST',
-        url: wmgui.factor_v_endpoint,
-        data: {a: result, ed: wmgui.edition}
-
-    }).done(function(data){
-
-        if (data.error) return wmgui.notify(data.error);
-        if (!data.sid || !data.name || !data.acclogin){
-            window.location.replace('#start');
-            return wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-        }
-        user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
-
-        reset_factor_form();
-
-        $('#userbox').trigger('click');
-
-    }).fail(function(xhr, textStatus, errorThrown){});
-}
-
-function update_dc(){
-    var title = [],
-        orepr = {};
-    for (var key in wmgui.search){
-        if (['search_type', 'phid', 'numeric'].indexOf(key) !== -1) continue;
-        orepr[key] = wmgui.search[key];
-        title.push(wmgui.search[key])
-    }
-    title = title.join(" ");
-
-    var count = 0,
-        cur_str = JSON.stringify(orepr),
-        cmp_html = '<option value="X" selected>To last searches...</option>';
-
-    $.each(JSON.parse(window.localStorage.getItem(wmgui.store_history_key) || '[]'), function(n, past){
-        if (count > 6) return false;
-
-        var title = [],
-            past_str = JSON.stringify(past);
-        if (cur_str == past_str) return true;
-
-        for (var prop in past){ title.push(past[prop]) }
-        title = title.join(" ");
-        cmp_html += '<option value="' + encodeURIComponent(past_str) + '">' + title + '</option>';
-        count++;
-    });
-    cmp_html += '<option value="Y">No comparison</option>';
-    $('#select_cmp_trigger').empty().append(cmp_html);
-}
-
-function show_aetmap(term){
-    var coords = wmgui.aets[term];
-    if (coords)
-        $('#aetmap').css('height', coords[1] + 'px').css('background', 'url(' + wmgui.aetmap_addr + ') 0 -' + coords[0] + 'px no-repeat').show();
-    else
-        $('#aetmap').hide();
-}
-
-function render_all_polyhedra(){
-    if (!$('#all_polyhedra_content').is(':empty')) return;
-    var aetypes_html = '',
-        defined_aetypes = Object.keys(wmgui.aets);
-    defined_aetypes.sort(function(a, b){
-        var partsa = a.split('-vertex')[0].split(' '),
-            va = parseInt(partsa[partsa.length - 1]),
-            partsb = b.split('-vertex')[0].split(' '),
-            vb = parseInt(partsb[partsb.length - 1]);
-        return va > vb ? 1 : va < vb ? -1 : (a.length > b.length ? 1 : a.length < b.length ? -1 : 0);
-    });
-    $.each(defined_aetypes, function(key, value){
-        var coords = wmgui.aets[value];
-        aetypes_html += '<div class="gallery_item" rel="' + value + '"><div style="width:125px;height:' + coords[1] + 'px;margin:10px auto;background:url(' + wmgui.aetmap_addr + ') 0 -' + coords[0] + 'px no-repeat;"></div><span>' + value + '</span></div>';
-    });
-    $('#all_polyhedra_content').html(aetypes_html);
-}
-
-function show_dunit_info(phid, bid, entry){
-    if (phid){
-        $('#ind_title').html('Phase ' + phid);
-        $('#ind_link').attr('href', 'https://mpds.io/phase_id/' + phid).html('www.mpds.io/phase_id/' + phid);
-
-    } else if (bid){
-        $('#ind_title').html('Publication B' + bid);
-        $('#ind_link').attr('href', 'https://mpds.io/article/' + bid).html('www.mpds.io/article/' + bid);
-
-    } else if (entry){
-        $('#ind_title').html('Entry ' + entry);
-        $('#ind_link').attr('href', 'https://mpds.io/entry/' + entry).html('www.mpds.io/entry/' + entry);
-    }
-
-    $('#refine_col, #ctx_col').hide();
-    $('#phase_info, #ind_col > span').empty();
-
-    if (phid){
-        $('#ind_col > span').html('<img src="' + wmgui.static_host + '/phid_thumbs/' + phid + '.png" />');
-
-        wmgui.active_ajax = $.ajax({
-            type: 'GET',
-            url: wmgui.phase_endpoint,
-            data: {phid: phid}
-
-        }).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-
-            var html = '<h4>' + data.out.formula_html.split(' ')[0] + ' ' + (data.out.spg || '?') + ' ' + (data.out.pearson || '&mdash;') + '</h4>';
-
-            if (data.out.mpid) html += '<h4 style="background:#ddd;margin-top:-7px;">Materials Project <a target="_blank" href="https://materialsproject.org/materials/mp-' + data.out.mpid + '">mp-' + data.out.mpid + '</a></h4>';
-
-            html += '<p>';
-            if (data.out.articles_count) html += 'This phase was reported in ' + data.out.articles_count + ' article' + (data.out.articles_count > 1 ? 's' : '')  + '.';
-            if (data.out.sim_count > 1) html += ' There are <a href="#interlinkage/' + phid + '">' + data.out.sim_count + ' structurally similar phases</a> from other articles.';
-            html += '</p>';
-
-            $('#phase_info').html(html);
-            $('#dtypes_phid').show();
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Sorry, a network error occured. Please, try again');
-        });
-
-    } else if (bid){
-        $('#ind_col > span').html('<strong>&#x1f4d6;</strong>'); // book icon
-        $('#phase_info').html('<h4>Ref. ' + bid + '</h4><p>Please make sure you are<br /><a target="_blank" href="#modal/menu">logged in</a> to see all the details.</p>');
-
-        wmgui.active_ajax = $.ajax({
-            type: 'GET',
-            url: wmgui.refs_endpoint + '?noredir=1&fmt=bib&ref_id=' + bid + '&sid=' + wmgui.sid
-
-        }).done(function(data){
-            var citation = wmgui.parse_bib(data),
-                citation_html = '',
-                main_author = '',
-                links_html = '';
-
-            if (citation[0].length){
-                citation[0].split(',').forEach(function(item, index){
-                    var author_name = item.trim().split('.')[0];
-                    author_name = author_name.substr(0, author_name.length - 2).replace("'", "");
-                    if (index === 0) main_author = author_name;
-                    links_html += '<a href="#inquiry/authors=' + author_name + '" style="color:#777;border-bottom-color:#777;">' + author_name + '</a> or ';
-                });
-                links_html = links_html.substr(0, links_html.length - 4); // " or "
-                if (citation[0].indexOf(',') !== -1) main_author += ' et al.';
-                citation_html += ' <a href="' + wmgui.refs_endpoint + '?fmt=bib&ref_id=' + bid + '&sid=' + wmgui.sid + '">' + main_author + ', ' + citation[1] + '. ' + citation[2] + ' <i>(' + citation[3] + ')</i></a>';
-            }
-
-            if (bid == 999999){
-                $('#phase_info').html('<h4>In-house data</h4><p>These data were generated automatically on the MPDS platform based on the original peer-reviewed Pauling File data. Please cite as ' + citation_html + '.</p>');
-
-            } else {
-                var n_entries = wmgui.thumbed_display ? $('div.gallery_item').length : $('tr.tcell').length;
-                if (n_entries == 1000) n_entries = 'more than ' + n_entries;
-                $('#phase_info').html('<h4>Ref. ' + bid + '</h4><p>We have ' + (n_entries == 1 ? 'one entry' : n_entries + ' entries') + ' from this reference' + citation_html + '.</p>' + (links_html.length ? '<p>Retrieve all data co-authored by ' + links_html + '.</p>' : ''));
-            }
-
-        }).fail(function(xhr, textStatus, errorThrown){});
-
-    } else {
-        $('#ind_col > span').html('<strong>&#x1f52c;</strong>'); // microscope icon
-    }
-
-    $('#ind_col').show();
-    $('#dtypes').hide();
-}
-
-function assign_edition(){
-
-    function run_edition(edition_key){
-        edition_key = parseInt(edition_key);
-        if (!wmgui.editions[edition_key])
-            edition_key = 0;
-        wmgui.edition = edition_key;
-        if (wmgui.editions[edition_key].css) wmgui.loadCSS(wmgui.editions[edition_key].css);
-        if (wmgui.editions[edition_key].actions) wmgui.editions[edition_key].actions();
-    }
-
-    $.each(wmgui.editions, function(key, value){
-        if (wmgui.gui_host == value['prod_url'] || wmgui.gui_host == value['dev_url']){
-            run_edition(key);
-            return false;
-        }
-    });
-
-    // for any unknown domain, ICDD MPDS is assumed
-    if (!wmgui.edition) run_edition(0);
-
-    // for any third-party integrations, id="mpds_native" should not be used
-    wmgui.mpds_native = !!document.getElementById("mpds_native");
-}
diff --git a/src_js/ptable.js b/src_js/ptable.js
deleted file mode 100644
index 4cf22f5..0000000
--- a/src_js/ptable.js
+++ /dev/null
@@ -1,520 +0,0 @@
-"use strict";
-
-var wmgui = window.wmgui || {};
-
-wmgui.ptable = {};
-wmgui.ptable.update_selectize = false;
-wmgui.ptable.active_ajax = window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP");
-wmgui.ptable.query = null;
-wmgui.ptable.els_data = [];
-wmgui.ptable.pdsvg_path = wmgui.static_host + '/pds_svgs';
-wmgui.ptable.crsvg_path = wmgui.static_host + '/crs_svgs';
-wmgui.ptable.ppsvg_path = wmgui.static_host + '/pps_svgs';
-wmgui.ptable.first_el = null;
-wmgui.ptable.second_el = null;
-wmgui.ptable.visible = false; // needed to debounce
-wmgui.ptable.activated = false; // should it "jump" on top by input
-wmgui.ptable.dtypes = 1; // 0, 1, 2, or 3, see #ptable_dtypes
-wmgui.ptable.subphases_button = '';
-wmgui.ptable.vis_fixed = false;
-wmgui.ptable.elements = ['X'].concat(wmutils.periodic_elements_cased);
-
-// patch display keyword unary to elementary
-wmgui.ptable.arity_keys = wmutils.arity_keys.slice();
-wmgui.ptable.arity_keys[1] = 'elementary';
-
-wmgui.ptable.show = function(){
-    if (wmgui.ptable.visible)
-        return;
-    document.getElementById('ptable_holder').style.display = 'block';
-    wmgui.ptable.visible = true;
-};
-
-wmgui.ptable.hide = function(){
-    if (!wmgui.ptable.visible)
-        return;
-    document.getElementById('ptable_holder').style.display = 'none';
-    wmgui.ptable.visible = false;
-};
-
-wmgui.ptable.activate = function(){
-    wmgui.ptable.activated = true;
-    document.getElementById('ermac_logo').classList.add('resulted');
-    document.getElementById('ptable_holder').classList.add('resulted');
-    if (window.scrollY <= 40) document.getElementById('ptable_dtypes_box').classList.add('resulted');
-    wmgui.mpdsgui.ptable_activate();
-};
-
-wmgui.ptable.deactivate = function(){
-    wmgui.ptable.activated = false;
-    document.getElementById('ermac_logo').classList.remove('resulted');
-    document.getElementById('ptable_holder').classList.remove('resulted');
-    document.getElementById('ptable_dtypes_box').classList.remove('resulted');
-    wmgui.mpdsgui.ptable_deactivate();
-};
-
-wmgui.ptable.decide = function(){
-    const scroll_pos = window.scrollY;
-    //console.log(scroll_pos);
-
-    if (scroll_pos > 60) // forward to intro_stats screen
-        wmgui.ptable.hide();
-
-    else // back to ptable screen
-        wmgui.ptable.show();
-}
-
-wmgui.ptable.subphases_set = function(state){
-    if (!state){
-        wmgui.ptable.subphases_button = '';
-
-    } else if (state === 1){
-        wmgui.ptable.subphases_button = '<div class="wmbutton subphases_trigger" data-state="2">Load binary and ternary phases <span>&uarr;</span></div>';
-
-    } else {
-        wmgui.ptable.subphases_button = '<div class="wmbutton subphases_trigger" data-state="1">Load ternary phases only <span>&uarr;</span></div>';
-    }
-}
-
-function read_ptable_html(){
-    let unaries_data = [{}]; // NB zero-th element (X)
-
-    wmgui.ptable.elements.forEach(function(_, idx){
-        if (idx == 0 || idx > 103) // X - Lr
-            return;
-
-        const item = document.querySelector('#ptable_area > ul > li[data-pos="' + idx + '"]');
-        let elem_data = {pos: idx, classes: []}; // NB prop html:
-
-        item.classList.forEach(function(cls){
-            elem_data.classes.push(cls);
-        });
-
-        unaries_data.push(elem_data);
-    });
-    return unaries_data;
-}
-
-function removeAllCls(cls){
-    const collection = document.getElementsByClassName(cls);
-    while (collection.length)
-        collection[0].classList.remove(cls);
-}
-
-function clear_results_area(){
-    try { wmgui.ptable.active_ajax.abort() } catch(e){}
-    document.getElementById('ptable_previews').innerHTML = '';
-    document.getElementById('ptable_vis').innerHTML = '';
-    wmgui.ptable.deactivate();
-}
-
-function refresh_ptable_results(elA, elB, elC){
-
-    if (wmgui.view_mode !== 1) return;
-
-    //console.log('Refreshing table with ' + [elA, elB, elC]);
-
-    const els = [elA, elB, elC].filter(function(item){ return !!item }),
-        query_ph = els.length ? {search_type: 1, classes: wmutils.arity_keys[els.length], elements: els.join('-')} : false;
-
-    if (wmgui.ptable.update_selectize){
-        wmgui.ptable.update_selectize = false;
-
-        wmgui.multiselects['main'].clear();
-        wmgui.multiselects['main'].write({'elements': els.join('-')});
-    }
-
-    wmgui.ptable.subphases_set();
-
-    if (query_ph){
-        wmgui.ptable.query = query_ph;
-        wmgui.ptable.vis_fixed = false;
-
-        let iframe_addr,
-            iframe_height = 900;
-
-        if (els.length == 1){
-
-            if (wmgui.ptable.dtypes == 2){
-                iframe_addr = wmgui.engines_addrs['cifplayer'];
-                wmgui.ptable.vis_fixed = true;
-
-            } else if (wmgui.ptable.dtypes == 3){
-                iframe_addr = wmgui.engines_addrs['visavis'];
-                wmgui.ptable.vis_fixed = true;
-
-            } else
-                document.getElementById('ptable_vis').innerHTML = '';
-
-        } else if (els.length == 2) {
-            iframe_height = 800;
-
-            if (wmgui.ptable.dtypes == 1){
-                const query_pds = {search_type: 0, classes: wmutils.arity_keys[els.length], elements: els.join('-'), props: 'phase diagram'};
-                ajax_download(null, wmgui.search_endpoint + '?q=' + JSON.stringify(query_pds), render_right);
-
-            } else if (wmgui.ptable.dtypes == 2){
-                iframe_addr = wmgui.engines_addrs['cifplayer'];
-                wmgui.ptable.vis_fixed = true;
-
-            } else if (wmgui.ptable.dtypes == 3){
-                iframe_addr = wmgui.engines_addrs['visavis'];
-                wmgui.ptable.vis_fixed = true;
-
-            } else
-                document.getElementById('ptable_vis').innerHTML = '';
-
-        } else {
-            wmgui.ptable.subphases_set(1);
-            iframe_height = window.innerHeight - 200;
-            wmgui.ptable.vis_fixed = true;
-
-            if (wmgui.ptable.dtypes == 1){
-                iframe_addr = wmgui.v_pd_3d_addr + els.join('-');
-
-            } else if (wmgui.ptable.dtypes == 2){
-                iframe_addr = wmgui.engines_addrs['cifplayer'];
-
-            } else if (wmgui.ptable.dtypes == 3){
-                iframe_addr = wmgui.engines_addrs['visavis'];
-
-            } else
-                document.getElementById('ptable_vis').innerHTML = '';
-        }
-        ajax_download(wmgui.ptable.active_ajax, wmgui.search_endpoint + '?q=' + JSON.stringify(query_ph) + '&strict=1', render_left);
-
-        if (iframe_addr)
-            document.getElementById('ptable_vis').innerHTML = '<iframe frameborder=0 scrolling="no" width="100%" height="' + iframe_height + '" src="' + iframe_addr + '"></iframe>';
-
-        wmgui.ptable.activate();
-
-    } else clear_results_area();
-}
-
-function ajax_download(api, url, callback){
-    wmgui.show_preloader();
-    const xmlhttp = api ? api : (window.XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject("Microsoft.XMLHTTP"));
-    xmlhttp.onreadystatechange = function(){
-        if (xmlhttp.readyState == 4){
-            wmgui.hide_preloader();
-            if (xmlhttp.status == 200) callback(xmlhttp.responseText);
-            else {
-                console.error("Error: HTTP " + xmlhttp.status + " status received during data retrieval from the server");
-            }
-        }
-    }
-    xmlhttp.open("GET", url);
-    xmlhttp.withCredentials = true;
-    xmlhttp.send(1);
-}
-
-function render_left(data){
-    data = JSON.parse(data);
-    if (data.error)
-        return wmgui.notify(data.error);
-
-    const header = '<h4>Reported phases of ' + wmgui.ptable.arity_keys[wmutils.arity_keys.indexOf(wmgui.ptable.query.classes)] + ' ' + wmgui.ptable.query.elements + (wmgui.ptable.query.elements.indexOf('-') == -1 ? '' : ' system') + '</h4>';
-
-    const parent = document.getElementById('ptable_previews');
-    parent.className = "";
-    parent.classList.add('ptable_dtype_' + wmgui.ptable.dtypes);
-    parent.innerHTML = header + (data.out.length ? build_thumbs_ph(data.out) : '<p>No results</p>') + wmgui.ptable.subphases_button;
-
-    if (data.out.length < 10) wmgui.ptable.vis_fixed = false; // prevent screen jumping
-
-    if (wmgui.ptable.dtypes == 2){
-        const els = document.querySelectorAll('#ptable_results div.gallery_img.renderable');
-        if (els.length){
-            const rnd_i = Math.floor(Math.random() * els.length);
-            els[rnd_i].parentNode.classList.add('active');
-            const phid = els[rnd_i].getAttribute('rel'),
-                target = document.querySelector('#ptable_vis > iframe'),
-                target_addr = '#' + wmgui.phase_endpoint + '?phid=' + phid + '&struct=1';
-
-            if (target) target.contentWindow.location.hash = target_addr;
-            else document.getElementById('ptable_vis').innerHTML = '<iframe frameborder=0 scrolling="no" width="100%" height="850" src="' + wmgui.engines_addrs['cifplayer'] + target_addr + '"></iframe>';
-
-        } else document.getElementById('ptable_vis').innerHTML = '';
-
-    } else if (wmgui.ptable.dtypes == 3){
-        const els = document.querySelectorAll('#ptable_results div.gallery_img.renderable');
-        if (els.length){
-            const rnd_i = Math.floor(Math.random() * els.length);
-            els[rnd_i].parentNode.classList.add('active');
-            const phid = els[rnd_i].getAttribute('rel'),
-                target = document.querySelector('#ptable_vis > iframe'),
-                target_addr = get_visavis_url({phid: phid}, 'graph', window.innerHeight - 50);
-
-            if (target) target.contentWindow.location.replace(target_addr);
-            else document.getElementById('ptable_vis').innerHTML = '<iframe frameborder=0 scrolling="no" width="100%" height="850" src="' + target_addr + '"></iframe>';
-
-        } else document.getElementById('ptable_vis').innerHTML = '';
-    }
-}
-
-function render_right(data){
-    data = JSON.parse(data);
-    if (data.error)
-        return wmgui.notify(data.error);
-
-    if (data.fuzzy_notice || !data.out.length)
-        document.getElementById('ptable_vis').innerHTML = '';
-    else
-        document.getElementById('ptable_vis').innerHTML = '<h4>Reported phase diagrams of ' + wmgui.ptable.query.elements + ' system</h4>' + build_thumbs_pd(data.out);
-}
-
-function render_unaries(){
-
-    if (!wmgui.ptable.first_el)
-        return;
-
-    wmgui.ptable.els_data.forEach(function(elem_data){
-        if (!elem_data.pos)
-            return;
-
-        const that = document.querySelector('#ptable_area > ul > li[data-pos="' + elem_data.pos + '"]');
-        that.style.backgroundImage = "none";
-        //that.innerHTML = elem_data.html;
-        that.className = "";
-        that.classList.add(...elem_data.classes);
-    });
-
-    wmgui.ptable.first_el = null;
-}
-
-function render_binaries(elA, elB){
-
-    //console.log('RENDERING BINARIES FOR: ' + [elA, elB]);
-
-    document.querySelectorAll('#ptable_area > ul > li').forEach(function(item){
-        if (!item.hasAttribute('data-pos'))
-            return;
-
-        const current_el = wmgui.ptable.elements[parseInt(item.getAttribute('data-pos'))];
-
-        if (wmgui.ptable.dtypes == 1){
-
-            if (current_el != elA && current_el != elB){
-                item.style.backgroundImage = "url('" + wmgui.ptable.pdsvg_path + "/bin/" + elA + "-" + current_el + ".svg')";
-                item.className = "active_a";
-            }
-        } else if (wmgui.ptable.dtypes == 2){
-
-            if (current_el != elA && current_el != elB){
-                let pair = [elA, current_el];
-                pair.sort();
-                item.style.backgroundImage = "url('" + wmgui.ptable.crsvg_path + "/bin/" + pair.join("-") + ".svg')";
-                item.className = "active_a";
-            }
-        } else if (wmgui.ptable.dtypes == 3){
-
-            if (current_el != elA && current_el != elB){
-                let pair = [elA, current_el];
-                pair.sort();
-                item.style.backgroundImage = "url('" + wmgui.ptable.ppsvg_path + "/bin/" + pair.join("-") + ".svg')";
-                item.className = "active_a";
-            }
-        } else {
-            if (current_el != elA && current_el != elB){
-                item.style.backgroundImage = "none";
-                item.className = "active_a";
-
-            } else if (current_el == elA) {
-                item.className = "selected_a";
-                item.classList.add(...wmgui.ptable.els_data[parseInt(item.getAttribute('data-pos'))].classes);
-            }
-        }
-    });
-}
-
-function render_ternaries(elA, elB){
-
-    //console.log('RENDERING TERNARIES FOR: ' + [elA, elB]);
-
-    document.querySelectorAll('#ptable_area > ul > li').forEach(function(item){
-        if (!item.hasAttribute('data-pos'))
-            return;
-
-        const current_el = wmgui.ptable.elements[parseInt(item.getAttribute('data-pos'))];
-
-        if (wmgui.ptable.dtypes == 1){
-
-            if (current_el != elA && current_el != elB){
-                let triple = [elA, elB, current_el];
-                triple.sort();
-                item.style.backgroundImage = "url('" + wmgui.ptable.pdsvg_path + "/ter/" + triple.join("-") + ".svg')";
-                item.classList.add('active_b');
-            }
-        } else if (wmgui.ptable.dtypes == 2){
-
-            if (current_el != elA && current_el != elB){
-                let triple = [elA, elB, current_el];
-                triple.sort();
-                item.style.backgroundImage = "url('" + wmgui.ptable.crsvg_path + "/ter/" + triple.join("-") + ".svg')";
-                item.classList.add('active_b');
-            }
-        } else if (wmgui.ptable.dtypes == 3){
-
-            if (current_el != elA && current_el != elB){
-                let triple = [elA, elB, current_el];
-                triple.sort();
-                item.style.backgroundImage = "url('" + wmgui.ptable.ppsvg_path + "/ter/" + triple.join("-") + ".svg')";
-                item.classList.add('active_b');
-            }
-        } else {
-            if (current_el != elA && current_el != elB){
-                item.style.backgroundImage = "none";
-                item.classList.add('active_b');
-
-            } else if (current_el == elA) {
-                item.className = "selected_a";
-                item.classList.add(...wmgui.ptable.els_data[parseInt(item.getAttribute('data-pos'))].classes);
-
-            } else if (current_el == elB) {
-                item.className = "selected_b";
-            }
-        }
-    });
-}
-
-function build_thumbs_ph(json){ // FIXME duplicates another function *build_thumbs*
-    let result_html = '';
-
-    json.sort(function(a, b){
-        return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
-    });
-
-    json.forEach(function(row){
-        result_html += '<div class="gallery_item">';
-        result_html += '  <div class="gallery_img' + (row[2] !== '&mdash;' ? ' renderable' : '') + '" rel="' + row[0] + '" style="background-image:url(https://mpds.io/phid_thumbs/' + row[0] + '.png);"><span><p>' + row[1] + '<br />space group ' + row[2] + '</p></span></div>';
-        result_html += '  <div class="gallery_label"><a class="launch_id" href="#phase_id/' + row[0] + '">Show ' + row[3] + (row[3] == 1 ? ' entry' : ' entries') + '</a><br />Publications: ' + row[4] + '</div>';
-        result_html += '</div>';
-    });
-    return result_html;
-}
-
-function build_thumbs_pd(json){ // FIXME duplicates another function *build_thumbs*
-    let result_html = '';
-
-    json.sort(function(a, b){
-        return a[1] > b[1] ? 1 : a[1] < b[1] ? -1 : 0;
-    });
-
-    json.forEach(function(row){
-        if (row[3] == 0) // filter unprocs
-            return;
-        row[2] = row[2].split(';')[0];
-        row[2] = row[2].split(' ')[row[2].split(' ').length - 1];
-        const content = '<img alt="' + row[0] + '" src="https://mpds.io/pd_thumbs/' + row[0].split('-')[0] + '.png" /><p>' + row[2] + '</p>';
-
-        result_html += '<div class="gallery_item' + (row[4] ? ' opened' : '') + '">';
-        result_html += '  <div class="gallery_img" rel="' + row[0] + '" data-path="entry">' + content + '</div>';
-        result_html += '  <div class="gallery_label"><a class="launch_id" href="#entry/' + row[0] + '">' + row[0] + '</a>' + '<br />[' + row[5] + '&rsquo;' + row[6].toString().substr(2, 2) + ']' + '</div>';
-        result_html += '</div>';
-    });
-    return result_html;
-}
-
-function select_ptable_el(selected_el, dom_el){
-    //console.log('Selected element is ' + selected_el);
-
-    if (!dom_el){
-        const dom_el = document.querySelector('#ptable_area > ul > li[data-pos="' + wmgui.ptable.elements.indexOf(selected_el) + '"]');
-        if (!dom_el) return wmgui.notify('Sorry, wrong element: ' + selected_el);
-    }
-
-    if (dom_el.classList.contains('selected_a')){
-        // first element removal
-        dom_el.classList.remove('selected_a');
-        render_unaries();
-        refresh_ptable_results();
-
-    } else if (dom_el.classList.contains('selected_b')){
-        // second element removal
-        dom_el.classList.remove('selected_b');
-        render_binaries(wmgui.ptable.first_el, selected_el);
-        wmgui.ptable.second_el = null;
-        refresh_ptable_results(wmgui.ptable.first_el);
-
-    } else if (dom_el.classList.contains('selected_c')){
-        // third element removal
-        dom_el.classList.remove('selected_c');
-        refresh_ptable_results(wmgui.ptable.first_el, wmgui.ptable.second_el);
-
-    } else if (dom_el.classList.contains('active_b')){
-        // third element selection
-        removeAllCls('selected_c');
-        dom_el.classList.add('selected_c');
-        refresh_ptable_results(wmgui.ptable.first_el, wmgui.ptable.second_el, selected_el);
-
-    } else if (dom_el.classList.contains('active_a')){
-        // second element selection
-        removeAllCls('selected_b');
-        dom_el.classList.add('selected_b');
-        render_ternaries(wmgui.ptable.first_el, selected_el);
-        wmgui.ptable.second_el = selected_el;
-        refresh_ptable_results(wmgui.ptable.first_el, selected_el);
-
-    } else {
-        // first element selection
-        dom_el.classList.add('selected_a');
-        wmgui.ptable.first_el = selected_el;
-        render_binaries(wmgui.ptable.first_el, selected_el);
-        refresh_ptable_results(selected_el);
-    }
-}
-
-function select_ptable_series(els){
-    //console.log('Received for TABLE DRAW: ' + els);
-    if (!els){
-        render_unaries();
-        clear_results_area();
-        return;
-    }
-
-    els = els.split('-');
-    if (els.length > 3)
-        els = els.slice(0, 3);
-
-    wmgui.ptable.first_el = els[0];
-    wmgui.ptable.second_el = els[1] || null;
-
-    const domelA = document.querySelector('#ptable_area > ul > li[data-pos="' + wmgui.ptable.elements.indexOf(els[0]) + '"]');
-
-    if (domelA){
-        removeAllCls('selected_a');
-        domelA.classList.add('selected_a');
-    }
-
-    if (els.length == 1){
-        render_binaries(els[0], els[0]);
-
-    } else if (els.length == 2){
-        const domelB = document.querySelector('#ptable_area > ul > li[data-pos="' + wmgui.ptable.elements.indexOf(els[1]) + '"]');
-
-        if (domelB){
-            removeAllCls('selected_b');
-            domelB.classList.add('selected_b');
-            domelB.classList.add(...wmgui.ptable.els_data[parseInt(domelB.getAttribute('data-pos'))].classes);
-            domelB.style.backgroundImage = "none";
-        }
-        render_ternaries(els[0], els[1]);
-
-    } else {
-        const domelB = document.querySelector('#ptable_area > ul > li[data-pos="' + wmgui.ptable.elements.indexOf(els[1]) + '"]'),
-            domelC = document.querySelector('#ptable_area > ul > li[data-pos="' + wmgui.ptable.elements.indexOf(els[2]) + '"]');
-
-        if (domelB){
-            removeAllCls('selected_b');
-            domelB.classList.add('selected_b');
-            domelB.classList.add(...wmgui.ptable.els_data[parseInt(domelB.getAttribute('data-pos'))].classes);
-            domelB.style.backgroundImage = "none";
-        }
-        if (domelC){
-            removeAllCls('selected_c');
-            domelC.classList.add('selected_c');
-        }
-        render_ternaries(els[0], els[1]);
-    }
-    refresh_ptable_results(...els);
-}
diff --git a/src_js/router.js b/src_js/router.js
deleted file mode 100755
index e8dbc8d..0000000
--- a/src_js/router.js
+++ /dev/null
@@ -1,434 +0,0 @@
-"use strict";
-
-var wmgui = window.wmgui || {};
-
-function url_redraw_react(){
-    var anchors = window.location.hash.substr(1).split('/');
-
-    if (!anchors.length) return;
-    $('#overlay, #aetmap, #dtypes_phid, div.modal, div.menu_collateral').hide();
-    $('#dtypes_phid > ul > li').removeClass('active');
-
-    try { wmgui.active_ajax.abort() } catch(e){}
-    try { wmgui.quick_ajax.abort() } catch(e){}
-
-    if (window['url__' + anchors[0]]) window['url__' + anchors[0]](anchors.slice(1).join('/'));
-    else wmgui.notify('Sorry, unknown route requested');
-}
-
-/**
- * The main landing route /#start
- */
-function url__start(arg){
-    switch_view_mode(1);
-    if (wmgui.tooltip_counter < 2) setTimeout(function(){ show_tooltip(wmgui.tooltips[wmgui.tooltip_landing]) }, 4000);
-}
-
-/**
- * A free-form fuzzy search /#search/arg
- * given by the OptimadeNLP wmutils
- */
-function url__search(arg, no_sync){
-    var query = decodeURIComponent(arg),
-        parsed = wmutils.guess(query);
-    //console.log(parsed);
-
-    if (parsed.numeric) wmgui.search_type = 1;
-
-    show_interpretation(parsed);
-    delete parsed.ignored;
-
-    $('#search_field-selectized').val('');
-    wmgui.multiselects['main'].clear();
-    wmgui.multiselects['main'].write(parsed);
-
-    wmgui.search = parsed;
-    parsed.search_type = wmgui.search_type;
-
-    if (!no_sync) request_search(parsed, query, wmgui.search_type);
-}
-
-/**
- * The parameters-based exact search /#inquiry/arg
- */
-function url__inquiry(arg, no_sync){
-    var inquiry = arg.split("&").map( function(n){ return n = n.split("="), this[n[0]] = n[1], this }.bind({}) )[0];
-
-    wmgui.facets.forEach(function(item){
-        if (inquiry[item]) inquiry[item] = decodeURIComponent(inquiry[item].replaceAll('+', ' '));
-    });
-
-    // re-inventing serialization for numeric nested arrays
-    if (inquiry.numeric){
-        inquiry.numeric = decodeURIComponent(inquiry.numeric).split(';').map(function(item){ return item.split(',') });
-        inquiry.numeric = inquiry.numeric.filter(function(item){ return item.length == 3 });
-        wmgui.search_type = 1; // force phases search type
-    }
-    //console.log(inquiry);
-
-    show_interpretation(inquiry);
-    delete inquiry.ignored;
-
-    var caption_items = [];
-    $.each(inquiry, function(k, v){ caption_items.push(v) });
-
-    $('#search_field-selectized').val('');
-    wmgui.multiselects['main'].clear();
-    wmgui.multiselects['main'].write(inquiry);
-
-    wmgui.search = inquiry;
-    inquiry.search_type = wmgui.search_type;
-
-    if (!no_sync) request_search(inquiry, caption_items.join(" ").replaceAll(",", " "), wmgui.search_type);
-}
-
-/**
- * The 3 brothers routing exact search into the search_type (TODO?)
- */
-function url__inquiry_entries(arg){
-    wmgui.search_type = 0;
-    return url__inquiry(arg);
-}
-function url__inquiry_phases(arg){
-    wmgui.search_type = 1;
-    return url__inquiry(arg);
-}
-function url__inquiry_articles(arg){
-    wmgui.search_type = 2;
-    return url__inquiry(arg);
-}
-
-/**
- * The plotting subsystem (Vis-a-vis) /#plot/arg
- */
-function url__plot(arg){
-    var q = arg.split('/'),
-        plot_type = q[0],
-        search_verb = q[1],
-        query = q[2];
-
-    if (!plot_type || !search_verb || !query)
-        return wmgui.notify('Sorry, unknown route: ' + arg);
-
-    if (search_verb == 'search')
-        url__search(query, true);
-
-    else if (search_verb == 'inquiry')
-        url__inquiry(query, true);
-
-    else
-        return wmgui.notify('Sorry, unknown route: ' + arg);
-
-    wmgui.visavis_curtype = plot_type;
-
-    //if (wmgui.view_mode == 1)
-    switch_view_mode(2);
-
-    setTimeout(function(){
-        start_visavis(plot_type);
-    }, 0);
-
-    if (wmgui.tooltip_counter < 2 && (plot_type == 'matrix' || plot_type == 'cube')){
-        setTimeout(function(){ show_tooltip(wmgui.tooltips['ss_axes'], true) }, 3000);
-    }
-}
-
-/**
- * The individual entry display /#entry/ID
- */
-function url__entry(arg){
-    wmgui.search_type = 0;
-    wmgui.visavis_terminating = true;
-    request_search({'entry': arg}, 'entry ' + arg, true);
-    wmgui.search = {}; // mockup to reset previous properties
-    wmgui.passive_sim_col = true;
-    $('#search_field-selectized').val('');
-    wmgui.multiselects['main'].clear();
-    show_interpretation();
-}
-
-/**
- * The individual phase display /#phase_id/integer
- */
-function url__phase_id(arg){
-    wmgui.search_type = 0;
-    if (!wmgui.ptable.visible){
-        $('#search_field-selectized').val('');
-        wmgui.multiselects['main'].clear();
-    }
-    show_interpretation();
-    var phid = parseInt(arg);
-    wmgui.search = {'phid': phid};
-    wmgui.search.search_type = wmgui.search_type;
-    request_search({'phid': phid}, 'phase ' + phid, true);
-}
-
-/**
- * The individual phase display /#phase/ID
- */
-function url__phase(arg){
-    var phase_data = arg.split('/'),
-        formula = phase_data[0],
-        spg = phase_data[1],
-        pearson = phase_data[2];
-
-    if (formula && spg && pearson){
-        wmgui.active_ajax = $.ajax({
-            type: 'GET',
-            url: wmgui.phph_endpoint,
-            data: {phase: [formula, spg, pearson].join('/')},
-            beforeSend: wmgui.show_preloader
-
-        }).always(wmgui.hide_preloader).done(function(data){
-            if (data.error) return wmgui.notify(data.error);
-            window.location.replace('#phase_id/' + data.phid);
-
-        }).fail(function(xhr, textStatus, errorThrown){
-            if (textStatus != 'abort')
-                wmgui.notify('Sorry, a network error occured. Please, try again');
-        });
-
-    } else return wmgui.notify('Sorry, wrong phase given');
-}
-
-/**
- * The individual B-entry display /#article/integer
- */
-function url__article(arg){
-    wmgui.search_type = 0;
-    $('#search_field-selectized').val('');
-    wmgui.multiselects['main'].clear();
-    show_interpretation();
-    var bentry = parseInt(arg);
-    wmgui.search = {'bid': bentry};
-    wmgui.search.search_type = wmgui.search_type;
-    request_search({'bid': bentry}, 'B' + bentry, true);
-}
-
-/**
- * The display of menu with all the physical props
- */
-function url__hierarchy(){
-    $('body').removeClass('noscroll');
-    $('#overlay').show();
-    window.scrollTo(0, 0);
-    $('#hy_box').show();
-}
-
-/**
- * The different types of modal windows
- */
-function url__modal(arg){
-
-    //var url_params = new URLSearchParams(window.location.search),
-    //    redir = url_params.get('redir');
-
-    if (arg == "login"){
-        if (wmgui.sid) return window.location.replace('#modal/menu');
-
-        // edition-based OAuth login (mpdsgui only)
-        if (wmgui.edition == 1){
-            return window.location.replace('oauth/asm.html'); // NB history replacement
-        }
-        show_modal(arg);
-
-    } else if (arg == "restore" || arg == "factor"){
-        if (wmgui.sid) return window.location.replace('#modal/menu');
-        show_modal(arg);
-
-    } else if (arg == "menu"){
-        if (!wmgui.sid) return window.location.replace('#modal/login');
-        $("#new_password_1, #new_password_2").val('');
-        arrange_menu_collateral();
-        $('#menubox, div.menu_collateral').show();
-
-    } else return wmgui.notify("Sorry, unknown modal window");
-
-    $('#overlay').show();
-}
-
-/**
- * Retrieving the access via email by the secret link
- */
-function url__access(arg){
-    $.ajax({
-        type: 'POST',
-        url: wmgui.access_endpoint,
-        data: {a: arg, ed: wmgui.edition}
-
-    }).done(function(data){
-        if (data.error){
-            window.location.replace('#start');
-            return wmgui.notify(data.error);
-        }
-        if (!data.sid || !data.name || !data.acclogin){
-            window.location.replace('#start');
-            return wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-        }
-        user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
-        window.location.replace('#start');
-
-    }).fail(function(xhr, textStatus, errorThrown){
-        window.location.replace('#start');
-        return wmgui.notify('Sorry, a network error occured. Please, try again');
-    });
-}
-
-/**
- * Confirming the access via email by the secret link
- */
-function url__ratify(arg){
-    $.ajax({
-        type: 'POST',
-        url: wmgui.ratify_endpoint,
-        data: {a: arg, ed: wmgui.edition}
-
-    }).done(function(data){
-        if (data.error){
-            window.location.replace('#start');
-            return wmgui.notify(data.error);
-        }
-        if (!data.sid || !data.name || !data.acclogin){
-            window.location.replace('#start');
-            return wmgui.notify('Connection to server is lost, please try to <a href=javascript:location.reload()>reload</a>');
-        }
-        user_login(data.sid, data.name, data.acclogin, data.admin, data.oauths);
-        window.location.replace('#modal/menu');
-
-    }).fail(function(xhr, textStatus, errorThrown){
-        window.location.replace('#start');
-        return wmgui.notify('Sorry, a network error occured. Please, try again');
-    });
-}
-
-/**
- * A special display of the related entries
- */
-function url__interlinkage(arg){
-    wmgui.search_type = 1;
-    request_search({interlinkage: arg}, 'linked phases for ' + arg, true);
-    wmgui.search = {numeric: true}; // mockup FIXME?
-    //$('#search_field-selectized').val('');
-    //wmgui.multiselects['main'].clear();
-    show_interpretation();
-}
-
-/**
- * All polyhedra menu
- */
-function url__polyhedra(arg){
-    $('body').removeClass('noscroll');
-    $('#overlay').show();
-    window.scrollTo(0, 0);
-    render_all_polyhedra();
-    $('#all_polyhedra_box').show();
-}
-
-/**
- * Access denied route: trying to identify the reason
- */
-function url__junction(arg){
-    if (!wmgui.sid)
-        return window.location.replace('#products');
-
-    var locals = JSON.parse(window.localStorage.getItem(wmgui.store_user_key) || '{}');
-
-    wmgui.active_ajax = $.ajax({
-        type: 'POST',
-        url: locals.ipbased ? wmgui.ip_perms_endpoint : wmgui.perms_endpoint,
-        data: {sid: wmgui.sid},
-        beforeSend: wmgui.show_preloader
-
-    }).always(wmgui.hide_preloader).done(function(data){
-
-        if (data.error)
-            return wmgui.notify(data.error);
-
-        if (!data.hasOwnProperty('gui') || !data.hasOwnProperty('api'))
-            return force_relogin('Please, re-login');
-
-        window.location.replace('#modal/menu');
-        $('#tab_links > li').removeClass('working');
-        $('#tab_links > li[rev=usr_tab_perms]').addClass('working');
-        $('div.menu_tabs').hide();
-        $('#usr_tab_perms').show();
-        $('#perms_view').html(describe_perms(data));
-        setTimeout(function(){
-            wmgui.notify('Please, check your data access.');
-        }, 1500);
-
-    }).fail(function(xhr, textStatus, errorThrown){
-        if (textStatus != 'abort')
-            return force_relogin('Please, re-login');
-    });
-}
-
-/**
- * Moved from mpdsgui
- */
-function url__products(arg){
-    if (!wmgui.mpds_native)
-        window.location.href = wmgui.static_host + '/#products';
-
-    if (wmgui.edition === 1){
-        // NB no history replacement and no new windows
-        window.location.href = 'https://www.asminternational.org/asm-materials-platform-for-data-science-api';
-
-    } else {
-        $('#overlay').show();
-        window.scrollTo(0, 0);
-        $('#productbox').show();
-    }
-}
-
-/**
- * Moved from mpdsgui
- */
-function url__formal(arg){
-    if (!wmgui.mpds_native)
-        window.location.href = wmgui.static_host + '/#formal/' + arg;
-
-    var header = '',
-        addr = '';
-
-    if (arg == 'terms')
-        header = 'Website Terms &amp; Conditions', addr = '/terms.json';
-
-    else if (arg == 'api')
-        header = 'MPDS API Terms &amp; Conditions', addr = '/api.json';
-
-    else if (arg == 'usfed')
-        header = 'Procurement Details', addr = '/usfed.json';
-
-    else if (arg == 'refunds')
-        header = 'Refund Policy', addr = '/refunds.json';
-
-    else if (arg == 'privacy')
-        header = 'Privacy Policy', addr = '/privacy.json';
-
-    else
-        return wmgui.notify('Sorry, unknown document requested');
-
-    wmgui.show_preloader();
-
-    $('#formalbox_navi > ul > li').removeClass('working');
-    $('a[href="#formal/' + arg + '"]').parent().addClass('working');
-
-    $.ajax({
-        url: addr,
-        type: 'GET',
-        data: {nocache: Math.floor(Math.random() * 1000)},
-        beforeSend: wmgui.show_preloader
-
-    }).always(wmgui.hide_preloader).done(function(answer){
-        var html = '<h2>' + header + '</h2>';
-        $.each(answer, function(n, value){
-            html += '<strong>&sect;' + (n + 1) + '. ' + value.header + '</strong><p>' + value.content + '</p>';
-        });
-        $('#formalbox_content').html(html);
-        $('#formalbox, #overlay').show();
-        window.scrollTo(0, 0);
-        wmgui.hide_preloader();
-
-    }).fail(function(xhr, textStatus, errorThrown){});
-}
diff --git a/src_js/run.js b/src_js/run.js
deleted file mode 100755
index 86b45c1..0000000
--- a/src_js/run.js
+++ /dev/null
@@ -1,14 +0,0 @@
-"use strict";
-
-// now, run everything
-
-assign_edition();
-
-register_html();
-
-satisfy_requirements();
-
-register_events();
-
-// use MPDS API, please
-console.log("%cWeb-scraping or automated usage apart of the public MPDS API is in violation of our ToS (https://mpds.io/formal/terms) and results in banned account.", "color:red;font-size:16px;")
diff --git a/src_js/sliders.js b/src_js/sliders.js
deleted file mode 100755
index 13cc4da..0000000
--- a/src_js/sliders.js
+++ /dev/null
@@ -1,102 +0,0 @@
-"use strict";
-
-var wmgui = window.wmgui || {};
-
-function create_floating_slider(prop_name, prop_id, units, p_min, p_max, p_step, p_start, p_end){
-    // FIXME compatibilize with *wmgui.numerics*
-
-    if ($('#slider_' + prop_id).length){
-        console.log('Attempted to create an existing slider id' + prop_id);
-        return;
-    }
-
-    //console.log(prop_name, prop_id, units, p_min, p_max, p_step, p_start, p_end);
-
-    var html = '<li>';
-    html += '<div class="slider_title">';
-    html +=   (wmgui.numerics[prop_name][5] || prop_name) + (units ? (',&nbsp;<em>' + units + '</em>') : '');
-    html += '</div>';
-    html += '<div class="cross slider_close"></div>';
-    html += '<div class="slider">'; // #numericbox > ul > li > div.slider
-    html += '<img src="' + wmgui.pdist_endpoint + '?pdist=' + encodeURIComponent(prop_name);
-    html +=   '&q=' + encodeURIComponent(JSON.stringify(wmgui.search)) + '" width="530" height="25" />';
-    html += '<div id="slider_' + prop_id + '" class="slider_numerics" rel="' + prop_name + '"></div></div>';
-    html += '</li>';
-
-    $('#numericbox').show();
-    $('#numericbox > ul').prepend(html);
-
-    var decimals = p_step ? Math.abs(Math.log10(p_step)) : Math.max(p_min.count_decimals(), p_max.count_decimals());
-    //console.log('decimals = ', decimals);
-
-    noUiSlider.create(document.getElementById('slider_' + prop_id), {
-        start: [p_start || p_min, p_end || p_max],
-        step: p_step || ((p_max - p_min) / 250),
-        tooltips: [wNumb({decimals: decimals}), wNumb({decimals: decimals})],
-        connect: true,
-        behaviour: 'drag',
-        range: {'min': p_min, 'max': p_max},
-        format: {
-            to: function (value){ return value },
-            from: function(value){ return Number(value) }
-        }
-    });
-}
-
-function destroy_numericbox(){
-    if ($('#numericbox').is(':visible')){
-        $('#numericbox > ul > li').each(function(){
-            var that = $(this);
-            that.find('div.slider_numerics')[0].noUiSlider.destroy();
-            that.remove();
-        });
-        $('#numericbox').hide();
-    }
-}
-
-function get_sliders_ranges(url_num_obj, num_database){
-    // given by:
-    // (1.) wmutils.guess, or
-    // (2.) from re-inventing serialization for numeric nested arrays, or
-    // (3.) by the user
-    var props = {},
-        output = [];
-
-    for (var i = 0; i < url_num_obj.length; i++){
-        if (url_num_obj[i][1] !== '>' && url_num_obj[i][1] !== '<')
-            continue;
-
-        var prop = (url_num_obj[i][1] == '>' ? 'start' : 'end');
-
-        if (!props[ url_num_obj[i][0] ]) props[url_num_obj[i][0]] = {};
-
-        props[url_num_obj[i][0]][prop] = parseFloat(url_num_obj[i][2]); // TODO? consequent series like > 100, > 200, etc.
-    }
-    //console.log(props);
-    for (var key in props){
-        if (!num_database[key]){ console.log("Unsupported key: " + key); continue; }
-
-        if (!props[key]['start']) props[key]['start'] = num_database[key][2]; // min
-        else if (!props[key]['end']) props[key]['end'] = num_database[key][3]; // max
-
-        if (props[key]['end'] < props[key]['start']) throw new Error("The end of range is lower than the start of range!");
-        output.push([
-            key,
-            num_database[key][0],
-            num_database[key][1],
-            num_database[key][2],
-            num_database[key][3],
-            num_database[key][4],
-            props[key]['start'],
-            props[key]['end']
-        ]);
-    }
-    output.sort(function(a, b){
-        return a[1] > b[1] ? 1 : -1; // prop_id
-    });
-    return output;
-}
-
-function serialize_numeric(prop, sign, value){ // re-inventing serialization for numeric nested arrays
-    return prop + ',' + sign + ',' + value + ';';
-}
diff --git a/src_js/startup.js b/src_js/startup.js
deleted file mode 100755
index ae2a486..0000000
--- a/src_js/startup.js
+++ /dev/null
@@ -1,402 +0,0 @@
-"use strict";
-
-var wmgui = window.wmgui || {};
-
-function satisfy_requirements(){
-
-    $('#notifybox, #preloader').hide();
-    //document.title = document.body.clientWidth + ' px';
-    $('#absolidize > span.disabled > span.href').attr('rel', wmgui.mydata_addr);
-
-    wmgui.ptable.els_data = read_ptable_html();
-
-    init_user_login();
-
-    // building history box
-    var history_html = '';
-    $.each(JSON.parse(window.localStorage.getItem(wmgui.store_history_key) || '[]'), function(n, past){
-        wmgui.tooltip_counter++;
-
-        if (n > 5)
-            return false;
-
-        var title = [],
-            inquiry = false;
-
-        for (var prop in past){ title.push(past[prop]) }
-        title = title.join(" ");
-        $.each(wmgui.inquiries, function(m, item){ if (past[item]){   inquiry = true; return false;   } });
-
-        if (inquiry) history_html += '<li><a href="#inquiry/' + $.param(past) + '">' + title + '</a></li>';
-        else         history_html += '<li><a href="#search/' + encodeURIComponent(title) + '">' + title + '</a></li>';
-    });
-    $('#history ul').append(history_html);
-
-    $.each(JSON.parse(window.localStorage.getItem(wmgui.store_bids_key) || '[]'), function(n, item){
-        wmgui.bid_history.push(parseInt(item));
-    });
-
-    $.each(JSON.parse(window.localStorage.getItem(wmgui.store_mydata_key) || '[]'), function(n, item){
-        wmgui.mydata_history.push(item);
-    });
-
-    // set client-side data features
-    $.ajax({
-        url: wmgui.wmdata_endpoint,
-        type: 'GET'
-        //data: {nocache: Math.floor(Math.random() * 1000)}
-
-    }).done(function(answer){
-
-        var i = 0, len = answer.props_ref.length;
-        for (i; i < len; i++){
-            if (!answer.props_ref[i]) answer.props_ref[i] = answer.props[i];
-        }
-
-        // local search algo
-        // #1
-        $.each(['props', 'lattices', 'sgs', 'protos', 'codens', 'geos', 'orgs'], function(idx, fct){
-            wmgui.create_autocomplete({
-                custom_type: fct,
-                selector: 'advs_fct_' + fct, minChars: 1, cache: 1,
-                source: function(term, fct_type, suggest){
-                    // other names are used, define them first here
-                    var fct_src = fct_type,
-                        fct_chk = fct_type,
-                        anypos = false;
-
-                    if (fct_type !== 'lattices'){
-                        anypos = true;
-                        if (fct_type == 'props') fct_src = 'props_ref';
-                        else if (fct_type == 'codens'){
-                            fct_src = 'jfull';
-                            fct_chk = 'jfull';
-                        }
-                    }
-
-                    var suggestions = [],
-                        cnt = 0,
-                        checks = [],
-                        i = 0,
-                        len = answer[fct_chk].length;
-
-                    term = term.toLowerCase();
-                    for (i; i < len; i++){
-                        if (answer[fct_chk][i].toLowerCase().startswith(term)){
-                            suggestions.push(answer[fct_src][i]);
-                            if (anypos) checks.push(answer[fct_src][i]);
-                            cnt++;
-                            if (cnt > 12) break;
-                        }
-                    }
-                    if (anypos && suggestions.length < 6){
-                        for (i = 0; i < len; i++){
-                            if (answer[fct_chk][i].toLowerCase().indexOf(term) != -1 && checks.indexOf(answer[fct_src][i]) == -1){
-                                suggestions.push(answer[fct_src][i]);
-                                cnt++;
-                                if (cnt > 12) break;
-                            }
-                        }
-                    }
-                    suggest(suggestions);
-                },
-                renderItem: function (item, search){
-                    return '<div class="autocomplete-suggestion" data-val="' + item + '">' + item + '</div>';
-                }
-            });
-        });
-
-        // local search algo
-        // #2
-        $.each(wmgui.multi_facets, function(idx, fct){
-            wmgui.multiselects[fct] = $('#advs_fct_' + fct).selectize({
-                plugins: ['remove_button', 'preserve_on_blur'],
-                valueField: 'id',
-                labelField: 'label',
-                searchField: 'label',
-                create: false,
-                highlight: false,
-                maxItems: 5,
-                closeAfterSelect: true,
-                diacritics: false,
-                options: [],
-                onChange: function(value){
-                    if (fct == 'aetypes'){
-                        var term = (wmgui.multiselects['aetypes'].read()['aetypes'] || "").split(', ').pop();
-                        show_aetmap(term);
-                        if ($('#aet_limit').is(':checked')) $('#aet_limit').trigger('click');
-
-                    } else if (fct == 'wyckoff'){
-                        var terms = (wmgui.multiselects['wyckoff'].read()['wyckoff'] || "").split(',').map(function(x){ return x.trim() });
-                        if (terms && terms[0] && terms.length > 1){
-                            var cmp = wmgui.is_wyckoff_position(terms[0]);
-                            if (!terms.every(function(x){ return cmp === wmgui.is_wyckoff_position(x) })) wmgui.notify('Wyckoff sequence and positions are mutually exclusive');
-                        }
-                    }
-                },
-                onItemRemove: function(value){
-                    var input = this;
-                    setTimeout(function(){
-                        input.close();
-                    }, 750);
-                },
-                load: function(term, callback){
-                    this.clearOptions();
-                    if (!term.length) return callback();
-
-                    var suggestions = [],
-                        cnt = 0,
-                        checks = [],
-                        i = 0,
-                        len = answer[fct].length;
-
-                    term = term.toLowerCase();
-                    for (i; i < len; i++){
-                        if (answer[fct][i].toLowerCase().startswith(term)){
-                            suggestions.push({'facet': fct, 'label': answer[fct][i], 'id': fct + i});
-                            checks.push(answer[fct][i]);
-                            cnt++;
-                            if (cnt > 12) break;
-                        }
-                    }
-                    if (suggestions.length < 6){
-                        for (i = 0; i < len; i++){
-                            if (answer[fct][i].toLowerCase().indexOf(term) != -1 && checks.indexOf(answer[fct][i]) == -1){
-                                suggestions.push({'facet': fct, 'label': answer[fct][i], 'id': fct + i});
-                                cnt++;
-                                if (cnt > 12) break;
-                            }
-                        }
-                    }
-                    callback(suggestions);
-                },
-                score: function(){ return function(){ return 1 } }, // no client scoring
-                render: {
-                    option: function(item, escape){
-                        return '<div class="fct_' + item.facet + '">' + item.label + '</div>';
-                    },
-                    item: function(item, escape){
-                        return '<div class="fct_' + item.facet + '" data-facet="' + item.facet + '" data-term="' + item.label + '">' + item.label + '</div>';
-                    }
-                }
-            })[0].selectize;
-
-            wmgui.multiselects[fct].read = function(){
-                return wmgui._selectize_read_facet(fct);
-            }
-            wmgui.multiselects[fct].write = function(search_obj){
-                wmgui._selectize_write(wmgui.multiselects[fct], fct, search_obj);
-            }
-            wmgui.multiselects[fct].display = function(facet, term){
-                wmgui._selectize_display(wmgui.multiselects[fct], facet, term);
-            }
-        });
-
-        wmgui.journal_converter.j2c = function(x){
-            var fi = answer.jfull.indexOf(x);
-            if (fi == -1){
-                wmgui.notify("Sorry, unknown journal: " + x);
-                return x;
-            }
-            return answer.codens[fi];
-        }
-        wmgui.journal_converter.c2j = function(x){
-            var fi = answer.codens.indexOf(x);
-            if (fi == -1){
-                wmgui.notify("Sorry, unknown CODEN: " + x);
-                return x;
-            }
-            return answer.jfull[fi];
-        }
-
-        var html_scalars = '',
-            html_complex = '',
-            html_arrays = '',
-            counter = 0;
-
-        $.each(answer.hy_scalars, function(term, content){
-            term = parseInt(term);
-            //console.log(term);
-            term = answer.props_ref[term] ? answer.props_ref[term] : answer.props[term];
-            //console.log(term);
-            counter += 1;
-            html_scalars += '<li><a class="dynprop" data-val="' + term + '" href="#inquiry/props=' + term.replace(/ /g, '+') + '">' + term + '</a> (<span class="hy' + counter + '">expand</span>)<ul style="display:none;">';
-            $.each(content, function(sub_term, sub_content){
-                sub_term = parseInt(sub_term);
-                //console.log(sub_term);
-                sub_term = answer.props_ref[sub_term] ? answer.props_ref[sub_term] : answer.props[sub_term];
-                //console.log('----' + sub_term);
-                html_scalars += '<li><a class="dynprop" data-val="' + sub_term + '" href="#inquiry/props=' + sub_term.replace(/ /g, '+') + '">' + sub_term + '</a><ul style="display:none;">';
-                $.each(sub_content, function(n, item){
-                    item = parseInt(item);
-                    var prop = answer.props_ref[item] ? answer.props_ref[item] : answer.props[item],
-                        specs = answer.numerics[item]; // NB object vs. array
-                    //console.log('---------' + item + ' ' + prop);
-                    html_scalars += '<li><a class="dynprop" data-val="' + prop + '" href="#inquiry/props=' + prop.replace(/ /g, '+') + '">' + prop + '</a>';
-                    if (specs){
-                        html_scalars += '<strong class="numeric" title="Numeric search" rel="' + prop + '">' + (specs[0] || '') + ' &nbsp;[' + specs[1] + ' &#8596; ' + specs[2] + ']&nbsp;&#x1F50D;</strong>';
-                        wmgui.numerics[prop] = [item, specs[0], specs[1], specs[2], specs[3]]; // prop_name: [client_prop_id, units, min, max, ?step, ?origname]
-                    }
-                    html_scalars += '</li>';
-                });
-                html_scalars += '</ul></li>';
-            });
-            html_scalars += '</ul></li>';
-        });
-        $('#hy_scalars > ul').append(html_scalars);
-
-        $.each(wmgui.hy_complex, function(n, item){
-            // FIXME cannot process with optimade NLP parser
-            html_complex += '<li><a class="dynprop" data-val="' + item + '" href="#search/' + item + '">' + item + '</a></li>';
-        });
-        $('#hy_complex > ul').append(html_complex);
-
-        $.each(answer.hy_textual, function(term, content){
-            term = parseInt(term);
-            term = answer.props_ref[term] ? answer.props_ref[term] : answer.props[term];
-            counter += 1;
-            html_arrays += '<li><a class="dynprop" data-val="' + term + '" href="#inquiry/props=' + term.replace(/ /g, '+') + '">' + term + '</a> (<span class="hy' + counter + '">expand</span>)<ul style="display:none;">';
-            $.each(content, function(sub_term, sub_content){
-                sub_term = parseInt(sub_term);
-                sub_term = answer.props_ref[sub_term] ? answer.props_ref[sub_term] : answer.props[sub_term];
-                html_arrays += '<li><a class="dynprop" data-val="' + sub_term + '" href="#inquiry/props=' + sub_term.replace(/ /g, '+') + '">' + sub_term + '</a><ul style="display:none;">';
-                $.each(sub_content, function(n, item){
-                    item = parseInt(item);
-                    item = answer.props_ref[item] ? answer.props_ref[item] : answer.props[item];
-                    html_arrays += '<li><a class="dynprop" data-val="' + item + '" href="#inquiry/props=' + item.replace(/ /g, '+') + '">' + item + '</a></li>';
-                });
-                html_arrays += '</ul></li>';
-            });
-            html_arrays += '</ul></li>';
-        });
-        $('#hy_arrays > ul').append(html_arrays);
-
-        wmgui.create_autocomplete({
-            selector: 'hy_suggest', minChars: 1, cache: 1,
-            source: function(term, fct_type, suggest){
-                var fct_src = 'props_ref',
-                    term = term.toLowerCase(),
-                    suggestions = [],
-                    cnt = 0,
-                    checks = [],
-                    i = 0,
-                    len = answer[fct_type].length;
-                for (i; i < len; i++){
-                    if (answer[fct_type][i].startswith(term)){
-                        suggestions.push(answer[fct_src][i]);
-                        checks.push(answer[fct_src][i]);
-                        cnt++;
-                        if (cnt > 18) break;
-                    }
-                }
-                if (suggestions.length < 12){
-                    for (i = 0; i < len; i++){
-                        if (answer[fct_type][i].indexOf(term) != -1 && checks.indexOf(answer[fct_src][i]) == -1){
-                            suggestions.push(answer[fct_src][i]);
-                            cnt++;
-                            if (cnt > 18) break;
-                        }
-                    }
-                }
-                suggest(suggestions);
-            },
-            renderItem: function (item, search){
-                return '<div class="autocomplete-suggestion" style="' + (wmgui.numerics[item] ? 'color:#c00' : '') + '" data-val="' + item + '">' + item + '</div>';
-            },
-            onSelect: function (e, term, item){
-                var numerics = wmgui.numerics[term];
-
-                if ($('#numericbox').is(':visible') && numerics)
-                    create_floating_slider(term, numerics[0], numerics[1], numerics[2], numerics[3], numerics[4]);
-                else
-                    window.location.hash = wmgui.aug_search_cmd("props", term);
-
-                $('#hy_suggest').val('');
-            }
-        });
-
-        rotate_interesting();
-        setInterval(rotate_interesting, 2000);
-
-        window.location.hash ? url_redraw_react() : window.location.replace('#start');
-
-    }).fail(function(xhr, textStatus, errorThrown){
-        console.error(errorThrown);
-        throw new Error("Failed to load GUI");
-    });
-
-    // set server-side data features
-    wmgui.multiselects['main'] = $('#search_field').selectize({
-        plugins: ['remove_button', 'preserve_on_blur'],
-        valueField: 'id',
-        labelField: 'label',
-        searchField: 'label',
-        create: false,
-        highlight: false,
-        maxItems: 10,
-        closeAfterSelect: true,
-        diacritics: false,
-        options: [],
-        onInitialize: function(){
-            $('#search_field-selectized').focus();
-        },
-        onItemAdd: function(){
-            if (wmgui.selectize_emit){
-                var check = wmgui.multiselects['main'].read();
-                select_ptable_series(check.elements);
-            }
-        },
-        onItemRemove: function(){
-            var check = wmgui.multiselects['main'].read(),
-                input = this;
-            if (!check.numeric){
-                destroy_numericbox();
-                delete wmgui.search.numeric;
-                if (wmgui.selectize_emit) select_ptable_series(check.elements);
-            }
-            setTimeout(function(){
-                input.close();
-            }, 750);
-        },
-        load: function(query, callback){
-            this.clearOptions();
-            if (!query.length) return callback();
-            $.ajax({
-                url: wmgui.auto_endpoint + '?q=' + encodeURIComponent(query),
-                type: 'GET',
-                error: callback,
-                success: function(res){
-                    if (!res.length){
-                        return;
-                    }
-                    callback(res);
-                }
-            });
-        },
-        score: function(){ return function(){ return 1 } }, // no client scoring
-        render: {
-            option: function(item, escape){
-                return '<div class="fct_' + item.facet + '">' + item.label + '</div>';
-            },
-            item: function(item, escape){
-                return '<div class="fct_' + item.facet + '" data-facet="' + item.facet + '" data-term="' + item.label + '">' + item.label + '</div>';
-            }
-        }
-    })[0].selectize;
-
-    wmgui.multiselects['main'].read = function(){
-        return wmgui._selectize_read_main();
-    }
-    wmgui.multiselects['main'].write = function(search_obj){
-        wmgui._selectize_write(wmgui.multiselects['main'], 'main', search_obj);
-    }
-    wmgui.multiselects['main'].display = function(facet, term){
-        wmgui._selectize_display(wmgui.multiselects['main'], facet, term);
-    }
-
-    wmgui.darkmode = new Darkmode({saveInCookies: false});
-    document.getElementById('darkmode_trigger').innerHTML = wmgui.darkmode.isActivated() ? 'enabled' : 'disabled';
-
-    //create_floating_slider('density', 42, 'Mg/m<sup>3</sup>', 10, 900, 10);
-    // EOF satisfy_requirements
-}
diff --git a/src_js/third_party/autocomplete.js b/src_js/third_party/autocomplete.js
deleted file mode 100755
index 433d142..0000000
--- a/src_js/third_party/autocomplete.js
+++ /dev/null
@@ -1,205 +0,0 @@
-
-// spin-off from https://github.com/Pixabay/JavaScript-autoComplete
-
-var wmgui = window.wmgui || {};
-
-wmgui.create_autocomplete = (function(){
-    function autoComplete(options){
-        if (!document.querySelector) return;
-
-        // helpers
-        function hasClass(el, className){ return el.classList ? el.classList.contains(className) : new RegExp('\\b' + className + '\\b').test(el.className); }
-
-        function addEvent(el, type, handler){
-            if (el.attachEvent) el.attachEvent('on' + type, handler);
-            else el.addEventListener(type, handler);
-        }
-        function removeEvent(el, type, handler){
-            // if (el.removeEventListener) not working in IE11
-            if (el.detachEvent) el.detachEvent('on' + type, handler);
-            else el.removeEventListener(type, handler);
-        }
-        function live(elClass, event, cb, context){
-            addEvent(context || document, event, function(e){
-                var found, el = e.target || e.srcElement;
-                while (el && !(found = hasClass(el, elClass))) el = el.parentElement;
-                if (found) cb.call(el, e);
-            });
-        }
-
-        var o = {
-            selector: 0,
-            source: 0,
-            minChars: 3,
-            delay: 150,
-            offsetLeft: 0,
-            offsetTop: 1,
-            cache: 1,
-            menuClass: '',
-            renderItem: function (item, search){},
-            onSelect: function(e, term, item){},
-            arrow_pressed: false,
-            custom_type: false
-        };
-        for (var k in options){ if (options.hasOwnProperty(k)) o[k] = options[k]; }
-
-        // init
-        var that = document.getElementById(o.selector),
-            fct_type = that.getAttribute("rel");
-
-        // create suggestions container "sc"
-        that.sc = document.createElement('div');
-        that.sc.className = 'autocomplete-suggestions ' + o.menuClass;
-
-        that.autocompleteAttr = that.getAttribute('autocomplete');
-        that.setAttribute('autocomplete', 'off');
-        that.cache = {};
-        that.last_val = '';
-
-        that.updateSC = function(resize, next){
-            var rect = that.getBoundingClientRect();
-            that.sc.style.left = Math.round(rect.left + (window.pageXOffset || document.documentElement.scrollLeft) + o.offsetLeft) + 'px';
-            that.sc.style.top = Math.round(rect.bottom + (window.pageYOffset || document.documentElement.scrollTop) + o.offsetTop) + 'px';
-            that.sc.style.width = Math.round(rect.right - rect.left) + 'px'; // outerWidth
-            if (!resize){
-                that.sc.style.display = 'block';
-                if (!that.sc.maxHeight){ that.sc.maxHeight = parseInt((window.getComputedStyle ? getComputedStyle(that.sc, null) : that.sc.currentStyle).maxHeight); }
-                if (!that.sc.suggestionHeight) that.sc.suggestionHeight = that.sc.querySelector('.autocomplete-suggestion').offsetHeight;
-                if (that.sc.suggestionHeight)
-                    if (!next) that.sc.scrollTop = 0;
-                    else {
-                        var scrTop = that.sc.scrollTop, selTop = next.getBoundingClientRect().top - that.sc.getBoundingClientRect().top;
-                        if (selTop + that.sc.suggestionHeight - that.sc.maxHeight > 0)
-                            that.sc.scrollTop = selTop + that.sc.suggestionHeight + scrTop - that.sc.maxHeight;
-                        else if (selTop < 0)
-                            that.sc.scrollTop = selTop + scrTop;
-                    }
-            }
-        }
-        addEvent(window, 'resize', that.updateSC);
-        document.body.appendChild(that.sc);
-
-        live('autocomplete-suggestion', 'mouseleave', function(e){
-            var sel = that.sc.querySelector('.autocomplete-suggestion.selected');
-            if (sel) setTimeout(function(){ sel.className = sel.className.replace('selected', '') }, 20);
-        }, that.sc);
-
-        live('autocomplete-suggestion', 'mouseover', function(e){
-            var sel = that.sc.querySelector('.autocomplete-suggestion.selected');
-            if (sel) sel.className = sel.className.replace('selected', '');
-            this.className += ' selected';
-
-            // account aetypes aetmap
-            if (o.custom_type == 'aetypes' && show_aetmap) show_aetmap(this.innerText);
-        }, that.sc);
-
-        live('autocomplete-suggestion', 'mousedown', function(e){
-            if (hasClass(this, 'autocomplete-suggestion')){ // else outside click
-                var v = this.getAttribute('data-val');
-                that.value = v;
-                o.onSelect(e, v, this);
-                that.sc.style.display = 'none';
-            }
-        }, that.sc);
-
-        that.blurHandler = function(){
-            try { var over_sb = document.querySelector('.autocomplete-suggestions:hover'); } catch(e){ var over_sb = 0; }
-            if (!over_sb){
-                that.last_val = that.value;
-                that.sc.style.display = 'none';
-                setTimeout(function(){ that.sc.style.display = 'none'; }, 350); // hide suggestions on fast input
-            } else if (that !== document.activeElement) setTimeout(function(){ that.focus() }, 20);
-        };
-        addEvent(that, 'blur', that.blurHandler);
-
-        var suggest = function(data){
-            o.arrow_pressed = false;
-            var val = that.value;
-            that.cache[val] = data;
-            if (data.length && val.length >= o.minChars){
-                var s = '';
-                for (var i = 0; i < data.length; i++) s += o.renderItem(data[i], val);
-                that.sc.innerHTML = s;
-                that.updateSC(0);
-            }
-            else
-                that.sc.style.display = 'none';
-        }
-
-        that.keydownHandler = function(e){
-            var key = window.event ? e.keyCode : e.which;
-            // down (40), up (38)
-            if ((key == 40 || key == 38) && that.sc.innerHTML){
-                o.arrow_pressed = true;
-                var next, sel = that.sc.querySelector('.autocomplete-suggestion.selected');
-                if (!sel){
-                    next = (key == 40) ? that.sc.querySelector('.autocomplete-suggestion') : that.sc.childNodes[that.sc.childNodes.length - 1]; // first : last
-                    next.className += ' selected';
-                    that.value = next.getAttribute('data-val');
-                } else {
-                    next = (key == 40) ? sel.nextSibling : sel.previousSibling;
-                    if (next){
-                        sel.className = sel.className.replace('selected', '');
-                        next.className += ' selected';
-                        that.value = next.getAttribute('data-val');
-                    }
-                    else {
-                        sel.className = sel.className.replace('selected', '');
-                        that.value = that.last_val;
-                        next = 0;
-                    }
-                }
-                that.updateSC(0, next);
-                return false;
-            }
-            // esc
-            else if (key == 27){ that.value = that.last_val; that.sc.style.display = 'none'; }
-            // enter
-            else if (key == 13 || key == 9){
-                var sel = that.sc.querySelector('.autocomplete-suggestion.selected');
-                if (sel && that.sc.style.display != 'none' && o.arrow_pressed){
-                    o.onSelect(e, sel.getAttribute('data-val'), sel);
-                    that.sc.style.display = 'none';
-                    //setTimeout(function(){ that.sc.style.display = 'none'; }, 20);
-                }
-            }
-        };
-        addEvent(that, 'keydown', that.keydownHandler);
-
-        that.keyupHandler = function(e){
-            var key = window.event ? e.keyCode : e.which;
-            if (!key || (key < 35 || key > 40) && key != 13 && key != 27){
-                var val = that.value;
-                if (val.length >= o.minChars){
-                    if (val != that.last_val){
-                        that.last_val = val;
-                        clearTimeout(that.timer);
-                        if (o.cache){
-                            if (val in that.cache){
-                                suggest(that.cache[val]);
-                                return;
-                            }
-                            // no requests if previous suggestions were empty
-                            for (var i = 1; i < val.length - o.minChars; i++){
-                                var part = val.slice(0, val.length - i);
-                                if (part in that.cache && !that.cache[part].length){ suggest([]); return; }
-                            }
-                        }
-                        that.timer = setTimeout(function(){ o.source(val, fct_type, suggest) }, o.delay);
-                    }
-                } else {
-                    that.last_val = val;
-                    that.sc.style.display = 'none';
-                }
-            }
-        };
-        addEvent(that, 'keyup', that.keyupHandler);
-
-        that.focusHandler = function(e){
-            that.last_val = '\n';
-            that.keyupHandler(e);
-        };
-        if (!o.minChars) addEvent(that, 'focus', that.focusHandler);
-    }
-    return autoComplete;
-})();
\ No newline at end of file
diff --git a/src_js/third_party/jquery.min.js b/src_js/third_party/jquery.min.js
deleted file mode 100644
index 7f37b5d..0000000
--- a/src_js/third_party/jquery.min.js
+++ /dev/null
@@ -1,2 +0,0 @@
-/*! jQuery v3.7.1 | (c) OpenJS Foundation and other contributors | jquery.org/license */
-!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(ie,e){"use strict";var oe=[],r=Object.getPrototypeOf,ae=oe.slice,g=oe.flat?function(e){return oe.flat.call(e)}:function(e){return oe.concat.apply([],e)},s=oe.push,se=oe.indexOf,n={},i=n.toString,ue=n.hasOwnProperty,o=ue.toString,a=o.call(Object),le={},v=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},y=function(e){return null!=e&&e===e.window},C=ie.document,u={type:!0,src:!0,nonce:!0,noModule:!0};function m(e,t,n){var r,i,o=(n=n||C).createElement("script");if(o.text=e,t)for(r in u)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function x(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[i.call(e)]||"object":typeof e}var t="3.7.1",l=/HTML$/i,ce=function(e,t){return new ce.fn.init(e,t)};function c(e){var t=!!e&&"length"in e&&e.length,n=x(e);return!v(e)&&!y(e)&&("array"===n||0===t||"number"==typeof t&&0<t&&t-1 in e)}function fe(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()}ce.fn=ce.prototype={jquery:t,constructor:ce,length:0,toArray:function(){return ae.call(this)},get:function(e){return null==e?ae.call(this):e<0?this[e+this.length]:this[e]},pushStack:function(e){var t=ce.merge(this.constructor(),e);return t.prevObject=this,t},each:function(e){return ce.each(this,e)},map:function(n){return this.pushStack(ce.map(this,function(e,t){return n.call(e,t,e)}))},slice:function(){return this.pushStack(ae.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},even:function(){return this.pushStack(ce.grep(this,function(e,t){return(t+1)%2}))},odd:function(){return this.pushStack(ce.grep(this,function(e,t){return t%2}))},eq:function(e){var t=this.length,n=+e+(e<0?t:0);return this.pushStack(0<=n&&n<t?[this[n]]:[])},end:function(){return this.prevObject||this.constructor()},push:s,sort:oe.sort,splice:oe.splice},ce.extend=ce.fn.extend=function(){var e,t,n,r,i,o,a=arguments[0]||{},s=1,u=arguments.length,l=!1;for("boolean"==typeof a&&(l=a,a=arguments[s]||{},s++),"object"==typeof a||v(a)||(a={}),s===u&&(a=this,s--);s<u;s++)if(null!=(e=arguments[s]))for(t in e)r=e[t],"__proto__"!==t&&a!==r&&(l&&r&&(ce.isPlainObject(r)||(i=Array.isArray(r)))?(n=a[t],o=i&&!Array.isArray(n)?[]:i||ce.isPlainObject(n)?n:{},i=!1,a[t]=ce.extend(l,o,r)):void 0!==r&&(a[t]=r));return a},ce.extend({expando:"jQuery"+(t+Math.random()).replace(/\D/g,""),isReady:!0,error:function(e){throw new Error(e)},noop:function(){},isPlainObject:function(e){var t,n;return!(!e||"[object Object]"!==i.call(e))&&(!(t=r(e))||"function"==typeof(n=ue.call(t,"constructor")&&t.constructor)&&o.call(n)===a)},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},globalEval:function(e,t,n){m(e,{nonce:t&&t.nonce},n)},each:function(e,t){var n,r=0;if(c(e)){for(n=e.length;r<n;r++)if(!1===t.call(e[r],r,e[r]))break}else for(r in e)if(!1===t.call(e[r],r,e[r]))break;return e},text:function(e){var t,n="",r=0,i=e.nodeType;if(!i)while(t=e[r++])n+=ce.text(t);return 1===i||11===i?e.textContent:9===i?e.documentElement.textContent:3===i||4===i?e.nodeValue:n},makeArray:function(e,t){var n=t||[];return null!=e&&(c(Object(e))?ce.merge(n,"string"==typeof e?[e]:e):s.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:se.call(t,e,n)},isXMLDoc:function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!l.test(t||n&&n.nodeName||"HTML")},merge:function(e,t){for(var n=+t.length,r=0,i=e.length;r<n;r++)e[i++]=t[r];return e.length=i,e},grep:function(e,t,n){for(var r=[],i=0,o=e.length,a=!n;i<o;i++)!t(e[i],i)!==a&&r.push(e[i]);return r},map:function(e,t,n){var r,i,o=0,a=[];if(c(e))for(r=e.length;o<r;o++)null!=(i=t(e[o],o,n))&&a.push(i);else for(o in e)null!=(i=t(e[o],o,n))&&a.push(i);return g(a)},guid:1,support:le}),"function"==typeof Symbol&&(ce.fn[Symbol.iterator]=oe[Symbol.iterator]),ce.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(e,t){n["[object "+t+"]"]=t.toLowerCase()});var pe=oe.pop,de=oe.sort,he=oe.splice,ge="[\\x20\\t\\r\\n\\f]",ve=new RegExp("^"+ge+"+|((?:^|[^\\\\])(?:\\\\.)*)"+ge+"+$","g");ce.contains=function(e,t){var n=t&&t.parentNode;return e===n||!(!n||1!==n.nodeType||!(e.contains?e.contains(n):e.compareDocumentPosition&&16&e.compareDocumentPosition(n)))};var f=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;function p(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e}ce.escapeSelector=function(e){return(e+"").replace(f,p)};var ye=C,me=s;!function(){var e,b,w,o,a,T,r,C,d,i,k=me,S=ce.expando,E=0,n=0,s=W(),c=W(),u=W(),h=W(),l=function(e,t){return e===t&&(a=!0),0},f="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",t="(?:\\\\[\\da-fA-F]{1,6}"+ge+"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",p="\\["+ge+"*("+t+")(?:"+ge+"*([*^$|!~]?=)"+ge+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+t+"))|)"+ge+"*\\]",g=":("+t+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+p+")*)|.*)\\)|)",v=new RegExp(ge+"+","g"),y=new RegExp("^"+ge+"*,"+ge+"*"),m=new RegExp("^"+ge+"*([>+~]|"+ge+")"+ge+"*"),x=new RegExp(ge+"|>"),j=new RegExp(g),A=new RegExp("^"+t+"$"),D={ID:new RegExp("^#("+t+")"),CLASS:new RegExp("^\\.("+t+")"),TAG:new RegExp("^("+t+"|[*])"),ATTR:new RegExp("^"+p),PSEUDO:new RegExp("^"+g),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+ge+"*(even|odd|(([+-]|)(\\d*)n|)"+ge+"*(?:([+-]|)"+ge+"*(\\d+)|))"+ge+"*\\)|)","i"),bool:new RegExp("^(?:"+f+")$","i"),needsContext:new RegExp("^"+ge+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+ge+"*((?:-\\d)?\\d*)"+ge+"*\\)|)(?=[^-]|$)","i")},N=/^(?:input|select|textarea|button)$/i,q=/^h\d$/i,L=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,H=/[+~]/,O=new RegExp("\\\\[\\da-fA-F]{1,6}"+ge+"?|\\\\([^\\r\\n\\f])","g"),P=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},M=function(){V()},R=J(function(e){return!0===e.disabled&&fe(e,"fieldset")},{dir:"parentNode",next:"legend"});try{k.apply(oe=ae.call(ye.childNodes),ye.childNodes),oe[ye.childNodes.length].nodeType}catch(e){k={apply:function(e,t){me.apply(e,ae.call(t))},call:function(e){me.apply(e,ae.call(arguments,1))}}}function I(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(V(e),e=e||T,C)){if(11!==p&&(u=L.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return k.call(n,a),n}else if(f&&(a=f.getElementById(i))&&I.contains(e,a)&&a.id===i)return k.call(n,a),n}else{if(u[2])return k.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&e.getElementsByClassName)return k.apply(n,e.getElementsByClassName(i)),n}if(!(h[t+" "]||d&&d.test(t))){if(c=t,f=e,1===p&&(x.test(t)||m.test(t))){(f=H.test(t)&&U(e.parentNode)||e)==e&&le.scope||((s=e.getAttribute("id"))?s=ce.escapeSelector(s):e.setAttribute("id",s=S)),o=(l=Y(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+Q(l[o]);c=l.join(",")}try{return k.apply(n,f.querySelectorAll(c)),n}catch(e){h(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return re(t.replace(ve,"$1"),e,n,r)}function W(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function F(e){return e[S]=!0,e}function $(e){var t=T.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function B(t){return function(e){return fe(e,"input")&&e.type===t}}function _(t){return function(e){return(fe(e,"input")||fe(e,"button"))&&e.type===t}}function z(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&R(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function X(a){return F(function(o){return o=+o,F(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function U(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}function V(e){var t,n=e?e.ownerDocument||e:ye;return n!=T&&9===n.nodeType&&n.documentElement&&(r=(T=n).documentElement,C=!ce.isXMLDoc(T),i=r.matches||r.webkitMatchesSelector||r.msMatchesSelector,r.msMatchesSelector&&ye!=T&&(t=T.defaultView)&&t.top!==t&&t.addEventListener("unload",M),le.getById=$(function(e){return r.appendChild(e).id=ce.expando,!T.getElementsByName||!T.getElementsByName(ce.expando).length}),le.disconnectedMatch=$(function(e){return i.call(e,"*")}),le.scope=$(function(){return T.querySelectorAll(":scope")}),le.cssHas=$(function(){try{return T.querySelector(":has(*,:jqfake)"),!1}catch(e){return!0}}),le.getById?(b.filter.ID=function(e){var t=e.replace(O,P);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&C){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(O,P);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&C){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):t.querySelectorAll(e)},b.find.CLASS=function(e,t){if("undefined"!=typeof t.getElementsByClassName&&C)return t.getElementsByClassName(e)},d=[],$(function(e){var t;r.appendChild(e).innerHTML="<a id='"+S+"' href='' disabled='disabled'></a><select id='"+S+"-\r\\' disabled='disabled'><option selected=''></option></select>",e.querySelectorAll("[selected]").length||d.push("\\["+ge+"*(?:value|"+f+")"),e.querySelectorAll("[id~="+S+"-]").length||d.push("~="),e.querySelectorAll("a#"+S+"+*").length||d.push(".#.+[+~]"),e.querySelectorAll(":checked").length||d.push(":checked"),(t=T.createElement("input")).setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),r.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&d.push(":enabled",":disabled"),(t=T.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||d.push("\\["+ge+"*name"+ge+"*="+ge+"*(?:''|\"\")")}),le.cssHas||d.push(":has"),d=d.length&&new RegExp(d.join("|")),l=function(e,t){if(e===t)return a=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!le.sortDetached&&t.compareDocumentPosition(e)===n?e===T||e.ownerDocument==ye&&I.contains(ye,e)?-1:t===T||t.ownerDocument==ye&&I.contains(ye,t)?1:o?se.call(o,e)-se.call(o,t):0:4&n?-1:1)}),T}for(e in I.matches=function(e,t){return I(e,null,null,t)},I.matchesSelector=function(e,t){if(V(e),C&&!h[t+" "]&&(!d||!d.test(t)))try{var n=i.call(e,t);if(n||le.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){h(t,!0)}return 0<I(t,T,null,[e]).length},I.contains=function(e,t){return(e.ownerDocument||e)!=T&&V(e),ce.contains(e,t)},I.attr=function(e,t){(e.ownerDocument||e)!=T&&V(e);var n=b.attrHandle[t.toLowerCase()],r=n&&ue.call(b.attrHandle,t.toLowerCase())?n(e,t,!C):void 0;return void 0!==r?r:e.getAttribute(t)},I.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},ce.uniqueSort=function(e){var t,n=[],r=0,i=0;if(a=!le.sortStable,o=!le.sortStable&&ae.call(e,0),de.call(e,l),a){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)he.call(e,n[r],1)}return o=null,e},ce.fn.uniqueSort=function(){return this.pushStack(ce.uniqueSort(ae.apply(this)))},(b=ce.expr={cacheLength:50,createPseudo:F,match:D,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(O,P),e[3]=(e[3]||e[4]||e[5]||"").replace(O,P),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||I.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&I.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return D.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&j.test(n)&&(t=Y(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(O,P).toLowerCase();return"*"===e?function(){return!0}:function(e){return fe(e,t)}},CLASS:function(e){var t=s[e+" "];return t||(t=new RegExp("(^|"+ge+")"+e+"("+ge+"|$)"))&&s(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=I.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1<t.indexOf(i):"$="===r?i&&t.slice(-i.length)===i:"~="===r?-1<(" "+t.replace(v," ")+" ").indexOf(i):"|="===r&&(t===i||t.slice(0,i.length+1)===i+"-"))}},CHILD:function(d,e,t,h,g){var v="nth"!==d.slice(0,3),y="last"!==d.slice(-4),m="of-type"===e;return 1===h&&0===g?function(e){return!!e.parentNode}:function(e,t,n){var r,i,o,a,s,u=v!==y?"nextSibling":"previousSibling",l=e.parentNode,c=m&&e.nodeName.toLowerCase(),f=!n&&!m,p=!1;if(l){if(v){while(u){o=e;while(o=o[u])if(m?fe(o,c):1===o.nodeType)return!1;s=u="only"===d&&!s&&"nextSibling"}return!0}if(s=[y?l.firstChild:l.lastChild],y&&f){p=(a=(r=(i=l[S]||(l[S]={}))[d]||[])[0]===E&&r[1])&&r[2],o=a&&l.childNodes[a];while(o=++a&&o&&o[u]||(p=a=0)||s.pop())if(1===o.nodeType&&++p&&o===e){i[d]=[E,a,p];break}}else if(f&&(p=a=(r=(i=e[S]||(e[S]={}))[d]||[])[0]===E&&r[1]),!1===p)while(o=++a&&o&&o[u]||(p=a=0)||s.pop())if((m?fe(o,c):1===o.nodeType)&&++p&&(f&&((i=o[S]||(o[S]={}))[d]=[E,p]),o===e))break;return(p-=g)===h||p%h==0&&0<=p/h}}},PSEUDO:function(e,o){var t,a=b.pseudos[e]||b.setFilters[e.toLowerCase()]||I.error("unsupported pseudo: "+e);return a[S]?a(o):1<a.length?(t=[e,e,"",o],b.setFilters.hasOwnProperty(e.toLowerCase())?F(function(e,t){var n,r=a(e,o),i=r.length;while(i--)e[n=se.call(e,r[i])]=!(t[n]=r[i])}):function(e){return a(e,0,t)}):a}},pseudos:{not:F(function(e){var r=[],i=[],s=ne(e.replace(ve,"$1"));return s[S]?F(function(e,t,n,r){var i,o=s(e,null,r,[]),a=e.length;while(a--)(i=o[a])&&(e[a]=!(t[a]=i))}):function(e,t,n){return r[0]=e,s(r,null,n,i),r[0]=null,!i.pop()}}),has:F(function(t){return function(e){return 0<I(t,e).length}}),contains:F(function(t){return t=t.replace(O,P),function(e){return-1<(e.textContent||ce.text(e)).indexOf(t)}}),lang:F(function(n){return A.test(n||"")||I.error("unsupported lang: "+n),n=n.replace(O,P).toLowerCase(),function(e){var t;do{if(t=C?e.lang:e.getAttribute("xml:lang")||e.getAttribute("lang"))return(t=t.toLowerCase())===n||0===t.indexOf(n+"-")}while((e=e.parentNode)&&1===e.nodeType);return!1}}),target:function(e){var t=ie.location&&ie.location.hash;return t&&t.slice(1)===e.id},root:function(e){return e===r},focus:function(e){return e===function(){try{return T.activeElement}catch(e){}}()&&T.hasFocus()&&!!(e.type||e.href||~e.tabIndex)},enabled:z(!1),disabled:z(!0),checked:function(e){return fe(e,"input")&&!!e.checked||fe(e,"option")&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,!0===e.selected},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!b.pseudos.empty(e)},header:function(e){return q.test(e.nodeName)},input:function(e){return N.test(e.nodeName)},button:function(e){return fe(e,"input")&&"button"===e.type||fe(e,"button")},text:function(e){var t;return fe(e,"input")&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:X(function(){return[0]}),last:X(function(e,t){return[t-1]}),eq:X(function(e,t,n){return[n<0?n+t:n]}),even:X(function(e,t){for(var n=0;n<t;n+=2)e.push(n);return e}),odd:X(function(e,t){for(var n=1;n<t;n+=2)e.push(n);return e}),lt:X(function(e,t,n){var r;for(r=n<0?n+t:t<n?t:n;0<=--r;)e.push(r);return e}),gt:X(function(e,t,n){for(var r=n<0?n+t:n;++r<t;)e.push(r);return e})}}).pseudos.nth=b.pseudos.eq,{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})b.pseudos[e]=B(e);for(e in{submit:!0,reset:!0})b.pseudos[e]=_(e);function G(){}function Y(e,t){var n,r,i,o,a,s,u,l=c[e+" "];if(l)return t?0:l.slice(0);a=e,s=[],u=b.preFilter;while(a){for(o in n&&!(r=y.exec(a))||(r&&(a=a.slice(r[0].length)||a),s.push(i=[])),n=!1,(r=m.exec(a))&&(n=r.shift(),i.push({value:n,type:r[0].replace(ve," ")}),a=a.slice(n.length)),b.filter)!(r=D[o].exec(a))||u[o]&&!(r=u[o](r))||(n=r.shift(),i.push({value:n,type:o,matches:r}),a=a.slice(n.length));if(!n)break}return t?a.length:a?I.error(e):c(e,s).slice(0)}function Q(e){for(var t=0,n=e.length,r="";t<n;t++)r+=e[t].value;return r}function J(a,e,t){var s=e.dir,u=e.next,l=u||s,c=t&&"parentNode"===l,f=n++;return e.first?function(e,t,n){while(e=e[s])if(1===e.nodeType||c)return a(e,t,n);return!1}:function(e,t,n){var r,i,o=[E,f];if(n){while(e=e[s])if((1===e.nodeType||c)&&a(e,t,n))return!0}else while(e=e[s])if(1===e.nodeType||c)if(i=e[S]||(e[S]={}),u&&fe(e,u))e=e[s]||e;else{if((r=i[l])&&r[0]===E&&r[1]===f)return o[2]=r[2];if((i[l]=o)[2]=a(e,t,n))return!0}return!1}}function K(i){return 1<i.length?function(e,t,n){var r=i.length;while(r--)if(!i[r](e,t,n))return!1;return!0}:i[0]}function Z(e,t,n,r,i){for(var o,a=[],s=0,u=e.length,l=null!=t;s<u;s++)(o=e[s])&&(n&&!n(o,r,i)||(a.push(o),l&&t.push(s)));return a}function ee(d,h,g,v,y,e){return v&&!v[S]&&(v=ee(v)),y&&!y[S]&&(y=ee(y,e)),F(function(e,t,n,r){var i,o,a,s,u=[],l=[],c=t.length,f=e||function(e,t,n){for(var r=0,i=t.length;r<i;r++)I(e,t[r],n);return n}(h||"*",n.nodeType?[n]:n,[]),p=!d||!e&&h?f:Z(f,u,d,n,r);if(g?g(p,s=y||(e?d:c||v)?[]:t,n,r):s=p,v){i=Z(s,l),v(i,[],n,r),o=i.length;while(o--)(a=i[o])&&(s[l[o]]=!(p[l[o]]=a))}if(e){if(y||d){if(y){i=[],o=s.length;while(o--)(a=s[o])&&i.push(p[o]=a);y(null,s=[],i,r)}o=s.length;while(o--)(a=s[o])&&-1<(i=y?se.call(e,a):u[o])&&(e[i]=!(t[i]=a))}}else s=Z(s===t?s.splice(c,s.length):s),y?y(null,t,s,r):k.apply(t,s)})}function te(e){for(var i,t,n,r=e.length,o=b.relative[e[0].type],a=o||b.relative[" "],s=o?1:0,u=J(function(e){return e===i},a,!0),l=J(function(e){return-1<se.call(i,e)},a,!0),c=[function(e,t,n){var r=!o&&(n||t!=w)||((i=t).nodeType?u(e,t,n):l(e,t,n));return i=null,r}];s<r;s++)if(t=b.relative[e[s].type])c=[J(K(c),t)];else{if((t=b.filter[e[s].type].apply(null,e[s].matches))[S]){for(n=++s;n<r;n++)if(b.relative[e[n].type])break;return ee(1<s&&K(c),1<s&&Q(e.slice(0,s-1).concat({value:" "===e[s-2].type?"*":""})).replace(ve,"$1"),t,s<n&&te(e.slice(s,n)),n<r&&te(e=e.slice(n)),n<r&&Q(e))}c.push(t)}return K(c)}function ne(e,t){var n,v,y,m,x,r,i=[],o=[],a=u[e+" "];if(!a){t||(t=Y(e)),n=t.length;while(n--)(a=te(t[n]))[S]?i.push(a):o.push(a);(a=u(e,(v=o,m=0<(y=i).length,x=0<v.length,r=function(e,t,n,r,i){var o,a,s,u=0,l="0",c=e&&[],f=[],p=w,d=e||x&&b.find.TAG("*",i),h=E+=null==p?1:Math.random()||.1,g=d.length;for(i&&(w=t==T||t||i);l!==g&&null!=(o=d[l]);l++){if(x&&o){a=0,t||o.ownerDocument==T||(V(o),n=!C);while(s=v[a++])if(s(o,t||T,n)){k.call(r,o);break}i&&(E=h)}m&&((o=!s&&o)&&u--,e&&c.push(o))}if(u+=l,m&&l!==u){a=0;while(s=y[a++])s(c,f,t,n);if(e){if(0<u)while(l--)c[l]||f[l]||(f[l]=pe.call(r));f=Z(f)}k.apply(r,f),i&&!e&&0<f.length&&1<u+y.length&&ce.uniqueSort(r)}return i&&(E=h,w=p),c},m?F(r):r))).selector=e}return a}function re(e,t,n,r){var i,o,a,s,u,l="function"==typeof e&&e,c=!r&&Y(e=l.selector||e);if(n=n||[],1===c.length){if(2<(o=c[0]=c[0].slice(0)).length&&"ID"===(a=o[0]).type&&9===t.nodeType&&C&&b.relative[o[1].type]){if(!(t=(b.find.ID(a.matches[0].replace(O,P),t)||[])[0]))return n;l&&(t=t.parentNode),e=e.slice(o.shift().value.length)}i=D.needsContext.test(e)?0:o.length;while(i--){if(a=o[i],b.relative[s=a.type])break;if((u=b.find[s])&&(r=u(a.matches[0].replace(O,P),H.test(o[0].type)&&U(t.parentNode)||t))){if(o.splice(i,1),!(e=r.length&&Q(o)))return k.apply(n,r),n;break}}}return(l||ne(e,c))(r,t,!C,n,!t||H.test(e)&&U(t.parentNode)||t),n}G.prototype=b.filters=b.pseudos,b.setFilters=new G,le.sortStable=S.split("").sort(l).join("")===S,V(),le.sortDetached=$(function(e){return 1&e.compareDocumentPosition(T.createElement("fieldset"))}),ce.find=I,ce.expr[":"]=ce.expr.pseudos,ce.unique=ce.uniqueSort,I.compile=ne,I.select=re,I.setDocument=V,I.tokenize=Y,I.escape=ce.escapeSelector,I.getText=ce.text,I.isXML=ce.isXMLDoc,I.selectors=ce.expr,I.support=ce.support,I.uniqueSort=ce.uniqueSort}();var d=function(e,t,n){var r=[],i=void 0!==n;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&ce(e).is(n))break;r.push(e)}return r},h=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},b=ce.expr.match.needsContext,w=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function T(e,n,r){return v(n)?ce.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?ce.grep(e,function(e){return e===n!==r}):"string"!=typeof n?ce.grep(e,function(e){return-1<se.call(n,e)!==r}):ce.filter(n,e,r)}ce.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?ce.find.matchesSelector(r,e)?[r]:[]:ce.find.matches(e,ce.grep(t,function(e){return 1===e.nodeType}))},ce.fn.extend({find:function(e){var t,n,r=this.length,i=this;if("string"!=typeof e)return this.pushStack(ce(e).filter(function(){for(t=0;t<r;t++)if(ce.contains(i[t],this))return!0}));for(n=this.pushStack([]),t=0;t<r;t++)ce.find(e,i[t],n);return 1<r?ce.uniqueSort(n):n},filter:function(e){return this.pushStack(T(this,e||[],!1))},not:function(e){return this.pushStack(T(this,e||[],!0))},is:function(e){return!!T(this,"string"==typeof e&&b.test(e)?ce(e):e||[],!1).length}});var k,S=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/;(ce.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||k,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:S.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof ce?t[0]:t,ce.merge(this,ce.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:C,!0)),w.test(r[1])&&ce.isPlainObject(t))for(r in t)v(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=C.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):v(e)?void 0!==n.ready?n.ready(e):e(ce):ce.makeArray(e,this)}).prototype=ce.fn,k=ce(C);var E=/^(?:parents|prev(?:Until|All))/,j={children:!0,contents:!0,next:!0,prev:!0};function A(e,t){while((e=e[t])&&1!==e.nodeType);return e}ce.fn.extend({has:function(e){var t=ce(e,this),n=t.length;return this.filter(function(){for(var e=0;e<n;e++)if(ce.contains(this,t[e]))return!0})},closest:function(e,t){var n,r=0,i=this.length,o=[],a="string"!=typeof e&&ce(e);if(!b.test(e))for(;r<i;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(n.nodeType<11&&(a?-1<a.index(n):1===n.nodeType&&ce.find.matchesSelector(n,e))){o.push(n);break}return this.pushStack(1<o.length?ce.uniqueSort(o):o)},index:function(e){return e?"string"==typeof e?se.call(ce(e),this[0]):se.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(ce.uniqueSort(ce.merge(this.get(),ce(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),ce.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return d(e,"parentNode")},parentsUntil:function(e,t,n){return d(e,"parentNode",n)},next:function(e){return A(e,"nextSibling")},prev:function(e){return A(e,"previousSibling")},nextAll:function(e){return d(e,"nextSibling")},prevAll:function(e){return d(e,"previousSibling")},nextUntil:function(e,t,n){return d(e,"nextSibling",n)},prevUntil:function(e,t,n){return d(e,"previousSibling",n)},siblings:function(e){return h((e.parentNode||{}).firstChild,e)},children:function(e){return h(e.firstChild)},contents:function(e){return null!=e.contentDocument&&r(e.contentDocument)?e.contentDocument:(fe(e,"template")&&(e=e.content||e),ce.merge([],e.childNodes))}},function(r,i){ce.fn[r]=function(e,t){var n=ce.map(this,i,e);return"Until"!==r.slice(-5)&&(t=e),t&&"string"==typeof t&&(n=ce.filter(t,n)),1<this.length&&(j[r]||ce.uniqueSort(n),E.test(r)&&n.reverse()),this.pushStack(n)}});var D=/[^\x20\t\r\n\f]+/g;function N(e){return e}function q(e){throw e}function L(e,t,n,r){var i;try{e&&v(i=e.promise)?i.call(e).done(t).fail(n):e&&v(i=e.then)?i.call(e,t,n):t.apply(void 0,[e].slice(r))}catch(e){n.apply(void 0,[e])}}ce.Callbacks=function(r){var e,n;r="string"==typeof r?(e=r,n={},ce.each(e.match(D)||[],function(e,t){n[t]=!0}),n):ce.extend({},r);var i,t,o,a,s=[],u=[],l=-1,c=function(){for(a=a||r.once,o=i=!0;u.length;l=-1){t=u.shift();while(++l<s.length)!1===s[l].apply(t[0],t[1])&&r.stopOnFalse&&(l=s.length,t=!1)}r.memory||(t=!1),i=!1,a&&(s=t?[]:"")},f={add:function(){return s&&(t&&!i&&(l=s.length-1,u.push(t)),function n(e){ce.each(e,function(e,t){v(t)?r.unique&&f.has(t)||s.push(t):t&&t.length&&"string"!==x(t)&&n(t)})}(arguments),t&&!i&&c()),this},remove:function(){return ce.each(arguments,function(e,t){var n;while(-1<(n=ce.inArray(t,s,n)))s.splice(n,1),n<=l&&l--}),this},has:function(e){return e?-1<ce.inArray(e,s):0<s.length},empty:function(){return s&&(s=[]),this},disable:function(){return a=u=[],s=t="",this},disabled:function(){return!s},lock:function(){return a=u=[],t||i||(s=t=""),this},locked:function(){return!!a},fireWith:function(e,t){return a||(t=[e,(t=t||[]).slice?t.slice():t],u.push(t),i||c()),this},fire:function(){return f.fireWith(this,arguments),this},fired:function(){return!!o}};return f},ce.extend({Deferred:function(e){var o=[["notify","progress",ce.Callbacks("memory"),ce.Callbacks("memory"),2],["resolve","done",ce.Callbacks("once memory"),ce.Callbacks("once memory"),0,"resolved"],["reject","fail",ce.Callbacks("once memory"),ce.Callbacks("once memory"),1,"rejected"]],i="pending",a={state:function(){return i},always:function(){return s.done(arguments).fail(arguments),this},"catch":function(e){return a.then(null,e)},pipe:function(){var i=arguments;return ce.Deferred(function(r){ce.each(o,function(e,t){var n=v(i[t[4]])&&i[t[4]];s[t[1]](function(){var e=n&&n.apply(this,arguments);e&&v(e.promise)?e.promise().progress(r.notify).done(r.resolve).fail(r.reject):r[t[0]+"With"](this,n?[e]:arguments)})}),i=null}).promise()},then:function(t,n,r){var u=0;function l(i,o,a,s){return function(){var n=this,r=arguments,e=function(){var e,t;if(!(i<u)){if((e=a.apply(n,r))===o.promise())throw new TypeError("Thenable self-resolution");t=e&&("object"==typeof e||"function"==typeof e)&&e.then,v(t)?s?t.call(e,l(u,o,N,s),l(u,o,q,s)):(u++,t.call(e,l(u,o,N,s),l(u,o,q,s),l(u,o,N,o.notifyWith))):(a!==N&&(n=void 0,r=[e]),(s||o.resolveWith)(n,r))}},t=s?e:function(){try{e()}catch(e){ce.Deferred.exceptionHook&&ce.Deferred.exceptionHook(e,t.error),u<=i+1&&(a!==q&&(n=void 0,r=[e]),o.rejectWith(n,r))}};i?t():(ce.Deferred.getErrorHook?t.error=ce.Deferred.getErrorHook():ce.Deferred.getStackHook&&(t.error=ce.Deferred.getStackHook()),ie.setTimeout(t))}}return ce.Deferred(function(e){o[0][3].add(l(0,e,v(r)?r:N,e.notifyWith)),o[1][3].add(l(0,e,v(t)?t:N)),o[2][3].add(l(0,e,v(n)?n:q))}).promise()},promise:function(e){return null!=e?ce.extend(e,a):a}},s={};return ce.each(o,function(e,t){var n=t[2],r=t[5];a[t[1]]=n.add,r&&n.add(function(){i=r},o[3-e][2].disable,o[3-e][3].disable,o[0][2].lock,o[0][3].lock),n.add(t[3].fire),s[t[0]]=function(){return s[t[0]+"With"](this===s?void 0:this,arguments),this},s[t[0]+"With"]=n.fireWith}),a.promise(s),e&&e.call(s,s),s},when:function(e){var n=arguments.length,t=n,r=Array(t),i=ae.call(arguments),o=ce.Deferred(),a=function(t){return function(e){r[t]=this,i[t]=1<arguments.length?ae.call(arguments):e,--n||o.resolveWith(r,i)}};if(n<=1&&(L(e,o.done(a(t)).resolve,o.reject,!n),"pending"===o.state()||v(i[t]&&i[t].then)))return o.then();while(t--)L(i[t],a(t),o.reject);return o.promise()}});var H=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;ce.Deferred.exceptionHook=function(e,t){ie.console&&ie.console.warn&&e&&H.test(e.name)&&ie.console.warn("jQuery.Deferred exception: "+e.message,e.stack,t)},ce.readyException=function(e){ie.setTimeout(function(){throw e})};var O=ce.Deferred();function P(){C.removeEventListener("DOMContentLoaded",P),ie.removeEventListener("load",P),ce.ready()}ce.fn.ready=function(e){return O.then(e)["catch"](function(e){ce.readyException(e)}),this},ce.extend({isReady:!1,readyWait:1,ready:function(e){(!0===e?--ce.readyWait:ce.isReady)||(ce.isReady=!0)!==e&&0<--ce.readyWait||O.resolveWith(C,[ce])}}),ce.ready.then=O.then,"complete"===C.readyState||"loading"!==C.readyState&&!C.documentElement.doScroll?ie.setTimeout(ce.ready):(C.addEventListener("DOMContentLoaded",P),ie.addEventListener("load",P));var M=function(e,t,n,r,i,o,a){var s=0,u=e.length,l=null==n;if("object"===x(n))for(s in i=!0,n)M(e,t,s,n[s],!0,o,a);else if(void 0!==r&&(i=!0,v(r)||(a=!0),l&&(a?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(ce(e),n)})),t))for(;s<u;s++)t(e[s],n,a?r:r.call(e[s],s,t(e[s],n)));return i?e:l?t.call(e):u?t(e[0],n):o},R=/^-ms-/,I=/-([a-z])/g;function W(e,t){return t.toUpperCase()}function F(e){return e.replace(R,"ms-").replace(I,W)}var $=function(e){return 1===e.nodeType||9===e.nodeType||!+e.nodeType};function B(){this.expando=ce.expando+B.uid++}B.uid=1,B.prototype={cache:function(e){var t=e[this.expando];return t||(t={},$(e)&&(e.nodeType?e[this.expando]=t:Object.defineProperty(e,this.expando,{value:t,configurable:!0}))),t},set:function(e,t,n){var r,i=this.cache(e);if("string"==typeof t)i[F(t)]=n;else for(r in t)i[F(r)]=t[r];return i},get:function(e,t){return void 0===t?this.cache(e):e[this.expando]&&e[this.expando][F(t)]},access:function(e,t,n){return void 0===t||t&&"string"==typeof t&&void 0===n?this.get(e,t):(this.set(e,t,n),void 0!==n?n:t)},remove:function(e,t){var n,r=e[this.expando];if(void 0!==r){if(void 0!==t){n=(t=Array.isArray(t)?t.map(F):(t=F(t))in r?[t]:t.match(D)||[]).length;while(n--)delete r[t[n]]}(void 0===t||ce.isEmptyObject(r))&&(e.nodeType?e[this.expando]=void 0:delete e[this.expando])}},hasData:function(e){var t=e[this.expando];return void 0!==t&&!ce.isEmptyObject(t)}};var _=new B,z=new B,X=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,U=/[A-Z]/g;function V(e,t,n){var r,i;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(U,"-$&").toLowerCase(),"string"==typeof(n=e.getAttribute(r))){try{n="true"===(i=n)||"false"!==i&&("null"===i?null:i===+i+""?+i:X.test(i)?JSON.parse(i):i)}catch(e){}z.set(e,t,n)}else n=void 0;return n}ce.extend({hasData:function(e){return z.hasData(e)||_.hasData(e)},data:function(e,t,n){return z.access(e,t,n)},removeData:function(e,t){z.remove(e,t)},_data:function(e,t,n){return _.access(e,t,n)},_removeData:function(e,t){_.remove(e,t)}}),ce.fn.extend({data:function(n,e){var t,r,i,o=this[0],a=o&&o.attributes;if(void 0===n){if(this.length&&(i=z.get(o),1===o.nodeType&&!_.get(o,"hasDataAttrs"))){t=a.length;while(t--)a[t]&&0===(r=a[t].name).indexOf("data-")&&(r=F(r.slice(5)),V(o,r,i[r]));_.set(o,"hasDataAttrs",!0)}return i}return"object"==typeof n?this.each(function(){z.set(this,n)}):M(this,function(e){var t;if(o&&void 0===e)return void 0!==(t=z.get(o,n))?t:void 0!==(t=V(o,n))?t:void 0;this.each(function(){z.set(this,n,e)})},null,e,1<arguments.length,null,!0)},removeData:function(e){return this.each(function(){z.remove(this,e)})}}),ce.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=_.get(e,t),n&&(!r||Array.isArray(n)?r=_.access(e,t,ce.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=ce.queue(e,t),r=n.length,i=n.shift(),o=ce._queueHooks(e,t);"inprogress"===i&&(i=n.shift(),r--),i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,function(){ce.dequeue(e,t)},o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return _.get(e,n)||_.access(e,n,{empty:ce.Callbacks("once memory").add(function(){_.remove(e,[t+"queue",n])})})}}),ce.fn.extend({queue:function(t,n){var e=2;return"string"!=typeof t&&(n=t,t="fx",e--),arguments.length<e?ce.queue(this[0],t):void 0===n?this:this.each(function(){var e=ce.queue(this,t,n);ce._queueHooks(this,t),"fx"===t&&"inprogress"!==e[0]&&ce.dequeue(this,t)})},dequeue:function(e){return this.each(function(){ce.dequeue(this,e)})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=ce.Deferred(),o=this,a=this.length,s=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=void 0),e=e||"fx";while(a--)(n=_.get(o[a],e+"queueHooks"))&&n.empty&&(r++,n.empty.add(s));return s(),i.promise(t)}});var G=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,Y=new RegExp("^(?:([+-])=|)("+G+")([a-z%]*)$","i"),Q=["Top","Right","Bottom","Left"],J=C.documentElement,K=function(e){return ce.contains(e.ownerDocument,e)},Z={composed:!0};J.getRootNode&&(K=function(e){return ce.contains(e.ownerDocument,e)||e.getRootNode(Z)===e.ownerDocument});var ee=function(e,t){return"none"===(e=t||e).style.display||""===e.style.display&&K(e)&&"none"===ce.css(e,"display")};function te(e,t,n,r){var i,o,a=20,s=r?function(){return r.cur()}:function(){return ce.css(e,t,"")},u=s(),l=n&&n[3]||(ce.cssNumber[t]?"":"px"),c=e.nodeType&&(ce.cssNumber[t]||"px"!==l&&+u)&&Y.exec(ce.css(e,t));if(c&&c[3]!==l){u/=2,l=l||c[3],c=+u||1;while(a--)ce.style(e,t,c+l),(1-o)*(1-(o=s()/u||.5))<=0&&(a=0),c/=o;c*=2,ce.style(e,t,c+l),n=n||[]}return n&&(c=+c||+u||0,i=n[1]?c+(n[1]+1)*n[2]:+n[2],r&&(r.unit=l,r.start=c,r.end=i)),i}var ne={};function re(e,t){for(var n,r,i,o,a,s,u,l=[],c=0,f=e.length;c<f;c++)(r=e[c]).style&&(n=r.style.display,t?("none"===n&&(l[c]=_.get(r,"display")||null,l[c]||(r.style.display="")),""===r.style.display&&ee(r)&&(l[c]=(u=a=o=void 0,a=(i=r).ownerDocument,s=i.nodeName,(u=ne[s])||(o=a.body.appendChild(a.createElement(s)),u=ce.css(o,"display"),o.parentNode.removeChild(o),"none"===u&&(u="block"),ne[s]=u)))):"none"!==n&&(l[c]="none",_.set(r,"display",n)));for(c=0;c<f;c++)null!=l[c]&&(e[c].style.display=l[c]);return e}ce.fn.extend({show:function(){return re(this,!0)},hide:function(){return re(this)},toggle:function(e){return"boolean"==typeof e?e?this.show():this.hide():this.each(function(){ee(this)?ce(this).show():ce(this).hide()})}});var xe,be,we=/^(?:checkbox|radio)$/i,Te=/<([a-z][^\/\0>\x20\t\r\n\f]*)/i,Ce=/^$|^module$|\/(?:java|ecma)script/i;xe=C.createDocumentFragment().appendChild(C.createElement("div")),(be=C.createElement("input")).setAttribute("type","radio"),be.setAttribute("checked","checked"),be.setAttribute("name","t"),xe.appendChild(be),le.checkClone=xe.cloneNode(!0).cloneNode(!0).lastChild.checked,xe.innerHTML="<textarea>x</textarea>",le.noCloneChecked=!!xe.cloneNode(!0).lastChild.defaultValue,xe.innerHTML="<option></option>",le.option=!!xe.lastChild;var ke={thead:[1,"<table>","</table>"],col:[2,"<table><colgroup>","</colgroup></table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};function Se(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&fe(e,t)?ce.merge([e],n):n}function Ee(e,t){for(var n=0,r=e.length;n<r;n++)_.set(e[n],"globalEval",!t||_.get(t[n],"globalEval"))}ke.tbody=ke.tfoot=ke.colgroup=ke.caption=ke.thead,ke.th=ke.td,le.option||(ke.optgroup=ke.option=[1,"<select multiple='multiple'>","</select>"]);var je=/<|&#?\w+;/;function Ae(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d<h;d++)if((o=e[d])||0===o)if("object"===x(o))ce.merge(p,o.nodeType?[o]:o);else if(je.test(o)){a=a||f.appendChild(t.createElement("div")),s=(Te.exec(o)||["",""])[1].toLowerCase(),u=ke[s]||ke._default,a.innerHTML=u[1]+ce.htmlPrefilter(o)+u[2],c=u[0];while(c--)a=a.lastChild;ce.merge(p,a.childNodes),(a=f.firstChild).textContent=""}else p.push(t.createTextNode(o));f.textContent="",d=0;while(o=p[d++])if(r&&-1<ce.inArray(o,r))i&&i.push(o);else if(l=K(o),a=Se(f.appendChild(o),"script"),l&&Ee(a),n){c=0;while(o=a[c++])Ce.test(o.type||"")&&n.push(o)}return f}var De=/^([^.]*)(?:\.(.+)|)/;function Ne(){return!0}function qe(){return!1}function Le(e,t,n,r,i,o){var a,s;if("object"==typeof t){for(s in"string"!=typeof n&&(r=r||n,n=void 0),t)Le(e,s,n,r,t[s],o);return e}if(null==r&&null==i?(i=n,r=n=void 0):null==i&&("string"==typeof n?(i=r,r=void 0):(i=r,r=n,n=void 0)),!1===i)i=qe;else if(!i)return e;return 1===o&&(a=i,(i=function(e){return ce().off(e),a.apply(this,arguments)}).guid=a.guid||(a.guid=ce.guid++)),e.each(function(){ce.event.add(this,t,i,r,n)})}function He(e,r,t){t?(_.set(e,r,!1),ce.event.add(e,r,{namespace:!1,handler:function(e){var t,n=_.get(this,r);if(1&e.isTrigger&&this[r]){if(n)(ce.event.special[r]||{}).delegateType&&e.stopPropagation();else if(n=ae.call(arguments),_.set(this,r,n),this[r](),t=_.get(this,r),_.set(this,r,!1),n!==t)return e.stopImmediatePropagation(),e.preventDefault(),t}else n&&(_.set(this,r,ce.event.trigger(n[0],n.slice(1),this)),e.stopPropagation(),e.isImmediatePropagationStopped=Ne)}})):void 0===_.get(e,r)&&ce.event.add(e,r,Ne)}ce.event={global:{},add:function(t,e,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=_.get(t);if($(t)){n.handler&&(n=(o=n).handler,i=o.selector),i&&ce.find.matchesSelector(J,i),n.guid||(n.guid=ce.guid++),(u=v.events)||(u=v.events=Object.create(null)),(a=v.handle)||(a=v.handle=function(e){return"undefined"!=typeof ce&&ce.event.triggered!==e.type?ce.event.dispatch.apply(t,arguments):void 0}),l=(e=(e||"").match(D)||[""]).length;while(l--)d=g=(s=De.exec(e[l])||[])[1],h=(s[2]||"").split(".").sort(),d&&(f=ce.event.special[d]||{},d=(i?f.delegateType:f.bindType)||d,f=ce.event.special[d]||{},c=ce.extend({type:d,origType:g,data:r,handler:n,guid:n.guid,selector:i,needsContext:i&&ce.expr.match.needsContext.test(i),namespace:h.join(".")},o),(p=u[d])||((p=u[d]=[]).delegateCount=0,f.setup&&!1!==f.setup.call(t,r,h,a)||t.addEventListener&&t.addEventListener(d,a)),f.add&&(f.add.call(t,c),c.handler.guid||(c.handler.guid=n.guid)),i?p.splice(p.delegateCount++,0,c):p.push(c),ce.event.global[d]=!0)}},remove:function(e,t,n,r,i){var o,a,s,u,l,c,f,p,d,h,g,v=_.hasData(e)&&_.get(e);if(v&&(u=v.events)){l=(t=(t||"").match(D)||[""]).length;while(l--)if(d=g=(s=De.exec(t[l])||[])[1],h=(s[2]||"").split(".").sort(),d){f=ce.event.special[d]||{},p=u[d=(r?f.delegateType:f.bindType)||d]||[],s=s[2]&&new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"),a=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||s&&!s.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));a&&!p.length&&(f.teardown&&!1!==f.teardown.call(e,h,v.handle)||ce.removeEvent(e,d,v.handle),delete u[d])}else for(d in u)ce.event.remove(e,d+t[l],n,r,!0);ce.isEmptyObject(u)&&_.remove(e,"handle events")}},dispatch:function(e){var t,n,r,i,o,a,s=new Array(arguments.length),u=ce.event.fix(e),l=(_.get(this,"events")||Object.create(null))[u.type]||[],c=ce.event.special[u.type]||{};for(s[0]=u,t=1;t<arguments.length;t++)s[t]=arguments[t];if(u.delegateTarget=this,!c.preDispatch||!1!==c.preDispatch.call(this,u)){a=ce.event.handlers.call(this,u,l),t=0;while((i=a[t++])&&!u.isPropagationStopped()){u.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!u.isImmediatePropagationStopped())u.rnamespace&&!1!==o.namespace&&!u.rnamespace.test(o.namespace)||(u.handleObj=o,u.data=o.data,void 0!==(r=((ce.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,s))&&!1===(u.result=r)&&(u.preventDefault(),u.stopPropagation()))}return c.postDispatch&&c.postDispatch.call(this,u),u.result}},handlers:function(e,t){var n,r,i,o,a,s=[],u=t.delegateCount,l=e.target;if(u&&l.nodeType&&!("click"===e.type&&1<=e.button))for(;l!==this;l=l.parentNode||this)if(1===l.nodeType&&("click"!==e.type||!0!==l.disabled)){for(o=[],a={},n=0;n<u;n++)void 0===a[i=(r=t[n]).selector+" "]&&(a[i]=r.needsContext?-1<ce(i,this).index(l):ce.find(i,this,null,[l]).length),a[i]&&o.push(r);o.length&&s.push({elem:l,handlers:o})}return l=this,u<t.length&&s.push({elem:l,handlers:t.slice(u)}),s},addProp:function(t,e){Object.defineProperty(ce.Event.prototype,t,{enumerable:!0,configurable:!0,get:v(e)?function(){if(this.originalEvent)return e(this.originalEvent)}:function(){if(this.originalEvent)return this.originalEvent[t]},set:function(e){Object.defineProperty(this,t,{enumerable:!0,configurable:!0,writable:!0,value:e})}})},fix:function(e){return e[ce.expando]?e:new ce.Event(e)},special:{load:{noBubble:!0},click:{setup:function(e){var t=this||e;return we.test(t.type)&&t.click&&fe(t,"input")&&He(t,"click",!0),!1},trigger:function(e){var t=this||e;return we.test(t.type)&&t.click&&fe(t,"input")&&He(t,"click"),!0},_default:function(e){var t=e.target;return we.test(t.type)&&t.click&&fe(t,"input")&&_.get(t,"click")||fe(t,"a")}},beforeunload:{postDispatch:function(e){void 0!==e.result&&e.originalEvent&&(e.originalEvent.returnValue=e.result)}}}},ce.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n)},ce.Event=function(e,t){if(!(this instanceof ce.Event))return new ce.Event(e,t);e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||void 0===e.defaultPrevented&&!1===e.returnValue?Ne:qe,this.target=e.target&&3===e.target.nodeType?e.target.parentNode:e.target,this.currentTarget=e.currentTarget,this.relatedTarget=e.relatedTarget):this.type=e,t&&ce.extend(this,t),this.timeStamp=e&&e.timeStamp||Date.now(),this[ce.expando]=!0},ce.Event.prototype={constructor:ce.Event,isDefaultPrevented:qe,isPropagationStopped:qe,isImmediatePropagationStopped:qe,isSimulated:!1,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=Ne,e&&!this.isSimulated&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=Ne,e&&!this.isSimulated&&e.stopPropagation()},stopImmediatePropagation:function(){var e=this.originalEvent;this.isImmediatePropagationStopped=Ne,e&&!this.isSimulated&&e.stopImmediatePropagation(),this.stopPropagation()}},ce.each({altKey:!0,bubbles:!0,cancelable:!0,changedTouches:!0,ctrlKey:!0,detail:!0,eventPhase:!0,metaKey:!0,pageX:!0,pageY:!0,shiftKey:!0,view:!0,"char":!0,code:!0,charCode:!0,key:!0,keyCode:!0,button:!0,buttons:!0,clientX:!0,clientY:!0,offsetX:!0,offsetY:!0,pointerId:!0,pointerType:!0,screenX:!0,screenY:!0,targetTouches:!0,toElement:!0,touches:!0,which:!0},ce.event.addProp),ce.each({focus:"focusin",blur:"focusout"},function(r,i){function o(e){if(C.documentMode){var t=_.get(this,"handle"),n=ce.event.fix(e);n.type="focusin"===e.type?"focus":"blur",n.isSimulated=!0,t(e),n.target===n.currentTarget&&t(n)}else ce.event.simulate(i,e.target,ce.event.fix(e))}ce.event.special[r]={setup:function(){var e;if(He(this,r,!0),!C.documentMode)return!1;(e=_.get(this,i))||this.addEventListener(i,o),_.set(this,i,(e||0)+1)},trigger:function(){return He(this,r),!0},teardown:function(){var e;if(!C.documentMode)return!1;(e=_.get(this,i)-1)?_.set(this,i,e):(this.removeEventListener(i,o),_.remove(this,i))},_default:function(e){return _.get(e.target,r)},delegateType:i},ce.event.special[i]={setup:function(){var e=this.ownerDocument||this.document||this,t=C.documentMode?this:e,n=_.get(t,i);n||(C.documentMode?this.addEventListener(i,o):e.addEventListener(r,o,!0)),_.set(t,i,(n||0)+1)},teardown:function(){var e=this.ownerDocument||this.document||this,t=C.documentMode?this:e,n=_.get(t,i)-1;n?_.set(t,i,n):(C.documentMode?this.removeEventListener(i,o):e.removeEventListener(r,o,!0),_.remove(t,i))}}}),ce.each({mouseenter:"mouseover",mouseleave:"mouseout",pointerenter:"pointerover",pointerleave:"pointerout"},function(e,i){ce.event.special[e]={delegateType:i,bindType:i,handle:function(e){var t,n=e.relatedTarget,r=e.handleObj;return n&&(n===this||ce.contains(this,n))||(e.type=r.origType,t=r.handler.apply(this,arguments),e.type=i),t}}}),ce.fn.extend({on:function(e,t,n,r){return Le(this,e,t,n,r)},one:function(e,t,n,r){return Le(this,e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,ce(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return!1!==t&&"function"!=typeof t||(n=t,t=void 0),!1===n&&(n=qe),this.each(function(){ce.event.remove(this,e,n,t)})}});var Oe=/<script|<style|<link/i,Pe=/checked\s*(?:[^=]|=\s*.checked.)/i,Me=/^\s*<!\[CDATA\[|\]\]>\s*$/g;function Re(e,t){return fe(e,"table")&&fe(11!==t.nodeType?t:t.firstChild,"tr")&&ce(e).children("tbody")[0]||e}function Ie(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function We(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Fe(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(_.hasData(e)&&(s=_.get(e).events))for(i in _.remove(t,"handle events"),s)for(n=0,r=s[i].length;n<r;n++)ce.event.add(t,i,s[i][n]);z.hasData(e)&&(o=z.access(e),a=ce.extend({},o),z.set(t,a))}}function $e(n,r,i,o){r=g(r);var e,t,a,s,u,l,c=0,f=n.length,p=f-1,d=r[0],h=v(d);if(h||1<f&&"string"==typeof d&&!le.checkClone&&Pe.test(d))return n.each(function(e){var t=n.eq(e);h&&(r[0]=d.call(this,e,t.html())),$e(t,r,i,o)});if(f&&(t=(e=Ae(r,n[0].ownerDocument,!1,n,o)).firstChild,1===e.childNodes.length&&(e=t),t||o)){for(s=(a=ce.map(Se(e,"script"),Ie)).length;c<f;c++)u=e,c!==p&&(u=ce.clone(u,!0,!0),s&&ce.merge(a,Se(u,"script"))),i.call(n[c],u,c);if(s)for(l=a[a.length-1].ownerDocument,ce.map(a,We),c=0;c<s;c++)u=a[c],Ce.test(u.type||"")&&!_.access(u,"globalEval")&&ce.contains(l,u)&&(u.src&&"module"!==(u.type||"").toLowerCase()?ce._evalUrl&&!u.noModule&&ce._evalUrl(u.src,{nonce:u.nonce||u.getAttribute("nonce")},l):m(u.textContent.replace(Me,""),u,l))}return n}function Be(e,t,n){for(var r,i=t?ce.filter(t,e):e,o=0;null!=(r=i[o]);o++)n||1!==r.nodeType||ce.cleanData(Se(r)),r.parentNode&&(n&&K(r)&&Ee(Se(r,"script")),r.parentNode.removeChild(r));return e}ce.extend({htmlPrefilter:function(e){return e},clone:function(e,t,n){var r,i,o,a,s,u,l,c=e.cloneNode(!0),f=K(e);if(!(le.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||ce.isXMLDoc(e)))for(a=Se(c),r=0,i=(o=Se(e)).length;r<i;r++)s=o[r],u=a[r],void 0,"input"===(l=u.nodeName.toLowerCase())&&we.test(s.type)?u.checked=s.checked:"input"!==l&&"textarea"!==l||(u.defaultValue=s.defaultValue);if(t)if(n)for(o=o||Se(e),a=a||Se(c),r=0,i=o.length;r<i;r++)Fe(o[r],a[r]);else Fe(e,c);return 0<(a=Se(c,"script")).length&&Ee(a,!f&&Se(e,"script")),c},cleanData:function(e){for(var t,n,r,i=ce.event.special,o=0;void 0!==(n=e[o]);o++)if($(n)){if(t=n[_.expando]){if(t.events)for(r in t.events)i[r]?ce.event.remove(n,r):ce.removeEvent(n,r,t.handle);n[_.expando]=void 0}n[z.expando]&&(n[z.expando]=void 0)}}}),ce.fn.extend({detach:function(e){return Be(this,e,!0)},remove:function(e){return Be(this,e)},text:function(e){return M(this,function(e){return void 0===e?ce.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return $e(this,arguments,function(e){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||Re(this,e).appendChild(e)})},prepend:function(){return $e(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=Re(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return $e(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return $e(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(ce.cleanData(Se(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return ce.clone(this,e,t)})},html:function(e){return M(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!Oe.test(e)&&!ke[(Te.exec(e)||["",""])[1].toLowerCase()]){e=ce.htmlPrefilter(e);try{for(;n<r;n++)1===(t=this[n]||{}).nodeType&&(ce.cleanData(Se(t,!1)),t.innerHTML=e);t=0}catch(e){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var n=[];return $e(this,arguments,function(e){var t=this.parentNode;ce.inArray(this,n)<0&&(ce.cleanData(Se(this)),t&&t.replaceChild(e,this))},n)}}),ce.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,a){ce.fn[e]=function(e){for(var t,n=[],r=ce(e),i=r.length-1,o=0;o<=i;o++)t=o===i?this:this.clone(!0),ce(r[o])[a](t),s.apply(n,t.get());return this.pushStack(n)}});var _e=new RegExp("^("+G+")(?!px)[a-z%]+$","i"),ze=/^--/,Xe=function(e){var t=e.ownerDocument.defaultView;return t&&t.opener||(t=ie),t.getComputedStyle(e)},Ue=function(e,t,n){var r,i,o={};for(i in t)o[i]=e.style[i],e.style[i]=t[i];for(i in r=n.call(e),t)e.style[i]=o[i];return r},Ve=new RegExp(Q.join("|"),"i");function Ge(e,t,n){var r,i,o,a,s=ze.test(t),u=e.style;return(n=n||Xe(e))&&(a=n.getPropertyValue(t)||n[t],s&&a&&(a=a.replace(ve,"$1")||void 0),""!==a||K(e)||(a=ce.style(e,t)),!le.pixelBoxStyles()&&_e.test(a)&&Ve.test(t)&&(r=u.width,i=u.minWidth,o=u.maxWidth,u.minWidth=u.maxWidth=u.width=a,a=n.width,u.width=r,u.minWidth=i,u.maxWidth=o)),void 0!==a?a+"":a}function Ye(e,t){return{get:function(){if(!e())return(this.get=t).apply(this,arguments);delete this.get}}}!function(){function e(){if(l){u.style.cssText="position:absolute;left:-11111px;width:60px;margin-top:1px;padding:0;border:0",l.style.cssText="position:relative;display:block;box-sizing:border-box;overflow:scroll;margin:auto;border:1px;padding:1px;width:60%;top:1%",J.appendChild(u).appendChild(l);var e=ie.getComputedStyle(l);n="1%"!==e.top,s=12===t(e.marginLeft),l.style.right="60%",o=36===t(e.right),r=36===t(e.width),l.style.position="absolute",i=12===t(l.offsetWidth/3),J.removeChild(u),l=null}}function t(e){return Math.round(parseFloat(e))}var n,r,i,o,a,s,u=C.createElement("div"),l=C.createElement("div");l.style&&(l.style.backgroundClip="content-box",l.cloneNode(!0).style.backgroundClip="",le.clearCloneStyle="content-box"===l.style.backgroundClip,ce.extend(le,{boxSizingReliable:function(){return e(),r},pixelBoxStyles:function(){return e(),o},pixelPosition:function(){return e(),n},reliableMarginLeft:function(){return e(),s},scrollboxSize:function(){return e(),i},reliableTrDimensions:function(){var e,t,n,r;return null==a&&(e=C.createElement("table"),t=C.createElement("tr"),n=C.createElement("div"),e.style.cssText="position:absolute;left:-11111px;border-collapse:separate",t.style.cssText="box-sizing:content-box;border:1px solid",t.style.height="1px",n.style.height="9px",n.style.display="block",J.appendChild(e).appendChild(t).appendChild(n),r=ie.getComputedStyle(t),a=parseInt(r.height,10)+parseInt(r.borderTopWidth,10)+parseInt(r.borderBottomWidth,10)===t.offsetHeight,J.removeChild(e)),a}}))}();var Qe=["Webkit","Moz","ms"],Je=C.createElement("div").style,Ke={};function Ze(e){var t=ce.cssProps[e]||Ke[e];return t||(e in Je?e:Ke[e]=function(e){var t=e[0].toUpperCase()+e.slice(1),n=Qe.length;while(n--)if((e=Qe[n]+t)in Je)return e}(e)||e)}var et=/^(none|table(?!-c[ea]).+)/,tt={position:"absolute",visibility:"hidden",display:"block"},nt={letterSpacing:"0",fontWeight:"400"};function rt(e,t,n){var r=Y.exec(t);return r?Math.max(0,r[2]-(n||0))+(r[3]||"px"):t}function it(e,t,n,r,i,o){var a="width"===t?1:0,s=0,u=0,l=0;if(n===(r?"border":"content"))return 0;for(;a<4;a+=2)"margin"===n&&(l+=ce.css(e,n+Q[a],!0,i)),r?("content"===n&&(u-=ce.css(e,"padding"+Q[a],!0,i)),"margin"!==n&&(u-=ce.css(e,"border"+Q[a]+"Width",!0,i))):(u+=ce.css(e,"padding"+Q[a],!0,i),"padding"!==n?u+=ce.css(e,"border"+Q[a]+"Width",!0,i):s+=ce.css(e,"border"+Q[a]+"Width",!0,i));return!r&&0<=o&&(u+=Math.max(0,Math.ceil(e["offset"+t[0].toUpperCase()+t.slice(1)]-o-u-s-.5))||0),u+l}function ot(e,t,n){var r=Xe(e),i=(!le.boxSizingReliable()||n)&&"border-box"===ce.css(e,"boxSizing",!1,r),o=i,a=Ge(e,t,r),s="offset"+t[0].toUpperCase()+t.slice(1);if(_e.test(a)){if(!n)return a;a="auto"}return(!le.boxSizingReliable()&&i||!le.reliableTrDimensions()&&fe(e,"tr")||"auto"===a||!parseFloat(a)&&"inline"===ce.css(e,"display",!1,r))&&e.getClientRects().length&&(i="border-box"===ce.css(e,"boxSizing",!1,r),(o=s in e)&&(a=e[s])),(a=parseFloat(a)||0)+it(e,t,n||(i?"border":"content"),o,r,a)+"px"}function at(e,t,n,r,i){return new at.prototype.init(e,t,n,r,i)}ce.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=Ge(e,"opacity");return""===n?"1":n}}}},cssNumber:{animationIterationCount:!0,aspectRatio:!0,borderImageSlice:!0,columnCount:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,gridArea:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnStart:!0,gridRow:!0,gridRowEnd:!0,gridRowStart:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,scale:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeMiterlimit:!0,strokeOpacity:!0},cssProps:{},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,a,s=F(t),u=ze.test(t),l=e.style;if(u||(t=Ze(s)),a=ce.cssHooks[t]||ce.cssHooks[s],void 0===n)return a&&"get"in a&&void 0!==(i=a.get(e,!1,r))?i:l[t];"string"===(o=typeof n)&&(i=Y.exec(n))&&i[1]&&(n=te(e,t,i),o="number"),null!=n&&n==n&&("number"!==o||u||(n+=i&&i[3]||(ce.cssNumber[s]?"":"px")),le.clearCloneStyle||""!==n||0!==t.indexOf("background")||(l[t]="inherit"),a&&"set"in a&&void 0===(n=a.set(e,n,r))||(u?l.setProperty(t,n):l[t]=n))}},css:function(e,t,n,r){var i,o,a,s=F(t);return ze.test(t)||(t=Ze(s)),(a=ce.cssHooks[t]||ce.cssHooks[s])&&"get"in a&&(i=a.get(e,!0,n)),void 0===i&&(i=Ge(e,t,r)),"normal"===i&&t in nt&&(i=nt[t]),""===n||n?(o=parseFloat(i),!0===n||isFinite(o)?o||0:i):i}}),ce.each(["height","width"],function(e,u){ce.cssHooks[u]={get:function(e,t,n){if(t)return!et.test(ce.css(e,"display"))||e.getClientRects().length&&e.getBoundingClientRect().width?ot(e,u,n):Ue(e,tt,function(){return ot(e,u,n)})},set:function(e,t,n){var r,i=Xe(e),o=!le.scrollboxSize()&&"absolute"===i.position,a=(o||n)&&"border-box"===ce.css(e,"boxSizing",!1,i),s=n?it(e,u,n,a,i):0;return a&&o&&(s-=Math.ceil(e["offset"+u[0].toUpperCase()+u.slice(1)]-parseFloat(i[u])-it(e,u,"border",!1,i)-.5)),s&&(r=Y.exec(t))&&"px"!==(r[3]||"px")&&(e.style[u]=t,t=ce.css(e,u)),rt(0,t,s)}}}),ce.cssHooks.marginLeft=Ye(le.reliableMarginLeft,function(e,t){if(t)return(parseFloat(Ge(e,"marginLeft"))||e.getBoundingClientRect().left-Ue(e,{marginLeft:0},function(){return e.getBoundingClientRect().left}))+"px"}),ce.each({margin:"",padding:"",border:"Width"},function(i,o){ce.cssHooks[i+o]={expand:function(e){for(var t=0,n={},r="string"==typeof e?e.split(" "):[e];t<4;t++)n[i+Q[t]+o]=r[t]||r[t-2]||r[0];return n}},"margin"!==i&&(ce.cssHooks[i+o].set=rt)}),ce.fn.extend({css:function(e,t){return M(this,function(e,t,n){var r,i,o={},a=0;if(Array.isArray(t)){for(r=Xe(e),i=t.length;a<i;a++)o[t[a]]=ce.css(e,t[a],!1,r);return o}return void 0!==n?ce.style(e,t,n):ce.css(e,t)},e,t,1<arguments.length)}}),((ce.Tween=at).prototype={constructor:at,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||ce.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(ce.cssNumber[n]?"":"px")},cur:function(){var e=at.propHooks[this.prop];return e&&e.get?e.get(this):at.propHooks._default.get(this)},run:function(e){var t,n=at.propHooks[this.prop];return this.options.duration?this.pos=t=ce.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):at.propHooks._default.set(this),this}}).init.prototype=at.prototype,(at.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=ce.css(e.elem,e.prop,""))&&"auto"!==t?t:0},set:function(e){ce.fx.step[e.prop]?ce.fx.step[e.prop](e):1!==e.elem.nodeType||!ce.cssHooks[e.prop]&&null==e.elem.style[Ze(e.prop)]?e.elem[e.prop]=e.now:ce.style(e.elem,e.prop,e.now+e.unit)}}}).scrollTop=at.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},ce.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},ce.fx=at.prototype.init,ce.fx.step={};var st,ut,lt,ct,ft=/^(?:toggle|show|hide)$/,pt=/queueHooks$/;function dt(){ut&&(!1===C.hidden&&ie.requestAnimationFrame?ie.requestAnimationFrame(dt):ie.setTimeout(dt,ce.fx.interval),ce.fx.tick())}function ht(){return ie.setTimeout(function(){st=void 0}),st=Date.now()}function gt(e,t){var n,r=0,i={height:e};for(t=t?1:0;r<4;r+=2-t)i["margin"+(n=Q[r])]=i["padding"+n]=e;return t&&(i.opacity=i.width=e),i}function vt(e,t,n){for(var r,i=(yt.tweeners[t]||[]).concat(yt.tweeners["*"]),o=0,a=i.length;o<a;o++)if(r=i[o].call(n,t,e))return r}function yt(o,e,t){var n,a,r=0,i=yt.prefilters.length,s=ce.Deferred().always(function(){delete u.elem}),u=function(){if(a)return!1;for(var e=st||ht(),t=Math.max(0,l.startTime+l.duration-e),n=1-(t/l.duration||0),r=0,i=l.tweens.length;r<i;r++)l.tweens[r].run(n);return s.notifyWith(o,[l,n,t]),n<1&&i?t:(i||s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l]),!1)},l=s.promise({elem:o,props:ce.extend({},e),opts:ce.extend(!0,{specialEasing:{},easing:ce.easing._default},t),originalProperties:e,originalOptions:t,startTime:st||ht(),duration:t.duration,tweens:[],createTween:function(e,t){var n=ce.Tween(o,l.opts,e,t,l.opts.specialEasing[e]||l.opts.easing);return l.tweens.push(n),n},stop:function(e){var t=0,n=e?l.tweens.length:0;if(a)return this;for(a=!0;t<n;t++)l.tweens[t].run(1);return e?(s.notifyWith(o,[l,1,0]),s.resolveWith(o,[l,e])):s.rejectWith(o,[l,e]),this}}),c=l.props;for(!function(e,t){var n,r,i,o,a;for(n in e)if(i=t[r=F(n)],o=e[n],Array.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),(a=ce.cssHooks[r])&&"expand"in a)for(n in o=a.expand(o),delete e[r],o)n in e||(e[n]=o[n],t[n]=i);else t[r]=i}(c,l.opts.specialEasing);r<i;r++)if(n=yt.prefilters[r].call(l,o,c,l.opts))return v(n.stop)&&(ce._queueHooks(l.elem,l.opts.queue).stop=n.stop.bind(n)),n;return ce.map(c,vt,l),v(l.opts.start)&&l.opts.start.call(o,l),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always),ce.fx.timer(ce.extend(u,{elem:o,anim:l,queue:l.opts.queue})),l}ce.Animation=ce.extend(yt,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return te(n.elem,e,Y.exec(t),n),n}]},tweener:function(e,t){v(e)?(t=e,e=["*"]):e=e.match(D);for(var n,r=0,i=e.length;r<i;r++)n=e[r],yt.tweeners[n]=yt.tweeners[n]||[],yt.tweeners[n].unshift(t)},prefilters:[function(e,t,n){var r,i,o,a,s,u,l,c,f="width"in t||"height"in t,p=this,d={},h=e.style,g=e.nodeType&&ee(e),v=_.get(e,"fxshow");for(r in n.queue||(null==(a=ce._queueHooks(e,"fx")).unqueued&&(a.unqueued=0,s=a.empty.fire,a.empty.fire=function(){a.unqueued||s()}),a.unqueued++,p.always(function(){p.always(function(){a.unqueued--,ce.queue(e,"fx").length||a.empty.fire()})})),t)if(i=t[r],ft.test(i)){if(delete t[r],o=o||"toggle"===i,i===(g?"hide":"show")){if("show"!==i||!v||void 0===v[r])continue;g=!0}d[r]=v&&v[r]||ce.style(e,r)}if((u=!ce.isEmptyObject(t))||!ce.isEmptyObject(d))for(r in f&&1===e.nodeType&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],null==(l=v&&v.display)&&(l=_.get(e,"display")),"none"===(c=ce.css(e,"display"))&&(l?c=l:(re([e],!0),l=e.style.display||l,c=ce.css(e,"display"),re([e]))),("inline"===c||"inline-block"===c&&null!=l)&&"none"===ce.css(e,"float")&&(u||(p.done(function(){h.display=l}),null==l&&(c=h.display,l="none"===c?"":c)),h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),u=!1,d)u||(v?"hidden"in v&&(g=v.hidden):v=_.access(e,"fxshow",{display:l}),o&&(v.hidden=!g),g&&re([e],!0),p.done(function(){for(r in g||re([e]),_.remove(e,"fxshow"),d)ce.style(e,r,d[r])})),u=vt(g?v[r]:0,r,p),r in v||(v[r]=u.start,g&&(u.end=u.start,u.start=0))}],prefilter:function(e,t){t?yt.prefilters.unshift(e):yt.prefilters.push(e)}}),ce.speed=function(e,t,n){var r=e&&"object"==typeof e?ce.extend({},e):{complete:n||!n&&t||v(e)&&e,duration:e,easing:n&&t||t&&!v(t)&&t};return ce.fx.off?r.duration=0:"number"!=typeof r.duration&&(r.duration in ce.fx.speeds?r.duration=ce.fx.speeds[r.duration]:r.duration=ce.fx.speeds._default),null!=r.queue&&!0!==r.queue||(r.queue="fx"),r.old=r.complete,r.complete=function(){v(r.old)&&r.old.call(this),r.queue&&ce.dequeue(this,r.queue)},r},ce.fn.extend({fadeTo:function(e,t,n,r){return this.filter(ee).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(t,e,n,r){var i=ce.isEmptyObject(t),o=ce.speed(e,n,r),a=function(){var e=yt(this,ce.extend({},t),o);(i||_.get(this,"finish"))&&e.stop(!0)};return a.finish=a,i||!1===o.queue?this.each(a):this.queue(o.queue,a)},stop:function(i,e,o){var a=function(e){var t=e.stop;delete e.stop,t(o)};return"string"!=typeof i&&(o=e,e=i,i=void 0),e&&this.queue(i||"fx",[]),this.each(function(){var e=!0,t=null!=i&&i+"queueHooks",n=ce.timers,r=_.get(this);if(t)r[t]&&r[t].stop&&a(r[t]);else for(t in r)r[t]&&r[t].stop&&pt.test(t)&&a(r[t]);for(t=n.length;t--;)n[t].elem!==this||null!=i&&n[t].queue!==i||(n[t].anim.stop(o),e=!1,n.splice(t,1));!e&&o||ce.dequeue(this,i)})},finish:function(a){return!1!==a&&(a=a||"fx"),this.each(function(){var e,t=_.get(this),n=t[a+"queue"],r=t[a+"queueHooks"],i=ce.timers,o=n?n.length:0;for(t.finish=!0,ce.queue(this,a,[]),r&&r.stop&&r.stop.call(this,!0),e=i.length;e--;)i[e].elem===this&&i[e].queue===a&&(i[e].anim.stop(!0),i.splice(e,1));for(e=0;e<o;e++)n[e]&&n[e].finish&&n[e].finish.call(this);delete t.finish})}}),ce.each(["toggle","show","hide"],function(e,r){var i=ce.fn[r];ce.fn[r]=function(e,t,n){return null==e||"boolean"==typeof e?i.apply(this,arguments):this.animate(gt(r,!0),e,t,n)}}),ce.each({slideDown:gt("show"),slideUp:gt("hide"),slideToggle:gt("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,r){ce.fn[e]=function(e,t,n){return this.animate(r,e,t,n)}}),ce.timers=[],ce.fx.tick=function(){var e,t=0,n=ce.timers;for(st=Date.now();t<n.length;t++)(e=n[t])()||n[t]!==e||n.splice(t--,1);n.length||ce.fx.stop(),st=void 0},ce.fx.timer=function(e){ce.timers.push(e),ce.fx.start()},ce.fx.interval=13,ce.fx.start=function(){ut||(ut=!0,dt())},ce.fx.stop=function(){ut=null},ce.fx.speeds={slow:600,fast:200,_default:400},ce.fn.delay=function(r,e){return r=ce.fx&&ce.fx.speeds[r]||r,e=e||"fx",this.queue(e,function(e,t){var n=ie.setTimeout(e,r);t.stop=function(){ie.clearTimeout(n)}})},lt=C.createElement("input"),ct=C.createElement("select").appendChild(C.createElement("option")),lt.type="checkbox",le.checkOn=""!==lt.value,le.optSelected=ct.selected,(lt=C.createElement("input")).value="t",lt.type="radio",le.radioValue="t"===lt.value;var mt,xt=ce.expr.attrHandle;ce.fn.extend({attr:function(e,t){return M(this,ce.attr,e,t,1<arguments.length)},removeAttr:function(e){return this.each(function(){ce.removeAttr(this,e)})}}),ce.extend({attr:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return"undefined"==typeof e.getAttribute?ce.prop(e,t,n):(1===o&&ce.isXMLDoc(e)||(i=ce.attrHooks[t.toLowerCase()]||(ce.expr.match.bool.test(t)?mt:void 0)),void 0!==n?null===n?void ce.removeAttr(e,t):i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:(e.setAttribute(t,n+""),n):i&&"get"in i&&null!==(r=i.get(e,t))?r:null==(r=ce.find.attr(e,t))?void 0:r)},attrHooks:{type:{set:function(e,t){if(!le.radioValue&&"radio"===t&&fe(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,i=t&&t.match(D);if(i&&1===e.nodeType)while(n=i[r++])e.removeAttribute(n)}}),mt={set:function(e,t,n){return!1===t?ce.removeAttr(e,n):e.setAttribute(n,n),n}},ce.each(ce.expr.match.bool.source.match(/\w+/g),function(e,t){var a=xt[t]||ce.find.attr;xt[t]=function(e,t,n){var r,i,o=t.toLowerCase();return n||(i=xt[o],xt[o]=r,r=null!=a(e,t,n)?o:null,xt[o]=i),r}});var bt=/^(?:input|select|textarea|button)$/i,wt=/^(?:a|area)$/i;function Tt(e){return(e.match(D)||[]).join(" ")}function Ct(e){return e.getAttribute&&e.getAttribute("class")||""}function kt(e){return Array.isArray(e)?e:"string"==typeof e&&e.match(D)||[]}ce.fn.extend({prop:function(e,t){return M(this,ce.prop,e,t,1<arguments.length)},removeProp:function(e){return this.each(function(){delete this[ce.propFix[e]||e]})}}),ce.extend({prop:function(e,t,n){var r,i,o=e.nodeType;if(3!==o&&8!==o&&2!==o)return 1===o&&ce.isXMLDoc(e)||(t=ce.propFix[t]||t,i=ce.propHooks[t]),void 0!==n?i&&"set"in i&&void 0!==(r=i.set(e,n,t))?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=ce.find.attr(e,"tabindex");return t?parseInt(t,10):bt.test(e.nodeName)||wt.test(e.nodeName)&&e.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),le.optSelected||(ce.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),ce.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){ce.propFix[this.toLowerCase()]=this}),ce.fn.extend({addClass:function(t){var e,n,r,i,o,a;return v(t)?this.each(function(e){ce(this).addClass(t.call(this,e,Ct(this)))}):(e=kt(t)).length?this.each(function(){if(r=Ct(this),n=1===this.nodeType&&" "+Tt(r)+" "){for(o=0;o<e.length;o++)i=e[o],n.indexOf(" "+i+" ")<0&&(n+=i+" ");a=Tt(n),r!==a&&this.setAttribute("class",a)}}):this},removeClass:function(t){var e,n,r,i,o,a;return v(t)?this.each(function(e){ce(this).removeClass(t.call(this,e,Ct(this)))}):arguments.length?(e=kt(t)).length?this.each(function(){if(r=Ct(this),n=1===this.nodeType&&" "+Tt(r)+" "){for(o=0;o<e.length;o++){i=e[o];while(-1<n.indexOf(" "+i+" "))n=n.replace(" "+i+" "," ")}a=Tt(n),r!==a&&this.setAttribute("class",a)}}):this:this.attr("class","")},toggleClass:function(t,n){var e,r,i,o,a=typeof t,s="string"===a||Array.isArray(t);return v(t)?this.each(function(e){ce(this).toggleClass(t.call(this,e,Ct(this),n),n)}):"boolean"==typeof n&&s?n?this.addClass(t):this.removeClass(t):(e=kt(t),this.each(function(){if(s)for(o=ce(this),i=0;i<e.length;i++)r=e[i],o.hasClass(r)?o.removeClass(r):o.addClass(r);else void 0!==t&&"boolean"!==a||((r=Ct(this))&&_.set(this,"__className__",r),this.setAttribute&&this.setAttribute("class",r||!1===t?"":_.get(this,"__className__")||""))}))},hasClass:function(e){var t,n,r=0;t=" "+e+" ";while(n=this[r++])if(1===n.nodeType&&-1<(" "+Tt(Ct(n))+" ").indexOf(t))return!0;return!1}});var St=/\r/g;ce.fn.extend({val:function(n){var r,e,i,t=this[0];return arguments.length?(i=v(n),this.each(function(e){var t;1===this.nodeType&&(null==(t=i?n.call(this,e,ce(this).val()):n)?t="":"number"==typeof t?t+="":Array.isArray(t)&&(t=ce.map(t,function(e){return null==e?"":e+""})),(r=ce.valHooks[this.type]||ce.valHooks[this.nodeName.toLowerCase()])&&"set"in r&&void 0!==r.set(this,t,"value")||(this.value=t))})):t?(r=ce.valHooks[t.type]||ce.valHooks[t.nodeName.toLowerCase()])&&"get"in r&&void 0!==(e=r.get(t,"value"))?e:"string"==typeof(e=t.value)?e.replace(St,""):null==e?"":e:void 0}}),ce.extend({valHooks:{option:{get:function(e){var t=ce.find.attr(e,"value");return null!=t?t:Tt(ce.text(e))}},select:{get:function(e){var t,n,r,i=e.options,o=e.selectedIndex,a="select-one"===e.type,s=a?null:[],u=a?o+1:i.length;for(r=o<0?u:a?o:0;r<u;r++)if(((n=i[r]).selected||r===o)&&!n.disabled&&(!n.parentNode.disabled||!fe(n.parentNode,"optgroup"))){if(t=ce(n).val(),a)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=ce.makeArray(t),a=i.length;while(a--)((r=i[a]).selected=-1<ce.inArray(ce.valHooks.option.get(r),o))&&(n=!0);return n||(e.selectedIndex=-1),o}}}}),ce.each(["radio","checkbox"],function(){ce.valHooks[this]={set:function(e,t){if(Array.isArray(t))return e.checked=-1<ce.inArray(ce(e).val(),t)}},le.checkOn||(ce.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})});var Et=ie.location,jt={guid:Date.now()},At=/\?/;ce.parseXML=function(e){var t,n;if(!e||"string"!=typeof e)return null;try{t=(new ie.DOMParser).parseFromString(e,"text/xml")}catch(e){}return n=t&&t.getElementsByTagName("parsererror")[0],t&&!n||ce.error("Invalid XML: "+(n?ce.map(n.childNodes,function(e){return e.textContent}).join("\n"):e)),t};var Dt=/^(?:focusinfocus|focusoutblur)$/,Nt=function(e){e.stopPropagation()};ce.extend(ce.event,{trigger:function(e,t,n,r){var i,o,a,s,u,l,c,f,p=[n||C],d=ue.call(e,"type")?e.type:e,h=ue.call(e,"namespace")?e.namespace.split("."):[];if(o=f=a=n=n||C,3!==n.nodeType&&8!==n.nodeType&&!Dt.test(d+ce.event.triggered)&&(-1<d.indexOf(".")&&(d=(h=d.split(".")).shift(),h.sort()),u=d.indexOf(":")<0&&"on"+d,(e=e[ce.expando]?e:new ce.Event(d,"object"==typeof e&&e)).isTrigger=r?2:3,e.namespace=h.join("."),e.rnamespace=e.namespace?new RegExp("(^|\\.)"+h.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,e.result=void 0,e.target||(e.target=n),t=null==t?[e]:ce.makeArray(t,[e]),c=ce.event.special[d]||{},r||!c.trigger||!1!==c.trigger.apply(n,t))){if(!r&&!c.noBubble&&!y(n)){for(s=c.delegateType||d,Dt.test(s+d)||(o=o.parentNode);o;o=o.parentNode)p.push(o),a=o;a===(n.ownerDocument||C)&&p.push(a.defaultView||a.parentWindow||ie)}i=0;while((o=p[i++])&&!e.isPropagationStopped())f=o,e.type=1<i?s:c.bindType||d,(l=(_.get(o,"events")||Object.create(null))[e.type]&&_.get(o,"handle"))&&l.apply(o,t),(l=u&&o[u])&&l.apply&&$(o)&&(e.result=l.apply(o,t),!1===e.result&&e.preventDefault());return e.type=d,r||e.isDefaultPrevented()||c._default&&!1!==c._default.apply(p.pop(),t)||!$(n)||u&&v(n[d])&&!y(n)&&((a=n[u])&&(n[u]=null),ce.event.triggered=d,e.isPropagationStopped()&&f.addEventListener(d,Nt),n[d](),e.isPropagationStopped()&&f.removeEventListener(d,Nt),ce.event.triggered=void 0,a&&(n[u]=a)),e.result}},simulate:function(e,t,n){var r=ce.extend(new ce.Event,n,{type:e,isSimulated:!0});ce.event.trigger(r,null,t)}}),ce.fn.extend({trigger:function(e,t){return this.each(function(){ce.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return ce.event.trigger(e,t,n,!0)}});var qt=/\[\]$/,Lt=/\r?\n/g,Ht=/^(?:submit|button|image|reset|file)$/i,Ot=/^(?:input|select|textarea|keygen)/i;function Pt(n,e,r,i){var t;if(Array.isArray(e))ce.each(e,function(e,t){r||qt.test(n)?i(n,t):Pt(n+"["+("object"==typeof t&&null!=t?e:"")+"]",t,r,i)});else if(r||"object"!==x(e))i(n,e);else for(t in e)Pt(n+"["+t+"]",e[t],r,i)}ce.param=function(e,t){var n,r=[],i=function(e,t){var n=v(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(null==e)return"";if(Array.isArray(e)||e.jquery&&!ce.isPlainObject(e))ce.each(e,function(){i(this.name,this.value)});else for(n in e)Pt(n,e[n],t,i);return r.join("&")},ce.fn.extend({serialize:function(){return ce.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=ce.prop(this,"elements");return e?ce.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!ce(this).is(":disabled")&&Ot.test(this.nodeName)&&!Ht.test(e)&&(this.checked||!we.test(e))}).map(function(e,t){var n=ce(this).val();return null==n?null:Array.isArray(n)?ce.map(n,function(e){return{name:t.name,value:e.replace(Lt,"\r\n")}}):{name:t.name,value:n.replace(Lt,"\r\n")}}).get()}});var Mt=/%20/g,Rt=/#.*$/,It=/([?&])_=[^&]*/,Wt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ft=/^(?:GET|HEAD)$/,$t=/^\/\//,Bt={},_t={},zt="*/".concat("*"),Xt=C.createElement("a");function Ut(o){return function(e,t){"string"!=typeof e&&(t=e,e="*");var n,r=0,i=e.toLowerCase().match(D)||[];if(v(t))while(n=i[r++])"+"===n[0]?(n=n.slice(1)||"*",(o[n]=o[n]||[]).unshift(t)):(o[n]=o[n]||[]).push(t)}}function Vt(t,i,o,a){var s={},u=t===_t;function l(e){var r;return s[e]=!0,ce.each(t[e]||[],function(e,t){var n=t(i,o,a);return"string"!=typeof n||u||s[n]?u?!(r=n):void 0:(i.dataTypes.unshift(n),l(n),!1)}),r}return l(i.dataTypes[0])||!s["*"]&&l("*")}function Gt(e,t){var n,r,i=ce.ajaxSettings.flatOptions||{};for(n in t)void 0!==t[n]&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&ce.extend(!0,e,r),e}Xt.href=Et.href,ce.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Et.href,type:"GET",isLocal:/^(?:about|app|app-storage|.+-extension|file|res|widget):$/.test(Et.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":zt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":ce.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Gt(Gt(e,ce.ajaxSettings),t):Gt(ce.ajaxSettings,e)},ajaxPrefilter:Ut(Bt),ajaxTransport:Ut(_t),ajax:function(e,t){"object"==typeof e&&(t=e,e=void 0),t=t||{};var c,f,p,n,d,r,h,g,i,o,v=ce.ajaxSetup({},t),y=v.context||v,m=v.context&&(y.nodeType||y.jquery)?ce(y):ce.event,x=ce.Deferred(),b=ce.Callbacks("once memory"),w=v.statusCode||{},a={},s={},u="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(h){if(!n){n={};while(t=Wt.exec(p))n[t[1].toLowerCase()+" "]=(n[t[1].toLowerCase()+" "]||[]).concat(t[2])}t=n[e.toLowerCase()+" "]}return null==t?null:t.join(", ")},getAllResponseHeaders:function(){return h?p:null},setRequestHeader:function(e,t){return null==h&&(e=s[e.toLowerCase()]=s[e.toLowerCase()]||e,a[e]=t),this},overrideMimeType:function(e){return null==h&&(v.mimeType=e),this},statusCode:function(e){var t;if(e)if(h)T.always(e[T.status]);else for(t in e)w[t]=[w[t],e[t]];return this},abort:function(e){var t=e||u;return c&&c.abort(t),l(0,t),this}};if(x.promise(T),v.url=((e||v.url||Et.href)+"").replace($t,Et.protocol+"//"),v.type=t.method||t.type||v.method||v.type,v.dataTypes=(v.dataType||"*").toLowerCase().match(D)||[""],null==v.crossDomain){r=C.createElement("a");try{r.href=v.url,r.href=r.href,v.crossDomain=Xt.protocol+"//"+Xt.host!=r.protocol+"//"+r.host}catch(e){v.crossDomain=!0}}if(v.data&&v.processData&&"string"!=typeof v.data&&(v.data=ce.param(v.data,v.traditional)),Vt(Bt,v,t,T),h)return T;for(i in(g=ce.event&&v.global)&&0==ce.active++&&ce.event.trigger("ajaxStart"),v.type=v.type.toUpperCase(),v.hasContent=!Ft.test(v.type),f=v.url.replace(Rt,""),v.hasContent?v.data&&v.processData&&0===(v.contentType||"").indexOf("application/x-www-form-urlencoded")&&(v.data=v.data.replace(Mt,"+")):(o=v.url.slice(f.length),v.data&&(v.processData||"string"==typeof v.data)&&(f+=(At.test(f)?"&":"?")+v.data,delete v.data),!1===v.cache&&(f=f.replace(It,"$1"),o=(At.test(f)?"&":"?")+"_="+jt.guid+++o),v.url=f+o),v.ifModified&&(ce.lastModified[f]&&T.setRequestHeader("If-Modified-Since",ce.lastModified[f]),ce.etag[f]&&T.setRequestHeader("If-None-Match",ce.etag[f])),(v.data&&v.hasContent&&!1!==v.contentType||t.contentType)&&T.setRequestHeader("Content-Type",v.contentType),T.setRequestHeader("Accept",v.dataTypes[0]&&v.accepts[v.dataTypes[0]]?v.accepts[v.dataTypes[0]]+("*"!==v.dataTypes[0]?", "+zt+"; q=0.01":""):v.accepts["*"]),v.headers)T.setRequestHeader(i,v.headers[i]);if(v.beforeSend&&(!1===v.beforeSend.call(y,T,v)||h))return T.abort();if(u="abort",b.add(v.complete),T.done(v.success),T.fail(v.error),c=Vt(_t,v,t,T)){if(T.readyState=1,g&&m.trigger("ajaxSend",[T,v]),h)return T;v.async&&0<v.timeout&&(d=ie.setTimeout(function(){T.abort("timeout")},v.timeout));try{h=!1,c.send(a,l)}catch(e){if(h)throw e;l(-1,e)}}else l(-1,"No Transport");function l(e,t,n,r){var i,o,a,s,u,l=t;h||(h=!0,d&&ie.clearTimeout(d),c=void 0,p=r||"",T.readyState=0<e?4:0,i=200<=e&&e<300||304===e,n&&(s=function(e,t,n){var r,i,o,a,s=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),void 0===r&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in s)if(s[i]&&s[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}a||(a=i)}o=o||a}if(o)return o!==u[0]&&u.unshift(o),n[o]}(v,T,n)),!i&&-1<ce.inArray("script",v.dataTypes)&&ce.inArray("json",v.dataTypes)<0&&(v.converters["text script"]=function(){}),s=function(e,t,n,r){var i,o,a,s,u,l={},c=e.dataTypes.slice();if(c[1])for(a in e.converters)l[a.toLowerCase()]=e.converters[a];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(!(a=l[u+" "+o]||l["* "+o]))for(i in l)if((s=i.split(" "))[1]===o&&(a=l[u+" "+s[0]]||l["* "+s[0]])){!0===a?a=l[i]:!0!==l[i]&&(o=s[0],c.unshift(s[1]));break}if(!0!==a)if(a&&e["throws"])t=a(t);else try{t=a(t)}catch(e){return{state:"parsererror",error:a?e:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}(v,s,T,i),i?(v.ifModified&&((u=T.getResponseHeader("Last-Modified"))&&(ce.lastModified[f]=u),(u=T.getResponseHeader("etag"))&&(ce.etag[f]=u)),204===e||"HEAD"===v.type?l="nocontent":304===e?l="notmodified":(l=s.state,o=s.data,i=!(a=s.error))):(a=l,!e&&l||(l="error",e<0&&(e=0))),T.status=e,T.statusText=(t||l)+"",i?x.resolveWith(y,[o,l,T]):x.rejectWith(y,[T,l,a]),T.statusCode(w),w=void 0,g&&m.trigger(i?"ajaxSuccess":"ajaxError",[T,v,i?o:a]),b.fireWith(y,[T,l]),g&&(m.trigger("ajaxComplete",[T,v]),--ce.active||ce.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return ce.get(e,t,n,"json")},getScript:function(e,t){return ce.get(e,void 0,t,"script")}}),ce.each(["get","post"],function(e,i){ce[i]=function(e,t,n,r){return v(t)&&(r=r||n,n=t,t=void 0),ce.ajax(ce.extend({url:e,type:i,dataType:r,data:t,success:n},ce.isPlainObject(e)&&e))}}),ce.ajaxPrefilter(function(e){var t;for(t in e.headers)"content-type"===t.toLowerCase()&&(e.contentType=e.headers[t]||"")}),ce._evalUrl=function(e,t,n){return ce.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,converters:{"text script":function(){}},dataFilter:function(e){ce.globalEval(e,t,n)}})},ce.fn.extend({wrapAll:function(e){var t;return this[0]&&(v(e)&&(e=e.call(this[0])),t=ce(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(n){return v(n)?this.each(function(e){ce(this).wrapInner(n.call(this,e))}):this.each(function(){var e=ce(this),t=e.contents();t.length?t.wrapAll(n):e.append(n)})},wrap:function(t){var n=v(t);return this.each(function(e){ce(this).wrapAll(n?t.call(this,e):t)})},unwrap:function(e){return this.parent(e).not("body").each(function(){ce(this).replaceWith(this.childNodes)}),this}}),ce.expr.pseudos.hidden=function(e){return!ce.expr.pseudos.visible(e)},ce.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},ce.ajaxSettings.xhr=function(){try{return new ie.XMLHttpRequest}catch(e){}};var Yt={0:200,1223:204},Qt=ce.ajaxSettings.xhr();le.cors=!!Qt&&"withCredentials"in Qt,le.ajax=Qt=!!Qt,ce.ajaxTransport(function(i){var o,a;if(le.cors||Qt&&!i.crossDomain)return{send:function(e,t){var n,r=i.xhr();if(r.open(i.type,i.url,i.async,i.username,i.password),i.xhrFields)for(n in i.xhrFields)r[n]=i.xhrFields[n];for(n in i.mimeType&&r.overrideMimeType&&r.overrideMimeType(i.mimeType),i.crossDomain||e["X-Requested-With"]||(e["X-Requested-With"]="XMLHttpRequest"),e)r.setRequestHeader(n,e[n]);o=function(e){return function(){o&&(o=a=r.onload=r.onerror=r.onabort=r.ontimeout=r.onreadystatechange=null,"abort"===e?r.abort():"error"===e?"number"!=typeof r.status?t(0,"error"):t(r.status,r.statusText):t(Yt[r.status]||r.status,r.statusText,"text"!==(r.responseType||"text")||"string"!=typeof r.responseText?{binary:r.response}:{text:r.responseText},r.getAllResponseHeaders()))}},r.onload=o(),a=r.onerror=r.ontimeout=o("error"),void 0!==r.onabort?r.onabort=a:r.onreadystatechange=function(){4===r.readyState&&ie.setTimeout(function(){o&&a()})},o=o("abort");try{r.send(i.hasContent&&i.data||null)}catch(e){if(o)throw e}},abort:function(){o&&o()}}}),ce.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),ce.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return ce.globalEval(e),e}}}),ce.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),ce.ajaxTransport("script",function(n){var r,i;if(n.crossDomain||n.scriptAttrs)return{send:function(e,t){r=ce("<script>").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),C.head.appendChild(r[0])},abort:function(){i&&i()}}});var Jt,Kt=[],Zt=/(=)\?(?=&|$)|\?\?/;ce.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=Kt.pop()||ce.expando+"_"+jt.guid++;return this[e]=!0,e}}),ce.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Zt.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Zt.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=v(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Zt,"$1"+r):!1!==e.jsonp&&(e.url+=(At.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||ce.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=ie[r],ie[r]=function(){o=arguments},n.always(function(){void 0===i?ce(ie).removeProp(r):ie[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,Kt.push(r)),o&&v(i)&&i(o[0]),o=i=void 0}),"script"}),le.createHTMLDocument=((Jt=C.implementation.createHTMLDocument("").body).innerHTML="<form></form><form></form>",2===Jt.childNodes.length),ce.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(le.createHTMLDocument?((r=(t=C.implementation.createHTMLDocument("")).createElement("base")).href=C.location.href,t.head.appendChild(r)):t=C),o=!n&&[],(i=w.exec(e))?[t.createElement(i[1])]:(i=Ae([e],t,o),o&&o.length&&ce(o).remove(),ce.merge([],i.childNodes)));var r,i,o},ce.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1<s&&(r=Tt(e.slice(s)),e=e.slice(0,s)),v(t)?(n=t,t=void 0):t&&"object"==typeof t&&(i="POST"),0<a.length&&ce.ajax({url:e,type:i||"GET",dataType:"html",data:t}).done(function(e){o=arguments,a.html(r?ce("<div>").append(ce.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},ce.expr.pseudos.animated=function(t){return ce.grep(ce.timers,function(e){return t===e.elem}).length},ce.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=ce.css(e,"position"),c=ce(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=ce.css(e,"top"),u=ce.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),v(t)&&(t=t.call(e,n,ce.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},ce.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){ce.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===ce.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===ce.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=ce(e).offset()).top+=ce.css(e,"borderTopWidth",!0),i.left+=ce.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-ce.css(r,"marginTop",!0),left:t.left-i.left-ce.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===ce.css(e,"position"))e=e.offsetParent;return e||J})}}),ce.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;ce.fn[t]=function(e){return M(this,function(e,t,n){var r;if(y(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),ce.each(["top","left"],function(e,n){ce.cssHooks[n]=Ye(le.pixelPosition,function(e,t){if(t)return t=Ge(e,n),_e.test(t)?ce(e).position()[n]+"px":t})}),ce.each({Height:"height",Width:"width"},function(a,s){ce.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){ce.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return M(this,function(e,t,n){var r;return y(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?ce.css(e,t,i):ce.style(e,t,n,i)},s,n?e:void 0,n)}})}),ce.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){ce.fn[t]=function(e){return this.on(t,e)}}),ce.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.on("mouseenter",e).on("mouseleave",t||e)}}),ce.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){ce.fn[n]=function(e,t){return 0<arguments.length?this.on(n,null,e,t):this.trigger(n)}});var en=/^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g;ce.proxy=function(e,t){var n,r,i;if("string"==typeof t&&(n=e[t],t=e,e=n),v(e))return r=ae.call(arguments,2),(i=function(){return e.apply(t||this,r.concat(ae.call(arguments)))}).guid=e.guid=e.guid||ce.guid++,i},ce.holdReady=function(e){e?ce.readyWait++:ce.ready(!0)},ce.isArray=Array.isArray,ce.parseJSON=JSON.parse,ce.nodeName=fe,ce.isFunction=v,ce.isWindow=y,ce.camelCase=F,ce.type=x,ce.now=Date.now,ce.isNumeric=function(e){var t=ce.type(e);return("number"===t||"string"===t)&&!isNaN(e-parseFloat(e))},ce.trim=function(e){return null==e?"":(e+"").replace(en,"$1")},"function"==typeof define&&define.amd&&define("jquery",[],function(){return ce});var tn=ie.jQuery,nn=ie.$;return ce.noConflict=function(e){return ie.$===ce&&(ie.$=nn),e&&ie.jQuery===ce&&(ie.jQuery=tn),ce},"undefined"==typeof e&&(ie.jQuery=ie.$=ce),ce});
diff --git a/src_js/third_party/jquery.tablesorter.js b/src_js/third_party/jquery.tablesorter.js
deleted file mode 100755
index 5a925da..0000000
--- a/src_js/third_party/jquery.tablesorter.js
+++ /dev/null
@@ -1,904 +0,0 @@
-/*
- * TableSorter 2.0 - Client-side table sorting with ease!
- * Version 2.0.5b
- * Copyright (c) 2007 Christian Bach
- * Modified by Evgeny Blokhin
- * added window.iframe check
- *
- * @requires jQuery v1.2.3
- *
- * Examples and docs at: http://tablesorter.com
- * Dual licensed under the MIT and GPL licenses:
- * http://www.opensource.org/licenses/mit-license.php
- * http://www.gnu.org/licenses/gpl.html
- */
-/**
- *
- * @description Create a sortable table with multi-column sorting capabilitys
- *
- * @example $('table').tablesorter();
- * @desc Create a simple tablesorter interface.
- *
- * @example $('table').tablesorter({ sortList:[[0,0],[1,0]] });
- * @desc Create a tablesorter interface and sort on the first and secound column column headers.
- *
- * @example $('table').tablesorter({ headers: { 0: { sorter: false}, 1: {sorter: false} } });
- *
- * @desc Create a tablesorter interface and disableing the first and second  column headers.
- *
- * @example $('table').tablesorter({ headers: { 0: {sorter:"integer"}, 1: {sorter:"currency"} } });
- *
- * @desc Create a tablesorter interface and set a column parser for the first
- *       and second column.
- *
- * @param Object
- *            settings An object literal containing key/value pairs to provide
- *            optional settings.
- *
- * @option String cssHeader (optional) A string of the class name to be appended
- *         to sortable tr elements in the thead of the table. Default value:
- *         "header"
- *
- * @option String cssAsc (optional) A string of the class name to be appended to
- *         sortable tr elements in the thead on a ascending sort. Default value:
- *         "headerSortUp"
- *
- * @option String cssDesc (optional) A string of the class name to be appended
- *         to sortable tr elements in the thead on a descending sort. Default
- *         value: "headerSortDown"
- *
- * @option String sortInitialOrder (optional) A string of the inital sorting
- *         order can be asc or desc. Default value: "asc"
- *
- * @option String sortMultisortKey (optional) A string of the multi-column sort
- *         key. Default value: "shiftKey"
- *
- * @option String textExtraction (optional) A string of the text-extraction
- *         method to use. For complex html structures inside td cell set this
- *         option to "complex", on large tables the complex option can be slow.
- *         Default value: "simple"
- *
- * @option Object headers (optional) An object of instructions for per-column
- *         controls in the format: headers: { 0: { option: setting }, ... }. For
- *         example, to disable sorting on the first two columns of a table:
- *         headers: { 0: { sorter: false}, 1: {sorter: false} }.
- *         Default value: null.
- *
- * @option Array sortList (optional) An array of instructions for per-column sorting
- *         and direction in the format: [[columnIndex, sortDirection], ... ] where
- *         columnIndex is a zero-based index for your columns left-to-right and
- *         sortDirection is 0 for Ascending and 1 for Descending. A valid argument
- *         that sorts ascending first by column 1 and then column 2 looks like:
- *         [[0,0],[1,0]]. Default value: null.
- *
- * @option Array sortForce (optional) An array containing forced sorting rules.
- *         Use to add an additional forced sort that will be appended to the dynamic
- *         selections by the user. For example, can be used to sort people alphabetically
- *         after some other user-selected sort that results in rows with the same value
- *         like dates or money due. It can help prevent data from appearing as though it
- *         has a random secondary sort. Default value: null.
- *
- * @option Boolean sortLocaleCompare (optional) Boolean flag indicating whatever
- *         to use String.localeCampare method or not. Default set to true.
- *
- * @option Array sortAppend (optional) An array containing forced sorting rules.
- *         This option let's you specify a default sorting rule, which is
- *         appended to user-selected rules. Default value: null
- *
- * @option Boolean widthFixed (optional) Boolean flag indicating if tablesorter
- *         should apply fixed widths to the table columns. This is usefull when
- *         using the pager companion plugin. This options requires the dimension
- *         jquery plugin. Default value: false
- *
- * @option Boolean cancelSelection (optional) Boolean flag indicating if
- *         tablesorter should cancel selection of the table headers text.
- *         Default value: true
- *
- * @option Boolean debug (optional) Boolean flag indicating if tablesorter
- *         should display debuging information usefull for development.
- *
- * @type jQuery
- *
- * @name tablesorter
- *
- * @cat Plugins/Tablesorter
- *
- * @author Christian Bach/christian.bach@polyester.se
- */
-(function ($) {
-    "use strict";
-    $.extend({
-        tablesorter: new function () {
-
-            var parsers = [],
-                widgets = [];
-
-            this.defaults = {
-                cssHeader: "header",
-                cssAsc: "headerSortUp",
-                cssDesc: "headerSortDown",
-                cssChildRow: "expand-child",
-                sortInitialOrder: "asc",
-                sortMultiSortKey: "shiftKey",
-                sortForce: null,
-                sortAppend: null,
-                sortLocaleCompare: true,
-                textExtraction: "simple",
-                parsers: {},
-                widgets: [],
-                headers: {},
-                widthFixed: false,
-                cancelSelection: true,
-                sortList: [],
-                headerList: [],
-                dateFormat: "us",
-                decimal: '/\.|\,/g',
-                onRenderHeader: null,
-                selectorHeaders: '#dataheader_entries > thead > tr > th', ///
-                selectorHeaderParent: 'dataheader_entries', ///
-                debug: false
-            };
-
-            /* debuging utils */
-
-            function benchmark(s, d) {
-                log(s + "," + (new Date().getTime() - d.getTime()) + "ms");
-            }
-
-            this.benchmark = benchmark;
-
-            function log(s) {
-                if (typeof console != "undefined" && typeof console.debug != "undefined") {
-                    console.log(s);
-                } else {
-                    alert(s);
-                }
-            }
-
-            /* parsers utils */
-
-            function buildParserCache(table, $headers) {
-
-                if (table.config.debug) {
-                    var parsersDebug = "";
-                }
-
-                if (table.tBodies.length == 0) return; // In the case of empty tables
-                var rows = table.tBodies[0].rows;
-
-                if (rows[0]) {
-
-                    var list = [],
-                        cells = rows[0].cells,
-                        l = cells.length;
-
-                    for (var i = 0; i < l; i++) {
-
-                        var p = false;
-
-                        if ($.metadata && ($($headers[i]).metadata() && $($headers[i]).metadata().sorter)) {
-
-                            p = getParserById($($headers[i]).metadata().sorter);
-
-                        } else if ((table.config.headers[i] && table.config.headers[i].sorter)) {
-
-                            p = getParserById(table.config.headers[i].sorter);
-                        }
-                        if (!p) {
-
-                            p = detectParserForColumn(table, rows, -1, i);
-                        }
-
-                        if (table.config.debug) {
-                            parsersDebug += "column:" + i + " parser:" + p.id + "\n";
-                        }
-
-                        list.push(p);
-                    }
-                }
-
-                if (table.config.debug) {
-                    log(parsersDebug);
-                }
-
-                return list;
-            };
-
-            function detectParserForColumn(table, rows, rowIndex, cellIndex) {
-                var l = parsers.length,
-                    node = false,
-                    nodeValue = false,
-                    keepLooking = true;
-                while (nodeValue == '' && keepLooking) {
-                    rowIndex++;
-                    if (rows[rowIndex]) {
-                        node = getNodeFromRowAndCellIndex(rows, rowIndex, cellIndex);
-                        nodeValue = trimAndGetNodeText(table.config, node);
-                        if (table.config.debug) {
-                            log('Checking if value was empty on row:' + rowIndex);
-                        }
-                    } else {
-                        keepLooking = false;
-                    }
-                }
-                for (var i = 1; i < l; i++) {
-                    if (parsers[i].is(nodeValue, table, node)) {
-                        return parsers[i];
-                    }
-                }
-                // 0 is always the generic parser (text)
-                return parsers[0];
-            }
-
-            function getNodeFromRowAndCellIndex(rows, rowIndex, cellIndex) {
-                return rows[rowIndex].cells[cellIndex];
-            }
-
-            function trimAndGetNodeText(config, node) {
-                return $.trim(getElementText(config, node));
-            }
-
-            function getParserById(name) {
-                var l = parsers.length;
-                for (var i = 0; i < l; i++) {
-                    if (parsers[i].id.toLowerCase() == name.toLowerCase()) {
-                        return parsers[i];
-                    }
-                }
-                return false;
-            }
-
-            /* utils */
-
-            function buildCache(table) {
-
-                if (table.config.debug) {
-                    var cacheTime = new Date();
-                }
-
-                var totalRows = (table.tBodies[0] && table.tBodies[0].rows.length) || 0,
-                    totalCells = (table.tBodies[0].rows[0] && table.tBodies[0].rows[0].cells.length) || 0,
-                    parsers = table.config.parsers,
-                    cache = {
-                        row: [],
-                        normalized: []
-                    };
-
-                for (var i = 0; i < totalRows; ++i) {
-
-                    /* Add the table data to main data array */
-                    var c = $(table.tBodies[0].rows[i]),
-                        cols = [];
-
-                    // if this is a child row, add it to the last row's children and
-                    // continue to the next row
-                    if (c.hasClass(table.config.cssChildRow)) {
-                        cache.row[cache.row.length - 1] = cache.row[cache.row.length - 1].add(c);
-                        // go to the next for loop
-                        continue;
-                    }
-
-                    cache.row.push(c);
-
-                    for (var j = 0; j < totalCells; ++j) {
-                        cols.push(parsers[j].format(getElementText(table.config, c[0].cells[j]), table, c[0].cells[j]));
-                    }
-
-                    cols.push(cache.normalized.length); // add position for rowCache
-                    cache.normalized.push(cols);
-                    cols = null;
-                };
-
-                if (table.config.debug) {
-                    benchmark("Building cache for " + totalRows + " rows:", cacheTime);
-                }
-
-                return cache;
-            };
-
-            function getElementText(config, node) {
-
-                if (!node) return "";
-
-                var $node = $(node),
-                    data = $node.attr('data-sort-value');
-                if (data !== undefined) return data;
-
-                var text = "";
-
-                if (!config.supportsTextContent) config.supportsTextContent = node.textContent || false;
-
-                if (config.textExtraction == "simple") {
-                    if (config.supportsTextContent) {
-                        text = node.textContent;
-                    } else {
-                        if (node.childNodes[0] && node.childNodes[0].hasChildNodes()) {
-                            text = node.childNodes[0].innerHTML;
-                        } else {
-                            text = node.innerHTML;
-                        }
-                    }
-                } else {
-                    if (typeof(config.textExtraction) == "function") {
-                        text = config.textExtraction(node);
-                    } else {
-                        text = $(node).text();
-                    }
-                }
-                return text;
-            }
-
-            function appendToTable(table, cache) {
-
-                if (table.config.debug) {
-                    var appendTime = new Date();
-                }
-
-                var c = cache,
-                    r = c.row,
-                    n = c.normalized,
-                    totalRows = n.length,
-                    checkCell = (n[0].length - 1),
-                    tableBody = $(table.tBodies[0]),
-                    rows = [];
-
-                for (var i = 0; i < totalRows; i++) {
-                    var pos = n[i][checkCell];
-
-                    rows.push(r[pos]);
-
-                    if (!table.config.appender) {
-
-                        //var o = ;
-                        var l = r[pos].length;
-                        for (var j = 0; j < l; j++) {
-                            tableBody[0].appendChild(r[pos][j]);
-                        }
-                    }
-                }
-
-                if (table.config.appender) {
-
-                    table.config.appender(table, rows);
-                }
-
-                rows = null;
-
-                if (table.config.debug) {
-                    benchmark("Rebuilt table:", appendTime);
-                }
-
-                // apply table widgets
-                ///applyWidget(table);
-
-                // trigger sortend
-                setTimeout(function () {
-                    $(table).trigger("sortEnd");
-                }, 0);
-
-            };
-
-            function buildHeaders(table) {
-
-                if (table.config.debug) {
-                    var time = new Date();
-                }
-
-                var meta = ($.metadata) ? true : false;
-
-                var header_index = computeTableHeaderCellIndexes(document.getElementById(table.config.selectorHeaderParent));
-
-                var $tableHeaders = $(table.config.selectorHeaders).each(function (index) { /// $(, table)
-
-                    this.column = header_index[this.parentNode.rowIndex + "-" + this.cellIndex];
-                    // this.column = index;
-                    this.order = formatSortingOrder(table.config.sortInitialOrder);
-
-                    this.count = this.order;
-
-                    if (checkHeaderMetadata(this) || checkHeaderOptions(table, index)) this.sortDisabled = true;
-                    if (checkHeaderOptionsSortingLocked(table, index)) this.order = this.lockedOrder = checkHeaderOptionsSortingLocked(table, index);
-
-                    if (!this.sortDisabled) {
-                        var $th = $(this).addClass(table.config.cssHeader);
-                        if (table.config.onRenderHeader) table.config.onRenderHeader.apply($th);
-                    }
-
-                    // add cell to headerList
-                    table.config.headerList[index] = this;
-                });
-
-                if (table.config.debug) {
-                    benchmark("Built headers:", time);
-                    log($tableHeaders);
-                }
-
-                return $tableHeaders;
-
-            };
-
-            // from:
-            // http://www.javascripttoolbox.com/lib/table/examples.php
-            // http://www.javascripttoolbox.com/temp/table_cellindex.html
-
-            function computeTableHeaderCellIndexes(t) {
-                var matrix = [];
-                var lookup = {};
-                var thead = t.getElementsByTagName('THEAD')[0];
-                var trs = thead.getElementsByTagName('TR');
-
-                for (var i = 0; i < trs.length; i++) {
-                    var cells = trs[i].cells;
-                    for (var j = 0; j < cells.length; j++) {
-                        var c = cells[j];
-
-                        var rowIndex = c.parentNode.rowIndex;
-                        var cellId = rowIndex + "-" + c.cellIndex;
-                        var rowSpan = c.rowSpan || 1;
-                        var colSpan = c.colSpan || 1
-                        var firstAvailCol;
-                        if (typeof(matrix[rowIndex]) == "undefined") {
-                            matrix[rowIndex] = [];
-                        }
-                        // Find first available column in the first row
-                        for (var k = 0; k < matrix[rowIndex].length + 1; k++) {
-                            if (typeof(matrix[rowIndex][k]) == "undefined") {
-                                firstAvailCol = k;
-                                break;
-                            }
-                        }
-                        lookup[cellId] = firstAvailCol;
-                        for (var k = rowIndex; k < rowIndex + rowSpan; k++) {
-                            if (typeof(matrix[k]) == "undefined") {
-                                matrix[k] = [];
-                            }
-                            var matrixrow = matrix[k];
-                            for (var l = firstAvailCol; l < firstAvailCol + colSpan; l++) {
-                                matrixrow[l] = "x";
-                            }
-                        }
-                    }
-                }
-                return lookup;
-            }
-
-            function checkCellColSpan(table, rows, row) {
-                var arr = [],
-                    r = document.getElementById(table.config.selectorHeaderParent).tHead.rows,
-                    c = r[row].cells;
-
-                for (var i = 0; i < c.length; i++) {
-                    var cell = c[i];
-
-                    if (cell.colSpan > 1) {
-                        arr = arr.concat(checkCellColSpan(table, headerArr, row++));
-                    } else {
-                        if (table.tHead.length == 1 || (cell.rowSpan > 1 || !r[row + 1])) {
-                            arr.push(cell);
-                        }
-                        // headerArr[row] = (i+row);
-                    }
-                }
-                return arr;
-            };
-
-            function checkHeaderMetadata(cell) {
-                if (($.metadata) && ($(cell).metadata().sorter === false)) {
-                    return true;
-                };
-                return false;
-            }
-
-            function checkHeaderOptions(table, i) {
-                if ((table.config.headers[i]) && (table.config.headers[i].sorter === false)) {
-                    return true;
-                };
-                return false;
-            }
-
-             function checkHeaderOptionsSortingLocked(table, i) {
-                if ((table.config.headers[i]) && (table.config.headers[i].lockedOrder)) return table.config.headers[i].lockedOrder;
-                return false;
-            }
-
-            function formatSortingOrder(v) {
-                if (typeof(v) != "Number") {
-                    return (v.toLowerCase() == "desc") ? 1 : 0;
-                } else {
-                    return (v == 1) ? 1 : 0;
-                }
-            }
-
-            function isValueInArray(v, a) {
-                var i = 0, l = a.length;
-                for (i; i < l; i++) {
-                    if (a[i][0] == v) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-
-            function setHeadersCss(table, $headers, list, css) {
-                // remove all header information
-                $headers.removeClass(css[0]).removeClass(css[1]);
-
-                var h = [];
-                $headers.each(function (offset) {
-                    if (!this.sortDisabled) {
-                        h[this.column] = $(this);
-                    }
-                });
-
-                var i = 0, l = list.length;
-                for (i; i < l; i++) {
-                    h[list[i][0]].addClass(css[list[i][1]]);
-                }
-            }
-
-            function fixColumnWidth(table, $headers) {
-                var c = table.config;
-                if (c.widthFixed) {
-                    var colgroup = $('<colgroup>');
-                    $("tr:first td", table.tBodies[0]).each(function () {
-                        colgroup.append($('<col>').css('width', $(this).width()));
-                    });
-                    $(table).prepend(colgroup);
-                };
-            }
-
-            function updateHeaderSortCount(table, sortList) {
-                var c = table.config,
-                    l = sortList.length;
-                for (var i = 0; i < l; i++) {
-                    var s = sortList[i],
-                        o = c.headerList[s[0]];
-                    o.count = s[1];
-                    o.count++;
-                }
-            }
-
-            /* sorting methods */
-            var sortWrapper;
-
-            function multisort(table, sortList, cache) {
-
-                if (table.config.debug) {
-                    var sortTime = new Date();
-                }
-
-                var dynamicExp = "sortWrapper = function(a,b) {",
-                    l = sortList.length;
-
-                // TODO: inline functions.
-                for (var i = 0; i < l; i++) {
-
-                    var c = sortList[i][0];
-                    var order = sortList[i][1];
-                    // var s = (getCachedSortType(table.config.parsers,c) == "text") ?
-                    // ((order == 0) ? "sortText" : "sortTextDesc") : ((order == 0) ?
-                    // "sortNumeric" : "sortNumericDesc");
-                    // var s = (table.config.parsers[c].type == "text") ? ((order == 0)
-                    // ? makeSortText(c) : makeSortTextDesc(c)) : ((order == 0) ?
-                    // makeSortNumeric(c) : makeSortNumericDesc(c));
-                    var s = (table.config.parsers[c].type == "text") ? ((order == 0) ? makeSortFunction("text", "asc", c) : makeSortFunction("text", "desc", c)) : ((order == 0) ? makeSortFunction("numeric", "asc", c) : makeSortFunction("numeric", "desc", c));
-                    var e = "e" + i;
-
-                    dynamicExp += "var " + e + " = " + s; // + "(a[" + c + "],b[" + c
-                    // + "]); ";
-                    dynamicExp += "if(" + e + ") { return " + e + "; } ";
-                    dynamicExp += "else { ";
-
-                }
-
-                // if value is the same keep orignal order
-                var orgOrderCol = cache.normalized[0].length - 1;
-                dynamicExp += "return a[" + orgOrderCol + "]-b[" + orgOrderCol + "];";
-
-                for (var i = 0; i < l; i++) {
-                    dynamicExp += "}; ";
-                }
-
-                dynamicExp += "return 0; ";
-                dynamicExp += "}; ";
-
-                if (table.config.debug) {
-                    benchmark("Evaling expression:" + dynamicExp, new Date());
-                }
-
-                eval(dynamicExp);
-
-                cache.normalized.sort(sortWrapper);
-
-                if (table.config.debug) {
-                    benchmark("Sorting on " + sortList.toString() + " and dir " + order + " time:", sortTime);
-                }
-
-                return cache;
-            };
-
-            function makeSortFunction(type, direction, index) {
-                var a = "a[" + index + "]",
-                    b = "b[" + index + "]";
-                if (type == 'text' && direction == 'asc') {
-                    return "(" + a + " == " + b + " ? 0 : (" + a + " === null ? Number.POSITIVE_INFINITY : (" + b + " === null ? Number.NEGATIVE_INFINITY : (" + a + " < " + b + ") ? -1 : 1 )));";
-                } else if (type == 'text' && direction == 'desc') {
-                    return "(" + a + " == " + b + " ? 0 : (" + a + " === null ? Number.POSITIVE_INFINITY : (" + b + " === null ? Number.NEGATIVE_INFINITY : (" + b + " < " + a + ") ? -1 : 1 )));";
-                } else if (type == 'numeric' && direction == 'asc') {
-                    return "(" + a + " === null && " + b + " === null) ? 0 :(" + a + " === null ? Number.POSITIVE_INFINITY : (" + b + " === null ? Number.NEGATIVE_INFINITY : " + a + " - " + b + "));";
-                } else if (type == 'numeric' && direction == 'desc') {
-                    return "(" + a + " === null && " + b + " === null) ? 0 :(" + a + " === null ? Number.POSITIVE_INFINITY : (" + b + " === null ? Number.NEGATIVE_INFINITY : " + b + " - " + a + "));";
-                }
-            };
-
-            function makeSortText(i) {
-                return "((a[" + i + "] < b[" + i + "]) ? -1 : ((a[" + i + "] > b[" + i + "]) ? 1 : 0));";
-            };
-
-            function makeSortTextDesc(i) {
-                return "((b[" + i + "] < a[" + i + "]) ? -1 : ((b[" + i + "] > a[" + i + "]) ? 1 : 0));";
-            };
-
-            function makeSortNumeric(i) {
-                return "a[" + i + "]-b[" + i + "];";
-            };
-
-            function makeSortNumericDesc(i) {
-                return "b[" + i + "]-a[" + i + "];";
-            };
-
-            function sortText(a, b) {
-                if (table.config.sortLocaleCompare) return a.localeCompare(b);
-                return ((a < b) ? -1 : ((a > b) ? 1 : 0));
-            };
-
-            function sortTextDesc(a, b) {
-                if (table.config.sortLocaleCompare) return b.localeCompare(a);
-                return ((b < a) ? -1 : ((b > a) ? 1 : 0));
-            };
-
-            function sortNumeric(a, b) {
-                return a - b;
-            };
-
-            function sortNumericDesc(a, b) {
-                return b - a;
-            };
-
-            function getCachedSortType(parsers, i) {
-                return parsers[i].type;
-            };
-            /* public methods */
-            this.construct = function (settings) {
-                return this.each(function () {
-                    // if no thead or tbody quit.
-                    if (!this.tBodies) return; //if (!this.tHead || !this.tBodies) return;
-                    // declare
-                    var $this, $document, $headers, cache, config, shiftDown = 0,
-                        sortOrder;
-                    // new blank config object
-                    this.config = {};
-                    // merge and extend.
-                    config = $.extend(this.config, $.tablesorter.defaults, settings);
-                    // store common expression for speed
-                    $this = $(this);
-                    // save the settings where they read
-                    $.data(this, "tablesorter", config);
-                    // build headers
-                    $headers = buildHeaders(this);
-                    // try to auto detect column type, and store in tables config
-                    this.config.parsers = buildParserCache(this, $headers);
-                    // build the cache for the tbody cells
-                    cache = buildCache(this);
-                    // get the css class names, could be done else where.
-                    var sortCSS = [config.cssDesc, config.cssAsc];
-                    // fixate columns if the users supplies the fixedWidth option
-                    fixColumnWidth(this);
-                    // apply event handling to headers
-                    // this is to big, perhaps break it out?
-                    $headers.unbind();
-                    $headers.click(function (e){
-                        if (window.iframe) return false;
-                        var totalRows = ($this[0].tBodies[0] && $this[0].tBodies[0].rows.length) || 0;
-                        if (!this.sortDisabled && totalRows > 0) {
-                            // Only call sortStart if sorting is
-                            // enabled.
-                            $this.trigger("sortStart");
-                            // store exp, for speed
-                            var $cell = $(this);
-                            // get current column index
-                            var i = this.column;
-                            // get current column sort order
-                            this.order = this.count++ % 2;
-                            // always sort on the locked order.
-                            if(this.lockedOrder) this.order = this.lockedOrder;
-
-                            // user only whants to sort on one
-                            // column
-                            if (!e[config.sortMultiSortKey]) {
-                                // flush the sort list
-                                config.sortList = [];
-                                if (config.sortForce != null) {
-                                    var a = config.sortForce;
-                                    for (var j = 0; j < a.length; j++) {
-                                        if (a[j][0] != i) {
-                                            config.sortList.push(a[j]);
-                                        }
-                                    }
-                                }
-                                // add column to sort list
-                                config.sortList.push([i, this.order]);
-                                // multi column sorting
-                            } else {
-                                // the user has clicked on an all
-                                // ready sortet column.
-                                if (isValueInArray(i, config.sortList)) {
-                                    // revers the sorting direction
-                                    // for all tables.
-                                    for (var j = 0; j < config.sortList.length; j++) {
-                                        var s = config.sortList[j],
-                                            o = config.headerList[s[0]];
-                                        if (s[0] == i) {
-                                            o.count = s[1];
-                                            o.count++;
-                                            s[1] = o.count % 2;
-                                        }
-                                    }
-                                } else {
-                                    // add column to sort list array
-                                    config.sortList.push([i, this.order]);
-                                }
-                            };
-                            setTimeout(function () {
-                                // set css for headers
-                                setHeadersCss($this[0], $headers, config.sortList, sortCSS);
-                                appendToTable(
-                                    $this[0], multisort($this[0], config.sortList, cache)
-                                );
-                            }, 1);
-                            // stop normal event by returning false
-                            return false;
-                        }
-                        // cancel selection
-                    }).mousedown(function () {
-                        if (config.cancelSelection) {
-                            this.onselectstart = function () {
-                                return false;
-                            };
-                            return false;
-                        }
-                    });
-                    // apply easy methods that trigger binded events
-                    $this.unbind("update updateCell sorton appendCache");
-                    $this.bind("update", function () {
-                        var me = this;
-                        setTimeout(function () {
-                            // rebuild parsers.
-                            me.config.parsers = buildParserCache(me, $headers);
-                            // rebuild the cache map
-                            cache = buildCache(me);
-                        }, 1);
-                    }).bind("updateCell", function (e, cell) {
-                        var config = this.config;
-                        // get position from the dom.
-                        var pos = [(cell.parentNode.rowIndex - 1), cell.cellIndex];
-                        // update cache
-                        cache.normalized[pos[0]][pos[1]] = config.parsers[pos[1]].format(getElementText(config, cell), cell);
-                    }).bind("sorton", function (e, list) {
-                        $(this).trigger("sortStart");
-                        config.sortList = list;
-                        // update and store the sortlist
-                        var sortList = config.sortList;
-                        // update header count index
-                        updateHeaderSortCount(this, sortList);
-                        // set css for headers
-                        setHeadersCss(this, $headers, sortList, sortCSS);
-                        // sort the table and append it to the dom
-                        appendToTable(this, multisort(this, sortList, cache));
-                    }).bind("appendCache", function () {
-                        appendToTable(this, cache);
-                    });
-                    if ($.metadata && ($(this).metadata() && $(this).metadata().sortlist)) {
-                        config.sortList = $(this).metadata().sortlist;
-                    }
-                    // if user has supplied a sort list to constructor.
-                    if (config.sortList.length > 0) {
-                        $this.trigger("sorton", [config.sortList]);
-                    }
-                    // apply widgets
-                    ///applyWidget(this);
-                });
-            };
-            this.addParser = function (parser) {
-                var l = parsers.length,
-                    a = true;
-                for (var i = 0; i < l; i++) {
-                    if (parsers[i].id.toLowerCase() == parser.id.toLowerCase()) {
-                        a = false;
-                    }
-                }
-                if (a) {
-                    parsers.push(parser);
-                };
-            };
-            this.formatFloat = function (s) {
-                var i = parseFloat(s);
-                return (isNaN(i)) ? 0 : i;
-            };
-            this.formatInt = function (s) {
-                var i = parseInt(s);
-                return (isNaN(i)) ? 0 : i;
-            };
-            this.isDigit = function (s, config) {
-                // replace all an wanted chars and match.
-                return /^[-+]?\d*$/.test($.trim(s.replace(/[,.']/g, '')));
-            };
-        }
-    });
-
-    // extend plugin scope
-    $.fn.extend({
-        tablesorter: $.tablesorter.construct
-    });
-
-    // make shortcut
-    var ts = $.tablesorter;
-
-    // add default parsers
-    ts.addParser({
-        id: "text",
-        is: function (s) {
-            return true;
-        }, format: function (s) {
-            return $.trim(s.toLocaleLowerCase());
-        }, type: "text"
-    });
-
-    ts.addParser({
-        id: "chemical",
-        is: function (s) {
-            return true;
-        }, format: function (s) {
-            return $.trim(s.replace("[", "").replace("(", ""));
-        }, type: "text"
-    });
-
-    ts.addParser({
-        id: "digit",
-        is: function (s, table) {
-            var c = table.config;
-            return $.tablesorter.isDigit(s, c);
-        }, format: function (s) {
-            return $.tablesorter.formatFloat(s);
-        }, type: "numeric"
-    });
-
-    ts.addParser({
-        id: "url",
-        is: function (s) {
-            return /^(https?|ftp|file):\/\/$/.test(s);
-        }, format: function (s) {
-            return jQuery.trim(s.replace(new RegExp(/(https?|ftp|file):\/\//), ''));
-        }, type: "text"
-    });
-
-    ts.addParser({
-        id: "doi",
-        is: function (s) {
-            return true;
-        }, format: function (s) {
-            return $.tablesorter.formatInt(s.replace("[", "").replace("]", ""));
-        }, type: "numeric"
-    });
-
-    ts.addParser({
-        id: "metadata",
-        is: function (s) {
-            return false;
-        }, format: function (s, table, cell) {
-            var c = table.config,
-                p = (!c.parserMetadataName) ? 'sortValue' : c.parserMetadataName;
-            return $(cell).metadata()[p];
-        }, type: "numeric"
-    });
-})(jQuery);
diff --git a/src_js/third_party/selectize.js b/src_js/third_party/selectize.js
deleted file mode 100644
index e9b3971..0000000
--- a/src_js/third_party/selectize.js
+++ /dev/null
@@ -1,3684 +0,0 @@
-/**
- * sifter.js
- * Copyright (c) 2013 Brian Reavis & contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
- * file except in compliance with the License. You may obtain a copy of the License at:
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
- * ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- *
- * @author Brian Reavis <brian@thirdroute.com>
- */
-
-(function(root, factory) {
-	if (typeof define === 'function' && define.amd) {
-		define('sifter', factory);
-	} else if (typeof exports === 'object') {
-		module.exports = factory();
-	} else {
-		root.Sifter = factory();
-	}
-}(this, function() {
-
-	/**
-	 * Textually searches arrays and hashes of objects
-	 * by property (or multiple properties). Designed
-	 * specifically for autocomplete.
-	 *
-	 * @constructor
-	 * @param {array|object} items
-	 * @param {object} items
-	 */
-	var Sifter = function(items, settings) {
-		this.items = items;
-		this.settings = settings || {diacritics: true};
-	};
-
-	/**
-	 * Splits a search string into an array of individual
-	 * regexps to be used to match results.
-	 *
-	 * @param {string} query
-	 * @returns {array}
-	 */
-	Sifter.prototype.tokenize = function(query) {
-		query = trim(String(query || '').toLowerCase());
-		if (!query || !query.length) return [];
-
-		var i, n, regex, letter;
-		var tokens = [];
-		var words = query.split(/ +/);
-
-		for (i = 0, n = words.length; i < n; i++) {
-			regex = escape_regex(words[i]);
-			if (this.settings.diacritics) {
-				for (letter in DIACRITICS) {
-					if (DIACRITICS.hasOwnProperty(letter)) {
-						regex = regex.replace(new RegExp(letter, 'g'), DIACRITICS[letter]);
-					}
-				}
-			}
-			tokens.push({
-				string : words[i],
-				regex  : new RegExp(regex, 'i')
-			});
-		}
-
-		return tokens;
-	};
-
-	/**
-	 * Iterates over arrays and hashes.
-	 *
-	 * ```
-	 * this.iterator(this.items, function(item, id) {
-	 *    // invoked for each item
-	 * });
-	 * ```
-	 *
-	 * @param {array|object} object
-	 */
-	Sifter.prototype.iterator = function(object, callback) {
-		var iterator;
-		if (is_array(object)) {
-			iterator = Array.prototype.forEach || function(callback) {
-				for (var i = 0, n = this.length; i < n; i++) {
-					callback(this[i], i, this);
-				}
-			};
-		} else {
-			iterator = function(callback) {
-				for (var key in this) {
-					if (this.hasOwnProperty(key)) {
-						callback(this[key], key, this);
-					}
-				}
-			};
-		}
-
-		iterator.apply(object, [callback]);
-	};
-
-	/**
-	 * Returns a function to be used to score individual results.
-	 *
-	 * Good matches will have a higher score than poor matches.
-	 * If an item is not a match, 0 will be returned by the function.
-	 *
-	 * @param {object|string} search
-	 * @param {object} options (optional)
-	 * @returns {function}
-	 */
-	Sifter.prototype.getScoreFunction = function(search, options) {
-		var self, fields, tokens, token_count, nesting;
-
-		self        = this;
-		search      = self.prepareSearch(search, options);
-		tokens      = search.tokens;
-		fields      = search.options.fields;
-		token_count = tokens.length;
-		nesting     = search.options.nesting;
-
-		/**
-		 * Calculates how close of a match the
-		 * given value is against a search token.
-		 *
-		 * @param {mixed} value
-		 * @param {object} token
-		 * @return {number}
-		 */
-		var scoreValue = function(value, token) {
-			var score, pos;
-
-			if (!value) return 0;
-			value = String(value || '');
-			pos = value.search(token.regex);
-			if (pos === -1) return 0;
-			score = token.string.length / value.length;
-			if (pos === 0) score += 0.5;
-			return score;
-		};
-
-		/**
-		 * Calculates the score of an object
-		 * against the search query.
-		 *
-		 * @param {object} token
-		 * @param {object} data
-		 * @return {number}
-		 */
-		var scoreObject = (function() {
-			var field_count = fields.length;
-			if (!field_count) {
-				return function() { return 0; };
-			}
-			if (field_count === 1) {
-				return function(token, data) {
-					return scoreValue(getattr(data, fields[0], nesting), token);
-				};
-			}
-			return function(token, data) {
-				for (var i = 0, sum = 0; i < field_count; i++) {
-					sum += scoreValue(getattr(data, fields[i], nesting), token);
-				}
-				return sum / field_count;
-			};
-		})();
-
-		if (!token_count) {
-			return function() { return 0; };
-		}
-		if (token_count === 1) {
-			return function(data) {
-				return scoreObject(tokens[0], data);
-			};
-		}
-
-		if (search.options.conjunction === 'and') {
-			return function(data) {
-				var score;
-				for (var i = 0, sum = 0; i < token_count; i++) {
-					score = scoreObject(tokens[i], data);
-					if (score <= 0) return 0;
-					sum += score;
-				}
-				return sum / token_count;
-			};
-		} else {
-			return function(data) {
-				for (var i = 0, sum = 0; i < token_count; i++) {
-					sum += scoreObject(tokens[i], data);
-				}
-				return sum / token_count;
-			};
-		}
-	};
-
-	/**
-	 * Returns a function that can be used to compare two
-	 * results, for sorting purposes. If no sorting should
-	 * be performed, `null` will be returned.
-	 *
-	 * @param {string|object} search
-	 * @param {object} options
-	 * @return function(a,b)
-	 */
-	Sifter.prototype.getSortFunction = function(search, options) {
-		var i, n, self, field, fields, fields_count, multiplier, multipliers, get_field, implicit_score, sort;
-
-		self   = this;
-		search = self.prepareSearch(search, options);
-		sort   = (!search.query && options.sort_empty) || options.sort;
-
-		/**
-		 * Fetches the specified sort field value
-		 * from a search result item.
-		 *
-		 * @param  {string} name
-		 * @param  {object} result
-		 * @return {mixed}
-		 */
-		get_field = function(name, result) {
-			if (name === '$score') return result.score;
-			return getattr(self.items[result.id], name, options.nesting);
-		};
-
-		// parse options
-		fields = [];
-		if (sort) {
-			for (i = 0, n = sort.length; i < n; i++) {
-				if (search.query || sort[i].field !== '$score') {
-					fields.push(sort[i]);
-				}
-			}
-		}
-
-		// the "$score" field is implied to be the primary
-		// sort field, unless it's manually specified
-		if (search.query) {
-			implicit_score = true;
-			for (i = 0, n = fields.length; i < n; i++) {
-				if (fields[i].field === '$score') {
-					implicit_score = false;
-					break;
-				}
-			}
-			if (implicit_score) {
-				fields.unshift({field: '$score', direction: 'desc'});
-			}
-		} else {
-			for (i = 0, n = fields.length; i < n; i++) {
-				if (fields[i].field === '$score') {
-					fields.splice(i, 1);
-					break;
-				}
-			}
-		}
-
-		multipliers = [];
-		for (i = 0, n = fields.length; i < n; i++) {
-			multipliers.push(fields[i].direction === 'desc' ? -1 : 1);
-		}
-
-		// build function
-		fields_count = fields.length;
-		if (!fields_count) {
-			return null;
-		} else if (fields_count === 1) {
-			field = fields[0].field;
-			multiplier = multipliers[0];
-			return function(a, b) {
-				return multiplier * cmp(
-					get_field(field, a),
-					get_field(field, b)
-				);
-			};
-		} else {
-			return function(a, b) {
-				var i, result, a_value, b_value, field;
-				for (i = 0; i < fields_count; i++) {
-					field = fields[i].field;
-					result = multipliers[i] * cmp(
-						get_field(field, a),
-						get_field(field, b)
-					);
-					if (result) return result;
-				}
-				return 0;
-			};
-		}
-	};
-
-	/**
-	 * Parses a search query and returns an object
-	 * with tokens and fields ready to be populated
-	 * with results.
-	 *
-	 * @param {string} query
-	 * @param {object} options
-	 * @returns {object}
-	 */
-	Sifter.prototype.prepareSearch = function(query, options) {
-		if (typeof query === 'object') return query;
-
-		options = extend({}, options);
-
-		var option_fields     = options.fields;
-		var option_sort       = options.sort;
-		var option_sort_empty = options.sort_empty;
-
-		if (option_fields && !is_array(option_fields)) options.fields = [option_fields];
-		if (option_sort && !is_array(option_sort)) options.sort = [option_sort];
-		if (option_sort_empty && !is_array(option_sort_empty)) options.sort_empty = [option_sort_empty];
-
-		return {
-			options : options,
-			query   : String(query || '').toLowerCase(),
-			tokens  : this.tokenize(query),
-			total   : 0,
-			items   : []
-		};
-	};
-
-	/**
-	 * Searches through all items and returns a sorted array of matches.
-	 *
-	 * The `options` parameter can contain:
-	 *
-	 *   - fields {string|array}
-	 *   - sort {array}
-	 *   - score {function}
-	 *   - filter {bool}
-	 *   - limit {integer}
-	 *
-	 * Returns an object containing:
-	 *
-	 *   - options {object}
-	 *   - query {string}
-	 *   - tokens {array}
-	 *   - total {int}
-	 *   - items {array}
-	 *
-	 * @param {string} query
-	 * @param {object} options
-	 * @returns {object}
-	 */
-	Sifter.prototype.search = function(query, options) {
-		var self = this, value, score, search, calculateScore;
-		var fn_sort;
-		var fn_score;
-
-		search  = this.prepareSearch(query, options);
-		options = search.options;
-		query   = search.query;
-
-		// generate result scoring function
-		fn_score = options.score || self.getScoreFunction(search);
-
-		// perform search and sort
-		if (query.length) {
-			self.iterator(self.items, function(item, id) {
-				score = fn_score(item);
-				if (options.filter === false || score > 0) {
-					search.items.push({'score': score, 'id': id});
-				}
-			});
-		} else {
-			self.iterator(self.items, function(item, id) {
-				search.items.push({'score': 1, 'id': id});
-			});
-		}
-
-		fn_sort = self.getSortFunction(search, options);
-		if (fn_sort) search.items.sort(fn_sort);
-
-		// apply limits
-		search.total = search.items.length;
-		if (typeof options.limit === 'number') {
-			search.items = search.items.slice(0, options.limit);
-		}
-
-		return search;
-	};
-
-	// utilities
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-	var cmp = function(a, b) {
-		if (typeof a === 'number' && typeof b === 'number') {
-			return a > b ? 1 : (a < b ? -1 : 0);
-		}
-		a = asciifold(String(a || ''));
-		b = asciifold(String(b || ''));
-		if (a > b) return 1;
-		if (b > a) return -1;
-		return 0;
-	};
-
-	var extend = function(a, b) {
-		var i, n, k, object;
-		for (i = 1, n = arguments.length; i < n; i++) {
-			object = arguments[i];
-			if (!object) continue;
-			for (k in object) {
-				if (object.hasOwnProperty(k)) {
-					a[k] = object[k];
-				}
-			}
-		}
-		return a;
-	};
-
-	/**
-	 * A property getter resolving dot-notation
-	 * @param  {Object}  obj     The root object to fetch property on
-	 * @param  {String}  name    The optionally dotted property name to fetch
-	 * @param  {Boolean} nesting Handle nesting or not
-	 * @return {Object}          The resolved property value
-	 */
-	var getattr = function(obj, name, nesting) {
-	    if (!obj || !name) return;
-	    if (!nesting) return obj[name];
-	    var names = name.split(".");
-	    while(names.length && (obj = obj[names.shift()]));
-	    return obj;
-	};
-
-	var trim = function(str) {
-		return (str + '').replace(/^\s+|\s+$|/g, '');
-	};
-
-	var escape_regex = function(str) {
-		return (str + '').replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1');
-	};
-
-	var is_array = Array.isArray || (typeof $ !== 'undefined' && $.isArray) || function(object) {
-		return Object.prototype.toString.call(object) === '[object Array]';
-	};
-
-	var DIACRITICS = {
-		'a': '[aḀḁĂăÂâǍǎȺⱥȦȧẠạÄäÀàÁáĀāÃãÅåąĄÃąĄ]',
-		'b': '[b␢βΒB฿𐌁ᛒ]',
-		'c': '[cĆćĈĉČčĊċC̄c̄ÇçḈḉȻȼƇƈɕᴄＣｃ]',
-		'd': '[dĎďḊḋḐḑḌḍḒḓḎḏĐđD̦d̦ƉɖƊɗƋƌᵭᶁᶑȡᴅＤｄð]',
-		'e': '[eÉéÈèÊêḘḙĚěĔĕẼẽḚḛẺẻĖėËëĒēȨȩĘęᶒɆɇȄȅẾếỀềỄễỂểḜḝḖḗḔḕȆȇẸẹỆệⱸᴇＥｅɘǝƏƐε]',
-		'f': '[fƑƒḞḟ]',
-		'g': '[gɢ₲ǤǥĜĝĞğĢģƓɠĠġ]',
-		'h': '[hĤĥĦħḨḩẖẖḤḥḢḣɦʰǶƕ]',
-		'i': '[iÍíÌìĬĭÎîǏǐÏïḮḯĨĩĮįĪīỈỉȈȉȊȋỊịḬḭƗɨɨ̆ᵻᶖİiIıɪＩｉ]',
-		'j': '[jȷĴĵɈɉʝɟʲ]',
-		'k': '[kƘƙꝀꝁḰḱǨǩḲḳḴḵκϰ₭]',
-		'l': '[lŁłĽľĻļĹĺḶḷḸḹḼḽḺḻĿŀȽƚⱠⱡⱢɫɬᶅɭȴʟＬｌ]',
-		'n': '[nŃńǸǹŇňÑñṄṅŅņṆṇṊṋṈṉN̈n̈ƝɲȠƞᵰᶇɳȵɴＮｎŊŋ]',
-		'o': '[oØøÖöÓóÒòÔôǑǒŐőŎŏȮȯỌọƟɵƠơỎỏŌōÕõǪǫȌȍՕօ]',
-		'p': '[pṔṕṖṗⱣᵽƤƥᵱ]',
-		'q': '[qꝖꝗʠɊɋꝘꝙq̃]',
-		'r': '[rŔŕɌɍŘřŖŗṘṙȐȑȒȓṚṛⱤɽ]',
-		's': '[sŚśṠṡṢṣꞨꞩŜŝŠšŞşȘșS̈s̈]',
-		't': '[tŤťṪṫŢţṬṭƮʈȚțṰṱṮṯƬƭ]',
-		'u': '[uŬŭɄʉỤụÜüÚúÙùÛûǓǔŰűŬŭƯưỦủŪūŨũŲųȔȕ∪]',
-		'v': '[vṼṽṾṿƲʋꝞꝟⱱʋ]',
-		'w': '[wẂẃẀẁŴŵẄẅẆẇẈẉ]',
-		'x': '[xẌẍẊẋχ]',
-		'y': '[yÝýỲỳŶŷŸÿỸỹẎẏỴỵɎɏƳƴ]',
-		'z': '[zŹźẐẑŽžŻżẒẓẔẕƵƶ]'
-	};
-
-	var asciifold = (function() {
-		var i, n, k, chunk;
-		var foreignletters = '';
-		var lookup = {};
-		for (k in DIACRITICS) {
-			if (DIACRITICS.hasOwnProperty(k)) {
-				chunk = DIACRITICS[k].substring(2, DIACRITICS[k].length - 1);
-				foreignletters += chunk;
-				for (i = 0, n = chunk.length; i < n; i++) {
-					lookup[chunk.charAt(i)] = k;
-				}
-			}
-		}
-		var regexp = new RegExp('[' +  foreignletters + ']', 'g');
-		return function(str) {
-			return str.replace(regexp, function(foreignletter) {
-				return lookup[foreignletter];
-			}).toLowerCase();
-		};
-	})();
-
-
-	// export
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-	return Sifter;
-}));
-
-
-
-/**
- * microplugin.js
- * Copyright (c) 2013 Brian Reavis & contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
- * file except in compliance with the License. You may obtain a copy of the License at:
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
- * ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- *
- * @author Brian Reavis <brian@thirdroute.com>
- */
-
-(function(root, factory) {
-	if (typeof define === 'function' && define.amd) {
-		define('microplugin', factory);
-	} else if (typeof exports === 'object') {
-		module.exports = factory();
-	} else {
-		root.MicroPlugin = factory();
-	}
-}(this, function() {
-	var MicroPlugin = {};
-
-	MicroPlugin.mixin = function(Interface) {
-		Interface.plugins = {};
-
-		/**
-		 * Initializes the listed plugins (with options).
-		 * Acceptable formats:
-		 *
-		 * List (without options):
-		 *   ['a', 'b', 'c']
-		 *
-		 * List (with options):
-		 *   [{'name': 'a', options: {}}, {'name': 'b', options: {}}]
-		 *
-		 * Hash (with options):
-		 *   {'a': { ... }, 'b': { ... }, 'c': { ... }}
-		 *
-		 * @param {mixed} plugins
-		 */
-		Interface.prototype.initializePlugins = function(plugins) {
-			var i, n, key;
-			var self  = this;
-			var queue = [];
-
-			self.plugins = {
-				names     : [],
-				settings  : {},
-				requested : {},
-				loaded    : {}
-			};
-
-			if (utils.isArray(plugins)) {
-				for (i = 0, n = plugins.length; i < n; i++) {
-					if (typeof plugins[i] === 'string') {
-						queue.push(plugins[i]);
-					} else {
-						self.plugins.settings[plugins[i].name] = plugins[i].options;
-						queue.push(plugins[i].name);
-					}
-				}
-			} else if (plugins) {
-				for (key in plugins) {
-					if (plugins.hasOwnProperty(key)) {
-						self.plugins.settings[key] = plugins[key];
-						queue.push(key);
-					}
-				}
-			}
-
-			while (queue.length) {
-				self.require(queue.shift());
-			}
-		};
-
-		Interface.prototype.loadPlugin = function(name) {
-			var self    = this;
-			var plugins = self.plugins;
-			var plugin  = Interface.plugins[name];
-
-			if (!Interface.plugins.hasOwnProperty(name)) {
-				throw new Error('Unable to find "' +  name + '" plugin');
-			}
-
-			plugins.requested[name] = true;
-			plugins.loaded[name] = plugin.fn.apply(self, [self.plugins.settings[name] || {}]);
-			plugins.names.push(name);
-		};
-
-		/**
-		 * Initializes a plugin.
-		 *
-		 * @param {string} name
-		 */
-		Interface.prototype.require = function(name) {
-			var self = this;
-			var plugins = self.plugins;
-
-			if (!self.plugins.loaded.hasOwnProperty(name)) {
-				if (plugins.requested[name]) {
-					throw new Error('Plugin has circular dependency ("' + name + '")');
-				}
-				self.loadPlugin(name);
-			}
-
-			return plugins.loaded[name];
-		};
-
-		/**
-		 * Registers a plugin.
-		 *
-		 * @param {string} name
-		 * @param {function} fn
-		 */
-		Interface.define = function(name, fn) {
-			Interface.plugins[name] = {
-				'name' : name,
-				'fn'   : fn
-			};
-		};
-	};
-
-	var utils = {
-		isArray: Array.isArray || function(vArg) {
-			return Object.prototype.toString.call(vArg) === '[object Array]';
-		}
-	};
-
-	return MicroPlugin;
-}));
-
-/**
- * selectize.js (v0.12.6)
- * Copyright (c) 2013–2015 Brian Reavis & contributors
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
- * file except in compliance with the License. You may obtain a copy of the License at:
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
- * ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- *
- * @author Brian Reavis <brian@thirdroute.com>
- */
-
-/*jshint curly:false */
-/*jshint browser:true */
-
-(function(root, factory) {
-	if (typeof define === 'function' && define.amd) {
-		define('selectize', ['jquery','sifter','microplugin'], factory);
-	} else if (typeof exports === 'object') {
-		module.exports = factory(require('jquery'), require('sifter'), require('microplugin'));
-	} else {
-		root.Selectize = factory(root.jQuery, root.Sifter, root.MicroPlugin);
-	}
-}(this, function($, Sifter, MicroPlugin) {
-	'use strict';
-
-	var highlight = function($element, pattern) {
-		if (typeof pattern === 'string' && !pattern.length) return;
-		var regex = (typeof pattern === 'string') ? new RegExp(pattern, 'i') : pattern;
-	
-		var highlight = function(node) {
-			var skip = 0;
-			// Wrap matching part of text node with highlighting <span>, e.g.
-			// Soccer  ->  <span class="highlight">Soc</span>cer  for regex = /soc/i
-			if (node.nodeType === 3) {
-				var pos = node.data.search(regex);
-				if (pos >= 0 && node.data.length > 0) {
-					var match = node.data.match(regex);
-					var spannode = document.createElement('span');
-					spannode.className = 'highlight';
-					var middlebit = node.splitText(pos);
-					var endbit = middlebit.splitText(match[0].length);
-					var middleclone = middlebit.cloneNode(true);
-					spannode.appendChild(middleclone);
-					middlebit.parentNode.replaceChild(spannode, middlebit);
-					skip = 1;
-				}
-			} 
-			// Recurse element node, looking for child text nodes to highlight, unless element 
-			// is childless, <script>, <style>, or already highlighted: <span class="hightlight">
-			else if (node.nodeType === 1 && node.childNodes && !/(script|style)/i.test(node.tagName) && ( node.className !== 'highlight' || node.tagName !== 'SPAN' )) {
-				for (var i = 0; i < node.childNodes.length; ++i) {
-					i += highlight(node.childNodes[i]);
-				}
-			}
-			return skip;
-		};
-	
-		return $element.each(function() {
-			highlight(this);
-		});
-	};
-	
-	/**
-	 * removeHighlight fn copied from highlight v5 and
-	 * edited to remove with() and pass js strict mode
-	 */
-	$.fn.removeHighlight = function() {
-		return this.find("span.highlight").each(function() {
-			this.parentNode.firstChild.nodeName;
-			var parent = this.parentNode;
-			parent.replaceChild(this.firstChild, this);
-			parent.normalize();
-		}).end();
-	};
-	
-	
-	var MicroEvent = function() {};
-	MicroEvent.prototype = {
-		on: function(event, fct){
-			this._events = this._events || {};
-			this._events[event] = this._events[event] || [];
-			this._events[event].push(fct);
-		},
-		off: function(event, fct){
-			var n = arguments.length;
-			if (n === 0) return delete this._events;
-			if (n === 1) return delete this._events[event];
-	
-			this._events = this._events || {};
-			if (event in this._events === false) return;
-			this._events[event].splice(this._events[event].indexOf(fct), 1);
-		},
-		trigger: function(event /* , args... */){
-			this._events = this._events || {};
-			if (event in this._events === false) return;
-			for (var i = 0; i < this._events[event].length; i++){
-				this._events[event][i].apply(this, Array.prototype.slice.call(arguments, 1));
-			}
-		}
-	};
-	
-	/**
-	 * Mixin will delegate all MicroEvent.js function in the destination object.
-	 *
-	 * - MicroEvent.mixin(Foobar) will make Foobar able to use MicroEvent
-	 *
-	 * @param {object} the object which will support MicroEvent
-	 */
-	MicroEvent.mixin = function(destObject){
-		var props = ['on', 'off', 'trigger'];
-		for (var i = 0; i < props.length; i++){
-			destObject.prototype[props[i]] = MicroEvent.prototype[props[i]];
-		}
-	};
-	
-	var IS_MAC        = /Mac/.test(navigator.userAgent);
-	
-	var KEY_A         = 65;
-	var KEY_COMMA     = 188;
-	//var KEY_RETURN    = 13;
-	var KEY_ESC       = 27;
-	var KEY_LEFT      = 37;
-	var KEY_UP        = 38;
-	var KEY_P         = 80;
-	var KEY_RIGHT     = 39;
-	var KEY_DOWN      = 40;
-	var KEY_N         = 78;
-	var KEY_BACKSPACE = 8;
-	var KEY_DELETE    = 46;
-	var KEY_SHIFT     = 16;
-	var KEY_CMD       = IS_MAC ? 91 : 17;
-	var KEY_CTRL      = IS_MAC ? 18 : 17;
-	var KEY_TAB       = 9;
-	
-	var TAG_SELECT    = 1;
-	var TAG_INPUT     = 2;
-	
-	// for now, android support in general is too spotty to support validity
-	var SUPPORTS_VALIDITY_API = !/android/i.test(window.navigator.userAgent) && !!document.createElement('input').validity;
-	
-	
-	var isset = function(object) {
-		return typeof object !== 'undefined';
-	};
-	
-	/**
-	 * Converts a scalar to its best string representation
-	 * for hash keys and HTML attribute values.
-	 *
-	 * Transformations:
-	 *   'str'     -> 'str'
-	 *   null      -> ''
-	 *   undefined -> ''
-	 *   true      -> '1'
-	 *   false     -> '0'
-	 *   0         -> '0'
-	 *   1         -> '1'
-	 *
-	 * @param {string} value
-	 * @returns {string|null}
-	 */
-	var hash_key = function(value) {
-		if (typeof value === 'undefined' || value === null) return null;
-		if (typeof value === 'boolean') return value ? '1' : '0';
-		return value + '';
-	};
-	
-	/**
-	 * Escapes a string for use within HTML.
-	 *
-	 * @param {string} str
-	 * @returns {string}
-	 */
-	var escape_html = function(str) {
-		return (str + '')
-			.replace(/&/g, '&amp;')
-			.replace(/</g, '&lt;')
-			.replace(/>/g, '&gt;')
-			.replace(/"/g, '&quot;');
-	};
-	
-	/**
-	 * Escapes "$" characters in replacement strings.
-	 *
-	 * @param {string} str
-	 * @returns {string}
-	 */
-	var escape_replace = function(str) {
-		return (str + '').replace(/\$/g, '$$$$');
-	};
-	
-	var hook = {};
-	
-	/**
-	 * Wraps `method` on `self` so that `fn`
-	 * is invoked before the original method.
-	 *
-	 * @param {object} self
-	 * @param {string} method
-	 * @param {function} fn
-	 */
-	hook.before = function(self, method, fn) {
-		var original = self[method];
-		self[method] = function() {
-			fn.apply(self, arguments);
-			return original.apply(self, arguments);
-		};
-	};
-	
-	/**
-	 * Wraps `method` on `self` so that `fn`
-	 * is invoked after the original method.
-	 *
-	 * @param {object} self
-	 * @param {string} method
-	 * @param {function} fn
-	 */
-	hook.after = function(self, method, fn) {
-		var original = self[method];
-		self[method] = function() {
-			var result = original.apply(self, arguments);
-			fn.apply(self, arguments);
-			return result;
-		};
-	};
-	
-	/**
-	 * Wraps `fn` so that it can only be invoked once.
-	 *
-	 * @param {function} fn
-	 * @returns {function}
-	 */
-	var once = function(fn) {
-		var called = false;
-		return function() {
-			if (called) return;
-			called = true;
-			fn.apply(this, arguments);
-		};
-	};
-	
-	/**
-	 * Wraps `fn` so that it can only be called once
-	 * every `delay` milliseconds (invoked on the falling edge).
-	 *
-	 * @param {function} fn
-	 * @param {int} delay
-	 * @returns {function}
-	 */
-	var debounce = function(fn, delay) {
-		var timeout;
-		return function() {
-			var self = this;
-			var args = arguments;
-			window.clearTimeout(timeout);
-			timeout = window.setTimeout(function() {
-				fn.apply(self, args);
-			}, delay);
-		};
-	};
-	
-	/**
-	 * Debounce all fired events types listed in `types`
-	 * while executing the provided `fn`.
-	 *
-	 * @param {object} self
-	 * @param {array} types
-	 * @param {function} fn
-	 */
-	var debounce_events = function(self, types, fn) {
-		var type;
-		var trigger = self.trigger;
-		var event_args = {};
-	
-		// override trigger method
-		self.trigger = function() {
-			var type = arguments[0];
-			if (types.indexOf(type) !== -1) {
-				event_args[type] = arguments;
-			} else {
-				return trigger.apply(self, arguments);
-			}
-		};
-	
-		// invoke provided function
-		fn.apply(self, []);
-		self.trigger = trigger;
-	
-		// trigger queued events
-		for (type in event_args) {
-			if (event_args.hasOwnProperty(type)) {
-				trigger.apply(self, event_args[type]);
-			}
-		}
-	};
-	
-	/**
-	 * A workaround for http://bugs.jquery.com/ticket/6696
-	 *
-	 * @param {object} $parent - Parent element to listen on.
-	 * @param {string} event - Event name.
-	 * @param {string} selector - Descendant selector to filter by.
-	 * @param {function} fn - Event handler.
-	 */
-	var watchChildEvent = function($parent, event, selector, fn) {
-		$parent.on(event, selector, function(e) {
-			var child = e.target;
-			while (child && child.parentNode !== $parent[0]) {
-				child = child.parentNode;
-			}
-			e.currentTarget = child;
-			return fn.apply(this, [e]);
-		});
-	};
-	
-	/**
-	 * Determines the current selection within a text input control.
-	 * Returns an object containing:
-	 *   - start
-	 *   - length
-	 *
-	 * @param {object} input
-	 * @returns {object}
-	 */
-	var getSelection = function(input) {
-		var result = {};
-		if ('selectionStart' in input) {
-			result.start = input.selectionStart;
-			result.length = input.selectionEnd - result.start;
-		} else if (document.selection) {
-			input.focus();
-			var sel = document.selection.createRange();
-			var selLen = document.selection.createRange().text.length;
-			sel.moveStart('character', -input.value.length);
-			result.start = sel.text.length - selLen;
-			result.length = selLen;
-		}
-		return result;
-	};
-	
-	/**
-	 * Copies CSS properties from one element to another.
-	 *
-	 * @param {object} $from
-	 * @param {object} $to
-	 * @param {array} properties
-	 */
-	var transferStyles = function($from, $to, properties) {
-		var i, n, styles = {};
-		if (properties) {
-			for (i = 0, n = properties.length; i < n; i++) {
-				styles[properties[i]] = $from.css(properties[i]);
-			}
-		} else {
-			styles = $from.css();
-		}
-		$to.css(styles);
-	};
-	
-	/**
-	 * Measures the width of a string within a
-	 * parent element (in pixels).
-	 *
-	 * @param {string} str
-	 * @param {object} $parent
-	 * @returns {int}
-	 */
-	var measureString = function(str, $parent) {
-		if (!str) {
-			return 0;
-		}
-	
-		if (!Selectize.$testInput) {
-			Selectize.$testInput = $('<span />').css({
-				position: 'absolute',
-				top: -99999,
-				left: -99999,
-				width: 'auto',
-				padding: 0,
-				whiteSpace: 'pre'
-			}).appendTo('body');
-		}
-	
-		Selectize.$testInput.text(str);
-	
-		transferStyles($parent, Selectize.$testInput, [
-			'letterSpacing',
-			'fontSize',
-			'fontFamily',
-			'fontWeight',
-			'textTransform'
-		]);
-	
-		return Selectize.$testInput.width();
-	};
-	
-	/**
-	 * Sets up an input to grow horizontally as the user
-	 * types. If the value is changed manually, you can
-	 * trigger the "update" handler to resize:
-	 *
-	 * $input.trigger('update');
-	 *
-	 * @param {object} $input
-	 */
-	var autoGrow = function($input) {
-		var currentWidth = null;
-	
-		var update = function(e, options) {
-			var value, keyCode, printable, placeholder, width;
-			var shift, character, selection;
-			e = e || window.event || {};
-			options = options || {};
-	
-			if (e.metaKey || e.altKey) return;
-			if (!options.force && $input.data('grow') === false) return;
-	
-			value = $input.val();
-			if (e.type && e.type.toLowerCase() === 'keydown') {
-				keyCode = e.keyCode;
-				printable = (
-					(keyCode >= 48 && keyCode <= 57)  || // 0-9
-					(keyCode >= 65 && keyCode <= 90)   || // a-z
-					(keyCode >= 96 && keyCode <= 111)  || // numpad 0-9, numeric operators
-					(keyCode >= 186 && keyCode <= 222) || // semicolon, equal, comma, dash, etc.
-					keyCode === 32 // space
-				);
-	
-				if (keyCode === KEY_DELETE || keyCode === KEY_BACKSPACE) {
-					selection = getSelection($input[0]);
-					if (selection.length) {
-						value = value.substring(0, selection.start) + value.substring(selection.start + selection.length);
-					} else if (keyCode === KEY_BACKSPACE && selection.start) {
-						value = value.substring(0, selection.start - 1) + value.substring(selection.start + 1);
-					} else if (keyCode === KEY_DELETE && typeof selection.start !== 'undefined') {
-						value = value.substring(0, selection.start) + value.substring(selection.start + 1);
-					}
-				} else if (printable) {
-					shift = e.shiftKey;
-					character = String.fromCharCode(e.keyCode);
-					if (shift) character = character.toUpperCase();
-					else character = character.toLowerCase();
-					value += character;
-				}
-			}
-	
-			placeholder = $input.attr('placeholder');
-			if (!value && placeholder) {
-				value = placeholder;
-			}
-	
-			width = measureString(value, $input) + 4;
-			if (width !== currentWidth) {
-				currentWidth = width;
-				$input.width(width);
-				$input.triggerHandler('resize');
-			}
-		};
-	
-		$input.on('keydown keyup update blur', update);
-		update();
-	};
-	
-	var domToString = function(d) {
-		var tmp = document.createElement('div');
-	
-		tmp.appendChild(d.cloneNode(true));
-	
-		return tmp.innerHTML;
-	};
-	
-	var logError = function(message, options){
-		if(!options) options = {};
-		var component = "Selectize";
-	
-		console.error(component + ": " + message)
-	
-		if(options.explanation){
-			// console.group is undefined in <IE11
-			if(console.group) console.group();
-			console.error(options.explanation);
-			if(console.group) console.groupEnd();
-		}
-	}
-	
-	
-	var Selectize = function($input, settings) {
-		var key, i, n, dir, input, self = this;
-		input = $input[0];
-		input.selectize = self;
-	
-		// detect rtl environment
-		var computedStyle = window.getComputedStyle && window.getComputedStyle(input, null);
-		dir = computedStyle ? computedStyle.getPropertyValue('direction') : input.currentStyle && input.currentStyle.direction;
-		dir = dir || $input.parents('[dir]:first').attr('dir') || '';
-	
-		// setup default state
-		$.extend(self, {
-			order            : 0,
-			settings         : settings,
-			$input           : $input,
-			tabIndex         : $input.attr('tabindex') || '',
-			tagType          : input.tagName.toLowerCase() === 'select' ? TAG_SELECT : TAG_INPUT,
-			rtl              : /rtl/i.test(dir),
-	
-			eventNS          : '.selectize' + (++Selectize.count),
-			highlightedValue : null,
-			isBlurring       : false,
-			isOpen           : false,
-			isDisabled       : false,
-			isRequired       : $input.is('[required]'),
-			isInvalid        : false,
-			isLocked         : false,
-			isFocused        : false,
-			isInputHidden    : false,
-			isSetup          : false,
-			isShiftDown      : false,
-			isCmdDown        : false,
-			isCtrlDown       : false,
-			ignoreFocus      : false,
-			ignoreBlur       : false,
-			ignoreHover      : false,
-			hasOptions       : false,
-			currentResults   : null,
-			lastValue        : '',
-			caretPos         : 0,
-			loading          : 0,
-			loadedSearches   : {},
-	
-			$activeOption    : null,
-			$activeItems     : [],
-	
-			optgroups        : {},
-			options          : {},
-			userOptions      : {},
-			items            : [],
-			renderCache      : {},
-			onSearchChange   : settings.loadThrottle === null ? self.onSearchChange : debounce(self.onSearchChange, settings.loadThrottle)
-		});
-	
-		// search system
-		self.sifter = new Sifter(this.options, {diacritics: settings.diacritics});
-	
-		// build options table
-		if (self.settings.options) {
-			for (i = 0, n = self.settings.options.length; i < n; i++) {
-				self.registerOption(self.settings.options[i]);
-			}
-			delete self.settings.options;
-		}
-	
-		// build optgroup table
-		if (self.settings.optgroups) {
-			for (i = 0, n = self.settings.optgroups.length; i < n; i++) {
-				self.registerOptionGroup(self.settings.optgroups[i]);
-			}
-			delete self.settings.optgroups;
-		}
-	
-		// option-dependent defaults
-		self.settings.mode = self.settings.mode || (self.settings.maxItems === 1 ? 'single' : 'multi');
-		if (typeof self.settings.hideSelected !== 'boolean') {
-			self.settings.hideSelected = self.settings.mode === 'multi';
-		}
-	
-		self.initializePlugins(self.settings.plugins);
-		self.setupCallbacks();
-		self.setupTemplates();
-		self.setup();
-	};
-	
-	// mixins
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-	
-	MicroEvent.mixin(Selectize);
-	
-	if(typeof MicroPlugin !== "undefined"){
-		MicroPlugin.mixin(Selectize);
-	}else{
-		logError("Dependency MicroPlugin is missing",
-			{explanation:
-				"Make sure you either: (1) are using the \"standalone\" "+
-				"version of Selectize, or (2) require MicroPlugin before you "+
-				"load Selectize."}
-		);
-	}
-	
-	
-	// methods
-	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-	
-	$.extend(Selectize.prototype, {
-	
-		/**
-		 * Creates all elements and sets up event bindings.
-		 */
-		setup: function() {
-			var self      = this;
-			var settings  = self.settings;
-			var eventNS   = self.eventNS;
-			var $window   = $(window);
-			var $document = $(document);
-			var $input    = self.$input;
-	
-			var $wrapper;
-			var $control;
-			var $control_input;
-			var $dropdown;
-			var $dropdown_content;
-			var $dropdown_parent;
-			var inputMode;
-			var timeout_blur;
-			var timeout_focus;
-			var classes;
-			var classes_plugins;
-			var inputId;
-	
-			inputMode         = self.settings.mode;
-			classes           = $input.attr('class') || '';
-	
-			$wrapper          = $('<div>').addClass(settings.wrapperClass).addClass(classes).addClass(inputMode);
-			$control          = $('<div>').addClass(settings.inputClass).addClass('items').appendTo($wrapper);
-			$control_input    = $('<input type="text" autocomplete="off" />').appendTo($control).attr('tabindex', $input.is(':disabled') ? '-1' : self.tabIndex);
-			$dropdown_parent  = $(settings.dropdownParent || $wrapper);
-			$dropdown         = $('<div>').addClass(settings.dropdownClass).addClass(inputMode).hide().appendTo($dropdown_parent);
-			$dropdown_content = $('<div>').addClass(settings.dropdownContentClass).appendTo($dropdown);
-	
-			if(inputId = $input.attr('id')) {
-				$control_input.attr('id', inputId + '-selectized');
-				$("label[for='"+inputId+"']").attr('for', inputId + '-selectized');
-			}
-	
-			if(self.settings.copyClassesToDropdown) {
-				$dropdown.addClass(classes);
-			}
-	
-			$wrapper.css({
-				width: $input[0].style.width
-			});
-	
-			if (self.plugins.names.length) {
-				classes_plugins = 'plugin-' + self.plugins.names.join(' plugin-');
-				$wrapper.addClass(classes_plugins);
-				$dropdown.addClass(classes_plugins);
-			}
-	
-			if ((settings.maxItems === null || settings.maxItems > 1) && self.tagType === TAG_SELECT) {
-				$input.attr('multiple', 'multiple');
-			}
-	
-			if (self.settings.placeholder) {
-				$control_input.attr('placeholder', settings.placeholder);
-			}
-	
-			// if splitOn was not passed in, construct it from the delimiter to allow pasting universally
-			if (!self.settings.splitOn && self.settings.delimiter) {
-				var delimiterEscaped = self.settings.delimiter.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-				self.settings.splitOn = new RegExp('\\s*' + delimiterEscaped + '+\\s*');
-			}
-	
-			if ($input.attr('autocorrect')) {
-				$control_input.attr('autocorrect', $input.attr('autocorrect'));
-			}
-	
-			if ($input.attr('autocapitalize')) {
-				$control_input.attr('autocapitalize', $input.attr('autocapitalize'));
-			}
-			$control_input[0].type = $input[0].type;
-	
-			self.$wrapper          = $wrapper;
-			self.$control          = $control;
-			self.$control_input    = $control_input;
-			self.$dropdown         = $dropdown;
-			self.$dropdown_content = $dropdown_content;
-	
-			$dropdown.on('mouseenter mousedown click', '[data-disabled]>[data-selectable]', function(e) { e.stopImmediatePropagation(); });
-			$dropdown.on('mouseenter', '[data-selectable]', function() { return self.onOptionHover.apply(self, arguments); });
-			$dropdown.on('mousedown click', '[data-selectable]', function() { return self.onOptionSelect.apply(self, arguments); });
-			watchChildEvent($control, 'mousedown', '*:not(input)', function() { return self.onItemSelect.apply(self, arguments); });
-			autoGrow($control_input);
-	
-			$control.on({
-				mousedown : function() { return self.onMouseDown.apply(self, arguments); },
-				click     : function() { return self.onClick.apply(self, arguments); }
-			});
-	
-			$control_input.on({
-				mousedown : function(e) { e.stopPropagation(); },
-				keydown   : function() { return self.onKeyDown.apply(self, arguments); },
-				keyup     : function() { return self.onKeyUp.apply(self, arguments); },
-				keypress  : function() { return self.onKeyPress.apply(self, arguments); },
-				resize    : function() { self.positionDropdown.apply(self, []); },
-				blur      : function() { return self.onBlur.apply(self, arguments); },
-				focus     : function() { self.ignoreBlur = false; return self.onFocus.apply(self, arguments); },
-				paste     : function() { return self.onPaste.apply(self, arguments); }
-			});
-	
-			$document.on('keydown' + eventNS, function(e) {
-				self.isCmdDown = e[IS_MAC ? 'metaKey' : 'ctrlKey'];
-				self.isCtrlDown = e[IS_MAC ? 'altKey' : 'ctrlKey'];
-				self.isShiftDown = e.shiftKey;
-			});
-	
-			$document.on('keyup' + eventNS, function(e) {
-				if (e.keyCode === KEY_CTRL) self.isCtrlDown = false;
-				if (e.keyCode === KEY_SHIFT) self.isShiftDown = false;
-				if (e.keyCode === KEY_CMD) self.isCmdDown = false;
-			});
-	
-			$document.on('mousedown' + eventNS, function(e) {
-				if (self.isFocused) {
-					// prevent events on the dropdown scrollbar from causing the control to blur
-					if (e.target === self.$dropdown[0] || e.target.parentNode === self.$dropdown[0]) {
-						return false;
-					}
-					// blur on click outside
-					if (!self.$control.has(e.target).length && e.target !== self.$control[0]) {
-						self.blur(e.target);
-					}
-				}
-			});
-	
-			$window.on(['scroll' + eventNS, 'resize' + eventNS].join(' '), function() {
-				if (self.isOpen) {
-					self.positionDropdown.apply(self, arguments);
-				}
-			});
-			$window.on('mousemove' + eventNS, function() {
-				self.ignoreHover = false;
-			});
-	
-			// store original children and tab index so that they can be
-			// restored when the destroy() method is called.
-			this.revertSettings = {
-				$children : $input.children().detach(),
-				tabindex  : $input.attr('tabindex')
-			};
-	
-			$input.attr('tabindex', -1).hide().after(self.$wrapper);
-	
-			if ($.isArray(settings.items)) {
-				self.setValue(settings.items);
-				delete settings.items;
-			}
-	
-			// feature detect for the validation API
-			if (SUPPORTS_VALIDITY_API) {
-				$input.on('invalid' + eventNS, function(e) {
-					e.preventDefault();
-					self.isInvalid = true;
-					self.refreshState();
-				});
-			}
-	
-			self.updateOriginalInput();
-			self.refreshItems();
-			self.refreshState();
-			self.updatePlaceholder();
-			self.isSetup = true;
-	
-			if ($input.is(':disabled')) {
-				self.disable();
-			}
-	
-			self.on('change', this.onChange);
-	
-			$input.data('selectize', self);
-			$input.addClass('selectized');
-			self.trigger('initialize');
-	
-			// preload options
-			if (settings.preload === true) {
-				self.onSearchChange('');
-			}
-	
-		},
-	
-		/**
-		 * Sets up default rendering functions.
-		 */
-		setupTemplates: function() {
-			var self = this;
-			var field_label = self.settings.labelField;
-			var field_optgroup = self.settings.optgroupLabelField;
-	
-			var templates = {
-				'optgroup': function(data) {
-					return '<div class="optgroup">' + data.html + '</div>';
-				},
-				'optgroup_header': function(data, escape) {
-					return '<div class="optgroup-header">' + escape(data[field_optgroup]) + '</div>';
-				},
-				'option': function(data, escape) {
-					return '<div class="option">' + escape(data[field_label]) + '</div>';
-				},
-				'item': function(data, escape) {
-					return '<div class="item">' + escape(data[field_label]) + '</div>';
-				},
-				'option_create': function(data, escape) {
-					return '<div class="create">Add <strong>' + escape(data.input) + '</strong>&hellip;</div>';
-				}
-			};
-	
-			self.settings.render = $.extend({}, templates, self.settings.render);
-		},
-	
-		/**
-		 * Maps fired events to callbacks provided
-		 * in the settings used when creating the control.
-		 */
-		setupCallbacks: function() {
-			var key, fn, callbacks = {
-				'initialize'      : 'onInitialize',
-				'change'          : 'onChange',
-				'item_add'        : 'onItemAdd',
-				'item_remove'     : 'onItemRemove',
-				'clear'           : 'onClear',
-				'option_add'      : 'onOptionAdd',
-				'option_remove'   : 'onOptionRemove',
-				'option_clear'    : 'onOptionClear',
-				'optgroup_add'    : 'onOptionGroupAdd',
-				'optgroup_remove' : 'onOptionGroupRemove',
-				'optgroup_clear'  : 'onOptionGroupClear',
-				'dropdown_open'   : 'onDropdownOpen',
-				'dropdown_close'  : 'onDropdownClose',
-				'type'            : 'onType',
-				'load'            : 'onLoad',
-				'focus'           : 'onFocus',
-				'blur'            : 'onBlur'
-			};
-	
-			for (key in callbacks) {
-				if (callbacks.hasOwnProperty(key)) {
-					fn = this.settings[callbacks[key]];
-					if (fn) this.on(key, fn);
-				}
-			}
-		},
-	
-		/**
-		 * Triggered when the main control element
-		 * has a click event.
-		 *
-		 * @param {object} e
-		 * @return {boolean}
-		 */
-		onClick: function(e) {
-			var self = this;
-	
-			// necessary for mobile webkit devices (manual focus triggering
-			// is ignored unless invoked within a click event)
-	    // also necessary to reopen a dropdown that has been closed by
-	    // closeAfterSelect
-			if (!self.isFocused || !self.isOpen) {
-				self.focus();
-				e.preventDefault();
-			}
-		},
-	
-		/**
-		 * Triggered when the main control element
-		 * has a mouse down event.
-		 *
-		 * @param {object} e
-		 * @return {boolean}
-		 */
-		onMouseDown: function(e) {
-			var self = this;
-			var defaultPrevented = e.isDefaultPrevented();
-			var $target = $(e.target);
-	
-			if (self.isFocused) {
-				// retain focus by preventing native handling. if the
-				// event target is the input it should not be modified.
-				// otherwise, text selection within the input won't work.
-				if (e.target !== self.$control_input[0]) {
-					if (self.settings.mode === 'single') {
-						// toggle dropdown
-						self.isOpen ? self.close() : self.open();
-					} else if (!defaultPrevented) {
-						self.setActiveItem(null);
-					}
-					return false;
-				}
-			} else {
-				// give control focus
-				if (!defaultPrevented) {
-					window.setTimeout(function() {
-						self.focus();
-					}, 0);
-				}
-			}
-		},
-	
-		/**
-		 * Triggered when the value of the control has been changed.
-		 * This should propagate the event to the original DOM
-		 * input / select element.
-		 */
-		onChange: function() {
-			this.$input.trigger('change');
-		},
-	
-		/**
-		 * Triggered on <input> paste.
-		 *
-		 * @param {object} e
-		 * @returns {boolean}
-		 */
-		onPaste: function(e) {
-			var self = this;
-	
-			if (self.isFull() || self.isInputHidden || self.isLocked) {
-				e.preventDefault();
-				return;
-			}
-	
-			// If a regex or string is included, this will split the pasted
-			// input and create Items for each separate value
-			if (self.settings.splitOn) {
-	
-				// Wait for pasted text to be recognized in value
-				setTimeout(function() {
-					var pastedText = self.$control_input.val();
-					if(!pastedText.match(self.settings.splitOn)){ return }
-	
-					var splitInput = $.trim(pastedText).split(self.settings.splitOn);
-					for (var i = 0, n = splitInput.length; i < n; i++) {
-						self.createItem(splitInput[i]);
-					}
-				}, 0);
-			}
-		},
-	
-		/**
-		 * Triggered on <input> keypress.
-		 *
-		 * @param {object} e
-		 * @returns {boolean}
-		 */
-		onKeyPress: function(e) {
-			if (this.isLocked) return e && e.preventDefault();
-			var character = String.fromCharCode(e.keyCode || e.which);
-			if (this.settings.create && this.settings.mode === 'multi' && character === this.settings.delimiter) {
-				this.createItem();
-				e.preventDefault();
-				return false;
-			}
-		},
-	
-		/**
-		 * Triggered on <input> keydown.
-		 *
-		 * @param {object} e
-		 * @returns {boolean}
-		 */
-		onKeyDown: function(e) {
-			var isInput = e.target === this.$control_input[0];
-			var self = this;
-	
-			if (self.isLocked) {
-				if (e.keyCode !== KEY_TAB) {
-					e.preventDefault();
-				}
-				return;
-			}
-	
-			switch (e.keyCode) {
-				case KEY_A:
-					if (self.isCmdDown) {
-						self.selectAll();
-						return;
-					}
-					break;
-				case KEY_ESC:
-					if (self.isOpen) {
-						e.preventDefault();
-						e.stopPropagation();
-						self.close();
-					}
-					return;
-				case KEY_N:
-					if (!e.ctrlKey || e.altKey) break;
-				case KEY_DOWN:
-					if (!self.isOpen && self.hasOptions) {
-						self.open();
-					} else if (self.$activeOption) {
-						self.ignoreHover = true;
-						var $next = self.getAdjacentOption(self.$activeOption, 1);
-						if ($next.length) self.setActiveOption($next, true, true);
-					}
-					e.preventDefault();
-					return;
-				case KEY_P:
-					if (!e.ctrlKey || e.altKey) break;
-				case KEY_UP:
-					if (self.$activeOption) {
-						self.ignoreHover = true;
-						var $prev = self.getAdjacentOption(self.$activeOption, -1);
-						if ($prev.length) self.setActiveOption($prev, true, true);
-					}
-					e.preventDefault();
-					return;
-				/* case KEY_RETURN:
-					if (self.isOpen && self.$activeOption) {
-						self.onOptionSelect({currentTarget: self.$activeOption});
-						e.preventDefault();
-					}
-					return; */
-				case KEY_LEFT:
-					self.advanceSelection(-1, e);
-					return;
-				case KEY_RIGHT:
-					self.advanceSelection(1, e);
-					return;
-				case KEY_TAB:
-					if (self.settings.selectOnTab && self.isOpen && self.$activeOption) {
-						self.onOptionSelect({currentTarget: self.$activeOption});
-	
-						// Default behaviour is to jump to the next field, we only want this
-						// if the current field doesn't accept any more entries
-						if (!self.isFull()) {
-							e.preventDefault();
-						}
-					}
-					if (self.settings.create && self.createItem()) {
-						e.preventDefault();
-					}
-					return;
-				case KEY_BACKSPACE:
-				case KEY_DELETE:
-					self.deleteSelection(e);
-					return;
-			}
-	
-			if ((self.isFull() || self.isInputHidden) && !(IS_MAC ? e.metaKey : e.ctrlKey)) {
-				e.preventDefault();
-				return;
-			}
-		},
-	
-		/**
-		 * Triggered on <input> keyup.
-		 *
-		 * @param {object} e
-		 * @returns {boolean}
-		 */
-		onKeyUp: function(e) {
-			var self = this;
-	
-			if (self.isLocked) return e && e.preventDefault();
-			var value = self.$control_input.val() || '';
-			if (self.lastValue !== value) {
-				self.lastValue = value;
-				self.onSearchChange(value);
-				self.refreshOptions();
-				self.trigger('type', value);
-			}
-		},
-	
-		/**
-		 * Invokes the user-provide option provider / loader.
-		 *
-		 * Note: this function is debounced in the Selectize
-		 * constructor (by `settings.loadThrottle` milliseconds)
-		 *
-		 * @param {string} value
-		 */
-		onSearchChange: function(value) {
-			var self = this;
-			var fn = self.settings.load;
-			if (!fn) return;
-			if (self.loadedSearches.hasOwnProperty(value)) return;
-			self.loadedSearches[value] = true;
-			self.load(function(callback) {
-				fn.apply(self, [value, callback]);
-			});
-		},
-	
-		/**
-		 * Triggered on <input> focus.
-		 *
-		 * @param {object} e (optional)
-		 * @returns {boolean}
-		 */
-		onFocus: function(e) {
-			var self = this;
-			var wasFocused = self.isFocused;
-	
-			if (self.isDisabled) {
-				self.blur();
-				e && e.preventDefault();
-				return false;
-			}
-	
-			if (self.ignoreFocus) return;
-			self.isFocused = true;
-			if (self.settings.preload === 'focus') self.onSearchChange('');
-	
-			if (!wasFocused) self.trigger('focus');
-	
-			if (!self.$activeItems.length) {
-				self.showInput();
-				self.setActiveItem(null);
-				self.refreshOptions(!!self.settings.openOnFocus);
-			}
-	
-			self.refreshState();
-		},
-	
-		/**
-		 * Triggered on <input> blur.
-		 *
-		 * @param {object} e
-		 * @param {Element} dest
-		 */
-		onBlur: function(e, dest) {
-			var self = this;
-			if (!self.isFocused) return;
-			self.isFocused = false;
-	
-			if (self.ignoreFocus) {
-				return;
-			} else if (!self.ignoreBlur && document.activeElement === self.$dropdown_content[0]) {
-				// necessary to prevent IE closing the dropdown when the scrollbar is clicked
-				self.ignoreBlur = true;
-				self.onFocus(e);
-				return;
-			}
-	
-			var deactivate = function() {
-				self.close();
-				self.setTextboxValue('');
-				self.setActiveItem(null);
-				self.setActiveOption(null);
-				self.setCaret(self.items.length);
-				self.refreshState();
-	
-				// IE11 bug: element still marked as active
-				dest && dest.focus && dest.focus();
-	
-				self.isBlurring = false;
-				self.ignoreFocus = false;
-				self.trigger('blur');
-			};
-	
-			self.isBlurring = true;
-			self.ignoreFocus = true;
-			if (self.settings.create && self.settings.createOnBlur) {
-				self.createItem(null, false, deactivate);
-			} else {
-				deactivate();
-			}
-		},
-	
-		/**
-		 * Triggered when the user rolls over
-		 * an option in the autocomplete dropdown menu.
-		 *
-		 * @param {object} e
-		 * @returns {boolean}
-		 */
-		onOptionHover: function(e) {
-			if (this.ignoreHover) return;
-			this.setActiveOption(e.currentTarget, false);
-		},
-	
-		/**
-		 * Triggered when the user clicks on an option
-		 * in the autocomplete dropdown menu.
-		 *
-		 * @param {object} e
-		 * @returns {boolean}
-		 */
-		onOptionSelect: function(e) {
-			var value, $target, $option, self = this;
-	
-			if (e.preventDefault) {
-				e.preventDefault();
-				e.stopPropagation();
-			}
-	
-			$target = $(e.currentTarget);
-			if ($target.hasClass('create')) {
-				self.createItem(null, function() {
-					if (self.settings.closeAfterSelect) {
-						self.close();
-					}
-				});
-			} else {
-				value = $target.attr('data-value');
-				if (typeof value !== 'undefined') {
-					self.lastQuery = null;
-					self.setTextboxValue('');
-					self.addItem(value);
-					if (self.settings.closeAfterSelect) {
-						self.close();
-					} else if (!self.settings.hideSelected && e.type && /mouse/.test(e.type)) {
-						self.setActiveOption(self.getOption(value));
-					}
-				}
-			}
-		},
-	
-		/**
-		 * Triggered when the user clicks on an item
-		 * that has been selected.
-		 *
-		 * @param {object} e
-		 * @returns {boolean}
-		 */
-		onItemSelect: function(e) {
-			var self = this;
-	
-			if (self.isLocked) return;
-			if (self.settings.mode === 'multi') {
-				e.preventDefault();
-				self.setActiveItem(e.currentTarget, e);
-			}
-		},
-	
-		/**
-		 * Invokes the provided method that provides
-		 * results to a callback---which are then added
-		 * as options to the control.
-		 *
-		 * @param {function} fn
-		 */
-		load: function(fn) {
-			var self = this;
-			var $wrapper = self.$wrapper.addClass(self.settings.loadingClass);
-	
-			self.loading++;
-			fn.apply(self, [function(results) {
-				self.loading = Math.max(self.loading - 1, 0);
-				if (results && results.length) {
-					self.addOption(results);
-					self.refreshOptions(self.isFocused && !self.isInputHidden);
-				}
-				if (!self.loading) {
-					$wrapper.removeClass(self.settings.loadingClass);
-				}
-				self.trigger('load', results);
-			}]);
-		},
-	
-		/**
-		 * Sets the input field of the control to the specified value.
-		 *
-		 * @param {string} value
-		 */
-		setTextboxValue: function(value) {
-			var $input = this.$control_input;
-			var changed = $input.val() !== value;
-			if (changed) {
-				$input.val(value).triggerHandler('update');
-				this.lastValue = value;
-			}
-		},
-	
-		/**
-		 * Returns the value of the control. If multiple items
-		 * can be selected (e.g. <select multiple>), this returns
-		 * an array. If only one item can be selected, this
-		 * returns a string.
-		 *
-		 * @returns {mixed}
-		 */
-		getValue: function() {
-			if (this.tagType === TAG_SELECT && this.$input.attr('multiple')) {
-				return this.items;
-			} else {
-				return this.items.join(this.settings.delimiter);
-			}
-		},
-	
-		/**
-		 * Resets the selected items to the given value.
-		 *
-		 * @param {mixed} value
-		 */
-		setValue: function(value, silent) {
-			var events = silent ? [] : ['change'];
-	
-			debounce_events(this, events, function() {
-				this.clear(silent);
-				this.addItems(value, silent);
-			});
-		},
-	
-		/**
-		 * Sets the selected item.
-		 *
-		 * @param {object} $item
-		 * @param {object} e (optional)
-		 */
-		setActiveItem: function($item, e) {
-			var self = this;
-			var eventName;
-			var i, idx, begin, end, item, swap;
-			var $last;
-	
-			if (self.settings.mode === 'single') return;
-			$item = $($item);
-	
-			// clear the active selection
-			if (!$item.length) {
-				$(self.$activeItems).removeClass('active');
-				self.$activeItems = [];
-				if (self.isFocused) {
-					self.showInput();
-				}
-				return;
-			}
-	
-			// modify selection
-			eventName = e && e.type.toLowerCase();
-	
-			if (eventName === 'mousedown' && self.isShiftDown && self.$activeItems.length) {
-				$last = self.$control.children('.active:last');
-				begin = Array.prototype.indexOf.apply(self.$control[0].childNodes, [$last[0]]);
-				end   = Array.prototype.indexOf.apply(self.$control[0].childNodes, [$item[0]]);
-				if (begin > end) {
-					swap  = begin;
-					begin = end;
-					end   = swap;
-				}
-				for (i = begin; i <= end; i++) {
-					item = self.$control[0].childNodes[i];
-					if (self.$activeItems.indexOf(item) === -1) {
-						$(item).addClass('active');
-						self.$activeItems.push(item);
-					}
-				}
-				e.preventDefault();
-			} else if ((eventName === 'mousedown' && self.isCtrlDown) || (eventName === 'keydown' && this.isShiftDown)) {
-				if ($item.hasClass('active')) {
-					idx = self.$activeItems.indexOf($item[0]);
-					self.$activeItems.splice(idx, 1);
-					$item.removeClass('active');
-				} else {
-					self.$activeItems.push($item.addClass('active')[0]);
-				}
-			} else {
-				$(self.$activeItems).removeClass('active');
-				self.$activeItems = [$item.addClass('active')[0]];
-			}
-	
-			// ensure control has focus
-			self.hideInput();
-			if (!this.isFocused) {
-				self.focus();
-			}
-		},
-	
-		/**
-		 * Sets the selected item in the dropdown menu
-		 * of available options.
-		 *
-		 * @param {object} $object
-		 * @param {boolean} scroll
-		 * @param {boolean} animate
-		 */
-		setActiveOption: function($option, scroll, animate) {
-			var height_menu, height_item, y;
-			var scroll_top, scroll_bottom;
-			var self = this;
-	
-			if (self.$activeOption) self.$activeOption.removeClass('active');
-			self.$activeOption = null;
-	
-			$option = $($option);
-			if (!$option.length) return;
-	
-			self.$activeOption = $option.addClass('active');
-	
-			if (scroll || !isset(scroll)) {
-	
-				height_menu   = self.$dropdown_content.height();
-				height_item   = self.$activeOption.outerHeight(true);
-				scroll        = self.$dropdown_content.scrollTop() || 0;
-				y             = self.$activeOption.offset().top - self.$dropdown_content.offset().top + scroll;
-				scroll_top    = y;
-				scroll_bottom = y - height_menu + height_item;
-	
-				if (y + height_item > height_menu + scroll) {
-					self.$dropdown_content.stop().animate({scrollTop: scroll_bottom}, animate ? self.settings.scrollDuration : 0);
-				} else if (y < scroll) {
-					self.$dropdown_content.stop().animate({scrollTop: scroll_top}, animate ? self.settings.scrollDuration : 0);
-				}
-	
-			}
-		},
-	
-		/**
-		 * Selects all items (CTRL + A).
-		 */
-		selectAll: function() {
-			var self = this;
-			if (self.settings.mode === 'single') return;
-	
-			self.$activeItems = Array.prototype.slice.apply(self.$control.children(':not(input)').addClass('active'));
-			if (self.$activeItems.length) {
-				self.hideInput();
-				self.close();
-			}
-			self.focus();
-		},
-	
-		/**
-		 * Hides the input element out of view, while
-		 * retaining its focus.
-		 */
-		hideInput: function() {
-			var self = this;
-	
-			self.setTextboxValue('');
-			self.$control_input.css({opacity: 0, position: 'absolute', left: self.rtl ? 10000 : -10000});
-			self.isInputHidden = true;
-		},
-	
-		/**
-		 * Restores input visibility.
-		 */
-		showInput: function() {
-			this.$control_input.css({opacity: 1, position: 'relative', left: 0});
-			this.isInputHidden = false;
-		},
-	
-		/**
-		 * Gives the control focus.
-		 */
-		focus: function() {
-			var self = this;
-			if (self.isDisabled) return;
-	
-			self.ignoreFocus = true;
-			self.$control_input[0].focus();
-			window.setTimeout(function() {
-				self.ignoreFocus = false;
-				self.onFocus();
-			}, 0);
-		},
-	
-		/**
-		 * Forces the control out of focus.
-		 *
-		 * @param {Element} dest
-		 */
-		blur: function(dest) {
-			this.$control_input[0].blur();
-			this.onBlur(null, dest);
-		},
-	
-		/**
-		 * Returns a function that scores an object
-		 * to show how good of a match it is to the
-		 * provided query.
-		 *
-		 * @param {string} query
-		 * @param {object} options
-		 * @return {function}
-		 */
-		getScoreFunction: function(query) {
-			return this.sifter.getScoreFunction(query, this.getSearchOptions());
-		},
-	
-		/**
-		 * Returns search options for sifter (the system
-		 * for scoring and sorting results).
-		 *
-		 * @see https://github.com/brianreavis/sifter.js
-		 * @return {object}
-		 */
-		getSearchOptions: function() {
-			var settings = this.settings;
-			var sort = settings.sortField;
-			if (typeof sort === 'string') {
-				sort = [{field: sort}];
-			}
-	
-			return {
-				fields      : settings.searchField,
-				conjunction : settings.searchConjunction,
-				sort        : sort,
-				nesting     : settings.nesting
-			};
-		},
-	
-		/**
-		 * Searches through available options and returns
-		 * a sorted array of matches.
-		 *
-		 * Returns an object containing:
-		 *
-		 *   - query {string}
-		 *   - tokens {array}
-		 *   - total {int}
-		 *   - items {array}
-		 *
-		 * @param {string} query
-		 * @returns {object}
-		 */
-		search: function(query) {
-			var i, value, score, result, calculateScore;
-			var self     = this;
-			var settings = self.settings;
-			var options  = this.getSearchOptions();
-	
-			// validate user-provided result scoring function
-			if (settings.score) {
-				calculateScore = self.settings.score.apply(this, [query]);
-				if (typeof calculateScore !== 'function') {
-					throw new Error('Selectize "score" setting must be a function that returns a function');
-				}
-			}
-	
-			// perform search
-			if (query !== self.lastQuery) {
-				self.lastQuery = query;
-				result = self.sifter.search(query, $.extend(options, {score: calculateScore}));
-				self.currentResults = result;
-			} else {
-				result = $.extend(true, {}, self.currentResults);
-			}
-	
-			// filter out selected items
-			if (settings.hideSelected) {
-				for (i = result.items.length - 1; i >= 0; i--) {
-					if (self.items.indexOf(hash_key(result.items[i].id)) !== -1) {
-						result.items.splice(i, 1);
-					}
-				}
-			}
-	
-			return result;
-		},
-	
-		/**
-		 * Refreshes the list of available options shown
-		 * in the autocomplete dropdown menu.
-		 *
-		 * @param {boolean} triggerDropdown
-		 */
-		refreshOptions: function(triggerDropdown) {
-			var i, j, k, n, groups, groups_order, option, option_html, optgroup, optgroups, html, html_children, has_create_option;
-			var $active, $active_before, $create;
-	
-			if (typeof triggerDropdown === 'undefined') {
-				triggerDropdown = true;
-			}
-	
-			var self              = this;
-			var query             = $.trim(self.$control_input.val());
-			var results           = self.search(query);
-			var $dropdown_content = self.$dropdown_content;
-			var active_before     = self.$activeOption && hash_key(self.$activeOption.attr('data-value'));
-	
-			// build markup
-			n = results.items.length;
-			if (typeof self.settings.maxOptions === 'number') {
-				n = Math.min(n, self.settings.maxOptions);
-			}
-	
-			// render and group available options individually
-			groups = {};
-			groups_order = [];
-	
-			for (i = 0; i < n; i++) {
-				option      = self.options[results.items[i].id];
-				option_html = self.render('option', option);
-				optgroup    = option[self.settings.optgroupField] || '';
-				optgroups   = $.isArray(optgroup) ? optgroup : [optgroup];
-	
-				for (j = 0, k = optgroups && optgroups.length; j < k; j++) {
-					optgroup = optgroups[j];
-					if (!self.optgroups.hasOwnProperty(optgroup)) {
-						optgroup = '';
-					}
-					if (!groups.hasOwnProperty(optgroup)) {
-						groups[optgroup] = document.createDocumentFragment();
-						groups_order.push(optgroup);
-					}
-					groups[optgroup].appendChild(option_html);
-				}
-			}
-	
-			// sort optgroups
-			if (this.settings.lockOptgroupOrder) {
-				groups_order.sort(function(a, b) {
-					var a_order = self.optgroups[a].$order || 0;
-					var b_order = self.optgroups[b].$order || 0;
-					return a_order - b_order;
-				});
-			}
-	
-			// render optgroup headers & join groups
-			html = document.createDocumentFragment();
-			for (i = 0, n = groups_order.length; i < n; i++) {
-				optgroup = groups_order[i];
-				if (self.optgroups.hasOwnProperty(optgroup) && groups[optgroup].childNodes.length) {
-					// render the optgroup header and options within it,
-					// then pass it to the wrapper template
-					html_children = document.createDocumentFragment();
-					html_children.appendChild(self.render('optgroup_header', self.optgroups[optgroup]));
-					html_children.appendChild(groups[optgroup]);
-	
-					html.appendChild(self.render('optgroup', $.extend({}, self.optgroups[optgroup], {
-						html: domToString(html_children),
-						dom:  html_children
-					})));
-				} else {
-					html.appendChild(groups[optgroup]);
-				}
-			}
-	
-			$dropdown_content.html(html);
-	
-			// highlight matching terms inline
-			if (self.settings.highlight) {
-				$dropdown_content.removeHighlight();
-				if (results.query.length && results.tokens.length) {
-					for (i = 0, n = results.tokens.length; i < n; i++) {
-						highlight($dropdown_content, results.tokens[i].regex);
-					}
-				}
-			}
-	
-			// add "selected" class to selected options
-			if (!self.settings.hideSelected) {
-				for (i = 0, n = self.items.length; i < n; i++) {
-					self.getOption(self.items[i]).addClass('selected');
-				}
-			}
-	
-			// add create option
-			has_create_option = self.canCreate(query);
-			if (has_create_option) {
-				$dropdown_content.prepend(self.render('option_create', {input: query}));
-				$create = $($dropdown_content[0].childNodes[0]);
-			}
-	
-			// activate
-			self.hasOptions = results.items.length > 0 || has_create_option;
-			if (self.hasOptions) {
-				if (results.items.length > 0) {
-					$active_before = active_before && self.getOption(active_before);
-					if ($active_before && $active_before.length) {
-						$active = $active_before;
-					} else if (self.settings.mode === 'single' && self.items.length) {
-						$active = self.getOption(self.items[0]);
-					}
-					if (!$active || !$active.length) {
-						if ($create && !self.settings.addPrecedence) {
-							$active = self.getAdjacentOption($create, 1);
-						} else {
-							$active = $dropdown_content.find('[data-selectable]:first');
-						}
-					}
-				} else {
-					$active = $create;
-				}
-				self.setActiveOption($active);
-				if (triggerDropdown && !self.isOpen) { self.open(); }
-			} else {
-				self.setActiveOption(null);
-				if (triggerDropdown && self.isOpen) { self.close(); }
-			}
-		},
-	
-		/**
-		 * Adds an available option. If it already exists,
-		 * nothing will happen. Note: this does not refresh
-		 * the options list dropdown (use `refreshOptions`
-		 * for that).
-		 *
-		 * Usage:
-		 *
-		 *   this.addOption(data)
-		 *
-		 * @param {object|array} data
-		 */
-		addOption: function(data) {
-			var i, n, value, self = this;
-	
-			if ($.isArray(data)) {
-				for (i = 0, n = data.length; i < n; i++) {
-					self.addOption(data[i]);
-				}
-				return;
-			}
-	
-			if (value = self.registerOption(data)) {
-				self.userOptions[value] = true;
-				self.lastQuery = null;
-				self.trigger('option_add', value, data);
-			}
-		},
-	
-		/**
-		 * Registers an option to the pool of options.
-		 *
-		 * @param {object} data
-		 * @return {boolean|string}
-		 */
-		registerOption: function(data) {
-			var key = hash_key(data[this.settings.valueField]);
-			if (typeof key === 'undefined' || key === null || this.options.hasOwnProperty(key)) return false;
-			data.$order = data.$order || ++this.order;
-			this.options[key] = data;
-			return key;
-		},
-	
-		/**
-		 * Registers an option group to the pool of option groups.
-		 *
-		 * @param {object} data
-		 * @return {boolean|string}
-		 */
-		registerOptionGroup: function(data) {
-			var key = hash_key(data[this.settings.optgroupValueField]);
-			if (!key) return false;
-	
-			data.$order = data.$order || ++this.order;
-			this.optgroups[key] = data;
-			return key;
-		},
-	
-		/**
-		 * Registers a new optgroup for options
-		 * to be bucketed into.
-		 *
-		 * @param {string} id
-		 * @param {object} data
-		 */
-		addOptionGroup: function(id, data) {
-			data[this.settings.optgroupValueField] = id;
-			if (id = this.registerOptionGroup(data)) {
-				this.trigger('optgroup_add', id, data);
-			}
-		},
-	
-		/**
-		 * Removes an existing option group.
-		 *
-		 * @param {string} id
-		 */
-		removeOptionGroup: function(id) {
-			if (this.optgroups.hasOwnProperty(id)) {
-				delete this.optgroups[id];
-				this.renderCache = {};
-				this.trigger('optgroup_remove', id);
-			}
-		},
-	
-		/**
-		 * Clears all existing option groups.
-		 */
-		clearOptionGroups: function() {
-			this.optgroups = {};
-			this.renderCache = {};
-			this.trigger('optgroup_clear');
-		},
-	
-		/**
-		 * Updates an option available for selection. If
-		 * it is visible in the selected items or options
-		 * dropdown, it will be re-rendered automatically.
-		 *
-		 * @param {string} value
-		 * @param {object} data
-		 */
-		updateOption: function(value, data) {
-			var self = this;
-			var $item, $item_new;
-			var value_new, index_item, cache_items, cache_options, order_old;
-	
-			value     = hash_key(value);
-			value_new = hash_key(data[self.settings.valueField]);
-	
-			// sanity checks
-			if (value === null) return;
-			if (!self.options.hasOwnProperty(value)) return;
-			if (typeof value_new !== 'string') throw new Error('Value must be set in option data');
-	
-			order_old = self.options[value].$order;
-	
-			// update references
-			if (value_new !== value) {
-				delete self.options[value];
-				index_item = self.items.indexOf(value);
-				if (index_item !== -1) {
-					self.items.splice(index_item, 1, value_new);
-				}
-			}
-			data.$order = data.$order || order_old;
-			self.options[value_new] = data;
-	
-			// invalidate render cache
-			cache_items = self.renderCache['item'];
-			cache_options = self.renderCache['option'];
-	
-			if (cache_items) {
-				delete cache_items[value];
-				delete cache_items[value_new];
-			}
-			if (cache_options) {
-				delete cache_options[value];
-				delete cache_options[value_new];
-			}
-	
-			// update the item if it's selected
-			if (self.items.indexOf(value_new) !== -1) {
-				$item = self.getItem(value);
-				$item_new = $(self.render('item', data));
-				if ($item.hasClass('active')) $item_new.addClass('active');
-				$item.replaceWith($item_new);
-			}
-	
-			// invalidate last query because we might have updated the sortField
-			self.lastQuery = null;
-	
-			// update dropdown contents
-			if (self.isOpen) {
-				self.refreshOptions(false);
-			}
-		},
-	
-		/**
-		 * Removes a single option.
-		 *
-		 * @param {string} value
-		 * @param {boolean} silent
-		 */
-		removeOption: function(value, silent) {
-			var self = this;
-			value = hash_key(value);
-	
-			var cache_items = self.renderCache['item'];
-			var cache_options = self.renderCache['option'];
-			if (cache_items) delete cache_items[value];
-			if (cache_options) delete cache_options[value];
-	
-			delete self.userOptions[value];
-			delete self.options[value];
-			self.lastQuery = null;
-			self.trigger('option_remove', value);
-			self.removeItem(value, silent);
-		},
-	
-		/**
-		 * Clears all options.
-		 */
-		clearOptions: function() {
-			var self = this;
-	
-			self.loadedSearches = {};
-			self.userOptions = {};
-			self.renderCache = {};
-			var options = self.options;
-			$.each(self.options, function(key, value) {
-				if(self.items.indexOf(key) == -1) {
-					delete options[key];
-				}
-			});
-			self.options = self.sifter.items = options;
-			self.lastQuery = null;
-			self.trigger('option_clear');
-		},
-	
-		/**
-		 * Returns the jQuery element of the option
-		 * matching the given value.
-		 *
-		 * @param {string} value
-		 * @returns {object}
-		 */
-		getOption: function(value) {
-			return this.getElementWithValue(value, this.$dropdown_content.find('[data-selectable]'));
-		},
-	
-		/**
-		 * Returns the jQuery element of the next or
-		 * previous selectable option.
-		 *
-		 * @param {object} $option
-		 * @param {int} direction  can be 1 for next or -1 for previous
-		 * @return {object}
-		 */
-		getAdjacentOption: function($option, direction) {
-			var $options = this.$dropdown.find('[data-selectable]');
-			var index    = $options.index($option) + direction;
-	
-			return index >= 0 && index < $options.length ? $options.eq(index) : $();
-		},
-	
-		/**
-		 * Finds the first element with a "data-value" attribute
-		 * that matches the given value.
-		 *
-		 * @param {mixed} value
-		 * @param {object} $els
-		 * @return {object}
-		 */
-		getElementWithValue: function(value, $els) {
-			value = hash_key(value);
-	
-			if (typeof value !== 'undefined' && value !== null) {
-				for (var i = 0, n = $els.length; i < n; i++) {
-					if ($els[i].getAttribute('data-value') === value) {
-						return $($els[i]);
-					}
-				}
-			}
-	
-			return $();
-		},
-	
-		/**
-		 * Returns the jQuery element of the item
-		 * matching the given value.
-		 *
-		 * @param {string} value
-		 * @returns {object}
-		 */
-		getItem: function(value) {
-			return this.getElementWithValue(value, this.$control.children());
-		},
-	
-		/**
-		 * "Selects" multiple items at once. Adds them to the list
-		 * at the current caret position.
-		 *
-		 * @param {string} value
-		 * @param {boolean} silent
-		 */
-		addItems: function(values, silent) {
-			this.buffer = document.createDocumentFragment();
-	
-			var childNodes = this.$control[0].childNodes;
-			for (var i = 0; i < childNodes.length; i++) {
-				this.buffer.appendChild(childNodes[i]);
-			}
-	
-			var items = $.isArray(values) ? values : [values];
-			for (var i = 0, n = items.length; i < n; i++) {
-				this.isPending = (i < n - 1);
-				this.addItem(items[i], silent);
-			}
-	
-			var control = this.$control[0];
-			control.insertBefore(this.buffer, control.firstChild);
-	
-			this.buffer = null;
-		},
-	
-		/**
-		 * "Selects" an item. Adds it to the list
-		 * at the current caret position.
-		 *
-		 * @param {string} value
-		 * @param {boolean} silent
-		 */
-		addItem: function(value, silent) {
-			var events = silent ? [] : ['change'];
-	
-			debounce_events(this, events, function() {
-				var $item, $option, $options;
-				var self = this;
-				var inputMode = self.settings.mode;
-				var i, active, value_next, wasFull;
-				value = hash_key(value);
-	
-				if (self.items.indexOf(value) !== -1) {
-					if (inputMode === 'single') self.close();
-					return;
-				}
-	
-				if (!self.options.hasOwnProperty(value)) return;
-				if (inputMode === 'single') self.clear(silent);
-				if (inputMode === 'multi' && self.isFull()) return;
-	
-				$item = $(self.render('item', self.options[value]));
-				wasFull = self.isFull();
-				self.items.splice(self.caretPos, 0, value);
-				self.insertAtCaret($item);
-				if (!self.isPending || (!wasFull && self.isFull())) {
-					self.refreshState();
-				}
-	
-				if (self.isSetup) {
-					$options = self.$dropdown_content.find('[data-selectable]');
-	
-					// update menu / remove the option (if this is not one item being added as part of series)
-					if (!self.isPending) {
-						$option = self.getOption(value);
-						value_next = self.getAdjacentOption($option, 1).attr('data-value');
-						self.refreshOptions(self.isFocused && inputMode !== 'single');
-						if (value_next) {
-							self.setActiveOption(self.getOption(value_next));
-						}
-					}
-	
-					// hide the menu if the maximum number of items have been selected or no options are left
-					if (!$options.length || self.isFull()) {
-						self.close();
-					} else if (!self.isPending) {
-						self.positionDropdown();
-					}
-	
-					self.updatePlaceholder();
-					self.trigger('item_add', value, $item);
-	
-					if (!self.isPending) {
-						self.updateOriginalInput({silent: silent});
-					}
-				}
-			});
-		},
-	
-		/**
-		 * Removes the selected item matching
-		 * the provided value.
-		 *
-		 * @param {string} value
-		 */
-		removeItem: function(value, silent) {
-			var self = this;
-			var $item, i, idx;
-	
-			$item = (value instanceof $) ? value : self.getItem(value);
-			value = hash_key($item.attr('data-value'));
-			i = self.items.indexOf(value);
-	
-			if (i !== -1) {
-				$item.remove();
-				if ($item.hasClass('active')) {
-					idx = self.$activeItems.indexOf($item[0]);
-					self.$activeItems.splice(idx, 1);
-				}
-	
-				self.items.splice(i, 1);
-				self.lastQuery = null;
-				if (!self.settings.persist && self.userOptions.hasOwnProperty(value)) {
-					self.removeOption(value, silent);
-				}
-	
-				if (i < self.caretPos) {
-					self.setCaret(self.caretPos - 1);
-				}
-	
-				self.refreshState();
-				self.updatePlaceholder();
-				self.updateOriginalInput({silent: silent});
-				self.positionDropdown();
-				self.trigger('item_remove', value, $item);
-			}
-		},
-	
-		/**
-		 * Invokes the `create` method provided in the
-		 * selectize options that should provide the data
-		 * for the new item, given the user input.
-		 *
-		 * Once this completes, it will be added
-		 * to the item list.
-		 *
-		 * @param {string} value
-		 * @param {boolean} [triggerDropdown]
-		 * @param {function} [callback]
-		 * @return {boolean}
-		 */
-		createItem: function(input, triggerDropdown) {
-			var self  = this;
-			var caret = self.caretPos;
-			input = input || $.trim(self.$control_input.val() || '');
-	
-			var callback = arguments[arguments.length - 1];
-			if (typeof callback !== 'function') callback = function() {};
-	
-			if (typeof triggerDropdown !== 'boolean') {
-				triggerDropdown = true;
-			}
-	
-			if (!self.canCreate(input)) {
-				callback();
-				return false;
-			}
-	
-			self.lock();
-	
-			var setup = (typeof self.settings.create === 'function') ? this.settings.create : function(input) {
-				var data = {};
-				data[self.settings.labelField] = input;
-				data[self.settings.valueField] = input;
-				return data;
-			};
-	
-			var create = once(function(data) {
-				self.unlock();
-	
-				if (!data || typeof data !== 'object') return callback();
-				var value = hash_key(data[self.settings.valueField]);
-				if (typeof value !== 'string') return callback();
-	
-				self.setTextboxValue('');
-				self.addOption(data);
-				self.setCaret(caret);
-				self.addItem(value);
-				self.refreshOptions(triggerDropdown && self.settings.mode !== 'single');
-				callback(data);
-			});
-	
-			var output = setup.apply(this, [input, create]);
-			if (typeof output !== 'undefined') {
-				create(output);
-			}
-	
-			return true;
-		},
-	
-		/**
-		 * Re-renders the selected item lists.
-		 */
-		refreshItems: function() {
-			this.lastQuery = null;
-	
-			if (this.isSetup) {
-				this.addItem(this.items);
-			}
-	
-			this.refreshState();
-			this.updateOriginalInput();
-		},
-	
-		/**
-		 * Updates all state-dependent attributes
-		 * and CSS classes.
-		 */
-		refreshState: function() {
-			this.refreshValidityState();
-			this.refreshClasses();
-		},
-	
-		/**
-		 * Update the `required` attribute of both input and control input.
-		 *
-		 * The `required` property needs to be activated on the control input
-		 * for the error to be displayed at the right place. `required` also
-		 * needs to be temporarily deactivated on the input since the input is
-		 * hidden and can't show errors.
-		 */
-		refreshValidityState: function() {
-			if (!this.isRequired) return false;
-	
-			var invalid = !this.items.length;
-	
-			this.isInvalid = invalid;
-			this.$control_input.prop('required', invalid);
-			this.$input.prop('required', !invalid);
-		},
-	
-		/**
-		 * Updates all state-dependent CSS classes.
-		 */
-		refreshClasses: function() {
-			var self     = this;
-			var isFull   = self.isFull();
-			var isLocked = self.isLocked;
-	
-			self.$wrapper
-				.toggleClass('rtl', self.rtl);
-	
-			self.$control
-				.toggleClass('focus', self.isFocused)
-				.toggleClass('disabled', self.isDisabled)
-				.toggleClass('required', self.isRequired)
-				.toggleClass('invalid', self.isInvalid)
-				.toggleClass('locked', isLocked)
-				.toggleClass('full', isFull).toggleClass('not-full', !isFull)
-				.toggleClass('input-active', self.isFocused && !self.isInputHidden)
-				.toggleClass('dropdown-active', self.isOpen)
-				.toggleClass('has-options', !$.isEmptyObject(self.options))
-				.toggleClass('has-items', self.items.length > 0);
-	
-			self.$control_input.data('grow', !isFull && !isLocked);
-		},
-	
-		/**
-		 * Determines whether or not more items can be added
-		 * to the control without exceeding the user-defined maximum.
-		 *
-		 * @returns {boolean}
-		 */
-		isFull: function() {
-			return this.settings.maxItems !== null && this.items.length >= this.settings.maxItems;
-		},
-	
-		/**
-		 * Refreshes the original <select> or <input>
-		 * element to reflect the current state.
-		 */
-		updateOriginalInput: function(opts) {
-			var i, n, options, label, self = this;
-			opts = opts || {};
-	
-			if (self.tagType === TAG_SELECT) {
-				options = [];
-				for (i = 0, n = self.items.length; i < n; i++) {
-					label = self.options[self.items[i]][self.settings.labelField] || '';
-					options.push('<option value="' + escape_html(self.items[i]) + '" selected="selected">' + escape_html(label) + '</option>');
-				}
-				if (!options.length && !this.$input.attr('multiple')) {
-					options.push('<option value="" selected="selected"></option>');
-				}
-				self.$input.html(options.join(''));
-			} else {
-				self.$input.val(self.getValue());
-				self.$input.attr('value',self.$input.val());
-			}
-	
-			if (self.isSetup) {
-				if (!opts.silent) {
-					self.trigger('change', self.$input.val());
-				}
-			}
-		},
-	
-		/**
-		 * Shows/hide the input placeholder depending
-		 * on if there items in the list already.
-		 */
-		updatePlaceholder: function() {
-			if (!this.settings.placeholder) return;
-			var $input = this.$control_input;
-	
-			if (this.items.length) {
-				$input.removeAttr('placeholder');
-			} else {
-				$input.attr('placeholder', this.settings.placeholder);
-			}
-			$input.triggerHandler('update', {force: true});
-		},
-	
-		/**
-		 * Shows the autocomplete dropdown containing
-		 * the available options.
-		 */
-		open: function() {
-			var self = this;
-	
-			if (self.isLocked || self.isOpen || (self.settings.mode === 'multi' && self.isFull())) return;
-			self.focus();
-			self.isOpen = true;
-			self.refreshState();
-			self.$dropdown.css({visibility: 'hidden', display: 'block'});
-			self.positionDropdown();
-			self.$dropdown.css({visibility: 'visible'});
-			self.trigger('dropdown_open', self.$dropdown);
-		},
-	
-		/**
-		 * Closes the autocomplete dropdown menu.
-		 */
-		close: function() {
-			var self = this;
-			var trigger = self.isOpen;
-	
-			if (self.settings.mode === 'single' && self.items.length) {
-				self.hideInput();
-	
-				// Do not trigger blur while inside a blur event,
-				// this fixes some weird tabbing behavior in FF and IE.
-				// See #1164
-				if (!self.isBlurring) {
-					self.$control_input.blur(); // close keyboard on iOS
-				}
-			}
-	
-			self.isOpen = false;
-			self.$dropdown.hide();
-			self.setActiveOption(null);
-			self.refreshState();
-	
-			if (trigger) self.trigger('dropdown_close', self.$dropdown);
-		},
-	
-		/**
-		 * Calculates and applies the appropriate
-		 * position of the dropdown.
-		 */
-		positionDropdown: function() {
-			var $control = this.$control;
-			var offset = this.settings.dropdownParent === 'body' ? $control.offset() : $control.position();
-			offset.top += $control.outerHeight(true);
-	
-			this.$dropdown.css({
-				width : $control[0].getBoundingClientRect().width,
-				top   : offset.top,
-				left  : offset.left
-			});
-		},
-	
-		/**
-		 * Resets / clears all selected items
-		 * from the control.
-		 *
-		 * @param {boolean} silent
-		 */
-		clear: function(silent) {
-			var self = this;
-	
-			if (!self.items.length) return;
-			self.$control.children(':not(input)').remove();
-			self.items = [];
-			self.lastQuery = null;
-			self.setCaret(0);
-			self.setActiveItem(null);
-			self.updatePlaceholder();
-			self.updateOriginalInput({silent: silent});
-			self.refreshState();
-			self.showInput();
-			self.trigger('clear');
-		},
-	
-		/**
-		 * A helper method for inserting an element
-		 * at the current caret position.
-		 *
-		 * @param {object} $el
-		 */
-		insertAtCaret: function($el) {
-			var caret = Math.min(this.caretPos, this.items.length);
-			var el = $el[0];
-			var target = this.buffer || this.$control[0];
-	
-			if (caret === 0) {
-				target.insertBefore(el, target.firstChild);
-			} else {
-				target.insertBefore(el, target.childNodes[caret]);
-			}
-	
-			this.setCaret(caret + 1);
-		},
-	
-		/**
-		 * Removes the current selected item(s).
-		 *
-		 * @param {object} e (optional)
-		 * @returns {boolean}
-		 */
-		deleteSelection: function(e) {
-			var i, n, direction, selection, values, caret, option_select, $option_select, $tail;
-			var self = this;
-	
-			direction = (e && e.keyCode === KEY_BACKSPACE) ? -1 : 1;
-			selection = getSelection(self.$control_input[0]);
-	
-			if (self.$activeOption && !self.settings.hideSelected) {
-				option_select = self.getAdjacentOption(self.$activeOption, -1).attr('data-value');
-			}
-	
-			// determine items that will be removed
-			values = [];
-	
-			if (self.$activeItems.length) {
-				$tail = self.$control.children('.active:' + (direction > 0 ? 'last' : 'first'));
-				caret = self.$control.children(':not(input)').index($tail);
-				if (direction > 0) { caret++; }
-	
-				for (i = 0, n = self.$activeItems.length; i < n; i++) {
-					values.push($(self.$activeItems[i]).attr('data-value'));
-				}
-				if (e) {
-					e.preventDefault();
-					e.stopPropagation();
-				}
-			} else if ((self.isFocused || self.settings.mode === 'single') && self.items.length) {
-				if (direction < 0 && selection.start === 0 && selection.length === 0) {
-					values.push(self.items[self.caretPos - 1]);
-				} else if (direction > 0 && selection.start === self.$control_input.val().length) {
-					values.push(self.items[self.caretPos]);
-				}
-			}
-	
-			// allow the callback to abort
-			if (!values.length || (typeof self.settings.onDelete === 'function' && self.settings.onDelete.apply(self, [values]) === false)) {
-				return false;
-			}
-	
-			// perform removal
-			if (typeof caret !== 'undefined') {
-				self.setCaret(caret);
-			}
-			while (values.length) {
-				self.removeItem(values.pop());
-			}
-	
-			self.showInput();
-			self.positionDropdown();
-			self.refreshOptions(true);
-	
-			// select previous option
-			if (option_select) {
-				$option_select = self.getOption(option_select);
-				if ($option_select.length) {
-					self.setActiveOption($option_select);
-				}
-			}
-	
-			return true;
-		},
-	
-		/**
-		 * Selects the previous / next item (depending
-		 * on the `direction` argument).
-		 *
-		 * > 0 - right
-		 * < 0 - left
-		 *
-		 * @param {int} direction
-		 * @param {object} e (optional)
-		 */
-		advanceSelection: function(direction, e) {
-			var tail, selection, idx, valueLength, cursorAtEdge, $tail;
-			var self = this;
-	
-			if (direction === 0) return;
-			if (self.rtl) direction *= -1;
-	
-			tail = direction > 0 ? 'last' : 'first';
-			selection = getSelection(self.$control_input[0]);
-	
-			if (self.isFocused && !self.isInputHidden) {
-				valueLength = self.$control_input.val().length;
-				cursorAtEdge = direction < 0
-					? selection.start === 0 && selection.length === 0
-					: selection.start === valueLength;
-	
-				if (cursorAtEdge && !valueLength) {
-					self.advanceCaret(direction, e);
-				}
-			} else {
-				$tail = self.$control.children('.active:' + tail);
-				if ($tail.length) {
-					idx = self.$control.children(':not(input)').index($tail);
-					self.setActiveItem(null);
-					self.setCaret(direction > 0 ? idx + 1 : idx);
-				}
-			}
-		},
-	
-		/**
-		 * Moves the caret left / right.
-		 *
-		 * @param {int} direction
-		 * @param {object} e (optional)
-		 */
-		advanceCaret: function(direction, e) {
-			var self = this, fn, $adj;
-	
-			if (direction === 0) return;
-	
-			fn = direction > 0 ? 'next' : 'prev';
-			if (self.isShiftDown) {
-				$adj = self.$control_input[fn]();
-				if ($adj.length) {
-					self.hideInput();
-					self.setActiveItem($adj);
-					e && e.preventDefault();
-				}
-			} else {
-				self.setCaret(self.caretPos + direction);
-			}
-		},
-	
-		/**
-		 * Moves the caret to the specified index.
-		 *
-		 * @param {int} i
-		 */
-		setCaret: function(i) {
-			var self = this;
-	
-			if (self.settings.mode === 'single') {
-				i = self.items.length;
-			} else {
-				i = Math.max(0, Math.min(self.items.length, i));
-			}
-	
-			if(!self.isPending) {
-				// the input must be moved by leaving it in place and moving the
-				// siblings, due to the fact that focus cannot be restored once lost
-				// on mobile webkit devices
-				var j, n, fn, $children, $child;
-				$children = self.$control.children(':not(input)');
-				for (j = 0, n = $children.length; j < n; j++) {
-					$child = $($children[j]).detach();
-					if (j <  i) {
-						self.$control_input.before($child);
-					} else {
-						self.$control.append($child);
-					}
-				}
-			}
-	
-			self.caretPos = i;
-		},
-	
-		/**
-		 * Disables user input on the control. Used while
-		 * items are being asynchronously created.
-		 */
-		lock: function() {
-			this.close();
-			this.isLocked = true;
-			this.refreshState();
-		},
-	
-		/**
-		 * Re-enables user input on the control.
-		 */
-		unlock: function() {
-			this.isLocked = false;
-			this.refreshState();
-		},
-	
-		/**
-		 * Disables user input on the control completely.
-		 * While disabled, it cannot receive focus.
-		 */
-		disable: function() {
-			var self = this;
-			self.$input.prop('disabled', true);
-			self.$control_input.prop('disabled', true).prop('tabindex', -1);
-			self.isDisabled = true;
-			self.lock();
-		},
-	
-		/**
-		 * Enables the control so that it can respond
-		 * to focus and user input.
-		 */
-		enable: function() {
-			var self = this;
-			self.$input.prop('disabled', false);
-			self.$control_input.prop('disabled', false).prop('tabindex', self.tabIndex);
-			self.isDisabled = false;
-			self.unlock();
-		},
-	
-		/**
-		 * Completely destroys the control and
-		 * unbinds all event listeners so that it can
-		 * be garbage collected.
-		 */
-		destroy: function() {
-			var self = this;
-			var eventNS = self.eventNS;
-			var revertSettings = self.revertSettings;
-	
-			self.trigger('destroy');
-			self.off();
-			self.$wrapper.remove();
-			self.$dropdown.remove();
-	
-			self.$input
-				.html('')
-				.append(revertSettings.$children)
-				.removeAttr('tabindex')
-				.removeClass('selectized')
-				.attr({tabindex: revertSettings.tabindex})
-				.show();
-	
-			self.$control_input.removeData('grow');
-			self.$input.removeData('selectize');
-	
-			if (--Selectize.count == 0 && Selectize.$testInput) {
-				Selectize.$testInput.remove();
-				Selectize.$testInput = undefined;
-			}
-	
-			$(window).off(eventNS);
-			$(document).off(eventNS);
-			$(document.body).off(eventNS);
-	
-			delete self.$input[0].selectize;
-		},
-	
-		/**
-		 * A helper method for rendering "item" and
-		 * "option" templates, given the data.
-		 *
-		 * @param {string} templateName
-		 * @param {object} data
-		 * @returns {string}
-		 */
-		render: function(templateName, data) {
-			var value, id, label;
-			var html = '';
-			var cache = false;
-			var self = this;
-			var regex_tag = /^[\t \r\n]*<([a-z][a-z0-9\-_]*(?:\:[a-z][a-z0-9\-_]*)?)/i;
-	
-			if (templateName === 'option' || templateName === 'item') {
-				value = hash_key(data[self.settings.valueField]);
-				cache = !!value;
-			}
-	
-			// pull markup from cache if it exists
-			if (cache) {
-				if (!isset(self.renderCache[templateName])) {
-					self.renderCache[templateName] = {};
-				}
-				if (self.renderCache[templateName].hasOwnProperty(value)) {
-					return self.renderCache[templateName][value];
-				}
-			}
-	
-			// render markup
-			html = $(self.settings.render[templateName].apply(this, [data, escape_html]));
-	
-			// add mandatory attributes
-			if (templateName === 'option' || templateName === 'option_create') {
-				if (!data[self.settings.disabledField]) {
-					html.attr('data-selectable', '');
-				}
-			}
-			else if (templateName === 'optgroup') {
-				id = data[self.settings.optgroupValueField] || '';
-				html.attr('data-group', id);
-				if(data[self.settings.disabledField]) {
-					html.attr('data-disabled', '');
-				}
-			}
-			if (templateName === 'option' || templateName === 'item') {
-				html.attr('data-value', value || '');
-			}
-	
-			// update cache
-			if (cache) {
-				self.renderCache[templateName][value] = html[0];
-			}
-	
-			return html[0];
-		},
-	
-		/**
-		 * Clears the render cache for a template. If
-		 * no template is given, clears all render
-		 * caches.
-		 *
-		 * @param {string} templateName
-		 */
-		clearCache: function(templateName) {
-			var self = this;
-			if (typeof templateName === 'undefined') {
-				self.renderCache = {};
-			} else {
-				delete self.renderCache[templateName];
-			}
-		},
-	
-		/**
-		 * Determines whether or not to display the
-		 * create item prompt, given a user input.
-		 *
-		 * @param {string} input
-		 * @return {boolean}
-		 */
-		canCreate: function(input) {
-			var self = this;
-			if (!self.settings.create) return false;
-			var filter = self.settings.createFilter;
-			return input.length
-				&& (typeof filter !== 'function' || filter.apply(self, [input]))
-				&& (typeof filter !== 'string' || new RegExp(filter).test(input))
-				&& (!(filter instanceof RegExp) || filter.test(input));
-		}
-	
-	});
-	
-	
-	Selectize.count = 0;
-	Selectize.defaults = {
-		options: [],
-		optgroups: [],
-	
-		plugins: [],
-		delimiter: ',',
-		splitOn: null, // regexp or string for splitting up values from a paste command
-		persist: true,
-		diacritics: true,
-		create: false,
-		createOnBlur: false,
-		createFilter: null,
-		highlight: true,
-		openOnFocus: true,
-		maxOptions: 1000,
-		maxItems: null,
-		hideSelected: null,
-		addPrecedence: false,
-		selectOnTab: false,
-		preload: false,
-		allowEmptyOption: false,
-		closeAfterSelect: false,
-	
-		scrollDuration: 60,
-		loadThrottle: 300,
-		loadingClass: 'loading',
-	
-		dataAttr: 'data-data',
-		optgroupField: 'optgroup',
-		valueField: 'value',
-		labelField: 'text',
-		disabledField: 'disabled',
-		optgroupLabelField: 'label',
-		optgroupValueField: 'value',
-		lockOptgroupOrder: false,
-	
-		sortField: '$order',
-		searchField: ['text'],
-		searchConjunction: 'and',
-	
-		mode: null,
-		wrapperClass: 'selectize-control',
-		inputClass: 'selectize-input',
-		dropdownClass: 'selectize-dropdown',
-		dropdownContentClass: 'selectize-dropdown-content',
-	
-		dropdownParent: null,
-	
-		copyClassesToDropdown: true,
-	
-		/*
-		load                 : null, // function(query, callback) { ... }
-		score                : null, // function(search) { ... }
-		onInitialize         : null, // function() { ... }
-		onChange             : null, // function(value) { ... }
-		onItemAdd            : null, // function(value, $item) { ... }
-		onItemRemove         : null, // function(value) { ... }
-		onClear              : null, // function() { ... }
-		onOptionAdd          : null, // function(value, data) { ... }
-		onOptionRemove       : null, // function(value) { ... }
-		onOptionClear        : null, // function() { ... }
-		onOptionGroupAdd     : null, // function(id, data) { ... }
-		onOptionGroupRemove  : null, // function(id) { ... }
-		onOptionGroupClear   : null, // function() { ... }
-		onDropdownOpen       : null, // function($dropdown) { ... }
-		onDropdownClose      : null, // function($dropdown) { ... }
-		onType               : null, // function(str) { ... }
-		onDelete             : null, // function(values) { ... }
-		*/
-	
-		render: {
-			/*
-			item: null,
-			optgroup: null,
-			optgroup_header: null,
-			option: null,
-			option_create: null
-			*/
-		}
-	};
-	
-	
-	$.fn.selectize = function(settings_user) {
-		var defaults             = $.fn.selectize.defaults;
-		var settings             = $.extend({}, defaults, settings_user);
-		var attr_data            = settings.dataAttr;
-		var field_label          = settings.labelField;
-		var field_value          = settings.valueField;
-		var field_disabled       = settings.disabledField;
-		var field_optgroup       = settings.optgroupField;
-		var field_optgroup_label = settings.optgroupLabelField;
-		var field_optgroup_value = settings.optgroupValueField;
-	
-		/**
-		 * Initializes selectize from a <input type="text"> element.
-		 *
-		 * @param {object} $input
-		 * @param {object} settings_element
-		 */
-		var init_textbox = function($input, settings_element) {
-			var i, n, values, option;
-	
-			var data_raw = $input.attr(attr_data);
-	
-			if (!data_raw) {
-				var value = $.trim($input.val() || '');
-				if (!settings.allowEmptyOption && !value.length) return;
-				values = value.split(settings.delimiter);
-				for (i = 0, n = values.length; i < n; i++) {
-					option = {};
-					option[field_label] = values[i];
-					option[field_value] = values[i];
-					settings_element.options.push(option);
-				}
-				settings_element.items = values;
-			} else {
-				settings_element.options = JSON.parse(data_raw);
-				for (i = 0, n = settings_element.options.length; i < n; i++) {
-					settings_element.items.push(settings_element.options[i][field_value]);
-				}
-			}
-		};
-	
-		/**
-		 * Initializes selectize from a <select> element.
-		 *
-		 * @param {object} $input
-		 * @param {object} settings_element
-		 */
-		var init_select = function($input, settings_element) {
-			var i, n, tagName, $children, order = 0;
-			var options = settings_element.options;
-			var optionsMap = {};
-	
-			var readData = function($el) {
-				var data = attr_data && $el.attr(attr_data);
-				if (typeof data === 'string' && data.length) {
-					return JSON.parse(data);
-				}
-				return null;
-			};
-	
-			var addOption = function($option, group) {
-				$option = $($option);
-	
-				var value = hash_key($option.val());
-				if (!value && !settings.allowEmptyOption) return;
-	
-				// if the option already exists, it's probably been
-				// duplicated in another optgroup. in this case, push
-				// the current group to the "optgroup" property on the
-				// existing option so that it's rendered in both places.
-				if (optionsMap.hasOwnProperty(value)) {
-					if (group) {
-						var arr = optionsMap[value][field_optgroup];
-						if (!arr) {
-							optionsMap[value][field_optgroup] = group;
-						} else if (!$.isArray(arr)) {
-							optionsMap[value][field_optgroup] = [arr, group];
-						} else {
-							arr.push(group);
-						}
-					}
-					return;
-				}
-	
-				var option             = readData($option) || {};
-				option[field_label]    = option[field_label] || $option.text();
-				option[field_value]    = option[field_value] || value;
-				option[field_disabled] = option[field_disabled] || $option.prop('disabled');
-				option[field_optgroup] = option[field_optgroup] || group;
-	
-				optionsMap[value] = option;
-				options.push(option);
-	
-				if ($option.is(':selected')) {
-					settings_element.items.push(value);
-				}
-			};
-	
-			var addGroup = function($optgroup) {
-				var i, n, id, optgroup, $options;
-	
-				$optgroup = $($optgroup);
-				id = $optgroup.attr('label');
-	
-				if (id) {
-					optgroup = readData($optgroup) || {};
-					optgroup[field_optgroup_label] = id;
-					optgroup[field_optgroup_value] = id;
-					optgroup[field_disabled] = $optgroup.prop('disabled');
-					settings_element.optgroups.push(optgroup);
-				}
-	
-				$options = $('option', $optgroup);
-				for (i = 0, n = $options.length; i < n; i++) {
-					addOption($options[i], id);
-				}
-			};
-	
-			settings_element.maxItems = $input.attr('multiple') ? null : 1;
-	
-			$children = $input.children();
-			for (i = 0, n = $children.length; i < n; i++) {
-				tagName = $children[i].tagName.toLowerCase();
-				if (tagName === 'optgroup') {
-					addGroup($children[i]);
-				} else if (tagName === 'option') {
-					addOption($children[i]);
-				}
-			}
-		};
-	
-		return this.each(function() {
-			if (this.selectize) return;
-	
-			var instance;
-			var $input = $(this);
-			var tag_name = this.tagName.toLowerCase();
-			var placeholder = $input.attr('placeholder') || $input.attr('data-placeholder');
-			if (!placeholder && !settings.allowEmptyOption) {
-				placeholder = $input.children('option[value=""]').text();
-			}
-	
-			var settings_element = {
-				'placeholder' : placeholder,
-				'options'     : [],
-				'optgroups'   : [],
-				'items'       : []
-			};
-	
-			if (tag_name === 'select') {
-				init_select($input, settings_element);
-			} else {
-				init_textbox($input, settings_element);
-			}
-	
-			instance = new Selectize($input, $.extend(true, {}, defaults, settings_element, settings_user));
-		});
-	};
-	
-	$.fn.selectize.defaults = Selectize.defaults;
-	$.fn.selectize.support = {
-		validity: SUPPORTS_VALIDITY_API
-	};
-	
-	
-	Selectize.define('remove_button', function(options) {
-		options = $.extend({
-				label     : '&times;',
-				title     : 'Remove',
-				className : 'remove',
-				append    : true
-			}, options);
-	
-			var singleClose = function(thisRef, options) {
-	
-				options.className = 'remove-single';
-	
-				var self = thisRef;
-				var html = '<a href="javascript:void(0)" class="' + options.className + '" tabindex="-1" title="' + escape_html(options.title) + '">' + options.label + '</a>';
-	
-				/**
-				 * Appends an element as a child (with raw HTML).
-				 *
-				 * @param {string} html_container
-				 * @param {string} html_element
-				 * @return {string}
-				 */
-				var append = function(html_container, html_element) {
-					return $('<span>').append(html_container)
-						.append(html_element);
-				};
-	
-				thisRef.setup = (function() {
-					var original = self.setup;
-					return function() {
-						// override the item rendering method to add the button to each
-						if (options.append) {
-							var id = $(self.$input.context).attr('id');
-							var selectizer = $('#'+id);
-	
-							var render_item = self.settings.render.item;
-							self.settings.render.item = function(data) {
-								return append(render_item.apply(thisRef, arguments), html);
-							};
-						}
-	
-						original.apply(thisRef, arguments);
-	
-						// add event listener
-						thisRef.$control.on('click', '.' + options.className, function(e) {
-							e.preventDefault();
-							if (self.isLocked) return;
-	
-							self.clear();
-						});
-	
-					};
-				})();
-			};
-	
-			var multiClose = function(thisRef, options) {
-	
-				var self = thisRef;
-				var html = '<a href="javascript:void(0)" class="' + options.className + '" tabindex="-1" title="' + escape_html(options.title) + '">' + options.label + '</a>';
-	
-				/**
-				 * Appends an element as a child (with raw HTML).
-				 *
-				 * @param {string} html_container
-				 * @param {string} html_element
-				 * @return {string}
-				 */
-				var append = function(html_container, html_element) {
-					var pos = html_container.search(/(<\/[^>]+>\s*)$/);
-					return html_container.substring(0, pos) + html_element + html_container.substring(pos);
-				};
-	
-				thisRef.setup = (function() {
-					var original = self.setup;
-					return function() {
-						// override the item rendering method to add the button to each
-						if (options.append) {
-							var render_item = self.settings.render.item;
-							self.settings.render.item = function(data) {
-								return append(render_item.apply(thisRef, arguments), html);
-							};
-						}
-	
-						original.apply(thisRef, arguments);
-	
-						// add event listener
-						thisRef.$control.on('click', '.' + options.className, function(e) {
-							e.preventDefault();
-							if (self.isLocked) return;
-	
-							var $item = $(e.currentTarget).parent();
-							self.setActiveItem($item);
-							if (self.deleteSelection()) {
-								self.setCaret(self.items.length);
-							}
-						});
-	
-					};
-				})();
-			};
-	
-			if (this.settings.mode === 'single') {
-				singleClose(this, options);
-				return;
-			} else {
-				multiClose(this, options);
-			}
-	});
-	
-
-	return Selectize;
-}));
\ No newline at end of file
diff --git a/src_js/third_party/selectize_preserve_on_blur.js b/src_js/third_party/selectize_preserve_on_blur.js
deleted file mode 100755
index 592f7c7..0000000
--- a/src_js/third_party/selectize_preserve_on_blur.js
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * Plugin: "preserve_on_blur" (selectize.js)
- * Copyright (c) 2016 Eric M. Klingensmith
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
- * file except in compliance with the License. You may obtain a copy of the License at:
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under
- * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
- * ANY KIND, either express or implied. See the License for the specific language
- * governing permissions and limitations under the License.
- *
- * @author Eric M. Klingensmith <eric.m.klingensmith@gmail.com>
- *
- * Based on methods used in restore_on_backspace plugin by Brian Reavis & contributors.
- */
- 
- Selectize.define( 'preserve_on_blur', function( options ) {
-    var self = this;
-
-    options.text = options.text || function(option) {
-        return option[this.settings.labelField];
-    };
-    
-    this.onBlur = ( function( e ) {
-        var original = self.onBlur;  
-        
-        return function( e ) {
-            // Capture the current input value
-            var $input = this.$control_input;
-            var inputValue = $input.val();
-            
-            // Do the default actions
-            original.apply( this, e );
-            
-            // Set the value back                    
-            this.setTextboxValue( inputValue );
-        };                                
-    } )();
-} );
\ No newline at end of file
diff --git a/src_js/wmcore.js b/src_js/wmcore.js
deleted file mode 100755
index efab377..0000000
--- a/src_js/wmcore.js
+++ /dev/null
@@ -1,446 +0,0 @@
-"use strict";
-
-if (!OptimadeNLP){
-    throw new Error("Failed to load OptimadeNLP");
-}
-
-var wmutils = OptimadeNLP();
-
-var wmgui = window.wmgui || {};
-
-/**
- * Support proxies
- */
-
-$.ajaxSetup({
-    xhrFields: {withCredentials: true}
-});
-
-/**
- * Extending base types with the utilities
- */
-
-Array.prototype.extend = function(other_array){
-    other_array.forEach(function(v){ this.push(v) }, this);
-}
-
-String.prototype.startswith = function(prefix){
-    return this.indexOf(prefix) === 0;
-}
-
-Number.prototype.count_decimals = function(){
-    if (isFinite(this) && Math.floor(this) === this) return 0; // is integer
-    var repr = this.toString();
-    if (repr.indexOf(".") == -1) return 0;
-    return repr.split(".")[1].length || 0;
-}
-
-/**
- * Auxiliary methods relevant for DOM, based on jQuery
- */
-
-wmgui.clean = function(str){
-    var html = $((str || '').bold());
-    html.find('script').remove();
-    return html.html();
-}
-
-wmgui.cancel_event = function(evt){
-    evt = evt || window.event;
-    if (evt.cancelBubble) evt.cancelBubble = true;
-    else {
-        if (evt.stopPropagation) evt.stopPropagation();
-        if (evt.preventDefault) evt.preventDefault();
-    }
-}
-
-wmgui.debounce = function(func, wait, immediate){
-
-    var timeout;
-
-    return function(){
-        var context = this,
-            args = arguments;
-        var later = function(){
-            timeout = null;
-            if (!immediate) func.apply(context, args);
-        }
-        var callNow = immediate && !timeout;
-        clearTimeout(timeout);
-        timeout = setTimeout(later, wait);
-        if (callNow) func.apply(context, args);
-    }
-}
-
-wmgui.is_inview = function(element){
-
-    var pageTop = $(window).scrollTop(),
-        pageBottom = pageTop + $(window).height(),
-        elementTop = $(element).offset().top,
-        elementBottom = elementTop + $(element).height();
-
-    return ((elementTop <= pageBottom) && (elementBottom >= pageTop));
-}
-
-wmgui.show_preloader = function(){ $('#preloader').show(); }
-
-wmgui.hide_preloader = function(){ $('#preloader').hide(); }
-
-wmgui.loadCSS = function(href, before, media, attributes){
-    // Arguments:
-    // `href` [REQUIRED] is the URL for your CSS file.
-    // `before` [OPTIONAL] is the element the script should use as a reference for injecting our stylesheet <link> before
-    // By default, loadCSS attempts to inject the link after the last stylesheet or script in the DOM. However, you might desire a more specific location in your document.
-    // `media` [OPTIONAL] is the media type or query of the stylesheet. By default it will be 'all'
-    // `attributes` [OPTIONAL] is the Object of attribute name/attribute value pairs to set on the stylesheet's DOM Element.
-    var ss = document.createElement( "link" );
-    var ref;
-
-    if( before ){
-        ref = before;
-    }
-    else {
-        var refs = ( document.body || document.getElementsByTagName( "head" )[ 0 ] ).childNodes;
-        ref = refs[ refs.length - 1];
-    }
-
-    var sheets = document.styleSheets;
-    // Set any of the provided attributes to the stylesheet DOM Element.
-    if( attributes ){
-        for( var attributeName in attributes ){
-            if( attributes.hasOwnProperty( attributeName ) ){
-                ss.setAttribute( attributeName, attributes[attributeName] );
-            }
-        }
-    }
-    ss.rel = "stylesheet";
-    ss.href = href;
-    // temporarily set media to something inapplicable to ensure it'll fetch without blocking render
-    ss.media = "only x";
-
-    // wait until body is defined before injecting link. This ensures a non-blocking load in IE11.
-    function ready( cb ){
-        if( document.body ){
-            return cb();
-        }
-        setTimeout(function(){
-            ready( cb );
-        });
-    }
-    // Inject link
-        // Note: the ternary preserves the existing behavior of "before" argument, but we could choose to change the argument to "after" in a later release and standardize on ref.nextSibling for all refs
-        // Note: `insertBefore` is used instead of `appendChild`, for safety re: http://www.paulirish.com/2011/surefire-dom-element-insertion/
-    ready( function(){
-        ref.parentNode.insertBefore( ss, ( before ? ref : ref.nextSibling ) );
-    });
-
-    // A method (exposed on return object for external use) that mimics onload by polling document.styleSheets until it includes the new sheet.
-    var onloadcssdefined = function( cb ){
-        var resolvedHref = ss.href;
-        var i = sheets.length;
-        while( i-- ){
-            if( sheets[ i ].href === resolvedHref ){
-                return cb();
-            }
-        }
-        setTimeout(function() {
-            onloadcssdefined( cb );
-        });
-    };
-
-    function loadCB(){
-        if( ss.addEventListener ){
-            ss.removeEventListener( "load", loadCB );
-        }
-        ss.media = media || "all";
-    }
-
-    // once loaded, set link's media back to `all` so that the stylesheet applies once it loads
-    if( ss.addEventListener ){
-        ss.addEventListener( "load", loadCB);
-    }
-    ss.onloadcssdefined = onloadcssdefined;
-    onloadcssdefined( loadCB );
-    return ss;
-}
-
-/**
- * Domain subject definitions
- */
-
-wmgui.most_frequent_els = ['O', 'Si', 'Al', 'Fe', 'Ca', 'Na', 'Mg', 'K', 'Ti',    'H', 'Cl', 'S', 'Br', 'C'];
-
-// just less probable than the *most_frequent_els*
-wmgui.probable_els = wmutils.periodic_elements_cased.slice(0, 55);
-wmgui.probable_els.splice(53, 1); // Xe
-wmgui.probable_els.splice(42, 1); // Tc
-wmgui.probable_els.splice(35, 1); // Kr
-wmgui.probable_els.splice(17, 1); // Ar
-wmgui.probable_els.splice(9, 1); // Ne
-wmgui.probable_els.splice(1, 1); // He
-
-wmgui.classes_groups = ['transitional','chalcogen','rare earth','lanthanoid','metalloid','alkaline','halogen','pnictogen','alkali','actinoid']; // NB noble gas
-
-wmgui.classes_families = ['metal','intermetallic','oxide','conductor','nonmetal','antiferromagnet','ferromagnet','semiconductor','intermediate valence','superconductor','close-packed','perovskite','scheelite','high-tc superconductor','silicide','diamagnetic','cuprate','ferrimagnet','sulfide','spin glass','rocksalt','ferroelectric','frank-kasper','selenide','adamantane','paramagnet','friauf-laves','boride','semimetal','pauli paramagnet','fluoride','telluride','hydrate','carbide','ionic conductor','chloride','spinel','intercalation','fluorite','hard magnet','arsenide','ferroelastic','orthophosphate','phosphide','nitride','piezoelectric','antiferroelectric','hydroxide','silicate','organic','hydride','iodide','bromide','charge-density wave state','spin-density wave state','ruddlesden-popper','sulfate','superionic conductor','pyrochlore','orthosilicate','borocarbide','molybdate','borate','garnet','cyanide','thermoelectric','helimagnet','vanadate','zeolite','birefringent','deuteride','orthoborate','van vleck paramagnet','mictomagnet','carbonate','phosphate','chevrel','gamma-brass','polaron conductor','nasicon','luminescent','tungstate','arsenate','nitrate','radioactive']; // NB pyrite-marcasite, pyroelectric, clathrate, heavy fermion etc.
-
-wmgui.most_frequent_classes = ['metal','oxide','conductor','nonmetal','antiferromagnet','semiconductor','perovskite','scheelite','sulfide','paramagnet','ab initio literature','hydrate','chloride','spinel','fluorite','orthophosphate','silicate', 'machine learning', 'ab initio calculations'];
-
-wmgui.most_frequent_props = ['magnetism', 'crystal structure', 'electronic properties', 'mechanical properties', 'thermodynamics', 'phase transitions', 'optical properties', 'superconductivity', 'enthalpy of formation', 'heat capacity', 'thermal expansion', 'Seebeck coefficient']; // TODO cell parameters
-
-wmgui.most_frequent_lats = ['cubic', 'tetragonal', 'orthorhombic', 'monoclinic'];
-
-wmgui.most_frequent_formulae = ['Ag2S','Ag2Se','Ag2Te','Ag3Sn','AgBr','AgCe','AgCl','AgCu4Yb','AgGaS2','AgGaSe2','AgI','AgYbGe','Al2O3','Al4C3','AlAs','AlF3','AlN','AlP','AlSb','Al[PO4]','As2S3','As2Se3','As2Te3','AsS','AuSn','AuTe2','B13C2','Ba2Cu2YFeO7','Ba2Cu3DyO7','Ba2Cu3ErO7','Ba2Cu3EuO7','Ba2Cu3GdO7','Ba2Cu3HoO7','Ba2Cu3LaO7','Ba2Cu3NdO7','Ba2Cu3PrO7','Ba2Cu3SmO7','Ba2Cu3TmO7','Ba2Cu3YO6','Ba2Cu3YO7','Ba2Cu3YbO7','Ba2Cu4YO8','Ba2CuTl2O6','Ba2MoFeO6','Ba4Ga8Ge15','Ba4Ga8Sn15','BaBiO3','BaCl2','BaF2','BaFe12O19','BaFe2As2','BaIrO3','BaLaMn2O6','BaMnF4','BaO','BaPbO3','BaRuO3','BaTiO3','BaVS3','BaYCo4O7','BaZrO3','Be13U','BeO','Bi2O3','Bi2S3','Bi2Se3','Bi2Te3','C60','Ca2ReFeO6','Ca2RuO4','Ca3Co2O6','Ca3Co4O9','CaAl2','CaAlSi','CaCu3Ti4O12','CaF2','CaFe2As2','CaIrO3','CaMnO3','CaO','CaRuO3','CaS','CaSi2','CaTiO3','Ca[CO3]','Ca[WO4]','Cd2Nb2O7','Cd3As2','CdAs2','CdCr2S4','CdCr2Se4','CdF2','CdI2','CdO','CdS','CdSb','CdSe','CdTe','Ce2Fe17','Ce3Al11','Ce3Sn','CeAl2','CeAl3','CeB6','CeBi','CeCo2','CeCo5','CeCoGe3','CeCoIn5','CeFe2','CeFe4Sb12','CeIn3','CeIrSi3','CeMn2Si2','CeNi','CeNi2Ge2','CeNi2Si2','CeNi2Sn2','CeNiGe2','CeNiSn','CeO2','CeP','CePd2Al3','CePd2Si2','CePd3','CePdSn','CePt2Si2','CePt3Si','CePtSn','CeRh2Si2','CeRh3B2','CeRhAs','CeRhGe','CeRhIn5','CeRhSb','CeRhSn','CeRu2','CeRu2Ge2','CeRu2Si2','CeRuRhSi2','CeSb','CeSi2','Co2Al9','Co2B','Co2Si','Co3O4','Co3[VO4]2','CoAl','CoGa','CoO','CoPt','CoS2','CoSb3','CoSi','CoSi2','Cr23C6','Cr2FeS4','Cr2O3','Cr2S3','Cr3C2','Cr3Si','Cr7Al45','Cr7C3','CrAs','CrB2','CrN','CrO2','CrSi2','CrTe','Cs2ZnI4','CsBr','CsC8','CsCl','CsI','Cu2Ce','Cu2CeSi2','Cu2GdSi2','Cu2Nd','Cu2O','Cu2S','Cu2Se','Cu2Te','Cu2UGe2','Cu2USi2','Cu2Y','Cu2Y2O5','Cu2YbSi2','Cu2ZnSnS4','Cu33Al17','Cu3As','Cu3Au','Cu3Sb','Cu3Sn','Cu41Sn11','Cu4CeAl','Cu4YbIn','Cu5U','Cu5Zn8','Cu6Ce','Cu9Al4','CuAl','CuAl2','CuAu','CuBr','CuCl','CuCr2Se4','CuCrO2','CuFe2O4','CuFeO2','CuGaS2','CuGaSe2','CuGd2O4','CuGeO3','CuI','CuInS2','CuInSe2','CuInTe2','CuIr2S4','CuLa2O4','CuNd2O4','CuO','CuPr2O4','CuS','CuTi2','CuV2S4','CuZn','Dy2Fe14B','Dy2Fe17','DyAl2','DyCo2','DyFe2','DyFe4Al8','DyMn2','DyMn2O5','DyMo2Fe10','DyTiFe11','Dy[VO4]','Er2Fe14B','Er2Fe17','Er2Fe17C3','Er5Si4','ErAl2','ErCo2','ErFe2','ErFeO3','ErMn2O5','ErNi2B2C','ErRh4B4','ErTiFe11','Eu2O3','Eu4Ga8Ge15','EuB6','EuFe2As2','EuFe4Sb12','EuMo6S8','EuO','EuS','EuSe','EuTe','Fe2As','Fe2B','Fe2CoO4','Fe2NiO4','Fe2O3','Fe2P','Fe3Al','Fe3C','Fe3Ga','Fe3O4','Fe3P','Fe3Si','Fe4Al13','Fe4N','Fe5Si3','FeAl','FeAs','FeB','FeBiO3','FeCl2','FeCo','FeCo2Si','FeGaO3','FeGe','FeGe2','FeNi3','FeO','FeP','FePt3','FeRh','FeS','FeS2','FeSb2','FeSe','FeSi','FeSi2','Ga2O3','GaAs','GaN','GaP','GaS','GaSb','GaSe','GaTe','Ga[PO4]','Gd2Fe14B','Gd2Fe17','Gd2O3','Gd2[MoO4]3','Gd3Co','Gd5Ge4','GdAl2','GdB6','GdCo2','GdCo5','GdFe2','GdFe3[BO3]4','GdMn2','GdMn2Ge2','GdMnO3','GdN','GdNi2','GdSi2','GdTiFe11','GeO2','GeS','GeSe','GeSe2','GeTe','H2','H2Cs[PO4]','H2K[PO4]','H2O','H2Rb[PO4]','H3Na[SeO3]2','HK[CO3]','HfB2','HfC','HfO2','HgCr2S4','HgCr2Se4','HgI2','HgS','HgSe','HgTe','Ho2Fe14B','HoAl2','HoCo2','HoFe2','HoMn2O5','HoMnO3','HoNi2','HoNi2B2C','In2O3','In2S3','In2Se3','InAs','InBi','InN','InP','InSb','InSe','InTe','K2[SeO4]','K3Mo10O30','K3Na[SeO4]2','K3[C60]','KBr','KC24','KC8','KCl','KLi[SO4]','KMnF3','KNbO3','KOs2O6','KTaO3','KTi[PO4]O','K[CN]','La2NiO4','La2O3','La3Ga5SiO14','La3S4','LaAl2','LaAlO3','LaB6','LaCoO3','LaCrO3','LaF3','LaFe11Si2','LaFe4Sb12','LaFeAsO','LaFeO3','LaGaO3','LaH3','LaMn2Ge2','LaMnO3','LaNi5','LaNiO3','LaTiO3','LaVO3','Li2Pd3B','Li2S','Li3N','LiAl','LiBr','LiCl','LiCoO2','LiF','LiFe[PO4]','LiH','LiMn2O4','LiNbO3','LiNiO2','LiTaO3','LiTi2O4','LiV2O5','LiVO2','LiYF4','Lu2Fe17','Lu5Ir4Si10','LuNi2B2C','Mg17Al12','Mg24Y5','Mg28Al45','Mg2Si','Mg2Sn','Mg2TiO4','Mg2[SiO4]','MgAl2O4','MgB2','MgCu2','MgF2','MgFe2O4','MgFeAlO4','MgFe[SiO4]','MgO','MgSiO3','MgZn2','Mn11Al15','Mn3C','Mn3O4','Mn5Si3','MnAl6','MnAs','MnBi','MnF2','MnFe2O4','MnNi2Ga','MnNi2In','MnNi2Sb','MnNi2Sn','MnNiSb','MnO','MnO2','MnP','MnS','MnSi','MnTe','Mo2S3','Mo3Al8','Mo4O11','Mo6PbS8','Mo7Ni7','MoB2','MoO3','MoS2','MoSi2','NaBr','NaCl','NaF','NaI','NaNbO3','Na[NO2]','Na[NO3]','Nb2Al','Nb3FeSe6','Nb3Ge','Nb3Si','Nb3Sn','Nb5Si3','Nb7Ni6','NbAl3','NbB2','NbC','NbCr2','NbFe2','NbH','NbN','NbNi3','NbO2','NbSe2','NbSe3','NbSi2','Nd2Co14B','Nd2Fe13CoB','Nd2Fe14B','Nd2Fe17','Nd2O3','Nd6Fe11Al3','NdAl2','NdB6','NdCo2','NdCo5','NdFeAsO','NdFeO3','NdMn2Ge2','NdMnFeGe2','NdMnO3','NdMo2Fe10','NdNiO3','NdTiFe11','NdTiO3','NdV2Fe10','Ni2Al3','Ni2B','Ni2Si','Ni31Si12','Ni3Al','Ni3B','Ni3Si','Ni3[VO4]2','Ni4B3','NiAl','NiAl3','NiO','NiS','NiS2','NiSb','NiSi','NiSi2','NpPd5Al2','O2','PbF2','PbI2','PbO','PbO2','PbS','PbSe','PbTe','Pb[WO4]','Pd2Si','PdAl','PdH','Pr2Fe14B','Pr2O3','PrAl2','PrB6','PrCo5','PrFe2Ge2','PrFe4P12','PrFeAsO','PrMn2Ge2','PrMnO3','PrNi2Si2','PrNi5','PrOs4Sb12','Rb2ZnBr4','Rb2ZnCl4','Rb3[C60]','RbBr','RbCl','RbF','RbI','RbLi[SO4]','Rb[C60]','ReO3','RuAl2','Sb2S3','Sb2Se3','Sb2Te3','SbSI','Sc2[WO4]3','ScAl3','Si3N4','SiC','SiO2','Sm2Co17','Sm2Fe17','Sm2Fe17N3','Sm2O3','SmB6','SmCo5','SmFeAsO','SmMn2Ge2','SmS','SmTiFe11','SnO2','SnS','SnS2','SnSe','SnSe2','SnTe','Sr14Cu24O41','Sr2CuBi2O6','Sr2LaMn2O7','Sr2MoFeO6','Sr2RuO4','SrAl4','SrCoO3','SrCuLaO4','SrF2','SrFe12O19','SrFe2As2','SrFeO3','SrLaMnO4','SrLaNiO4','SrMnO3','SrNb2Bi2O9','SrO','SrRuO3','SrTa2Bi2O9','SrTiO3','SrZrO3','TaC','TaS2','TaS3','TaSe2','Tb3Fe5O12','TbFe2','TbMn2','TbMn2O5','TbMnO3','TbNi2Si2','TbRh2Si2','TbTiFe11','TeO2','ThO2','Ti2Ni','Ti2O3','Ti3Al','Ti3Bi4O12','Ti5Si3','TiAl','TiAl2','TiAl3','TiB2','TiC','TiCo','TiCo2Al','TiCo2Sn','TiCoSb','TiCr2','TiFe','TiFe2','TiFeO3','TiH2','TiN','TiNi','TiNi3','TiO','TiO2','TiPbO3','TiS2','TiSe2','TiSi2','TiVO3','Tl2S','Tl5Se3','Tl5Te3','TlBr','TlCl','TlGaSe2','TlI','TlInS2','TlS','TlSe','TlTe','Tm2Fe14B','TmSe','TmTe','U2C3','U2Ni2Sn','U2Pt2In','U6Fe','UAl2','UAs','UC2','UCo2Ge2','UCoAl','UFe10Si2','UFe2','UFe4Al8','UGe2','UMn2','UNi2Al3','UNiAl','UNiGa','UNiSn','UO2','UPd2Al3','UPd3','UPdSn','UPt3','UPtGe','URu2Si2','USb','UTe','V2MnO4','V2O3','V2O5','V3Ga','V3Ge','V3O5','V3Si','V4O7','V5Al8','V5O9','V6O11','V6O13','V7O13','VAl3','VFe2Al','VO2','VSe2','W2C','WBi2O6','WMnO4','WO3','WSi2','Y2Co17','Y2Fe14B','Y2Fe17','Y2O3','Y3Al5O12','Y3Fe5O12','YAl2','YAl3','YB6','YCo2','YCo3','YCo4B','YCo5','YFe2','YFe4Al8','YH3','YMn2','YMnO3','YMo2Fe10','YNi2B2C','YTiFe11','YTiO3','YV2Fe10','YVO3','Yb2O3','Yb4As3','YbAl3','YbFe4Sb12','YbMnO3','YbRh2Si2','Zn10Fe3','Zn2Zr','Zn3As2','Zn3P2','ZnCr2O4','ZnCr2Se4','ZnF2','ZnFe2O4','ZnGeP2','ZnO','ZnS','ZnSe','ZnSiP2','ZnTe','Zr2Ni','ZrAl2','ZrAl3','ZrB2','ZrC','ZrCo2','ZrCr2','ZrFe2','ZrMn2','ZrMo2','ZrN','ZrNiSn','ZrO2','ZrPbO3','ZrV2','Zr[WO4]2','[NH4]2ZnCl4'];
-
-wmgui.most_frequent_anonymous = ['AB','AB2','ABC3','ABC','ABC2','ABCD3','AB3','AB2C4','AB2C2','ABC4','ABC2D6','ABCD4','A2B3','ABC2D4','ABCD','ABCD2','AB2C3','AB2C6','AB2C5','AB2C3D7','A3B4','A3B5','ABC2D2','A2B2C7','AB3C5','ABC2D5','ABC2D7','AB5','AB3C6','AB3C4','ABC5','ABC2D8','AB3C3','AB4','AB6','AB2C2D7','AB4C12','A2B17','AB3C4D12','ABCD5','ABCD6','A2B3C4','ABC3D7','A2B3C5','AB2C10','A2B2C5','AB2C2D6','AB2C3D8','AB2C8','ABC2D3','A2B5','AB2C3D6','AB4C8','ABC6','AB2C2D8','AB6C6','AB3C7','A4B5'];
-
-// FIXME? this concerns MPDS S-numerics:
-//if (props_fgrs) props_fgrs.extend(['c--a', 'a--b', 'b--c', 'volume', 'density', 'alat', 'blat', 'clat']);
-//if (props_ref) props_ref.extend(  ['c--a', 'a--b', 'b--c', 'volume', 'density', 'alat', 'blat', 'clat']);
-
-/**
- * Methods
- */
-
-wmgui.get_random_term = function(sequence){
-    return sequence[ Math.floor(Math.random() * sequence.length) ];
-}
-
-wmgui.is_wyckoff_position = function(input){
-    return /^[1-9]/.test(input.trim());
-}
-
-/**
- * Generate random sequences
- */
-
-wmgui.get_realistic = function(facet, cur_nlen){
-
-    var term;
-
-    if (facet == 'elements'){
-        var i = 0,
-            els = [],
-            prob_arity = [2, 3], // 4 is improbable
-            cur_nlen = cur_nlen || wmgui.get_random_term(prob_arity);
-
-        while (i < cur_nlen){
-            var el;
-            if (i < 2)
-                el = wmgui.get_random_term(wmgui.probable_els);
-            else
-                el = wmgui.get_random_term(wmgui.most_frequent_els);
-            if (els.indexOf(el) > -1) continue;
-            els.push(el);
-            i++;
-        }
-        term = els.join('-');
-
-    } else if (facet == 'formulae'){
-        term = wmgui.get_random_term(wmgui.most_frequent_formulae);
-
-    } else if (facet == 'anonymous'){
-        term = wmgui.get_random_term(wmgui.most_frequent_anonymous);
-
-    } else if (facet == 'props'){
-        term = wmgui.get_random_term(wmgui.most_frequent_props);
-
-    } else if (facet == 'classes'){
-        term = wmgui.get_random_term(wmgui.classes_families);
-
-    } else if (facet == 'lattices'){
-        term = wmgui.get_random_term(wmgui.most_frequent_lats);
-
-    } else return wmgui.get_realistic(['elements', 'formulae', 'props', 'classes', 'lattices'][ Math.floor(Math.random() * 5) ]);
-
-    return term;
-}
-
-/**
- * Generate random sequences
- */
-
-wmgui.get_interesting = function(scene){
-
-    var scenarios = [1, 2, 3, 4, 5, 6, 7, 8],
-        scene = scene || wmgui.get_random_term(scenarios),
-        result = {'text': '', 'terms': [], 'facets': []};
-
-    if (scene == 1){ // classes-elements, 4% fails
-        result['facets'].extend(['classes', 'elements']);
-        result['terms'].extend([wmgui.get_random_term(wmgui.most_frequent_classes), wmgui.get_realistic('elements', 2)]);
-        result['text'] += result['terms'][0] + ' ' + result['terms'][1];
-
-    } else if (scene == 2){ // classes-classes, 4.5% fails
-        result['facets'].extend(['classes', 'classes']);
-        result['terms'].extend([wmgui.get_random_term(wmgui.classes_groups), wmgui.get_realistic('classes')]);
-        result['text'] += result['terms'][0] + ' group, ' + result['terms'][1];
-
-    } else if (scene == 3){ // formulae-lattices, 1% fails
-        result['facets'].extend(['formulae', 'lattices']);
-        result['terms'].extend([wmgui.get_realistic('formulae'), wmgui.get_realistic('lattices')]);
-        result['text'] += result['terms'][0] + ' ' + result['terms'][1] + ' crystal';
-
-    } else if (scene == 4){ // props-classes, always correct
-        result['facets'].extend(['props', 'classes']);
-        result['terms'].extend([wmgui.get_realistic('props'), wmgui.get_realistic('classes')]);
-        result['text'] += result['terms'][0] + ' for ' + result['terms'][1];
-        if (!result['text'].endsWith('d') && !result['text'].endsWith('s'))
-            result['text'] += 's';
-
-    } else if (scene == 5){ // classes-lattices, 3% fails
-        result['facets'].extend(['classes', 'lattices']);
-        result['terms'].extend([wmgui.get_realistic('classes'), wmgui.get_realistic('lattices')]);
-        result['text'] += result['terms'][0] + ', ' + result['terms'][1] + ' crystal';
-
-    } else if (scene == 6){ // elements-lattices, 3% fails
-        result['facets'].extend(['elements', 'lattices']);
-        result['terms'].extend([wmgui.get_realistic('elements'), wmgui.get_realistic('lattices')]);
-        result['text'] += result['terms'][0] + ', ' + result['terms'][1] + ' crystal';
-
-    } else if (scene == 7){ // props and anonymous formulae
-        result['facets'].extend(['props', 'formulae']);
-        result['terms'].extend([wmgui.get_realistic('props'), wmgui.get_realistic('anonymous')]);
-        result['text'] += result['terms'][0] + ' ' + result['terms'][1];
-
-    } else { // props-formulae, 4% fails
-        result['facets'].extend(['props', 'formulae']);
-        result['terms'].extend([wmgui.get_realistic('props'), wmgui.get_realistic('formulae')]);
-        result['text'] += result['terms'][0] + ' of ' + result['terms'][1];
-    }
-    return result;
-}
-
-/**
- * Convert formula to HTML
- */
-
-wmgui.to_formula = function(input){
-    return input.replace(/\d/g, "<sub>$&</sub>");
-}
-
-/**
- * Display processing results in HTML, based on jQuery
- */
-
-wmgui.get_interpretation = function(search, facet_names, num_database){
-    if (!search) search = {};
-
-    var interpret_html = '',
-        cur_nlen = 0;
-
-    $.each(search, function(k, val){
-        if (!facet_names[k] || !val) return true;
-
-        else if (k == 'formulae') val = wmgui.to_formula(val);
-
-        else if (k == 'doi' || k == 'sgs') val = decodeURIComponent(val);
-
-        else if (k == 'elements'){
-            var els = val.split('-');
-            cur_nlen = els.length;
-            val = els.map(function(x){ return x.charAt(0).toUpperCase() + x.slice(1).toLowerCase() }).join(', ');
-
-        } else if (k == 'classes'){
-            val = val.split(',').map(function(x){ return x.trim() }).join(', ');
-
-        } else if (k == 'authors'){
-            val = val.split(',').map(function(surname){
-                return surname.trim().split(' ').map(function(part){
-                    return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-                }).join(' ');
-            }).join(', ');
-
-        } else if (k == 'aeatoms'){
-            val = wmutils.parse_aeatoms(val);
-            val = val[0] + '&nbsp;center and ' + val[1] + '&nbsp;as ligands';
-
-        } else if (k == 'aetypes'){
-            val = val.split(',').map(function(x){
-                var parts = x.trim().split('-vertex')[0].split(' '),
-                    va = parseInt(parts[parts.length - 1]);
-                return x.replace(/\d{1,2}\-vertex/, "CN&nbsp;=&nbsp;" + va);
-            }).join(', ');
-
-        } else if (k == 'wyckoff'){
-            if (wmgui.is_wyckoff_position(val)){
-                facet_names[k] = 'Wyckoff positions';
-            } else {
-                facet_names[k] = 'Wyckoff sequence';
-                val = val.replace(/\d/g, function(x){ return ["&#x2070;", "&#x00B9;", "&#x00B2;", "&#x00B3;", "&#x2074;", "&#x2075;", "&#x2076;", "&#x2077;", "&#x2078;", "&#x2079;"][x] });
-            }
-
-        } else if (k == 'numeric'){
-            var out = '';
-            val.forEach(function(member){
-                var repr = member[0],
-                    units = '';
-
-                if (num_database[repr]){
-                    var decimals = num_database[repr][4] ? Math.abs(Math.log10(num_database[repr][4])) : Math.max(num_database[repr][2].count_decimals(), num_database[repr][3].count_decimals());
-                    member[2] = Number(member[2]).toFixed(decimals);
-
-                    if (num_database[repr][1]) units = '&nbsp;' + num_database[repr][1]; // units
-
-                    if (num_database[repr][5]) repr = num_database[repr][5]; // origname
-                }
-                out += repr + ' ' + member[1] + ' ' + member[2] + units + '<br />';
-            });
-            val = out;
-        }
-
-        interpret_html += '<li class="fct_' + k + '"><span>' + facet_names[k] + '</span><br />' + val + '</li>';
-    });
-
-    if (!search.formulae && !$.isEmptyObject(search)){
-
-        var add_arity_helper = true,
-            arity_helper_html = '';
-
-        $.each(wmutils.arity_keys.slice(1), function(num, value){
-
-            if (search.classes && search.classes.indexOf(value) !== -1){
-                add_arity_helper = false;
-                return false;
-            }
-
-            if (cur_nlen - 1 > num)
-                return true;
-
-            if ((cur_nlen < 4 && num > 3) || num > 4)
-                return false;
-
-            if (window.location.hash.indexOf('inquiry') > -1){
-                if (window.location.hash.indexOf('classes=') > -1)
-                    var addr = window.location.hash.replace('classes=', 'classes=' + value + ',');
-                else
-                    var addr = window.location.hash.replace('inquiry/', 'inquiry/classes=' + value + '&');
-
-            } else var addr = window.location.hash + ' ' + value;
-
-            arity_helper_html += '<li class="fct_classes" rel="' + addr + '" style="letter-spacing:0.5px;">Show only ' + value.substr(0, value.length - 1) + 'ies</li>';
-        });
-        if (add_arity_helper) interpret_html += arity_helper_html;
-    }
-
-    return interpret_html;
-}
-
-/**
- * Parse MPDS BIBTEX
- */
-
-wmgui.parse_bib = function(string){
-    try {
-        var title = string.split('title={')[1].split('},')[0].trim(),
-            authors = string.split('author={')[1].split('},')[0].trim(),
-            journal = string.split('journal={')[1].split('},')[0].trim(),
-            pubyear = string.split('year={')[1].split('},')[0].trim();
-    } catch (error){
-        console.error('Misformatted BIB, terminating...');
-        var title = '',
-            authors = '',
-            journal = '',
-            pubyear = '';
-    }
-    return [authors, title, journal, pubyear];
-}
diff --git a/src_js/wmsettings.js b/src_js/wmsettings.js
deleted file mode 100755
index 79715ac..0000000
--- a/src_js/wmsettings.js
+++ /dev/null
@@ -1,366 +0,0 @@
-"use strict";
-
-var wmgui = window.wmgui || {};
-
-wmgui.search = {}; // the main object containing the app state synced to the server
-wmgui.search_type = 0; // 0 = entries, 1 = phases, or 2 = articles (NB copied into the main state object, defines *without_history*)
-wmgui.view_mode = 1; // 1 = intro screen, 2 = results screen
-wmgui.thumbed_display = false;
-wmgui.ctx_strict_phases = ''; // empty string or anything (bool)
-//wmgui.ctx_subphases = ''; // empty string or anything (bool)
-wmgui.ntab_tolerance = 100;
-wmgui.chosen_table_browser = false;
-wmgui.fuzzyout = false;
-wmgui.passive_sim_col = true;
-
-wmgui.active_ajax = null;
-wmgui.quick_ajax = null;
-
-// these are all usual search categories
-wmgui.facets = ['formulae', 'props', 'elements', 'classes', 'lattices', 'sgs', 'protos', 'authors', 'years', 'codens', 'doi', 'aeatoms', 'aetypes', 'geos', 'orgs', 'wyckoff'];
-
-// these are those categories only accessible from the advanced search menu
-wmgui.inquiries = [                                                     'sgs', 'protos', 'authors', 'years', 'codens', 'doi', 'aeatoms', 'aetypes', 'geos', 'orgs', 'wyckoff'];
-wmgui.other_facets = wmgui.inquiries.filter(function(item){ return item !== 'aetypes' }); // NOT main search field or NLP-handled
-wmgui.simple_facets = ['formulae', 'props', 'elements', 'lattices', 'sgs', 'protos', 'years', 'codens', 'doi', 'aeatoms', 'geos', 'orgs'];
-wmgui.multi_facets = ['classes', 'authors', 'aetypes', 'wyckoff'];
-wmgui.facet_names = {
-    props: 'Physical properties',
-    elements: 'Chemical elements',
-    classes: 'Materials classes',
-    lattices: 'Crystal systems',
-    formulae: 'Chemical formulae',
-    protos: 'Prototypes',
-    sgs: 'Space groups',
-    numeric: 'Numerical search', // NB not a real facet
-    authors: 'Authors',
-    years: 'Years',
-    codens: 'Journal codes',
-    doi: 'DOI',
-    aeatoms: 'Polyhedron atoms',
-    aetypes: 'Polyhedral types',
-    geos: 'Geography',
-    orgs: 'Organization',
-    wyckoff: 'Wyckoff search' // also positions and sequence
-};
-wmgui.multiselects = {}; // selectize instances, for *wmgui.multi_facets* and *main*
-wmgui.selectize_emit = true;
-wmgui.unfinished_page = false;
-wmgui.quick_page_size = 150;
-wmgui.fetch_page_size = 850;
-wmgui.notify_counter = null;
-wmgui.cliff_counter = null;
-wmgui.sid = null;
-wmgui.oauths = null;
-wmgui.prod = (window.location.host.indexOf('localhost') === -1);
-wmgui.darkmode = null;
-
-wmgui.cliffhangers = [
-    "binary compounds with negative thermal expansion",
-    "band gap of hexagonal ZnO",
-    "ternary oxides of indium",
-    //"microhardness < 0.05",
-    //"temperature for metal-nonmetal transition < 10",
-    //"thermoelectric figure of merit > 0.5",
-    "electronic properties for semiconductor carbides",
-    //"c/a > 3, a/b > 3, density < 4",
-    "noble gases superconductivity",
-    "W-Mo ternary phase diagram",
-    //"density < 3 and temperature for congruent melting > 2000",
-    "tetragonal SrTiO&#x2083; phonons",
-    "radioactive elements conductivity",
-    "O&#x2083;Al&#x2082; elastic properties",
-    //"refractive index > 5", // FIXME
-    "sidorenkite crystal cell",
-    //"birefringence < 0.005 and static permittivity > 7.5",
-    "phase diagrams from ab initio literature",
-    //"adiabatic bulk modulus > 250 and isothermal bulk modulus > 250",
-    "magnetic properties of binary compounds",
-    "radioactive binary compounds",
-    "binary frank-kasper type",
-    "liquidus projection phase diagrams"
-];
-wmgui.welcome_msgs = [
-    "The distinct phases is the central concept at the MPDS. Thanks to it, the crystal structures are linked to the phase diagrams and physical properties. Any distinct phase is uniquely determined by its chemical formula, space group, and Pearson symbol <i>e.g.</i> <a href='/#phase/CuAl2/140/tI12'>CuAl2 140 tI12</a>.",
-    "Our data back up such products as Springer Materials, ICDD PDF-5+, ASM Alloy Phase Diagrams, Pearson's Crystal Data, MedeA Materials Design, and AtomWork Advanced.",
-    "Each peer-reviewed crystal structure, phase diagram, or physical property at the MPDS originates from a particular publication.",
-    "There are two search modes, simple and advanced. The simple one presents one \"smart\" input field, the advanced one offers many various search fields.",
-    "The MPDS includes the data extracted from the rare USSR and Japanese journals from 60-es, 70-es, and 80-es. These journals were never online.",
-    "A unique feature of the MPDS is the support of the <a href='/#polyhedra'>polyhedral type searches</a>, taking into account the atomic environments."
-];
-// NB this is used also in legacy Ermac detection (FIXME)
-wmgui.api_msg = 'Try to run <i>e.g.</i> the command given below in a terminal. As finished, do not forget to revoke your API key. See the <a href="https://developer.mpds.io">manual</a> for more details and the <a href="/#formal/api">license</a> for open data listing. <pre style="overflow-x:scroll;margin:1em 0;">curl -H Key:YOUR_API_KEY \'https://api.mpds.io/v0/download/facet?q=&bsol;{"elements":"Ag-K"&bsol;}\'</pre><div class="wmbutton" style="background:#999;border-color:#999;width:150px;margin:0 auto;font-size:0.9em;">Copy to clipboard</div>';
-
-wmgui.bid_history = [];
-wmgui.mydata_history = [];
-wmgui.journal_converter = {j2c: function(){}, c2j: function(){}};
-wmgui.hy_complex = ['crystalline structure', 'phase diagram', 'electron energy band structure', 'electron density of states', 'vibrational spectra']; // NB check exact match in "props" p2i FIXME 'electron density of states - ab initio calculations'
-
-wmgui.visavis_curtype = 'pie'; // pie, graph, discovery, matrix, cube, qproj, lit, TODO heuristic plot type detection
-wmgui.visavis_ready = false;
-wmgui.visavis_working = false;
-wmgui.visavis_terminating = false;
-wmgui.visavis_starting = false; // only used by an old engine, to delete TODO
-
-wmgui.numerics = {
-    // these first 8 below are *pseudo_numerics*, client_prop_id > 5000
-    'volume': [5001, '&#8491;<sup>3</sup>', 3, 10000, 1],
-    'density':[5002, 'Mg/m<sup>3</sup>', 0.1, 30, 0.1],
-    'a--b':   [5003, false, 0.1, 10, false, '<i>a/b</i>'],
-    'b--c':   [5004, false, 0.1, 10, false, '<i>b/c</i>'],
-    'c--a':   [5005, false, 0.1, 10, false, '<i>c/a</i>'],
-    'alat':   [5006, '&#8491;', 1.5, 20, 0.1, '<i>a<sub>lat</sub></i>'],
-    'blat':   [5007, '&#8491;', 1.5, 20, 0.1, '<i>b<sub>lat</sub></i>'],
-    'clat':   [5008, '&#8491;', 1.5, 20, 0.1, '<i>c<sub>lat</sub></i>']
-}; // client data *numerics*: prop_name: [client_prop_id, units, min, max, ?step, ?origname]
-
-// NB all URLs follow below
-wmgui.gui_host = window.location.protocol + '//' + window.location.host;
-wmgui.api_host = wmgui.prod ? 'https://api.mpds.io/v0' : 'http://localhost:7070';
-wmgui.static_host = 'https://mpds.io';
-wmgui.app_folder = window.location.pathname.slice(0, window.location.pathname.lastIndexOf('/'));
-
-// below are the main MPDS API endpoints
-wmgui.login_endpoint =    wmgui.api_host + '/users/login';
-wmgui.logout_endpoint =   wmgui.api_host + '/users/logout';
-wmgui.factor_endpoint =   wmgui.api_host + '/users/factor';
-wmgui.factor_v_endpoint = wmgui.api_host + '/users/factor_v';
-wmgui.restore_endpoint =  wmgui.api_host + '/users/lost_password';
-wmgui.password_endpoint = wmgui.api_host + '/users/new_password';
-wmgui.access_endpoint =   wmgui.api_host + '/users/access';
-wmgui.ip_endpoint =       wmgui.api_host + '/users/ip';
-wmgui.ratify_endpoint =   wmgui.api_host + '/users/ratify';
-wmgui.api_key_endpoint =  wmgui.api_host + '/users/api_key';
-wmgui.perms_endpoint =    wmgui.api_host + '/users/perms';
-wmgui.ip_perms_endpoint = wmgui.api_host + '/users/ip_perms';
-wmgui.funnel_endpoint =   wmgui.api_host + '/users/funnel';
-//wmgui.fd_endpoint =       wmgui.api_host + '/users/feedback';
-wmgui.search_endpoint =   wmgui.api_host + '/search/facet';
-wmgui.rfn_endpoint =      wmgui.api_host + '/search/refinement';
-wmgui.sim_endpoint =      wmgui.api_host + '/search/interlinkage';
-wmgui.phase_endpoint =    wmgui.api_host + '/search/phase';
-wmgui.phph_endpoint =     wmgui.api_host + '/search/phase_phid';
-wmgui.auto_endpoint =     wmgui.api_host + '/search/selectize';
-wmgui.refs_endpoint =     wmgui.api_host + '/download/bib';
-wmgui.wmdata_endpoint =   wmgui.api_host + '/download/wmdata';
-wmgui.vis_endpoint =      wmgui.api_host + '/visavis';
-wmgui.pdist_endpoint =    wmgui.api_host + '/visavis/pdistribs';
-wmgui.mydata_endpoint =   wmgui.api_host + '/extension/mydata';
-
-wmgui.dd_addr_tpl =       wmgui.api_host + '/download';
-wmgui.mydata_addr =       wmgui.prod ? 'https://app.absolidix.com' : 'http://localhost:5000';
-
-wmgui.path_c_entry = '#' + wmgui.api_host + '/download/c?fmt=json&q='
-wmgui.path_s_entry = '#' + wmgui.api_host + '/download/s?fmt=cif&q=';
-wmgui.path_s_xrpd = '#' + wmgui.api_host + '/download/s?fmt=xrpd&q=';
-wmgui.path_sd_plot = '#' + wmgui.api_host + '/download/p?fmt=json&q=';
-wmgui.path_pp_plot = '#https://data.mpds.io/export?fmt=json&q='; // TODO
-wmgui.path_pp_ping = wmgui.prod ? 'https://data.mpds.io/ping?q=' : 'http://localhost:8080/ping?q=';
-
-wmgui.engines_addrs = {
-    'cifplayer': wmgui.app_folder + '/webassets/iframe_cifplayer.html',
-    'visavis': wmgui.app_folder + '/webassets/iframe_visavis.html'
-}
-
-wmgui.v_pd_user_addr = wmgui.app_folder + '/webassets/pd_stub.html#';
-wmgui.v_ab_vis_addr =  wmgui.app_folder + '/labs/view-phonons/#' + wmgui.api_host + '/download/p?fmt=json&q=';
-wmgui.v_pd_3d_addr =   wmgui.app_folder + '/labs/pd3d/?';
-wmgui.aetmap_addr =    wmgui.static_host + '/aets.jpg';
-
-wmgui.mpds_native = false; // TODO relate to wmgui.edition
-wmgui.edition = null; // NB edition ID (e.g. 0, 1) is determined by a domain
-
-wmgui.editions = {
-    0: {
-        'name': 'Materials Platform for Data Science',
-        'prod_url': 'https://mpds.io',
-        'dev_url': 'http://localhost:8070',
-        'css': wmgui.static_host + '/editions/wm/style.css?220923',
-        'actions': function(){
-            $('#logo_l').text('MPDS');
-            $('.only_asm').hide();
-            $('.only_mpds').css('display', 'inline-block');
-        }
-    },
-    1: {
-        'name': 'ASM International Materials Platform',
-        'prod_url': 'https://asm.mpds.io',
-        'dev_url': 'http://localhost:8075',
-        'css': wmgui.static_host + '/editions/asm/style.css?150125',
-        'actions': function(){
-            $('.only_mpds').hide();
-            $('.only_asm').css('display', 'inline-block');
-            // custom favicon
-            var link = document.querySelector("link[rel*='icon']") || document.createElement('link');
-            link.type = 'image/x-icon';
-            link.rel = 'shortcut icon';
-            link.href = wmgui.static_host + '/editions/asm/asm.ico';
-            document.getElementsByTagName('head')[0].appendChild(link);
-        }
-    }
-}
-// NB all URLs are above
-
-wmgui.elemental_names = {
-    "num": "atomic number",
-    "nump": "periodic number",
-    "size": "atomic size",
-    "rea": "atomic reactivity",
-    "rpp": "pseudopotential radii",
-    "rion": "ionic radii",
-    "rcov": "covalent radii",
-    "rmet": "metallic radii",
-    "tmelt": "melting temperature",
-    "eneg": "electronegativity"
-};
-
-wmgui.collateral_links = [ // [link_href, link_rel_attr, link_value, _blank]
-    ['#', 'my', 'search my publications'],
-    ['#', 'adv', 'try advanced search'],
-    ['#polyhedra', false, 'explore polyhedra'],
-    ['#hierarchy', false, 'browse physical properties'],
-    [wmgui.static_host + '/labs/mpds-ml-labs/design.html', false, 'design new material', true],
-    [wmgui.static_host + '/labs/mpds-ml-labs/props.html', false, 'predict properties for crystal', true],
-    ['#', 'idea', 'get inspired'],
-    ['#', 'sod', 'show structure of the day'],
-    ['oauth/asm.html', false, 'connect ASM profile', true],
-    ['oauth/github.html', false, 'connect GitHub profile', true],
-    ['oauth/orcid.html', false, 'connect ORCID profile', true],
-    ['oauth/linkedin.html', false, 'connect LinkedIn profile', true]
-];
-
-wmgui.aets = {
-'single atom 1-vertex': [0, 83],
-'4-capped trigonal prism 10-vertex': [85, 102],
-'bicapped square prism 10-vertex': [189, 123],
-'bicapped square antiprism 10-vertex': [314, 125],
-'triangle-pentagon faced polyhedron 10-vertex': [441, 125],
-'distorted equatorial 4-capped trigonal prism 10-vertex': [568, 113],
-'truncated hexagonal bipyramid 10-vertex': [683, 111],
-'polar bicapped square prism 10-vertex': [796, 125],
-'pentagonal prism 10-vertex': [923, 121],
-'octagonal bipyramid 10-vertex': [1046, 122],
-'5-capped trigonal prism 11-vertex': [1170, 119],
-'pseudo Frank-Kasper 11-vertex': [1291, 125],
-'monotruncated icosahedron 11-vertex': [1418, 102],
-'tricapped cube same plane 11-vertex': [1522, 87],
-'tricapped cube different plane 11-vertex': [1611, 123],
-'icosahedron 12-vertex': [1736, 125],
-'cuboctahedron 12-vertex': [1863, 117],
-'bicapped pentagonal prism 12-vertex': [1982, 125],
-'anticuboctahedron 12-vertex': [2109, 109],
-'hexagonal prism 12-vertex': [2220, 90],
-'triangle-hexagon faced polyhedron 12-vertex': [2312, 112],
-'double-bicapped cube 12-vertex': [2426, 114],
-'pseudo Frank-Kasper 13-vertex': [2542, 125],
-'tricapped pentagonal prism 13-vertex': [2669, 114],
-'monocapped cuboctahedron-a 13-vertex': [2785, 111],
-'monocapped cuboctahedron-b 13-vertex': [2898, 120],
-'14-vertex Frank-Kasper': [3020, 116],
-'rhombic dodecahedron 14-vertex': [3138, 121],
-'distorted rhombic dodecahedron 14-vertex': [3261, 123],
-'bicapped hexagonal prism 14-vertex': [3386, 122],
-'6-capped hexagonal bipyramid 14-vertex': [3510, 125],
-'double-bicapped hexagonal prism 14-vertex': [3637, 111],
-'15-vertex Frank-Kasper': [3750, 125],
-'equatorial 5-capped pentagonal-prism 15-vertex': [3877, 97],
-'polar equatorial tricapped pentagonal-prism 15-vertex': [3976, 125],
-'monotruncated 16-vertex Frank-Kasper': [4103, 107],
-'16-vertex Frank-Kasper': [4212, 125],
-'defective 8-equatorial capped pentagonal prism 16-vertex': [4339, 92],
-'octagonal prism 16-vertex': [4433, 119],
-'7-capped pentagonal prism 17-vertex': [4554, 125],
-'8-equatorial capped pentagonal prism 18-vertex': [4681, 125],
-'pseudo Frank-Kasper 18-vertex': [4808, 125],
-'6-capped hexagonal prism 18-vertex': [4935, 108],
-'double-bicapped heptagonal prism 18-vertex': [5045, 110],
-'distorted pseudo Frank-Kasper 19-vertex': [5157, 125],
-'pseudo Frank-Kasper 19-vertex': [5284, 122],
-'non-collinear atoms 2-vertex': [5408, 41],
-'collinear atoms 2-vertex': [5451, 111],
-'pseudo Frank-Kasper 20-vertex': [5564, 125],
-'20-pentagonal faced polyhedron 20-vertex': [5691, 114],
-'pseudo Frank-Kasper 21-vertex': [5807, 125],
-'polar 8-equatorial capped hexagonal prism 22-vertex': [5934, 125],
-'pseudo Frank-Kasper 23-vertex': [6061, 118],
-'6-square 8-hexagonal faced polyhedron 24-vertex': [6181, 118],
-'pseudo Frank-Kasper 24-vertex': [6301, 125],
-'truncated cube dice 24-vertex': [6428, 118],
-'triangle-square-hexagon faced polyhedron 24-vertex': [6548, 97],
-'triangle-square faced polyhedron 24-vertex': [6647, 125],
-'pseudo Frank-Kasper 26-vertex': [6774, 125],
-'pseudo Frank-Kasper 28-vertex': [6901, 123],
-'non-coplanar triangle 3-vertex': [7026, 75],
-'coplanar triangle 3-vertex': [7103, 64],
-'32-vertex': [7169, 122],
-'tetrahedron central atom outside 4-vertex': [7293, 99],
-'coplanar square 4-vertex': [7394, 68],
-'non-coplanar square 4-vertex': [7464, 69],
-'tetrahedron 4-vertex': [7535, 120],
-'square pyramid central atom outside of base plane 5-vertex': [7657, 81],
-'coplanar pentagon 5-vertex': [7740, 67],
-'square pyramid 5-vertex': [7809, 125],
-'trigonal bipyramid 5-vertex': [7936, 107],
-'coplanar hexagon 6-vertex': [8045, 49],
-'non-coplanar hexagon 6-vertex': [8096, 80],
-'octahedron 6-vertex': [8178, 125],
-'trigonal prism 6-vertex': [8305, 120],
-'pentagonal pyramid 6-vertex': [8427, 116],
-'distorted prism 6-vertex': [8545, 110],
-'monocapped octahedron 7-vertex': [8657, 125],
-'top-monocapped trigonal prism 7-vertex': [8784, 125],
-'bicapped hexagon 7-vertex': [8911, 108],
-'hexagonal pyramid 7-vertex': [9021, 96],
-'monocapped trigonal prism 7-vertex': [9119, 125],
-'pentagonal bipyramid 7-vertex': [9246, 122],
-'square prism cube 8-vertex': [9370, 115],
-'square antiprism 8-vertex': [9487, 103],
-'hexagonal bipyramid 8-vertex': [9592, 125],
-'distorted square anti-prism-a 8-vertex': [9719, 123],
-'double anti-trigonal prism 8-vertex': [9844, 99],
-'side-bicapped trigonal prism 8-vertex': [9945, 107],
-'distorted square anti-prism-b 8-vertex': [10054, 125],
-'tricapped trigonal prism 9-vertex': [10181, 119],
-'monocapped square prism 9-vertex': [10302, 125],
-'monocapped double anti-trigonal prism 9-vertex': [10429, 113],
-'truncated hexagonal pyramid 9-vertex': [10544, 75],
-'bicapped hexagonal pyramid 9-vertex': [10621, 116]
-};
-
-//wmgui.contact_html = '<textarea id="fdwidget_msg" placeholder="Please tell us why, anonymously"></textarea><select id="fdwidget_msgtype"><option value="No reason" selected>Please select reason...</option><option value="Data missing">Data missing</option><option value="Error in data">Error in data</option><option value="Other">Other</option></select><div id="fdwidget_trigger" class="wmbutton">Send</div>';
-
-wmgui.s_examples = [251737, 261485, 301194, 458778, 525194, 533193, 1005414, 1030546, 1122968, 1215422, 1232477, 1321212, 1406036, 1613664, 1638591, 1640622, 1707997, 1711681, 1722027, 1819191, 1928624, 1933647, 1940797];
-wmgui.mockyear = '2022'; // used for the in-house generated data, TODO switch to 2024
-
-wmgui.store_history_key = 'wm_search_log_v5';
-wmgui.store_user_key = 'wm';
-wmgui.store_bids_key = 'bid_history'; // TODO rename to wm_bid_history
-wmgui.store_mydata_key = 'absolidix_v1';
-wmgui.store_oauth_email_key = 'wm_u_email';
-wmgui.store_comm_exec_key = 'wm_reload_v1';
-wmgui.store_redir_key = 'wm_redir_v1';
-
-wmgui.tooltips = {
-    //'advsearch': {el: 'advsearch_init_trigger', oleft: -90, otop: 60, view_mode: 1, text: 'Use the &#9776; button for the detailed search by 15+ categories.<br /><span rel="userbox">Next</span>'},
-    //'hierarchy': {el: 'advsearch_init_trigger', oleft: -50, otop: 60, view_mode: 1, text: 'Use the <i>&mu;</i> button to select physical properties from the curated hierarchy.<br /><span rel="userbox">Next</span>'},
-    'userbox': {el: 'userbox', oleft: -105, otop: 60, view_mode: 1, text: 'Check your full access<br />with your account here.<br /><span rel="close_tooltip">OK</span>'},
-    'interpretation': {el: 'right_col', oleft: -70, otop: 99, view_mode: 2, text: 'The entries are grouped in the phases.<br /><span rel="databrowser">Next</span>'},
-    'databrowser': {el: 'databrowser', oleft: 0, otop: 200, view_mode: 2, text: 'Click the particular entry to get more info. Opened lock means open access.<br /><span rel="close_tooltip">OK</span>'},
-    //'plots': {el: 'databrowser', oleft: 0, otop: 500, view_mode: 2, text: 'Use the graph chart buttons in the footer (at the very bottom of the page).<br /><span rel="close_tooltip">OK</span>'},
-    'ss_axes': {el: 'ctxpanel_plots', oleft: 60, otop: 114, view_mode: 2, text: 'Click gear icon to sort axes differently.<br /><span rel="visavis" class="forced">Next</span>'},
-    'visavis': {el: 'right_col', oleft: -150, otop: 500, view_mode: 2, text: 'Fine-tune visualizations with the commands here.<br /><span rel="close_tooltip">OK</span>'}
-};
-wmgui.tooltip_counter = 0;
-wmgui.tooltip_landing = 'userbox';
-
-wmgui.entries_messages = {'C900500': 'This system is stable (dashed metastable)', 'C904090': 'This system is metastable (dashed stable)', 'C904091': 'This system is metastable', 'C904092': 'This system is metastable (dashed stable)', 'C904124': 'This system is metastable (dashed stable)', 'C904221': 'This system is stable; allotropic transition of Fe is not shown', 'C904222': 'This system is stable', 'C904223': 'This system is stable', 'C904313': 'This system is stable', 'C904322': 'This system is stable', 'C904329': 'This system is stable', 'C904330': 'This system is metastable (dashed stable)', 'C904331': 'This system is metastable (dashed stable)', 'C904332': 'This system is stable', 'C904343': 'This system is stable', 'C904344': 'This system is stable', 'C904345': 'This system is stable (dashed metastable)', 'C904354': 'This system is metastable (dashed stable)', 'C904366': 'This system is metastable', 'C904376': 'This system is metastable (dashed stable)', 'C904437': 'This system is stable', 'C904478': 'This system is stable', 'C905006': 'This system is metastable', 'C905621': 'This system is metastable', 'C905635': 'This system is stable (dashed metastable)', 'C905636': 'This system is stable', 'C905637': 'This system is stable (dashed metastable)', 'C905638': 'This system is stable (dashed metastable)', 'C905985': 'This system is metastable (dashed stable)', 'C906635': 'This system is stable', 'C906931': 'This system is stable', 'C908341': 'This system is stable; p = 8.0 GPa', 'C908342': 'This system is metastable', 'C908343': 'This system is metastable', 'C979860': 'This system is stable', 'C979861': 'This system is stable', 'C979862': 'This system is stable', 'C979863': 'This system is metastable', 'C979864': 'This system is stable', 'C979865': 'This system is stable', 'C102059': 'This system is metastable', 'C103150': 'This system is stable', 'C104069': 'This system is metastable', 'C105034': 'This system is metastable', 'C105035': 'This system is metastable'};
-
-wmgui.poly_limits = {1: 'isopolyhedral', 2: 'dipolyhedral', 3: 'tripolyhedral'};
-
-// external integrations
-// TODO account contentWindow iframe calls here
-
-wmgui.mpdsgui = {};
-wmgui.mpdsgui.view = function(){};
-wmgui.mpdsgui.ptable_activate = function(){};
-wmgui.mpdsgui.ptable_deactivate = function(){};
diff --git a/webassets/ermac.css b/webassets/ermac.css
index 153901a..ebb2fbf 100755
--- a/webassets/ermac.css
+++ b/webassets/ermac.css
@@ -813,3 +813,56 @@ div.darkmode-layer{z-index:9999;}
 @font-face {
 font-family:Exo2;src:local('Exo 2 Regular'),local('Exo2-Regular'),url('data:font/woff;charset=utf-8;base64,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') format('woff');
 }
+
+/* ACCESSIBILITY (VPAT 2.1.1 Keyboard, 1.4.4 Resize Text), see src_js/core/a11y.js */
+
+/* visible keyboard focus; NB not on text inputs: they show the caret, and the
+   autofocused search field would otherwise look different on every page */
+[role=button]:focus-visible, [role=tab]:focus-visible, [role=radio]:focus-visible, [role=link]:focus-visible,
+[data-a11y-activate]:focus-visible, a:focus-visible, button:focus-visible, .noUi-handle:focus-visible,
+#visavis_col > ul > li > a:focus-visible{outline:2px solid #1a73e8;outline-offset:1px;}
+#databrowser tr.tcell:focus-visible{outline:2px solid #1a73e8;outline-offset:-2px;}
+#ptable_area > ul > li:focus-visible{outline:3px solid #1a73e8;outline-offset:-3px;z-index:100;}
+#ctx_col div.col_title:focus{outline:none;}
+div.user_dialogue:focus{outline:none;} /* NB the dialog itself takes focus when it opens */
+
+/* the first Tab stop, visible only when focused */
+#a11y_skip{position:fixed;left:8px;top:-80px;z-index:300;padding:8px 14px;background:#fff;color:#000;border:2px solid #1a73e8;border-radius:3px;font-family:Exo2,Arial;font-size:1em;cursor:pointer;}
+#a11y_skip:focus{top:8px;}
+
+/* zoom: the periodic table is pinned to the left edge when the window is
+   narrower than the table (was: centred with a negative margin, so its left
+   columns went off-page where no scrolling reaches); unchanged when wider */
+#ptable_holder{left:max(0px, calc(50% - 525px));margin-left:0;}
+
+/* zoom: the fixed side columns scroll instead of cutting their content off */
+#refine_col, #right_col{max-height:calc(100vh - 62px);overflow-x:hidden;overflow-y:auto;}
+#ctx_col, #sim_col{max-height:calc(100vh - 62px);overflow-x:hidden;overflow-y:auto;}
+#sim_col > ul > li > a{box-sizing:border-box;} /* NB width:100% plus padding overflowed by 3px */
+
+@media all and (max-width:1100px){
+    /* the hierarchy dialog stays inside the window (was margin-left:-365px) */
+    #hy_box{left:max(0px, calc(50% - 365px));margin-left:0;}
+    /* the user box (fixed, top-right) and the cornered logo (fixed, top-left)
+       get their own room instead of covering the search field and buttons */
+    #search_area.prolonged{width:auto;margin-left:110px;margin-right:115px;}
+    #search_holder.prolonged{width:calc(100% - 132px);}
+    /* the results grid: the property column yields room to journal, year, ref. */
+    th.c2, td.c2{width:33%;max-width:33%;}
+    th.cj, td.cj{width:9%;max-width:9%;}
+    th.c4, td.c4{width:7%;max-width:7%;}
+    th.c5, td.c5, th.c55, td.c55{width:14%;max-width:14%;}
+    /* the narrow side columns: titles (with their close crosses) and links wrap */
+    div.col_title{height:auto;min-height:40px;line-height:20px;padding:10px 0;box-sizing:border-box;}
+    #sim_col > ul > li > a{white-space:normal;}
+    #sim_trigger{width:auto;max-width:125px;}
+}
+@media all and (max-height:700px){
+    /* dialogs taller than the window scroll (#hy_box and #all_polyhedra_box
+       are absolute: they scroll with the page). NB content-box: the bound
+       leaves room for a top up to 10% and up to 60px of padding + border */
+    div.user_dialogue:not(#hy_box):not(#all_polyhedra_box){max-height:calc(90vh - 60px);overflow-y:auto;}
+    /* NB the property hierarchy sizes its lines in vh, inside overflow:hidden
+       rows: on a short window a 4.2vh line is lower than the text, which got cut */
+    #hy_box > div > ul li, #hy_box > div > ul > li, #hy_box span{line-height:max(4.2vh, 1.6em);}
+}