@describe-me/core 0.4.0 → 0.5.0-next.1

package/README.md

@@ -25,8 +25,15 @@ import { step } from '@describe-me/core'
 await step('open the menu', () => screen.getByRole('button', { name: 'Menu' }).click())
 ```
 
+`elementLabel()` names a DOM element the way frame labels do, e.g.
+`button "Save"`, for adapters that record their own interactions.
+
 The manifest types live in `@describe-me/core/types`, for tools that want to
-read `.describe-me/manifest.json` themselves.
+read `.describe-me/manifest.json` themselves. Stored snapshots point into
+`assets/` and `styles/` through `ASSET_URL_PREFIX` and `STYLE_URL_PREFIX`
+([Output directory](https://github.com/grzehub/describe-me#output-directory) in
+the root README). `@describe-me/core/css-references` lists the `url()` and
+`@import` references in CSS text.
 
 See the [root README](https://github.com/grzehub/describe-me#readme) for the
 full picture.

package/dist/css-references.d.ts

@@ -0,0 +1,17 @@
+/** A `url()` or `@import` target in CSS text. */
+export interface CssReference {
+    /** The URL as written, without quotes or surrounding whitespace. */
+    url: string;
+    /** Offset of the URL's first character in the scanned text. */
+    start: number;
+    /** Offset just past the URL's last character. */
+    end: number;
+    /** `import` for an `@import` target, written as a string or as `url()`. */
+    kind: 'url' | 'import';
+}
+/**
+ * Every `url()` and `@import` target in CSS text, in source order, remote,
+ * `data:` and `#fragment` URLs included. Comments and other strings are
+ * skipped, so `content: "url(x)"` yields nothing.
+ */
+export declare function cssReferences(cssText: string): CssReference[];

package/dist/css-references.js

@@ -0,0 +1,129 @@
+/** Where a scan step can start: a comment, a string, an escape, `@import` or `url(`. */
+const TOKEN = /\/\*|["'\\]|@import|url\(/gi;
+const NAME_CHARACTER = /[\w\u0080-\uffff-]/;
+const WHITESPACE = /\s/;
+function isNameCharacter(char) {
+    return char !== undefined && NAME_CHARACTER.test(char);
+}
+function isQuote(char) {
+    return char === '"' || char === "'";
+}
+/** The offset of the quote that closes the string opening at `open`. A newline ends a broken string. */
+function closingQuote(css, open) {
+    let index = open + 1;
+    while (index < css.length) {
+        const char = css[index];
+        if (char === '\\') {
+            index += 2;
+            continue;
+        }
+        if (char === css[open] || char === '\n') {
+            return index;
+        }
+        index++;
+    }
+    return css.length;
+}
+/** The offset just past the comment opening at `open`. */
+function commentEnd(css, open) {
+    const close = css.indexOf('*/', open + 2);
+    return close === -1 ? css.length : close + 2;
+}
+function skipWhitespaceAndComments(css, start) {
+    let index = start;
+    while (index < css.length) {
+        if (WHITESPACE.test(css[index])) {
+            index++;
+        }
+        else if (css.startsWith('/*', index)) {
+            index = commentEnd(css, index);
+        }
+        else {
+            break;
+        }
+    }
+    return index;
+}
+/** `url(` at `index` as a function of its own, not the tail of a longer name such as `my-url(`. */
+function isUrlFunction(css, index) {
+    return css.slice(index, index + 4).toLowerCase() === 'url(' && !isNameCharacter(css[index - 1]);
+}
+function referenceOf(css, start, end, kind) {
+    if (end <= start) {
+        return null;
+    }
+    return { url: css.slice(start, end), start, end, kind };
+}
+/** The quoted string opening at `open`, as a reference. */
+function scanString(css, open, kind) {
+    const close = closingQuote(css, open);
+    return { reference: referenceOf(css, open + 1, close, kind), next: close + 1 };
+}
+/**
+ * The target of the `url(` starting at `index`. An unquoted URL runs until the
+ * first `)`, because a Google Fonts `css2` URL contains semicolons.
+ */
+function scanUrl(css, index, kind) {
+    let start = index + 'url('.length;
+    while (start < css.length && WHITESPACE.test(css[start])) {
+        start++;
+    }
+    if (isQuote(css[start])) {
+        return scanString(css, start, kind);
+    }
+    const close = css.indexOf(')', start);
+    if (close === -1) {
+        return { reference: null, next: start };
+    }
+    let end = close;
+    while (end > start && WHITESPACE.test(css[end - 1])) {
+        end--;
+    }
+    return { reference: referenceOf(css, start, end, kind), next: close + 1 };
+}
+/** The target of the `@import` starting at `index`: a string or a `url()`. */
+function scanImport(css, index) {
+    const target = skipWhitespaceAndComments(css, index + '@import'.length);
+    if (isQuote(css[target])) {
+        return scanString(css, target, 'import');
+    }
+    if (isUrlFunction(css, target)) {
+        return scanUrl(css, target, 'import');
+    }
+    return { reference: null, next: target };
+}
+function scanToken(css, index, token) {
+    const skipped = (next) => ({ reference: null, next });
+    if (token === '/*') {
+        return skipped(commentEnd(css, index));
+    }
+    if (token === '\\') {
+        return skipped(index + 2);
+    }
+    if (isQuote(token)) {
+        return skipped(closingQuote(css, index) + 1);
+    }
+    if (token.startsWith('@')) {
+        return isNameCharacter(css[index + token.length]) ? skipped(index + 1) : scanImport(css, index);
+    }
+    return isUrlFunction(css, index) ? scanUrl(css, index, 'url') : skipped(index + 1);
+}
+/**
+ * Every `url()` and `@import` target in CSS text, in source order, remote,
+ * `data:` and `#fragment` URLs included. Comments and other strings are
+ * skipped, so `content: "url(x)"` yields nothing.
+ */
+export function cssReferences(cssText) {
+    const references = [];
+    const token = new RegExp(TOKEN);
+    let match = token.exec(cssText);
+    while (match !== null) {
+        const scanned = scanToken(cssText, match.index, match[0]);
+        if (scanned.reference) {
+            references.push(scanned.reference);
+        }
+        token.lastIndex = scanned.next;
+        match = token.exec(cssText);
+    }
+    return references;
+}

package/dist/element-label.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A readable target for a frame label, e.g. `button "show details"`.
+ * Testing Library hands interactions a real `Element` rather than a Vitest
+ * locator, so the label is read off the element instead of a selector string.
+ */
+export declare function elementLabel(target: unknown): string | undefined;

package/dist/element-label.js

@@ -0,0 +1,34 @@
+/** Attributes that name an element better than its text, in order of preference. */
+const NAME_ATTRIBUTES = ['aria-label', 'name', 'placeholder', 'title'];
+function roleOf(element) {
+    const explicit = element.getAttribute('role');
+    if (explicit) {
+        return explicit;
+    }
+    const tag = element.tagName.toLowerCase();
+    if (tag === 'input') {
+        return element.getAttribute('type') ?? 'input';
+    }
+    return tag;
+}
+function nameOf(element) {
+    for (const attribute of NAME_ATTRIBUTES) {
+        const value = element.getAttribute(attribute);
+        if (value) {
+            return value;
+        }
+    }
+    return (element.textContent ?? '').trim().slice(0, 40);
+}
+/**
+ * A readable target for a frame label, e.g. `button "show details"`.
+ * Testing Library hands interactions a real `Element` rather than a Vitest
+ * locator, so the label is read off the element instead of a selector string.
+ */
+export function elementLabel(target) {
+    if (typeof Element === 'undefined' || !(target instanceof Element)) {
+        return undefined;
+    }
+    const name = nameOf(target);
+    return name ? `${roleOf(target)} "${name}"` : roleOf(target);
+}

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from './types.js';
+export { cssReferences, type CssReference } from './css-references.js';
 export { describeComponentType } from './describe-component-type.js';
+export { elementLabel } from './element-label.js';
 export { manifestDiagnostics } from './manifest-diagnostics.js';
 export { recorder } from './recorder.js';
 export { serializeValue } from './serialize-value.js';

package/dist/index.js

@@ -1,5 +1,7 @@
 export * from './types.js';
+export { cssReferences } from './css-references.js';
 export { describeComponentType } from './describe-component-type.js';
+export { elementLabel } from './element-label.js';
 export { manifestDiagnostics } from './manifest-diagnostics.js';
 export { recorder } from './recorder.js';
 export { serializeValue } from './serialize-value.js';

package/dist/materialize-adopted-styles.d.ts

@@ -2,6 +2,8 @@
  * Constructable stylesheets (`document.adoptedStyleSheets`, used by Lit and
  * other web-component libraries) are not part of the DOM tree, so rrweb's
  * snapshot never sees them. For the duration of `run`, mirror their rules into
- * a temporary `<style>` element so they end up in the capture.
+ * a temporary `<style>` element so they end up in the capture. Synchronous,
+ * like rrweb's snapshot, so a `settle: false` capture records its frame before
+ * `recorder.capture()` returns.
  */
-export declare function materializeAdoptedStyles<T>(run: () => T | Promise<T>): Promise<T>;
+export declare function materializeAdoptedStyles<T>(run: () => T): T;

package/dist/materialize-adopted-styles.js

@@ -2,9 +2,11 @@
  * Constructable stylesheets (`document.adoptedStyleSheets`, used by Lit and
  * other web-component libraries) are not part of the DOM tree, so rrweb's
  * snapshot never sees them. For the duration of `run`, mirror their rules into
- * a temporary `<style>` element so they end up in the capture.
+ * a temporary `<style>` element so they end up in the capture. Synchronous,
+ * like rrweb's snapshot, so a `settle: false` capture records its frame before
+ * `recorder.capture()` returns.
  */
-export async function materializeAdoptedStyles(run) {
+export function materializeAdoptedStyles(run) {
     const sheets = document.adoptedStyleSheets ?? [];
     if (sheets.length === 0) {
         return run();
@@ -16,7 +18,7 @@ export async function materializeAdoptedStyles(run) {
         .join('\n');
     document.head.append(mirror);
     try {
-        return await run();
+        return run();
     }
     finally {
         mirror.remove();

package/dist/page-has-content.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether the page shows anything at all. False for what Testing Library
+ * leaves behind: an empty body after `cleanup()`, the bare container `div`
+ * after `unmount()`. Any text, any other element and any attribute count as
+ * content, so a styled box or an icon is never taken for an empty page.
+ */
+export declare function pageHasContent(): boolean;

package/dist/page-has-content.js

@@ -0,0 +1,21 @@
+/**
+ * Whether the page shows anything at all. False for what Testing Library
+ * leaves behind: an empty body after `cleanup()`, the bare container `div`
+ * after `unmount()`. Any text, any other element and any attribute count as
+ * content, so a styled box or an icon is never taken for an empty page.
+ */
+export function pageHasContent() {
+    const body = document.body;
+    if (!body) {
+        return false;
+    }
+    if ((body.textContent ?? '').trim() !== '') {
+        return true;
+    }
+    for (const element of body.querySelectorAll('*')) {
+        if (element.localName !== 'div' || element.attributes.length > 0) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/real-timers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `setTimeout` and `performance.now()` as they were before any test faked
+ * them, so `vi.useFakeTimers()` neither hangs a capture nor skews frame times.
+ */
+export declare const realTimers: {
+    setTimeout: typeof setTimeout;
+    now: () => number;
+};

package/dist/real-timers.js

@@ -0,0 +1,23 @@
+/** The global `setTimeout`, unwrapped when a setup file faked timers before this module loaded. */
+function originalSetTimeout() {
+    const current = globalThis.setTimeout;
+    return current.clock ? current.clock._setTimeout : current;
+}
+/** The global `performance`, unwrapped the same way. */
+function originalPerformance() {
+    const current = globalThis.performance;
+    return current.clock ? current.clock._performance : current;
+}
+// Bound, because browsers throw "Illegal invocation" when `setTimeout` is
+// called without its global as `this`.
+const setTimeoutAtLoad = originalSetTimeout().bind(globalThis);
+// Fake timers replace `performance` as a whole object, so this reference stays real.
+const performanceAtLoad = originalPerformance();
+/**
+ * `setTimeout` and `performance.now()` as they were before any test faked
+ * them, so `vi.useFakeTimers()` neither hangs a capture nor skews frame times.
+ */
+export const realTimers = {
+    setTimeout: setTimeoutAtLoad,
+    now: () => performanceAtLoad.now(),
+};

package/dist/recorder.d.ts

@@ -10,13 +10,16 @@ declare class Recorder {
     private component?;
     private startedAt;
     private active;
-    private lastHash;
+    private closed;
+    private lastJson;
     private seq;
     private teardowns;
     begin(): void;
     get isActive(): boolean;
     setComponent(info: ComponentInfo): void;
     capture(kind: FrameKind, label: string, meta?: Record<string, unknown>, options?: CaptureOptions): Promise<void>;
+    /** The test went on after `cleanup()`, so the closing frame it took names the state before it. */
+    private reopen;
     end(): TestRecord;
     /**
      * Register work that must run after the test's frames are handed over, such

package/dist/recorder.js

@@ -1,6 +1,6 @@
-import { snapshot, createMirror } from 'rrweb-snapshot';
-import { materializeAdoptedStyles } from './materialize-adopted-styles.js';
-import { quickHash } from './quick-hash.js';
+import { pageHasContent } from './page-has-content.js';
+import { realTimers } from './real-timers.js';
+import { serializeDocument } from './serialize-document.js';
 import { settle } from './settle.js';
 /**
  * Test-side recorder, running wherever the tests run: the browser-mode iframe
@@ -12,15 +12,18 @@ class Recorder {
     component;
     startedAt = 0;
     active = false;
-    lastHash = '';
+    // Once `cleanup()` or the setup file took the closing frame, a second one is skipped.
+    closed = false;
+    lastJson = '';
     seq = 0;
     teardowns = new Set();
     begin() {
         this.frames = [];
         this.component = undefined;
-        this.startedAt = performance.now();
+        this.startedAt = realTimers.now();
         this.active = true;
-        this.lastHash = '';
+        this.closed = false;
+        this.lastJson = '';
         this.seq = 0;
     }
     get isActive() {
@@ -35,36 +38,56 @@ class Recorder {
         if (!this.active) {
             return;
         }
+        if (kind !== 'end' && this.closed) {
+            this.reopen();
+        }
+        if (kind === 'end' && (this.frames.length === 0 || this.closed)) {
+            return;
+        }
         if (options.settle !== false) {
             await settle();
         }
-        const node = await materializeAdoptedStyles(() => snapshot(document, { mirror: createMirror(), inlineStylesheet: true }));
-        if (!node) {
+        if (kind === 'end') {
+            this.closed = true;
+            // After `cleanup()` or `unmount()` there is nothing left to show.
+            if (!pageHasContent()) {
+                return;
+            }
+        }
+        const json = serializeDocument();
+        if (json === null) {
             return;
         }
-        // rrweb numbers nodes with a global counter, so ids differ between otherwise identical captures.
-        const hash = quickHash(JSON.stringify(node, (key, value) => (key === 'id' || key === 'rootId' ? undefined : value)));
         // The closing frame is only interesting if something changed since the last one.
-        if (kind === 'end' && hash === this.lastHash) {
+        if (kind === 'end' && json === this.lastJson) {
             return;
         }
         // A step whose body already produced this exact DOM (e.g. via an action) just names that frame.
-        if (kind === 'step' && hash === this.lastHash && this.frames.length) {
+        if (kind === 'step' && json === this.lastJson && this.frames.length) {
             const last = this.frames[this.frames.length - 1];
             last.label = `${label} · ${last.label}`;
             last.kind = 'step';
             return;
         }
-        this.lastHash = hash;
+        this.lastJson = json;
         this.frames.push({
             id: `f${this.seq++}`,
             kind,
             label,
-            at: Math.round(performance.now() - this.startedAt),
+            at: Math.round(realTimers.now() - this.startedAt),
             meta,
-            snapshot: node,
+            snapshot: json,
         });
     }
+    /** The test went on after `cleanup()`, so the closing frame it took names the state before it. */
+    reopen() {
+        this.closed = false;
+        const last = this.frames[this.frames.length - 1];
+        if (last?.kind === 'end') {
+            last.kind = 'step';
+            last.label = 'before cleanup()';
+        }
+    }
     end() {
         this.active = false;
         // The reporter needs the origin rrweb resolved every URL against. Optional

package/dist/serialize-document.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Serialize the current document with rrweb, as JSON text, or `null` when
+ * rrweb has nothing to serialize.
+ *
+ * rrweb numbers nodes from a module-level counter that only
+ * `cleanupSnapshot()` resets. Resetting it before every capture makes ids
+ * start at 1, drops `rootId` (added whenever the document's id is not 1), and
+ * makes identical DOM serialize to identical text, so the snapshot store
+ * writes it once. Gotcha: any other rrweb user in the same realm shares that
+ * counter; none is expected inside tests.
+ */
+export declare function serializeDocument(): string | null;

package/dist/serialize-document.js

@@ -0,0 +1,20 @@
+import { cleanupSnapshot, createMirror, snapshot } from 'rrweb-snapshot';
+import { materializeAdoptedStyles } from './materialize-adopted-styles.js';
+/**
+ * Serialize the current document with rrweb, as JSON text, or `null` when
+ * rrweb has nothing to serialize.
+ *
+ * rrweb numbers nodes from a module-level counter that only
+ * `cleanupSnapshot()` resets. Resetting it before every capture makes ids
+ * start at 1, drops `rootId` (added whenever the document's id is not 1), and
+ * makes identical DOM serialize to identical text, so the snapshot store
+ * writes it once. Gotcha: any other rrweb user in the same realm shares that
+ * counter; none is expected inside tests.
+ */
+export function serializeDocument() {
+    return materializeAdoptedStyles(() => {
+        cleanupSnapshot();
+        const node = snapshot(document, { mirror: createMirror(), inlineStylesheet: true });
+        return node ? JSON.stringify(node) : null;
+    });
+}

package/dist/settle.d.ts

@@ -3,5 +3,6 @@
  * One macrotask is enough for React to commit batched updates. We deliberately
  * do not wait for requestAnimationFrame: the snapshot is DOM + stylesheets, not
  * layout, and a rAF costs a whole vsync (~16ms) per capture in headless Chromium.
+ * It uses real timers, so a test that leaves fake timers on still settles.
  */
 export declare function settle(): Promise<void>;

package/dist/settle.js

@@ -1,9 +1,11 @@
+import { realTimers } from './real-timers.js';
 /**
  * Let the framework flush pending updates before we look at the DOM.
  * One macrotask is enough for React to commit batched updates. We deliberately
  * do not wait for requestAnimationFrame: the snapshot is DOM + stylesheets, not
  * layout, and a rAF costs a whole vsync (~16ms) per capture in headless Chromium.
+ * It uses real timers, so a test that leaves fake timers on still settles.
  */
 export async function settle() {
-    await new Promise((resolve) => setTimeout(resolve, 0));
+    await new Promise((resolve) => realTimers.setTimeout(resolve, 0));
 }

package/dist/types.d.ts

@@ -31,17 +31,25 @@ export declare const EXPORT_REGISTRY_KEY: "describe-me.exports";
  * `<outDir>/assets/` and the viewer resolves the prefix against `__data/assets/`.
  */
 export declare const ASSET_URL_PREFIX: "describe-me-asset:";
+/**
+ * Prefix of stylesheet references inside stored snapshots, e.g.
+ * `describe-me-style:3f2a9c1d0b7e4a55+9c1d…`. The reporter stores an rrweb
+ * `_cssText` of 256+ characters as chunks in `<outDir>/styles/<hash>.css`, and
+ * the viewer joins them back in order before replaying.
+ */
+export declare const STYLE_URL_PREFIX: "describe-me-style:";
 /** Options for `recorder.capture()`. */
 export interface CaptureOptions {
     /**
      * Wait one macrotask for the framework to flush before looking at the DOM.
      * Default: true. Pass false when the caller knows the DOM is already
      * committed (e.g. right after Testing Library's `act()`-wrapped `rerender`):
-     * the snapshot is then taken synchronously, before the caller moves on.
+     * the snapshot is then taken and the frame recorded before `capture()`
+     * returns, so the caller can move on without awaiting it.
      */
     settle?: boolean;
 }
-/** A frame as captured in the browser. `snapshot` is an rrweb serialized document. */
+/** A frame as captured by the recorder. `snapshot` is the DOM, already serialized to JSON. */
 export interface Frame {
     id: string;
     kind: FrameKind;
@@ -49,7 +57,8 @@ export interface Frame {
     /** ms since the test began */
     at: number;
     meta?: Record<string, unknown>;
-    snapshot: unknown;
+    /** rrweb serialized document, as JSON text */
+    snapshot: string;
 }
 /** What a single test hands over to the reporter via task.meta[META_KEY]. */
 export interface TestRecord {
@@ -127,11 +136,17 @@ export interface Manifest {
     /** Keyed by component name, as reported by the framework adapter. */
     components: Record<string, ComponentDoc>;
     /**
-     * Asset URLs the snapshots point at on the test page's origin that could not
-     * be found in the project, as root-relative paths (`/lib/images/logo.svg`).
+     * Asset URLs the snapshots, the preview head or copied CSS files point at
+     * that could not be found in the project, as root-relative paths
+     * (`/lib/images/logo.svg`). Paths outside the root use the `/@fs/` form.
      * They will not load in the viewer. Absent in manifests written before 0.4.
      */
     assetsMissing?: string[];
+    /**
+     * The preview head HTML, with project files as `describe-me-asset:` URLs.
+     * Absent when `previewHead` is not set.
+     */
+    head?: string;
 }
 /** The name adapters fall back to when a component has no usable name. */
 export declare const ANONYMOUS_COMPONENT: "Anonymous";
@@ -147,6 +162,6 @@ export interface ManifestDiagnostics {
         name: string;
         tests: number;
     }[];
-    /** Root-relative asset paths that will not load in the viewer. */
+    /** Asset paths that will not load in the viewer, root-relative or in the `/@fs/` form. */
     assetsMissing: string[];
 }

package/dist/types.js

@@ -13,6 +13,13 @@ export const EXPORT_REGISTRY_KEY = 'describe-me.exports';
  * `<outDir>/assets/` and the viewer resolves the prefix against `__data/assets/`.
  */
 export const ASSET_URL_PREFIX = 'describe-me-asset:';
+/**
+ * Prefix of stylesheet references inside stored snapshots, e.g.
+ * `describe-me-style:3f2a9c1d0b7e4a55+9c1d…`. The reporter stores an rrweb
+ * `_cssText` of 256+ characters as chunks in `<outDir>/styles/<hash>.css`, and
+ * the viewer joins them back in order before replaying.
+ */
+export const STYLE_URL_PREFIX = 'describe-me-style:';
 export const META_KEY = 'describeMe';
 /** The name adapters fall back to when a component has no usable name. */
 export const ANONYMOUS_COMPONENT = 'Anonymous';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@describe-me/core",
-  "version": "0.4.0",
+  "version": "0.5.0-next.1",
   "description": "Recorder and manifest types for describe-me: living component docs from your tests",
   "keywords": [
     "vitest",
@@ -38,6 +38,10 @@
     "./diagnostics": {
       "types": "./dist/manifest-diagnostics.d.ts",
       "default": "./dist/manifest-diagnostics.js"
+    },
+    "./css-references": {
+      "types": "./dist/css-references.d.ts",
+      "default": "./dist/css-references.js"
     }
   },
   "files": [

package/dist/quick-hash.d.ts

@@ -1,7 +0,0 @@
-/**
- * Inexpensive, non-cryptographic hash used to tell two captures apart.
- * `| 0` keeps the accumulator a 32-bit integer, so overflow wraps like a Java
- * int instead of drifting into floating point. A collision merely skips one
- * frame, which is why this is good enough here and SHA-1 is not needed.
- */
-export declare function quickHash(input: string): string;

package/dist/quick-hash.js

@@ -1,19 +0,0 @@
-/**
- * Multiplier of the polynomial rolling hash, the same one `String.hashCode()`
- * uses in Java. Odd, so no bit is lost to a plain shift on every step; prime,
- * so common inputs spread evenly; and `x * 31` is just `(x << 5) - x`.
- */
-const MULTIPLIER = 31;
-/**
- * Inexpensive, non-cryptographic hash used to tell two captures apart.
- * `| 0` keeps the accumulator a 32-bit integer, so overflow wraps like a Java
- * int instead of drifting into floating point. A collision merely skips one
- * frame, which is why this is good enough here and SHA-1 is not needed.
- */
-export function quickHash(input) {
-    let hash = 0;
-    for (let i = 0; i < input.length; i++) {
-        hash = (hash * MULTIPLIER + input.charCodeAt(i)) | 0;
-    }
-    return `${input.length}:${hash}`;
-}