@acornly/core 0.1.0 → 0.3.0

package/dist/anchoring/profiles.js

@@ -0,0 +1,682 @@
+/**
+ * Site profiles: most sites the generic engine cannot see well need no code of their own, only a
+ * description of where their stable units are (the lines of a diff, keyed by line number). A
+ * profile is that description as plain JSON, read by one built-in anchor provider, `profile`. See
+ * the design doc's "Hard pages in M7 > Anchor providers".
+ *
+ * A profile names the sites it is for (`hosts`, `paths`) and, with CSS selectors only, the units
+ * (`unit`), what each unit's key is read from (`key`) and where its text is (`text`). No profile
+ * field is code or a regular expression, so a profile can be checked (`validateProfile`) and come
+ * from a list the extension did not ship with.
+ *
+ * The provider describes a text selection inside one unit as `{ profile, rev, unit, start, end }`:
+ * the profile's name and revision, the unit's key, and offsets in the unit's normalized text. To
+ * resolve, it finds the unit by key and checks that the offsets still cover the note's stored quote;
+ * when they don't, it looks for the quote in the same unit, then (with `follow`) in the other units,
+ * nearest key first, which is how a note on a line follows it to a newer commit. Anything else is
+ * left to the generic engine: a selection across units, a note without a quote, a page whose units
+ * are not rendered yet.
+ */
+import { normalizeText } from "./normalize.js";
+import { anchorProviders, PROVIDER_NAME, } from "./providers.js";
+export { FIRST_PARTY_PROFILES, GITHUB_DIFF_PROFILE } from "./site-profiles.js";
+/** Longest a profile may be, as JSON text. */
+export const PROFILE_MAX = 16 * 1024;
+/** The name of the provider that reads profiles. */
+export const PROFILE_PROVIDER = "profile";
+/** Longest a unit key may be. */
+const KEY_MAX = 200;
+/** Longest a CSS selector in a profile may be. */
+const SELECTOR_MAX = 500;
+/** Most hosts or paths in a profile. */
+const LIST_MAX = 32;
+/** Most units looked at when following a quote, and candidates normalized. */
+const SCAN_MAX = 20_000;
+const CANDIDATES_MAX = 20;
+/** Longest stretch of a stored prefix or suffix compared with a candidate's surroundings. */
+const CONTEXT_MAX = 32;
+/** Most places of the quote looked at in one unit. */
+const PER_UNIT_MAX = 20;
+/** Default time one resolve may take before it leaves the note to the generic engine: well under
+ * the registry's budget, so no stored value can get the provider turned off for the page. */
+export const PROFILE_RESOLVE_MS = 8;
+/** How many units are scanned between looks at the clock. */
+const CLOCK_EVERY = 16;
+/** How much of the stored surroundings the text inside a unit must agree with to confirm the
+ * stored place by itself. */
+const OWN_ENOUGH = 8;
+/** Most earlier siblings a key part's `prev` looks at. */
+const PREV_MAX = 8;
+const HOST = /^(\*\.)?([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+const ATTR = /^[a-z_][a-z0-9_.:-]{0,63}$/;
+const PATH_SEGMENT = /^[A-Za-z0-9._~!$&'()+,;=:@%-]+$/;
+const PROFILE_KEYS = ["name", "rev", "hosts", "paths", "unit", "key", "text", "follow"];
+const KEY_PART_KEYS = ["closest", "prev", "in", "attr"];
+/** Thrown by `validateProfile` for a malformed profile. */
+export class ProfileError extends TypeError {
+    constructor(message) {
+        super(message);
+        this.name = "ProfileError";
+    }
+}
+/**
+ * Checks a profile and returns a frozen copy of it. Throws a ProfileError for anything but plain
+ * JSON of the shape above within PROFILE_MAX characters: unknown fields, a path pattern that is not
+ * one, a selector that is not valid CSS. Selectors are parsed with `document` (default the global
+ * one); where there is none (a service worker), only their form is checked, and a selector the page
+ * later refuses turns that profile off for the page.
+ */
+export function validateProfile(input, document = globalThis.document) {
+    // Serialized once, and the copy made from that same text: no getter, prototype or later change
+    // reaches what is checked.
+    let json;
+    try {
+        json = JSON.stringify(input);
+    }
+    catch {
+        json = undefined;
+    }
+    if (typeof json !== "string")
+        throw new ProfileError("a site profile must be plain JSON");
+    if (json.length > PROFILE_MAX) {
+        throw new ProfileError(`a site profile must be under ${PROFILE_MAX} characters`);
+    }
+    const p = JSON.parse(json);
+    if (!p || typeof p !== "object" || Array.isArray(p)) {
+        throw new ProfileError("a site profile must be an object");
+    }
+    const name = typeof p.name === "string" ? p.name : "";
+    const fail = (what) => {
+        throw new ProfileError(`site profile "${name}": ${what}`);
+    };
+    for (const k of Object.keys(p))
+        if (!PROFILE_KEYS.includes(k))
+            fail(`unknown field "${k}"`);
+    if (!PROVIDER_NAME.test(name))
+        fail(`name must match ${String(PROVIDER_NAME)}`);
+    if (!Number.isSafeInteger(p.rev) || p.rev < 1)
+        fail("rev must be a positive integer");
+    const hosts = list(p.hosts, "hosts", fail);
+    if (hosts.length === 0)
+        fail("hosts must name at least one host");
+    for (const h of hosts) {
+        if (!HOST.test(h))
+            fail(`"${h}" is not a lower case host name`);
+        // `*.com` would be every site under a top-level domain: a wildcard needs at least two labels.
+        // (A public suffix such as `*.co.uk` still passes: a list from outside the release checks its
+        // wildcards against the public suffix list, which core does not carry.)
+        if (h.startsWith("*.") && h.split(".").length < 3)
+            fail(`"${h}" is too wide a wildcard`);
+    }
+    if (p.paths !== undefined) {
+        const paths = list(p.paths, "paths", fail);
+        if (paths.length === 0)
+            fail("paths, when given, must hold at least one pattern");
+        for (const path of paths)
+            if (!isPathPattern(path))
+                fail(`"${path}" is not a path pattern`);
+    }
+    const selector = (v, field) => checkSelector(v, field, fail, document);
+    selector(p.unit, "unit");
+    if (p.text !== undefined)
+        selector(p.text, "text");
+    if (!Array.isArray(p.key) || p.key.length < 1 || p.key.length > 3) {
+        fail("key must be a list of one to three parts");
+    }
+    for (const part of p.key) {
+        if (!part || typeof part !== "object" || Array.isArray(part))
+            fail("each key part must be an object");
+        const k = part;
+        for (const f of Object.keys(k))
+            if (!KEY_PART_KEYS.includes(f))
+                fail(`unknown key field "${f}"`);
+        if (typeof k.attr !== "string" || !ATTR.test(k.attr))
+            fail("each key part needs an attribute name");
+        for (const f of ["closest", "prev", "in"]) {
+            if (k[f] !== undefined)
+                selector(k[f], `key.${f}`);
+        }
+    }
+    if (p.follow !== undefined && typeof p.follow !== "boolean")
+        fail("follow must be true or false");
+    return deepFreeze(p);
+}
+function list(v, field, fail) {
+    if (!Array.isArray(v) || v.length > LIST_MAX || v.some((s) => typeof s !== "string")) {
+        fail(`${field} must be a list of at most ${LIST_MAX} strings`);
+    }
+    return v;
+}
+/** Fails unless `v` is a CSS selector `document` accepts. */
+function checkSelector(v, field, fail, document) {
+    if (typeof v !== "string" || !v.trim() || v.length > SELECTOR_MAX) {
+        fail(`${field} must be a CSS selector of at most ${SELECTOR_MAX} characters`);
+    }
+    // A selector cannot run code, but a rule body has no place here, and `:has()` can make one
+    // query cost far more than the provider's time budget before it is measured.
+    // Nor escapes or comments, which could spell a forbidden name (`:\68 as(`, `:/**/has(`).
+    if (/[{}\\]|\/\*/.test(v))
+        fail(`${field} is not a CSS selector`);
+    if (/:has\s*\(/i.test(v))
+        fail(`${field} may not use :has()`);
+    if (!document)
+        return;
+    try {
+        document.createDocumentFragment().querySelector(v);
+    }
+    catch {
+        fail(`${field} is not a valid CSS selector`);
+    }
+}
+function isPathPattern(path) {
+    if (!path.startsWith("/") || path.length > 200)
+        return false;
+    const segments = path.slice(1).split("/");
+    return segments.every((s, i) => s === "*" ||
+        (s === "**" && i === segments.length - 1) ||
+        (s !== "**" && PATH_SEGMENT.test(s)));
+}
+function deepFreeze(v) {
+    if (v && typeof v === "object") {
+        for (const child of Object.values(v))
+            deepFreeze(child);
+        Object.freeze(v);
+    }
+    return v;
+}
+/** Whether `profile` is for this URL. */
+export function profileMatches(profile, url) {
+    if (url.protocol !== "https:" && url.protocol !== "http:")
+        return false;
+    const host = url.hostname.toLowerCase();
+    const hostOk = profile.hosts.some((h) => h.startsWith("*.") ? host.endsWith(h.slice(1)) && host.length > h.length - 1 : host === h);
+    if (!hostOk)
+        return false;
+    if (!profile.paths)
+        return true;
+    const segments = url.pathname.replace(/\/+$/, "").slice(1).split("/");
+    return profile.paths.some((pattern) => pathMatches(pattern, segments));
+}
+function pathMatches(pattern, segments) {
+    const parts = pattern.replace(/\/+$/, "").slice(1).split("/");
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === "**")
+            return true;
+        const seg = segments[i];
+        if (seg === undefined || seg === "")
+            return false;
+        if (part !== "*" && part !== seg)
+            return false;
+    }
+    return parts.length === segments.length;
+}
+/**
+ * The `profile` provider: reads every profile added to it. The core keeps one for the page
+ * (`profileProvider`, registered by `registerAnchorProfiles`); tests and embedders can make their
+ * own.
+ */
+export class ProfileProvider {
+    name = PROFILE_PROVIDER;
+    version = 1;
+    /** By the object it was added as, so adding the same list again (two SDK instances) is counted. */
+    entries = new Map();
+    now;
+    limitMs;
+    constructor(profiles = [], options = {}) {
+        this.now = options.now ?? (() => performance.now());
+        this.limitMs = options.limitMs ?? PROFILE_RESOLVE_MS;
+        if (profiles.length)
+            this.add(profiles);
+    }
+    /**
+     * Adds profiles; returns a function that removes them. Throws a ProfileError, adding none, for a
+     * malformed profile or another one of the same name. A registry that already asked `matches`
+     * keeps its answer until told otherwise: use `registerAnchorProfiles`, or call the registry's
+     * `rematch` after adding to a registered provider.
+     */
+    add(profiles) {
+        if (!Array.isArray(profiles))
+            throw new ProfileError("site profiles must be a list");
+        const fresh = new Map();
+        const names = new Set(this.profiles.map((p) => p.name));
+        for (const input of profiles) {
+            if (this.entries.has(input) || fresh.has(input))
+                continue;
+            const profile = validateProfile(input);
+            if (names.has(profile.name)) {
+                throw new ProfileError(`a site profile named "${profile.name}" is already added`);
+            }
+            names.add(profile.name);
+            fresh.set(input, profile);
+        }
+        const added = [...new Set(profiles)];
+        for (const input of added) {
+            const entry = this.entries.get(input);
+            if (entry)
+                entry.count++;
+            else
+                this.entries.set(input, { profile: fresh.get(input), count: 1 });
+        }
+        let removed = false;
+        return () => {
+            if (removed)
+                return;
+            removed = true;
+            for (const input of added) {
+                const entry = this.entries.get(input);
+                if (entry && --entry.count === 0)
+                    this.entries.delete(input);
+            }
+        };
+    }
+    /** The profiles added, in the order they were added. */
+    get profiles() {
+        return [...this.entries.values()].map((e) => e.profile);
+    }
+    matches(url) {
+        return this.profiles.some((p) => profileMatches(p, url));
+    }
+    describe(target, context) {
+        if (!("startContainer" in target))
+            return null;
+        for (const profile of this.profiles) {
+            if (!profileMatches(profile, context.url))
+                continue;
+            const value = this.guard(profile, context, () => describeIn(profile, target, context));
+            if (value)
+                return value;
+        }
+        return null;
+    }
+    resolve(value, _version, context) {
+        const v = asValue(value);
+        const quote = context.quote;
+        if (!v || !quote)
+            return null;
+        const profile = this.profiles.find((p) => p.name === v.profile);
+        if (!profile || v.rev > profile.rev || !profileMatches(profile, context.url))
+            return null;
+        return this.guard(profile, context, () => resolveIn(profile, v, context, this.now, this.limitMs));
+    }
+    /** Per document: the profiles whose selectors it refused. */
+    refused = new WeakMap();
+    /**
+     * Runs one profile's work; a selector the page's engine refuses (checked without a DOM, or
+     * syntax this browser lacks) turns only that profile off for the document.
+     */
+    guard(profile, context, fn) {
+        const refused = this.refused.get(context.document);
+        if (refused?.has(profile))
+            return null;
+        try {
+            return fn();
+        }
+        catch (err) {
+            if (err?.name !== "SyntaxError")
+                throw err;
+            if (refused)
+                refused.add(profile);
+            else
+                this.refused.set(context.document, new WeakSet([profile]));
+            return null;
+        }
+    }
+}
+/** The page's profile provider. */
+export const profileProvider = new ProfileProvider();
+/**
+ * Adds site profiles for the page and registers the `profile` provider with the page's providers
+ * (`anchorProviders`). Returns a function that removes them. Throws a ProfileError for a malformed
+ * profile, or another of the same name; nothing is added then.
+ */
+export function registerAnchorProfiles(profiles, providers = anchorProviders) {
+    const remove = profileProvider.add(profiles);
+    let unregister;
+    try {
+        unregister = providers.register(profileProvider);
+    }
+    catch (err) {
+        remove();
+        throw err;
+    }
+    providers.rematch();
+    return () => {
+        remove();
+        unregister();
+        providers.rematch();
+    };
+}
+function asValue(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const v = value;
+    if (typeof v.profile !== "string" || typeof v.unit !== "string" || v.unit.length > KEY_MAX) {
+        return null;
+    }
+    if (!Number.isSafeInteger(v.rev) || v.rev < 1)
+        return null;
+    if (!Number.isSafeInteger(v.start) || !Number.isSafeInteger(v.end))
+        return null;
+    if (v.start < 0 || v.end <= v.start)
+        return null;
+    return v;
+}
+/** The unit's key, or null when one of its parts is missing. */
+function keyOf(profile, unit) {
+    const parts = [];
+    for (const part of profile.key) {
+        let el = unit;
+        if (part.closest)
+            el = el.closest(part.closest);
+        if (el && part.prev) {
+            // A few steps at most: a profile whose `prev` matches nothing must not walk a long list
+            // once per unit.
+            let sib = el.previousElementSibling;
+            for (let n = 1; sib && !sib.matches(part.prev); n++) {
+                sib = n < PREV_MAX ? sib.previousElementSibling : null;
+            }
+            el = sib;
+        }
+        if (el && part.in)
+            el = el.querySelector(part.in);
+        const value = el?.getAttribute(part.attr);
+        if (!value)
+            return null;
+        parts.push(value);
+    }
+    const key = parts.join(":");
+    return key.length <= KEY_MAX ? key : null;
+}
+function textOf(profile, unit) {
+    return profile.text ? unit.querySelector(profile.text) : unit;
+}
+/** The unit holding `node`, inside the root. */
+function unitAround(profile, node, root) {
+    const el = node.nodeType === 1 ? node : node.parentElement;
+    const unit = el?.closest(profile.unit) ?? null;
+    if (!unit)
+        return null;
+    if (root.nodeType === 1 && !root.contains(unit))
+        return null;
+    return unit;
+}
+function describeIn(profile, range, context) {
+    const unit = unitAround(profile, range.startContainer, context.root);
+    if (!unit || unitAround(profile, range.endContainer, context.root) !== unit)
+        return null;
+    const textEl = textOf(profile, unit);
+    const key = textEl && keyOf(profile, unit);
+    if (!key)
+        return null;
+    // An end outside the text (a selection from the line's number cell) is clamped to it.
+    const text = normalizeText(textEl);
+    let { start, end } = text.offsetsFromRange(range);
+    // Trimmed as the generic quote is, so the two hold the same text.
+    while (start < end && text.text[start] === " ")
+        start++;
+    while (end > start && text.text[end - 1] === " ")
+        end--;
+    if (start >= end)
+        return null;
+    return { profile: profile.name, rev: profile.rev, unit: key, start, end };
+}
+/** Thrown inside a resolve that ran out of time. */
+const OUT_OF_TIME = Symbol("out of time");
+function resolveIn(profile, v, context, now, limitMs) {
+    const quote = context.quote;
+    const deadline = now() + limitMs;
+    const tick = (i) => {
+        if (i % CLOCK_EVERY === 0 && now() > deadline)
+            throw OUT_OF_TIME;
+    };
+    const units = context.root.querySelectorAll(profile.unit);
+    const count = Math.min(units.length, SCAN_MAX);
+    /** The stored place when nothing better was found: confirmed by the text inside its unit. */
+    let keep = () => null;
+    try {
+        // A key from an older revision of the profile may mean something else now: only its quote is
+        // followed.
+        let keyed = -1;
+        if (v.rev === profile.rev) {
+            for (let i = 0; i < count; i++) {
+                tick(i);
+                if (keyOf(profile, units[i]) === v.unit) {
+                    keyed = i;
+                    break;
+                }
+            }
+        }
+        const raw = new Map();
+        const textAt = (i) => {
+            let t = raw.get(i);
+            if (t === undefined)
+                raw.set(i, (t = rawText(profile, units[i])));
+            return t;
+        };
+        const elAt = (i) => textOf(profile, units[i]);
+        const prefix = (context.prefix ?? "").slice(-CONTEXT_MAX);
+        const suffix = (context.suffix ?? "").slice(0, CONTEXT_MAX);
+        const stored = prefix.length + suffix.length;
+        /** The least agreement a place other than the stored one needs: half the stored surroundings. */
+        const least = Math.ceil(stored / 2);
+        const places = [];
+        const texts = new Map();
+        /** Every place of the quote in a unit, scored by how well its surroundings agree with the
+         * stored prefix and suffix. */
+        const placesIn = (index, distance) => {
+            const textEl = textOf(profile, units[index]);
+            if (!textEl)
+                return;
+            // Built afresh: the page may have changed since a cached one was built.
+            const text = normalizeText(textEl);
+            texts.set(index, text);
+            let found = 0;
+            for (let at = text.text.indexOf(quote); at >= 0 && found < PER_UNIT_MAX; at = text.text.indexOf(quote, at + 1)) {
+                found++;
+                const before = around(textAt, elAt, count, index, -1, text.text.slice(0, at), prefix.length);
+                const after = around(textAt, elAt, count, index, 1, text.text.slice(at + quote.length), suffix.length);
+                const p = agree(prefix, before, -1);
+                const q = agree(suffix, after, 1);
+                const ownBefore = text.text.slice(0, at);
+                const ownAfter = text.text.slice(at + quote.length);
+                places.push({
+                    index,
+                    at,
+                    score: p + q,
+                    full: stored > 0 &&
+                        p === Math.min(prefix.length, before.length) &&
+                        q === Math.min(suffix.length, after.length),
+                    own: ownAgreement(prefix, suffix, ownBefore, ownAfter),
+                    stored: index === keyed && at === v.start,
+                    distance,
+                });
+            }
+        };
+        const answer = (place, confidence) => {
+            const ranges = texts.get(place.index).rangesFromOffsets(place.at, place.at + quote.length);
+            return ranges && ranges.length ? { ranges, confidence } : null;
+        };
+        // The common case: the stored unit still holds the quote where it was, in the same
+        // surroundings.
+        let likely;
+        if (keyed >= 0) {
+            placesIn(keyed, -1);
+            const same = places.find((p) => p.stored && p.full);
+            if (same)
+                return answer(same, 1);
+            // In the same text inside its unit, when there is enough of it to tell: kept unless another
+            // place fits the stored surroundings better (the same line, moved, with a copy now in its
+            // place).
+            likely = places.find((p) => p.stored && (p.own >= Math.min(OWN_ENOUGH, stored) || stored === 0));
+            if (likely && !profile.follow)
+                return answer(likely, 1);
+            if (likely) {
+                const stored = likely;
+                keep = () => answer(stored, 1);
+            }
+        }
+        // Otherwise, with `follow`, the nearest other units whose raw text has the quote's words: each
+        // distance worked out once, only the nearest kept.
+        if (profile.follow) {
+            const nearest = [];
+            const words = quote.split(" ");
+            for (let i = 0; i < count; i++) {
+                tick(i);
+                if (i === keyed || !hasWords(textAt(i), words))
+                    continue;
+                const key = keyOf(profile, units[i]);
+                if (!key)
+                    continue;
+                const distance = keyDistance(key, v.unit);
+                const last = nearest[nearest.length - 1];
+                if (nearest.length === CANDIDATES_MAX && distance >= last.distance)
+                    continue;
+                let j = nearest.length;
+                while (j > 0 && nearest[j - 1].distance > distance)
+                    j--;
+                nearest.splice(j, 0, { index: i, distance });
+                if (nearest.length > CANDIDATES_MAX)
+                    nearest.pop();
+            }
+            for (const [n, { index, distance }] of nearest.entries()) {
+                tick(n * CLOCK_EVERY);
+                placesIn(index, distance);
+            }
+        }
+        if (likely && !places.some((p) => p !== likely && p.full && p.score > likely.score)) {
+            return answer(likely, 1);
+        }
+        if (places.length === 0)
+            return null;
+        places.sort((a, b) => b.score - a.score ||
+            Number(b.stored) - Number(a.stored) ||
+            a.distance - b.distance ||
+            Math.abs(a.at - v.start) - Math.abs(b.at - v.start));
+        const best = places[0];
+        const tied = places.length > 1 && places[1].score === best.score;
+        // A note stored without any surroundings moves only to the one place holding its quote.
+        if (stored === 0)
+            return places.length === 1 ? answer(best, 0.8) : null;
+        // Too little of what was around the note is around this place: an unrelated line holding the
+        // same short text (`}`). The generic engine decides, and may leave the note unplaced.
+        if (best.score < least)
+            return keep();
+        // Another place whose surroundings agree with the stored ones, and nothing else as well.
+        if (best.full && !tied)
+            return answer(best, 0.95);
+        // Most of the surroundings agree and nothing agrees better: shown as approximate. (The stored
+        // place, unconfirmed above, is left to the generic engine, which reads the page's own text.)
+        if (!tied && !best.stored)
+            return answer(best, 0.8);
+        // Several places fit as well as each other: the generic engine, which reads the whole page's
+        // text, decides.
+        return keep();
+    }
+    catch (err) {
+        if (err === OUT_OF_TIME)
+            return keep();
+        throw err;
+    }
+}
+/** A unit's text as the DOM has it, with whitespace collapsed and invisible characters removed
+ * (normalization rules 3 and 5): cheap, close to the normalized text. */
+function rawText(profile, unit) {
+    return collapse(textOf(profile, unit)?.textContent ?? "");
+}
+/** Whether `raw` holds the words in order. */
+function hasWords(raw, words) {
+    let from = 0;
+    for (const w of words) {
+        const at = raw.indexOf(w, from);
+        if (at < 0)
+            return false;
+        from = at + w.length;
+    }
+    return true;
+}
+/**
+ * The text before (`dir` -1) or after (1) a place, at least `want` characters when the page has
+ * them: `own` from its unit, then each neighbouring unit's text with whatever the page shows
+ * between the two (a diff's hunk header), whitespace collapsed as the normalized text has it.
+ */
+function around(textAt, elAt, count, index, dir, own, want) {
+    let text = own;
+    let inner = elAt(index);
+    for (let i = index + dir, n = 0; text.length < want && n < 8 && i >= 0 && i < count && inner; i += dir, n++) {
+        const el = elAt(i);
+        if (!el)
+            break;
+        const gap = dir < 0 ? between(el, inner, -1) : between(inner, el, 1);
+        const t = textAt(i);
+        text = dir < 0 ? `${t} ${gap} ${text}` : `${text} ${gap} ${t}`;
+        text = text.replace(/ {2,}/g, " ");
+        inner = el;
+    }
+    return text;
+}
+/** Most characters of the page between two units read. */
+const BETWEEN_MAX = 200;
+/** The text the page has between the end of `a` and the start of `b`, whitespace collapsed: at
+ * most BETWEEN_MAX characters, those nearest the place (`near` -1 means nearest `b`). */
+function between(a, b, near) {
+    const range = a.ownerDocument.createRange();
+    try {
+        range.setStart(a, a.childNodes.length);
+        range.setEnd(b, 0);
+    }
+    catch {
+        return "";
+    }
+    if (range.collapsed)
+        return "";
+    const text = collapse(range.toString());
+    return near < 0 ? text.slice(-BETWEEN_MAX) : text.slice(0, BETWEEN_MAX);
+}
+function collapse(text) {
+    return text
+        .replace(/[\u00AD\u200B\u2060\uFEFF]/g, "")
+        .replace(/[\s\u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]+/g, " ")
+        .trim();
+}
+/** How much of the stored prefix and suffix the text beside a place in its unit agrees with, or
+ * -1 when any of that text disagrees. */
+function ownAgreement(prefix, suffix, before, after) {
+    const p = agree(prefix, before, -1);
+    const q = agree(suffix, after, 1);
+    const whole = p === Math.min(prefix.length, before.length) && q === Math.min(suffix.length, after.length);
+    return whole ? p + q : -1;
+}
+/** How many characters of `stored` agree with `seen`, counted from the place outwards. */
+function agree(stored, seen, dir) {
+    const n = Math.min(stored.length, seen.length);
+    let k = 0;
+    while (k < n &&
+        (dir < 0 ? stored[stored.length - 1 - k] === seen[seen.length - 1 - k] : stored[k] === seen[k])) {
+        k++;
+    }
+    return k;
+}
+/**
+ * How far one key is from another. A key is a stem and a trailing number (`diff-…R151`, or just
+ * `151`): keys whose stems share a longer start (the same file and side of a diff) are nearer, then
+ * those whose numbers (line numbers) are closer.
+ */
+function keyDistance(a, b) {
+    const [stemA, numA] = splitKey(a);
+    const [stemB, numB] = splitKey(b);
+    let common = 0;
+    while (common < stemA.length && common < stemB.length && stemA[common] === stemB[common])
+        common++;
+    if (common === stemA.length && common === stemB.length)
+        common = KEY_MAX;
+    const gap = numA === null || numB === null ? GAP_MAX : Math.min(Math.abs(numA - numB), GAP_MAX);
+    // Every character of shared stem outranks any gap between numbers.
+    return (KEY_MAX - common) * (GAP_MAX + 1) + gap;
+}
+const GAP_MAX = 1e7;
+function splitKey(key) {
+    const m = /^(.*?)(\d{1,9})$/.exec(key);
+    return m ? [m[1], Number(m[2])] : [key, null];
+}
+//# sourceMappingURL=profiles.js.map