flea-qml 0.0.0-stage → 0.2.0

package/ui/js/ColumnsCarry.js

@@ -0,0 +1,103 @@
+.pragma library
+.import "Columns.js" as Columns
+.import "FolderSorts.js" as FolderSorts
+.import "Format.js" as Format
+
+// Navigations carry answered peeks across a listing and refresh them without clearing drawn rows.
+
+// A peek answers at most this many rows, src/backend/peek.rs PEEK_CAP.
+var PEEK_CAP = 512
+
+// The folder order a column asks under, as the tag its peek key and reply carry.
+// Sample input: orderOf({ folderSorts: {}, rememberSort: true }, "/a", []) is "" for a folder with no order of its own.
+function orderOf(state, path, drawn, newest) {
+    var order = FolderSorts.peekOrder(state.folderSorts, path, state.rememberSort, drawn, newest, state.sort)
+    return Columns.orderTag(order.by, order.desc)
+}
+
+// A read of the peeked rows that a binding re-evaluates when a peek lands; version is the trigger.
+function rowsFor(peeked, key, path, version) {
+    return version >= 0 && path.length > 0 && peeked[key] ? peeked[key] : []
+}
+
+// -1 for a path that was not denied, so mode 0, the denial whose stat failed too, stays its own answer.
+function deniedMode(denials, key, version) {
+    return version >= 0 && denials[key] !== undefined ? denials[key] : -1
+}
+
+// What a drag from a peek column's row needs. Sample input: peekSource(pane, "/a", { "/a": { v: 7, w: false } }, 0).
+function peekSource(pane, path, facts, version) {
+    var held = version >= 0 ? facts[path] : undefined
+    return path.length > 0 ? { pane: pane, dir: path, v: held ? held.v : 0, w: held ? held.w : true } : null
+}
+
+// True when the target is the parent of the shown path: the one hop whose child is the folder left.
+// Sample input: isBack("/a/b/c", "/a/b") is true, isBack("/a/b", "/a/b/c") and isBack("/", "/") are false.
+function isBack(here, target) {
+    return String(target) !== String(here) && String(target) === Columns.ancestorParent(here)
+}
+
+// A peek sorts name-first with folders first, so the listing must match that order exactly.
+// Sample input: sameOrder({ by: "name", desc: false, foldersFirst: true, groupByKind: false }, "") is true.
+function sameOrder(list, tag) {
+    return list.by === "name" && list.desc !== true && list.foldersFirst !== false && list.groupByKind !== true
+        && (tag === "" || tag === "name0")
+}
+
+// The held window as peek rows; a link or an executable seeds nothing, shaped differently in a peek.
+// Sample input: peekRows([{ n: "a", d: false, i: "text-x-generic", s: 1 }], 1).
+function peekRows(rows, count) {
+    var out = []
+    for (var i = 0; i < count; i++) {
+        var row = rows[i]
+        if (!row || row.l !== undefined || (Number(row.p) & Format.S_IFMT) === Format.S_IFLNK || (row.d !== true && row.i === "application-x-executable"))
+            return null
+        out.push({ n: row.n, d: row.d === true, i: row.i })
+    }
+    return out
+}
+
+// A navigation plan, or null before the first listing has anything to carry.
+// Sample input: plan(area at "/a/b/c" listing "/a/b", ["/a"], { foldersFirst: true, groupByKind: false }).pre is ["/a"].
+function plan(area, asks, state) {
+    var p = area.pane, here = p.path, target = p.listingPath
+    if (!here || !target)
+        return null
+    var tag = area.orderOf(here), count = Math.min(p.windowSize, PEEK_CAP, p.total)
+    var list = { by: p.backend.sortBy, desc: p.backend.sortDesc, foldersFirst: state.foldersFirst, groupByKind: state.groupByKind }
+    var clean = p.held === 0 && p.filterQuery === "" && p.searchMode === "" && p.rows.length >= count && sameOrder(list, tag)
+    return { target: target, seed: here, tag: tag, pre: asks.filter(function (path) { return path !== target && path !== here }),
+             rows: clean ? peekRows(p.rows, count) : null, facts: { v: p.backend.dirDev || 0, w: p.backend.dirWritable !== false } }
+}
+
+// A landing keeps answered drawn folders under the same key and order, plus the old third while its replacement waits.
+function landing(carry, area, asks) {
+    var next = { peeked: {}, denials: {}, orders: {}, facts: {}, pending: {} }
+    if (!carry || carry.target !== area.pane.path)
+        return next
+    var paths = asks.slice()
+    if (area.shownChildPath && paths.indexOf(area.shownChildPath) < 0) paths.push(area.shownChildPath)
+    for (var i = 0; i < paths.length; i++) {
+        var path = paths[i], key = area.peekKey(path)
+        if (area.peeked[key] === undefined || area.peekOrders[key] !== area.orderOf(path))
+            continue
+        next.peeked[key] = area.peeked[key]
+        next.orders[key] = area.peekOrders[key]
+        if (area.denials[key] !== undefined) next.denials[key] = area.denials[key]
+        if (area.peekFacts[path] !== undefined) next.facts[path] = area.peekFacts[path]
+    }
+    var seedKey = area.peekKey(carry.seed), seedTag = area.orderOf(carry.seed)
+    if ((asks.indexOf(carry.seed) >= 0 || isBack(carry.seed, carry.target))
+            && carry.rows !== null && carry.tag === seedTag && next.peeked[seedKey] === undefined) {
+        next.peeked[seedKey] = carry.rows
+        next.orders[seedKey] = seedTag
+        next.facts[carry.seed] = carry.facts
+    }
+    if (asks.indexOf(carry.seed) >= 0 || isBack(carry.seed, carry.target)) paths.push(carry.seed)
+    // A watched refresh already out must still land after navigation, even when its folder's settled rows are kept.
+    for (var path of paths) {
+        var sent = Columns.sentKey(area.peekKey(path), area.pane.windowSize, area.orderOf(path))
+        if (Columns.hasAsk(area.pending, sent)) next.pending[sent] = area.pending[sent]
+    }
+    return next
+}

package/ui/js/Compare.js

@@ -0,0 +1,74 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "CopyAs.js" as CopyAs
+.import "Ops.js" as Ops
+
+// The Compare overlay's text and rows: ui/CompareView.qml draws what these return and keeps no wording of its own.
+
+// The board's sentences for a pair with no patch, by the backend's state (src/backend/compare.rs).
+var SENTENCES = {
+    identical: "The two files are identical.",
+    binary: "These files are binary, so there is nothing to compare.",
+    over: "These files are over 1 MiB, too large to compare.",
+    failed: "These files could not be compared."
+}
+
+var HUNK = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+
+function sentence(state) {
+    return SENTENCES[state] || ""
+}
+
+// Fills %1, %2 ... in one pass, so a file name holding "%2" is never read as a placeholder.
+function fill(template, values) {
+    return template.replace(/%(\d)/g, function (whole, n) { return values[Number(n) - 1] })
+}
+
+// "notes-a.md and notes-b.md · 12 lines differ" with a patch; without one, the two names alone.
+// Sample input: title("a.md", "b.md", 1) gives "a.md and b.md · 1 line differs".
+function title(nameA, nameB, differing) {
+    if (differing === undefined || differing === null)
+        return fill("%1 and %2", [nameA, nameB])
+    var count = fill(Ops.pluralWord(differing, "%1 line differs", "%1 lines differ"), [Format.count(differing)])
+    return fill("%1 and %2 · %3", [nameA, nameB, count])
+}
+
+// What diff -u prints, as the rows the overlay draws; the --- and +++ lines are the copied patch's, not rows.
+// Sample input: "--- a\n+++ b\n@@ -1,2 +1,2 @@\n x\n-y\n+z\n" gives a hunk row, a context row 1/1, a removed row 2/0 and an added row 0/2.
+function rows(patch) {
+    var out = [], oldAt = 0, newAt = 0, inHunk = false
+    var lines = String(patch).split("\n")
+    if (lines[lines.length - 1] === "")
+        lines.pop()
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i], head = HUNK.exec(line)
+        if (head) {
+            oldAt = Number(head[1])
+            newAt = Number(head[3])
+            inHunk = true
+            out.push({ kind: "hunk", oldNo: 0, newNo: 0, text: line })
+        } else if (!inHunk) {
+            continue
+        } else if (line.charAt(0) === "-") {
+            out.push({ kind: "removed", oldNo: oldAt++, newNo: 0, text: line.substring(1) })
+        } else if (line.charAt(0) === "+") {
+            out.push({ kind: "added", oldNo: 0, newNo: newAt++, text: line.substring(1) })
+        } else if (line.charAt(0) === "\\") {
+            out.push({ kind: "note", oldNo: 0, newNo: 0, text: line })
+        } else {
+            out.push({ kind: "context", oldNo: oldAt++, newNo: newAt++, text: line.substring(1) })
+        }
+    }
+    return out
+}
+
+// The removed plus added lines, which is what the title counts.
+function changed(rowList) {
+    return rowList.filter(function (r) { return r.kind === "removed" || r.kind === "added" }).length
+}
+
+// The file name a title shows for a path.
+function leaf(path) {
+    return CopyAs.leaf(path)
+}

package/ui/js/Contrast.js

@@ -0,0 +1,157 @@
+.pragma library
+
+// WCAG 2.1 relative luminance, so a test can assert a ratio rather than an eye judging a screenshot.
+function channel(c) {
+    return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4)
+}
+
+function luminance(r, g, b) {
+    return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b)
+}
+
+// Sample input: "#c8ccd0"
+function parse(hex) {
+    var s = String(hex).replace("#", "")
+    if (s.length === 8)
+        s = s.substring(2)
+    return [parseInt(s.substr(0, 2), 16) / 255,
+            parseInt(s.substr(2, 2), 16) / 255,
+            parseInt(s.substr(4, 2), 16) / 255]
+}
+
+function over(fg, alpha, bg) {
+    var f = parse(fg)
+    var b = parse(bg)
+    return [f[0] * alpha + b[0] * (1 - alpha),
+            f[1] * alpha + b[1] * (1 - alpha),
+            f[2] * alpha + b[2] * (1 - alpha)]
+}
+
+function ratioOf(a, b) {
+    var la = luminance(a[0], a[1], a[2])
+    var lb = luminance(b[0], b[1], b[2])
+    var hi = Math.max(la, lb)
+    var lo = Math.min(la, lb)
+    return (hi + 0.05) / (lo + 0.05)
+}
+
+function ratio(fgHex, bgHex) {
+    return ratioOf(parse(fgHex), parse(bgHex))
+}
+
+function pad2(n) {
+    return n < 16 ? "0" + n.toString(16) : n.toString(16)
+}
+
+function hexOf(rgb) {
+    return "#" + pad2(Math.round(Math.max(0, Math.min(1, rgb[0])) * 255))
+            + pad2(Math.round(Math.max(0, Math.min(1, rgb[1])) * 255))
+            + pad2(Math.round(Math.max(0, Math.min(1, rgb[2])) * 255))
+}
+
+function mix(a, b, t) {
+    return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t]
+}
+
+// Keep hue; walk lightness toward black or white until WCAG AA (or minRatio) holds.
+function ensureRatio(fgHex, bgHex, minRatio) {
+    var need = minRatio > 0 ? minRatio : 4.5
+    if (ratio(fgHex, bgHex) >= need)
+        return String(fgHex)
+    var fg = parse(fgHex)
+    var bg = parse(bgHex)
+    var toward = luminance(bg[0], bg[1], bg[2]) > 0.179 ? [0, 0, 0] : [1, 1, 1]
+    var lo = 0
+    var hi = 1
+    var best = toward
+    for (var i = 0; i < 18; i++) {
+        var mid = (lo + hi) / 2
+        var cand = mix(fg, toward, mid)
+        if (ratioOf(cand, bg) >= need) {
+            best = cand
+            hi = mid
+        } else {
+            lo = mid
+        }
+    }
+    if (ratioOf(best, bg) < need)
+        best = toward
+    return stepped(hexOf(best), bgHex, need, toward)
+}
+
+// Rounding to 8 bits can land just under the ratio asked for, 2.99 for 3 on 20 of the 22 stock palettes.
+function stepped(hex, bgHex, need, toward) {
+    var c = parse(hex)
+    var step = toward[0] > 0.5 ? 1 / 255 : -1 / 255
+    var bg = parse(bgHex)
+    for (var i = 0; i < 255; i++) {
+        if (ratioOf(c, bg) >= need)
+            break
+        // Each channel clamps on its own, so one already at the extreme cannot carry the others out.
+        var next = [clamp(c[0] + step), clamp(c[1] + step), clamp(c[2] + step)]
+        // A step that moves no channel at all is the extreme itself, and there is nowhere further to go.
+        if (hexOf(next) === hexOf(c))
+            break
+        c = next
+    }
+    return hexOf(c)
+}
+
+function clamp(v) {
+    return v < 0 ? 0 : (v > 1 ? 1 : v)
+}
+
+// The seven tag names, member for member with src/backend/tags.rs NAMES and ui/js/Tags.js NAMES.
+var TAG_NAMES = ["Red", "Orange", "Yellow", "Green", "Blue", "Purple", "Gray"];
+var TAG_ROLES = { Red: "red", Orange: "orange", Yellow: "yellow", Green: "green",
+                  Blue: "blue", Purple: "magenta", Gray: "dark_foreground" };
+var TAG_HUES = { Red: [335, 12], Orange: [8, 45], Yellow: [28, 70],
+                 Green: [80, 170], Blue: [195, 255], Purple: [250, 335] };
+
+// Each role lifted to 3:1 on the listing ground and the menu ground, plus the digit fallback, decided once per theme load.
+function tagTheme(found, bg, surface) {
+    var colors = {};
+    var menuColors = {};
+    var seen = {};
+    var fallback = false;
+    for (var i = 0; i < TAG_NAMES.length; i++) {
+        var name = TAG_NAMES[i];
+        var hex = (found || {})[TAG_ROLES[name]] || "";
+        if (!hex) {
+            fallback = true;
+        } else {
+            var key = String(hex).toLowerCase();
+            if (seen[key]) fallback = true;
+            seen[key] = true;
+        }
+        colors[name] = hex ? ensureRatio(hex, bg, 3) : "";
+        menuColors[name] = hex ? ensureRatio(hex, surface, 3) : "";
+        if (name !== "Gray" && hex) {
+            var rgb = parse(hex);
+            var hi = Math.max(rgb[0], rgb[1], rgb[2]);
+            var lo = Math.min(rgb[0], rgb[1], rgb[2]);
+            // Almost no chroma is a grey whatever its name claims.
+            if (hi === 0 || (hi - lo) / hi < 0.12) fallback = true;
+            else if (!tagHueHolds(rgb, TAG_HUES[name])) fallback = true;
+        }
+    }
+    return { colors: colors, menuColors: menuColors, fallback: fallback };
+}
+
+// A hue inside a window that wraps past red, so one comparison covers both ends.
+function tagHueHolds(rgb, window) {
+    var hi = Math.max(rgb[0], rgb[1], rgb[2]);
+    var lo = Math.min(rgb[0], rgb[1], rgb[2]);
+    var delta = hi - lo;
+    var hue = 0;
+    if (delta > 0) {
+        if (hi === rgb[0]) {
+            hue = 60 * (((rgb[1] - rgb[2]) / delta + 6) % 6);
+        } else if (hi === rgb[1]) {
+            hue = 60 * ((rgb[2] - rgb[0]) / delta + 2);
+        } else {
+            hue = 60 * ((rgb[0] - rgb[1]) / delta + 4);
+        }
+    }
+    return window[0] <= window[1] ? hue >= window[0] && hue <= window[1] : hue >= window[0] || hue <= window[1];
+}

package/ui/js/ControlReader.js

@@ -0,0 +1,42 @@
+.pragma library
+
+// Sample input: read(window, window.contentItem, /^(DialogButton)_QML/, {}) === {focus: {kind: "DialogButton", via: "owner", ...}, controls: [{kind: "DialogButton", name: "Open", x: 900, ...}]}.
+// The cohesion captures' reader, shared by the window and the picker: every visible control that draws focus, its window box and its states.
+function read(quick, top, kinds, alias) {
+    var out = []
+    function kindOf(item) { var m = String(item).match(kinds); return m ? (alias[m[1]] || m[1]) : "" }
+    function pointerFlag(item, name) {
+        if (item[name] !== undefined) return item[name]
+        var handler = name === "hovered" ? "QQuickHoverHandler" : "QQuickTapHandler"
+        var data = item.data || []
+        for (var i = 0; i < data.length; i++)
+            if (data[i] && String(data[i]).indexOf(handler) === 0) return data[i][name]
+        return undefined
+    }
+    function entry(item, kind, via) {
+        var p = item.mapToItem(null, 0, 0)
+        var hovered = pointerFlag(item, "hovered"), pressed = pointerFlag(item, "pressed")
+        return {kind: kind, name: String(item.label || item.accessName || item.title || item.objectName || item.name || item.glyph || ""),
+            x: Math.round(p.x), y: Math.round(p.y), w: Math.round(item.width), h: Math.round(item.height),
+            focused: !!(item.activeFocus || item.focused === true || item.keyboardFocused === true),
+            hovered: hovered === true, pressed: pressed === true,
+            hoverable: hovered !== undefined, pressable: pressed !== undefined,
+            enabled: !!item.enabled && item.available !== false && item.inputLive !== false,
+            value: item.value !== undefined ? String(item.value) : "",
+            primary: item.primary === true, destructive: item.destructive === true, member: item.setMember === true, via: via}
+    }
+    function walk(item) {
+        if (!item || !item.visible || item.opacity <= 0) return
+        var kind = kindOf(item)
+        if (kind) out.push(entry(item, kind, ""))
+        for (var i = 0; i < item.children.length; i++) walk(item.children[i])
+    }
+    walk(top)
+    var item = quick ? quick.activeFocusItem : null, owner = item
+    while (owner && !kindOf(owner)) owner = owner.parent
+    // A dialog that keeps the keyboard on its own scope names its focused control through that control's focused flag.
+    var focus = owner ? entry(owner, kindOf(owner), "owner") : null
+    for (var j = 0; !focus && j < out.length; j++) if (out[j].focused) focus = Object.assign({}, out[j], {via: "flag"})
+    if (!focus && item) focus = entry(item, String(item).split("(")[0], "item")
+    return JSON.stringify({focus: focus, controls: out})
+}

package/ui/js/Convert.js

@@ -0,0 +1,52 @@
+.pragma library
+
+// The convert popup's own two decisions: which format, and whether to strip. The destination name is
+// built here because the popup is what decides it; the wire carries no format field at all, since
+// ImageMagick reads the codec off the destination's extension.
+
+// What the popup offers. Every one of these is in this box's ImageMagick delegate list.
+var FORMATS = ["jpg", "png", "webp", "avif", "heic", "tiff", "bmp"]
+
+// The canvas's own suffixes: a real conversion is "(converted)", a same-format strip is "(stripped)".
+var CONVERTED = "(converted)"
+var STRIPPED = "(stripped)"
+
+function extensionOf(name) {
+    var cut = String(name).lastIndexOf(".")
+    return cut > 0 ? String(name).substring(cut + 1).toLowerCase() : ""
+}
+
+function stemOf(name) {
+    var cut = String(name).lastIndexOf(".")
+    return cut > 0 ? String(name).substring(0, cut) : String(name)
+}
+
+// Never the file it came from: an interrupted in-place strip destroys the file it was given, so no
+// in-place option is offered at all.
+function destName(name, format) {
+    var want = String(format).replace(/^\./, "").toLowerCase()
+    var word = want === extensionOf(name) ? STRIPPED : CONVERTED
+    return stemOf(name) + " " + word + "." + want
+}
+
+// The format row that starts selected: the canvas shows JPEG picked on a PNG, so it is the first
+// format that is not the one the file already is.
+function defaultFormat(name) {
+    var current = extensionOf(name)
+    for (var i = 0; i < FORMATS.length; i++) {
+        if (FORMATS[i] !== current) {
+            return FORMATS[i]
+        }
+    }
+    return FORMATS[0]
+}
+
+function destination(source, format) {
+    var parent = source.path.substring(0, source.path.lastIndexOf("/") + 1)
+    return parent + destName(source.name, format)
+}
+
+function matchesReply(source, requestId, reply) {
+    return source !== null && reply.requestId === requestId
+            && reply.source === source.path
+}

package/ui/js/CopyAs.js

@@ -0,0 +1,52 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// Sample input: "/home/gm/archive.tar.gz"; every Copy as variant covers the
+// whole selection, one path per line, as plain text.
+function leaf(path) {
+    var text = String(path)
+    var cut = text.lastIndexOf("/")
+    return cut < 0 ? text : text.substring(cut + 1)
+}
+
+// Sample input: "/home/gm/archive.tar.gz" -> "archive.tar"; a dotfile keeps
+// its whole name, so ".bashrc" never becomes an empty stem.
+function stem(path) {
+    var name = leaf(path)
+    var start = name.charAt(0) === "." ? 1 : 0
+    var dot = name.lastIndexOf(".")
+    if (dot <= start)
+        return name
+    return name.substring(0, dot)
+}
+
+// Sample input: "/home/gm/a.txt" -> "/home/gm"; "/" stays "/".
+function dirpath(path) {
+    var text = String(path)
+    var cut = text.lastIndexOf("/")
+    if (cut < 0)
+        return text
+    return cut === 0 ? "/" : text.substring(0, cut)
+}
+
+function one(path, kind) {
+    if (kind === "name")
+        return leaf(path)
+    if (kind === "stem")
+        return stem(path)
+    if (kind === "dirpath")
+        return dirpath(path)
+    if (kind === "uri")
+        return Format.fileUri(String(path))
+    if (kind === "quoted")
+        return "'" + String(path).split("'").join("'\\''") + "'"
+    return String(path)
+}
+
+function lines(paths, kind) {
+    var out = []
+    for (var i = 0; i < paths.length; i++)
+        out.push(one(paths[i], kind))
+    return out.join("\n")
+}

package/ui/js/Crumbs.js

@@ -0,0 +1,178 @@
+.pragma library
+
+// The chrome's breadcrumb: one path as the pieces a click can land on, and what fits when the bar is
+// narrower than the path. Split out of ui/js/Nav.js, which walks the tree; this only draws where it is.
+
+// Issue 45: the chrome's path as the pieces a click can land on. text is what is drawn, including
+// the separator that follows it, so the pieces concatenate to exactly the one line they replace;
+// path is the directory the piece names, which is what ui/ChromeBar.qml hands to pathEntered. The
+// home test is the whole-component one, home itself or home and a separator, which ui/js/Format.js
+// tilde and ui/js/Search.js scopeRoot now both make too: a sibling like /home/gmx is not inside home.
+function crumbs(path, home, rootAlias) {
+    var text = String(path)
+    if (text === "trash:///") return [{ text: text, path: text, last: true }]
+    var aliasRoot = rootAlias ? cleanRoot(rootAlias.path) : ""
+    var aliasLabel = rootAlias ? String(rootAlias.label || "") : ""
+    var aliased = aliasRoot.length > 0 && aliasLabel.length > 0 && inside(text, aliasRoot)
+    if (aliased) {
+        // The label is one crumb even when it holds a "/"; only the real path's suffix adds separators and targets.
+        var aliasedParts = text.substring(aliasRoot.length).split("/").filter(function (part) { return part.length > 0 })
+        var aliasedOut = [{ text: aliasLabel + (aliasedParts.length > 0 ? "/" : ""),
+                            path: aliasRoot, last: false }]
+        var aliasedWalked = aliasRoot
+        for (var a = 0; a < aliasedParts.length; a++) {
+            aliasedWalked += "/" + aliasedParts[a]
+            aliasedOut.push({ text: aliasedParts[a] + "/", path: aliasedWalked, last: false })
+        }
+        var aliasedEnd = aliasedOut[aliasedOut.length - 1]
+        if (aliasedOut.length > 1)
+            aliasedEnd.text = aliasedEnd.text.substring(0, aliasedEnd.text.length - 1)
+        aliasedEnd.last = true
+        return aliasedOut
+    }
+
+    var base = String(home)
+    var inHome = base.length > 0 && inside(text, base)
+    var display = inHome ? "~" + text.substring(base.length) : text
+    var parts = display.split("/")
+    var walked = inHome ? base : ""
+    // The leading "~" and the leading "/" are each a crumb of their own: one names home and the
+    // other names the root, and neither is a component the split hands back.
+    var out = [{ text: parts.length > 1 ? parts[0] + "/" : parts[0],
+                 path: walked.length > 0 ? walked : "/", last: false }]
+    for (var i = 1; i < parts.length; i++) {
+        if (parts[i].length === 0) {
+            continue
+        }
+        walked = walked + "/" + parts[i]
+        out.push({ text: parts[i] + "/", path: walked, last: false })
+    }
+    // Only a crumb with another after it carries a separator, so the last one gives its own back.
+    var end = out[out.length - 1]
+    if (out.length > 1) {
+        end.text = end.text.substring(0, end.text.length - 1)
+    }
+    end.last = true
+    return out
+}
+
+function cleanRoot(path) {
+    var text = String(path || "")
+    while (text.length > 1 && text.charAt(text.length - 1) === "/")
+        text = text.substring(0, text.length - 1)
+    return text
+}
+
+function inside(path, root) {
+    return path === root || path.indexOf(root + "/") === 0
+}
+
+// Issue 237: the deepest remembered display root wins, so nested WebDAV spaces on one host stay distinct.
+function aliasAt(path, aliases) {
+    var text = String(path || "")
+    var best = null
+    for (var i = 0; aliases && i < aliases.length; i++) {
+        var root = cleanRoot(aliases[i].path)
+        if (root.length > 0 && inside(text, root) && (!best || root.length > best.path.length))
+            best = { path: root, label: String(aliases[i].label || ""), key: aliases[i].key }
+    }
+    return best && best.label.length > 0 ? best : null
+}
+
+function rememberAlias(aliases, path, label, key) {
+    var root = cleanRoot(path)
+    var name = String(label || "")
+    if (root.length === 0 || name.length === 0)
+        return aliases || []
+    var id = String(key || root)
+    var out = []
+    for (var i = 0; aliases && i < aliases.length; i++) {
+        if (aliases[i].key !== id && cleanRoot(aliases[i].path) !== root)
+            out.push(aliases[i])
+    }
+    out.push({ path: root, label: name, key: id })
+    return out
+}
+
+// Only a persisted source may rename an alias; a live mount's generated label is not a saved name.
+function labelsByKey(entries, keyFor) {
+    var out = {}
+    for (var i = 0; entries && i < entries.length; i++) {
+        var address = entries[i].uri || entries[i].path
+        if (entries[i].saved === true && address && entries[i].label)
+            out[keyFor(address)] = entries[i].label
+    }
+    return out
+}
+
+// A saved-place rename changes the visible root without changing a real path or navigation target.
+function relabelAliases(aliases, labels) {
+    var changed = false
+    var out = []
+    for (var i = 0; aliases && i < aliases.length; i++) {
+        var name = labels && labels[aliases[i].key] ? String(labels[aliases[i].key]) : aliases[i].label
+        changed = changed || name !== aliases[i].label
+        out.push(name === aliases[i].label ? aliases[i]
+                                          : { path: aliases[i].path, label: name, key: aliases[i].key })
+    }
+    return changed ? out : (aliases || [])
+}
+
+// Below this a leaf gives up more to the ellipsis than the ellipsis saves, so it is drawn whole.
+var LEAF_FLOOR = 6
+
+// What the crumbs before it leave the leaf, in characters.
+function leafRoom(list, budget) {
+    return budget - (crumbChars(list) - list[list.length - 1].text.length)
+}
+
+// Chrome rule 2 collapses whole crumbs, but the leaf is the one crumb that cannot be dropped: when
+// even it does not fit, it takes the ellipsis in its own middle rather than a cut at the strip's edge.
+function elideLeaf(list, budget) {
+    var end = list[list.length - 1]
+    var room = leafRoom(list, budget)
+    if (room >= end.text.length || end.text.length <= LEAF_FLOOR) {
+        return list
+    }
+    // corner: a strip with less room than the floor draws the floor, which is short rather than cut.
+    var keep = Math.max(LEAF_FLOOR, room)
+    var head = Math.ceil((keep - 1) / 2)
+    var tail = keep - 1 - head
+    var cut = end.text.substring(0, head) + "\u2026" + (tail > 0 ? end.text.substring(end.text.length - tail) : "")
+    return list.slice(0, list.length - 1).concat([{ text: cut, path: end.path, last: true }])
+}
+
+// Chrome rule 2: a path too long for the strip reads as its root, one collapsed crumb and the segments nearest you, whole crumbs only, so the marker is a crumb of its own. budget is the strip's width in characters, monospace.
+function fitCrumbs(list, budget) {
+    if (list.length < 4 || crumbChars(list) <= budget) {
+        return elideLeaf(list, budget)
+    }
+    var shown = [list[0], { text: "\u2026/", path: "", last: false, elided: true },
+                 list[list.length - 2], list[list.length - 1]]
+    // Whatever room the marker leaves goes back to the crumbs nearest the root, in walking order.
+    for (var i = 1; i < list.length - 2; i++) {
+        var next = shown.slice()
+        next.splice(i, 0, list[i])
+        if (crumbChars(next) > budget) {
+            break
+        }
+        shown = next
+    }
+    // A parent that leaves the leaf less than it needs and less than its floor goes the way the
+    // middle went: rule 2 elides whole crumbs, and the leaf is the one that may not be the one to go.
+    if (shown.length === 4) {
+        var left = leafRoom(shown, budget)
+        if (left < shown[3].text.length && left < LEAF_FLOOR) {
+            shown = [shown[0], shown[1], shown[3]]
+        }
+    }
+    return elideLeaf(shown, budget)
+}
+
+function crumbChars(list) {
+    var chars = 0
+    for (var i = 0; i < list.length; i++) {
+        chars += list[i].text.length
+    }
+    return chars
+}