flea-qml 0.0.0-stage → 0.2.0

package/ui/js/MarkdownPrepared.js

@@ -0,0 +1,139 @@
+.pragma library
+
+.import "Lists.js" as Lists
+.import "Kinds.js" as Kinds
+.import "ExtThumbs.js" as ExtThumbs
+.import "Contrast.js" as Contrast
+.import "Format.js" as Format
+
+// The one parsed Markdown document Quick Look takes without parsing, keyed by its text so an edited file misses and one past MAX_BYTES is never held.
+var entry = null
+var MAX_BYTES = 65536
+
+// Sample input: the row { n: "a.md", d: false } answers true; { n: "a.md", d: true }, { n: "a.txt", d: false } and null answer false.
+// Whether the cursor row is a Markdown file by name, the one trigger Quick Look's warm and its ahead-of-Space build share.
+function isMarkdownRow(row) {
+    return row !== null && row !== undefined && !row.d && Kinds.isMarkdown(row.n)
+}
+
+// Sample input: a 900 byte regular "a.md" row on class "" with the class known answers true; a named pipe row, class "network" or an unknown class answers false.
+// Only a regular local file under MAX_BYTES in a folder whose class has landed is read ahead or inside the key; cifs, nfs and listed FUSE shares classify "network" in extclass.rs.
+function readsInline(row, storageClass, storageKnown) {
+    if (!row || row.d || !storageKnown || ExtThumbs.present(storageClass) || !Kinds.isMarkdown(row.n))
+        return false
+    return (row.p & Format.S_IFMT) === Format.S_IFREG && row.s > 0 && row.s <= MAX_BYTES
+}
+
+// A picture at most this big is decoded ahead of the open, and a document is asked about at most this many.
+var PICTURE_MAX_BYTES = 262144
+var PICTURE_LIMIT = 8
+var FILE_SCHEME_LENGTH = 7
+// The stat child that sizes the pictures is dropped after this long, so a hung mount holds nothing past it.
+var PICTURE_SIZE_DEADLINE_MS = 1500
+
+// Sample input: "file:///d/b%20c.png" answers "/d/b c.png"; "file:///d/100%.png" (a stray percent) answers "".
+function pathOfUrl(url) {
+    try {
+        return decodeURIComponent(String(url).slice(FILE_SCHEME_LENGTH))
+    } catch (e) {
+        return ""
+    }
+}
+
+// Sample input: path "/d/img/a.png" in dir "/d" answers true; "/mnt/nas/a.png" and "/d/../e/a.png" answer false.
+// Only a picture under the document's folder shares the storage class readsInline cleared, so a stat never reaches another mount.
+function insideDir(path, dir) {
+    return dir !== "" && path.indexOf(dir + "/") === 0 && path.split("/").indexOf("..") < 0
+}
+
+// Sample input: blocks [{ type: "image", url: "file:///d/a.png" }, { type: "images", items: [{ url: "file:///d/b%20c.png" }, { url: "file:///d/a.png" }] }, { type: "run" }] in dir "/d" answer ["file:///d/a.png", "file:///d/b%20c.png"].
+// The local pictures a parsed document draws at its top level under its own folder, each once, in reading order, at most limit of them.
+function pictureUrls(blocks, limit, dir) {
+    var urls = []
+    function add(url) {
+        if (typeof url === "string" && url.indexOf("file://") === 0 && urls.length < limit && urls.indexOf(url) < 0
+                && insideDir(pathOfUrl(url), dir))
+            urls.push(url)
+    }
+    for (var i = 0; i < blocks.length; i++) {
+        var b = blocks[i]
+        if (b.type === "image") {
+            add(b.url)
+        } else if (b.type === "images" && b.items !== undefined) {
+            for (var j = 0; j < b.items.length; j++)
+                add(b.items[j].url)
+        }
+    }
+    return urls
+}
+
+// Sample input: urls ["file:///d/a.png", "file:///d/big.png", "file:///d/gone.png"] with the stat text "2048\t/d/a.png\n900000\t/d/big.png\n" answer ["file:///d/a.png"].
+// The pictures stat sized at PICTURE_MAX_BYTES or less; a name stat did not print (a missing file) or a bigger one keeps the open's own load.
+function smallPictures(urls, statText) {
+    var sizes = {}
+    var lines = String(statText).split("\n")
+    for (var i = 0; i < lines.length; i++) {
+        var tab = lines[i].indexOf("\t")
+        if (tab > 0)
+            sizes[lines[i].slice(tab + 1)] = Number(lines[i].slice(0, tab))
+    }
+    return urls.filter(function (url) {
+        var size = sizes[pathOfUrl(url)]
+        return size !== undefined && size > 0 && size <= PICTURE_MAX_BYTES
+    })
+}
+
+// The most formulas a rested document typesets ahead, so a document full of them never queues a render per rest.
+var FORMULA_LIMIT = 8
+
+// Sample input: [{ type: "run", maths: ["x", "x"] }, { type: "figure", kind: "math", source: "y" }, { type: "quote", parts: [{ type: "run", maths: ["z"] }] }] answer [{ source: "x", display: false }, { source: "y", display: true }, { source: "z", display: false }].
+// The distinct maths a prepared document draws, in reading order and at most limit of them: inline formulas and display figures, a quote's or a list item's parts included.
+function formulasIn(blocks, limit) {
+    var out = []
+    var seen = {}
+    function add(source, display) {
+        var key = (display ? "d" : "i") + source
+        if (out.length < limit && seen[key] === undefined) {
+            seen[key] = true
+            out.push({ source: source, display: display })
+        }
+    }
+    function walk(list) {
+        for (var i = 0; i < list.length; i++) {
+            var b = list[i]
+            if (!b)
+                continue
+            if (Lists.isList(b)) {
+                walk(b)
+                continue
+            }
+            if (b.type === "figure" && b.kind === "math")
+                add(b.source, true)
+            for (var k = 0; b.maths !== undefined && k < b.maths.length; k++)
+                add(b.maths[k], false)
+            if (b.parts !== undefined)
+                walk(b.parts)
+        }
+    }
+    walk(blocks)
+    return out
+}
+
+// QML color components read 0..1, so the hex a style attribute needs is assembled from them, never coerced from the colour.
+// Sample input: a colour with r 0.0627, g 0.0745, b 0.0745 answers "#101313".
+function hexOf(c) {
+    return Contrast.hexOf([c.r, c.g, c.b])
+}
+
+function store(path, text, dir, chrome, ink, blocks) {
+    if (text.length > MAX_BYTES) return
+    entry = { path: path, text: text, dir: dir, chrome: chrome, ink: ink, blocks: blocks }
+}
+
+// The blocks parsed from exactly this text with exactly these inputs, or null.
+function take(path, text, dir, chrome, ink) {
+    var e = entry
+    if (e === null || e.path !== path || e.dir !== dir || e.chrome !== chrome || e.ink !== ink || e.text !== text)
+        return null
+    return e.blocks
+}

package/ui/js/MarkdownTableFit.js

@@ -0,0 +1,34 @@
+.pragma library
+
+// MarkdownTableFit: how a table shares the width its block gives it, a pure function of column widths in pixels.
+
+// Sample input: fit([100, 400], [50, 100], 300, 10) is [71, 228]: each column keeps its longest word, the rest goes by want.
+// A table that fits keeps its natural widths; past that no column falls under its longest word or least (one narrower keeps its natural), so a hopeless one is wider than avail.
+function fit(natural, minimum, avail, least) {
+    function heldAt(c) {
+        return natural[c] < least ? natural[c] : Math.max(least, Math.min(minimum[c], natural[c]))
+    }
+    function capped(w, c) {
+        return Math.max(Math.min(least, natural[c]), Math.floor(w))
+    }
+    var total = 0
+    var floor = 0
+    for (var i = 0; i < natural.length; i++) {
+        total += natural[i]
+        floor += heldAt(i)
+    }
+    if (total <= avail)
+        return natural.slice()
+    var widths = []
+    if (floor <= avail) {
+        for (var c = 0; c < natural.length; c++) {
+            var held = heldAt(c)
+            widths.push(held + (avail - floor) * (natural[c] - held) / (total - floor))
+        }
+    } else {
+        // Even the longest words do not fit: every column holds its longest word whole and the table scrolls sideways.
+        for (var h = 0; h < natural.length; h++)
+            widths.push(heldAt(h))
+    }
+    return widths.map(capped)
+}

package/ui/js/Marks.js

@@ -0,0 +1,148 @@
+.pragma library
+
+.import "Filter.js" as Filter
+
+// Marking rows: ctrl+A, the shift range in both its keyboard and its pointer form, and ctrl+click.
+// Split out of ui/js/Filter.js, which narrows the listing; these move the cursor and the marks over
+// whatever that narrowing left drawn, which is why every one of them reads through it.
+
+// Ctrl+A takes what is drawn, never what is listed: under a filter that is the matches alone.
+function selectAll(pane) {
+    if (pane.shown === null) {
+        pane.selection.all(pane.total)
+        return
+    }
+    pane.selection.clear()
+    for (var i = 0; i < pane.shown.length; i++) {
+        pane.selection.toggle(pane.shown[i])
+    }
+}
+
+// A gesture continues while nothing else moved the cursor since the last extend left it;
+// any other cursor move, and any mark made outside the gesture, ends it through shiftState.
+function continuing(pane) {
+    var state = pane.selection.shiftState()
+    return state !== null && pane.cursorIndex === state.last && (pane.cursorSeq || 0) === (state.seq || 0)
+}
+
+// Invert flips the drawn marks; a row no filter draws is never selected.
+function inverted(total, shown, selected) {
+    var drawn = shown === null ? range(total) : shown.slice()
+    var has = {}
+    for (var s = 0; s < selected.length; s++)
+        has[selected[s]] = true
+    var out = []
+    for (var i = 0; i < drawn.length; i++) {
+        if (has[drawn[i]] !== true)
+            out.push(drawn[i])
+    }
+    return out
+}
+
+function range(total) {
+    var out = []
+    for (var r = 0; r < total; r++)
+        out.push(r)
+    return out
+}
+
+// The pane's own invert, through the same drawn set selectAll reads.
+function invert(pane) {
+    var next = inverted(pane.total, pane.shown, pane.selectedIndices())
+    pane.selection.clear()
+    for (var i = 0; i < next.length; i++)
+        pane.selection.toggle(next[i])
+    pane.selectionVersion += 1
+}
+
+// A range starts at the cursor, or where it stood before the wheel pulled it onto the viewport.
+function latchAnchor(pane) {
+    var from = Filter.pulledFrom(pane)
+    pane.selectionAnchor = from >= 0 ? from : pane.cursorIndex
+}
+
+// Shift+J and Shift+K, the whole gesture: the cursor moves through what is drawn and the selection
+// is the base the gesture started from plus the drawn rows between the anchor and the cursor, so
+// several blocks can be marked and the gesture's own range still grows and shrinks.
+function extend(pane, delta) {
+    if (!continuing(pane)) {
+        pane.selection.shiftBegin(pane.selectedIndices(), pane.cursorIndex, pane.cursorSeq || 0)
+        latchAnchor(pane)
+    }
+    Filter.moveCursor(pane, delta)
+    extendTo(pane, pane.selectionAnchor)
+    pane.selection.shiftMoved(pane.cursorIndex, pane.cursorSeq || 0)
+    pane.selectionVersion += 1
+}
+
+// Shift+click, the absolute twin of extend() above: the anchor latches through latchAnchor before the
+// click, which a plain click or ctrl+click already sets, and consecutive shift+clicks share one base.
+// A click carries context 0 so the list never moves under the pointer.
+function extendToRow(pane, index) {
+    if (!continuing(pane)) {
+        pane.selection.shiftBegin(pane.selectedIndices(), pane.cursorIndex, pane.cursorSeq || 0)
+        latchAnchor(pane)
+    }
+    Filter.setCursor(pane, index, 0)
+    extendTo(pane, pane.selectionAnchor)
+    pane.selection.shiftMoved(pane.cursorIndex, pane.cursorSeq || 0)
+    pane.selectionVersion += 1
+}
+
+// Ctrl+click, v's mouse twin. An empty set means the cursor row is selected, so it joins first.
+// A click carries context 0 so the list never moves under the pointer.
+function toggleRow(pane, index) {
+    if (pane.selection.count() === 0 && pane.cursorIndex !== index) {
+        pane.selection.toggle(pane.cursorIndex)
+    }
+    Filter.setCursor(pane, index, 0)
+    pane.selection.toggle(index)
+    pane.selectionAnchor = index
+    pane.selectionVersion += 1
+}
+
+// A lone selection follows a plain move so delete takes the cursor row; deliberate marks drop lone.
+function follow(pane) {
+    if (!pane.selection.follows() || pane.cursorIndex === pane.selectedIndices()[0])
+        return
+    var keep = pane.selection.isLanded ? pane.selection.isLanded() : false
+    pane.selection.only(pane.cursorIndex, keep)
+    pane.selectionAnchor = pane.cursorIndex
+    pane.selectionVersion += 1
+}
+
+// v on a lone following row keeps it as a deliberate mark instead of toggling it off.
+function toggleSelect(pane) {
+    if (!pane.selection.promote(pane.cursorIndex)) pane.selection.toggle(pane.cursorIndex)
+    pane.selectionAnchor = pane.cursorIndex
+    pane.selectionVersion += 1
+}
+
+// The drawn rows between cursor and anchor; a shrinking gesture keeps its base.
+function extendTo(pane, anchor) {
+    var state = pane.selection.shiftState()
+    if (state === null) {
+        if (pane.shown === null) {
+            pane.selection.extendTo(pane.cursorIndex, anchor)
+            return
+        }
+        pane.selection.clear()
+        var single = Filter.between(pane.shown, pane.cursorIndex, anchor)
+        for (var i = 0; i < single.length; i++) {
+            pane.selection.toggle(single[i])
+        }
+        return
+    }
+    var range
+    if (pane.shown === null) {
+        range = []
+        var lo = Math.min(pane.cursorIndex, anchor)
+        var hi = Math.max(pane.cursorIndex, anchor)
+        for (var r = lo; r <= hi; r++) {
+            range.push(r)
+        }
+    } else {
+        range = Filter.between(pane.shown, pane.cursorIndex, anchor)
+    }
+    pane.selection.shiftApply(range)
+}

package/ui/js/Marquee.js

@@ -0,0 +1,96 @@
+.pragma library
+.import "Selection.js" as Selection
+
+// Cell coordinates avoid inspecting or instantiating delegates outside the viewport.
+function cells(x1, y1, x2, y2, width, height, columns, count) {
+    var left = Math.min(x1, x2), right = Math.max(x1, x2)
+    var top = Math.min(y1, y2), bottom = Math.max(y1, y2)
+    if (width <= 0 || height <= 0 || count <= 0 || left === right || top === bottom
+            || right <= 0 || bottom <= 0 || left >= columns * width)
+        return null
+    var box = { left: Math.max(0, Math.floor(left / width)),
+                right: Math.min(columns - 1, Math.ceil(right / width) - 1),
+                top: Math.max(0, Math.floor(top / height)),
+                bottom: Math.min(Math.ceil(count / columns) - 1, Math.ceil(bottom / height) - 1) }
+    return box.top <= box.bottom ? box : null
+}
+
+function same(a, b) {
+    return a === b || (a !== null && b !== null && a.left === b.left && a.right === b.right
+        && a.top === b.top && a.bottom === b.bottom)
+}
+
+// Visit only strips entering or leaving the rectangle; a one-row move never scans all old marks.
+function difference(box, other, columns, count, backwardsX, backwardsY, visit) {
+    if (box === null) return
+    var strips = [box]
+    if (other !== null && other.left <= box.right && other.right >= box.left
+            && other.top <= box.bottom && other.bottom >= box.top) {
+        var top = Math.max(box.top, other.top), bottom = Math.min(box.bottom, other.bottom)
+        strips = [
+            {left: box.left, right: box.right, top: box.top, bottom: top - 1},
+            {left: box.left, right: Math.min(box.right, other.left - 1), top: top, bottom: bottom},
+            {left: Math.max(box.left, other.right + 1), right: box.right, top: top, bottom: bottom},
+            {left: box.left, right: box.right, top: bottom + 1, bottom: box.bottom}
+        ]
+        strips.sort(function (a, b) {
+            return (backwardsY ? b.bottom - a.bottom : a.top - b.top)
+                || (backwardsX ? b.right - a.right : a.left - b.left)
+        })
+    }
+    var rowStep = backwardsY ? -1 : 1
+    var columnStep = backwardsX ? -1 : 1
+    for (var s = 0; s < strips.length; s++) {
+        var strip = strips[s]
+        if (strip.left > strip.right) continue
+        for (var row = backwardsY ? strip.bottom : strip.top;
+             row >= strip.top && row <= strip.bottom; row += rowStep) {
+            for (var column = backwardsX ? strip.right : strip.left;
+                 column >= strip.left && column <= strip.right; column += columnStep) {
+                var index = row * columns + column
+                if (index < count) visit(index)
+            }
+        }
+    }
+}
+
+function begin(pane, additive) {
+    var selection = Selection.create()
+    if (additive) {
+        var saved = pane.selectedIndices()
+        for (var i = 0; i < saved.length; i++) selection.toggle(saved[i])
+    }
+    var state = { before: pane.selection, cursor: pane.cursorIndex, anchor: pane.selectionAnchor,
+                  additive: additive, box: null, last: -1 }
+    pane.selection = selection
+    pane.selectionVersion++
+    return state
+}
+
+function update(pane, state, box, columns, count, backwardsX, backwardsY, listingIndex) {
+    if (same(state.box, box)) return
+    difference(state.box, box, columns, count, false, false, function (viewIndex) {
+        var index = listingIndex(viewIndex)
+        if (index >= 0 && !(state.additive && state.before.has(index))) pane.selection.toggle(index)
+    })
+    difference(box, state.box, columns, count, backwardsX, backwardsY, function (viewIndex) {
+        var index = listingIndex(viewIndex)
+        if (index < 0) return
+        if (!pane.selection.has(index)) pane.selection.toggle(index)
+        state.last = index
+    })
+    state.box = box
+    pane.selectionVersion++
+}
+
+function finish(pane, state, cancelled) {
+    if (cancelled) {
+        pane.selection = state.before
+        pane.cursorIndex = state.cursor
+        pane.selectionAnchor = state.anchor
+        pane.selectionVersion++
+    } else if (state.last >= 0) {
+        pane.setCursor(state.last, 0)
+        pane.selectionAnchor = state.last
+    }
+}

package/ui/js/Match.js

@@ -0,0 +1,93 @@
+.pragma library
+
+// A search row's name is its path relative to the search root, so the display splits it here and
+// the wire never carries a second shape; see docs/protocol.md "search".
+function base(path) {
+    var i = String(path).lastIndexOf("/")
+    return i < 0 ? String(path) : String(path).substring(i + 1)
+}
+
+// A Trash row's storage name is an IO identity, never its visible caption.
+function rowName(row, locating) {
+    if (!row) return ""
+    if (row.trash) return row.trash.name !== undefined ? String(row.trash.name) : base(row.trash.original || row.n)
+    return locating ? base(row.n) : row.n
+}
+
+// The location column: the parent path relative to the scope, empty for a match in the root itself.
+function location(path) {
+    var i = String(path).lastIndexOf("/")
+    return i < 0 ? "" : String(path).substring(0, i)
+}
+
+// Where to paint the accent run inside a name, mirroring the backend's own case-insensitive match.
+// corner: a character whose lowercase form is a different length (Turkish dotted capital I) can
+// shift the run by one; the name still renders whole, and the backend alone decides what matched.
+function run(hay, needle) {
+    var h = String(hay)
+    var n = String(needle)
+    if (n.length === 0) {
+        return { start: -1, length: 0 }
+    }
+    // flea-qml: a query with a glob character is a shell glob over the whole name, so `*.js` is the
+    // names ending in .js; the run is then the whole name. Plain text stays a substring, as upstream.
+    var glob = globPattern(n)
+    if (glob !== null)
+        return glob.test(h) ? { start: 0, length: h.length } : { start: -1, length: 0 }
+    var at = h.toLowerCase().indexOf(n.toLowerCase())
+    return at < 0 ? { start: -1, length: 0 } : { start: at, length: n.length }
+}
+
+// flea-qml: `*` any run, `?` one character, `[abc]` `[a-z]` `[!a]` `[^a]` a class, `{js,ts}` one of
+// the words, and `\` takes the next character literally; letter case is ignored, as the plain
+// filter ignores it. A `[` or `{` with no close is that character itself. Null for a query with no
+// glob character. Sample input: "*.{js,ts}" matches "app.js" and "types.ts", not "app.json".
+var globCache = { source: null, regex: null }
+function globPattern(query) {
+    if (!/[*?[{]/.test(query))
+        return null
+    if (globCache.source === query)
+        return globCache.regex
+    var out = "", depth = 0
+    for (var i = 0; i < query.length; i++) {
+        var c = query.charAt(i)
+        if (c === "\\" && i + 1 < query.length) {
+            out += escapeRegex(query.charAt(++i))
+        } else if (c === "*") {
+            out += ".*"
+        } else if (c === "?") {
+            out += "."
+        } else if (c === "[") {
+            var close = query.indexOf("]", i + 2)
+            if (close < 0) { out += "\\["; continue }
+            var body = query.substring(i + 1, close)
+            var negate = body.charAt(0) === "!" || body.charAt(0) === "^"
+            if (negate) body = body.substring(1)
+            out += "[" + (negate ? "^" : "") + body.replace(/[\\\]]/g, "\\$&") + "]"
+            i = close
+        } else if (c === "{" && query.indexOf("}", i) > i) {
+            out += "(?:"
+            depth++
+        } else if (c === "," && depth > 0) {
+            out += "|"
+        } else if (c === "}" && depth > 0) {
+            out += ")"
+            depth--
+        } else {
+            out += escapeRegex(c)
+        }
+    }
+    var regex = null
+    try {
+        regex = new RegExp("^" + out + "$", "i")
+    } catch (e) {
+        // A pattern the engine refuses matches nothing rather than everything.
+        regex = /(?!)/
+    }
+    globCache = { source: query, regex: regex }
+    return regex
+}
+
+function escapeRegex(c) {
+    return /[.*+?^${}()|[\]\\\/]/.test(c) ? "\\" + c : c
+}

package/ui/js/Material.js

@@ -0,0 +1,109 @@
+.pragma library
+.import "Contrast.js" as Contrast
+
+// Omarchy Glassy dims its blurred backdrop to 0.75; channels and alpha use whole 8-bit steps.
+var STEPS = 255
+var MIN_ALPHA = Math.ceil(0.75 * STEPS)
+var INK_STEP = 1.25
+// Twenty bisections resolve lightness more finely than one 8-bit colour channel.
+var LIGHTNESS_SEARCH_STEPS = 20
+// Half an 8-bit channel step repairs rounding without skipping the first passing colour.
+var ROUNDING_REPAIR_STEPS = 512
+
+function ground(plane, a, backdrop) {
+    return Contrast.hexOf(Contrast.over(String(plane), a / STEPS, backdrop))
+}
+
+function worst(ink, c, a, planes) {
+    var least = Infinity
+    var grounds = planes || [c.background, c.surface]
+    var brightness = c.blurBrightness === undefined ? 0.75 : c.blurBrightness
+    var white = Contrast.hexOf([brightness, brightness, brightness])
+    var backdrops = [white, "#000000"]
+    for (var p = 0; p < grounds.length; p++)
+        for (var b = 0; b < backdrops.length; b++)
+            least = Math.min(least, Contrast.ratio(String(ink), ground(grounds[p], a, backdrops[b])))
+    return least
+}
+
+function direction(c) {
+    var fg = Contrast.parse(String(c.foreground)), bg = Contrast.parse(String(c.background))
+    return Contrast.luminance(fg[0], fg[1], fg[2]) > Contrast.luminance(bg[0], bg[1], bg[2]) ? [1, 1, 1] : [0, 0, 0]
+}
+
+// The R3 lightness walk, including its rounding repair, applied to the live palette rather than a theme-name table.
+function inkHolds(ink, c, a, need, quiet) {
+    if (worst(ink, c, a) < need) return false
+    if (quiet === undefined) return true
+    var x = Contrast.parse(String(ink)), q = Contrast.parse(String(quiet))
+    var lx = Contrast.luminance(x[0], x[1], x[2]), lq = Contrast.luminance(q[0], q[1], q[2])
+    return direction(c)[0] === 1 ? lx >= lq : lx <= lq
+}
+
+function liftInk(ink, c, a, need, quiet) {
+    if (inkHolds(ink, c, a, need, quiet)) return String(ink)
+    var from = Contrast.parse(String(ink)), to = direction(c), lo = 0, hi = 1
+    for (var i = 0; i < LIGHTNESS_SEARCH_STEPS; i++) {
+        var mid = (lo + hi) / 2
+        if (inkHolds(Contrast.hexOf(Contrast.mix(from, to, mid)), c, a, need, quiet)) hi = mid
+        else lo = mid
+    }
+    for (var t = hi; t <= 1; t += 1 / ROUNDING_REPAIR_STEPS) {
+        var hex = Contrast.hexOf(Contrast.mix(from, to, t))
+        if (inkHolds(hex, c, a, need, quiet)) return hex
+    }
+    return Contrast.hexOf(to)
+}
+
+function quieter(ink, primary, c) {
+    var x = Contrast.parse(String(ink)), fg = Contrast.parse(String(primary))
+    var lx = Contrast.luminance(x[0], x[1], x[2]), lf = Contrast.luminance(fg[0], fg[1], fg[2])
+    return (direction(c)[0] === 1 ? lx < lf : lx > lf) && Contrast.ratio(String(ink), String(primary)) >= INK_STEP
+}
+
+function primaryHolds(primary, c, a, need, muted, metadata) {
+    return worst(primary, c, a) >= need && quieter(muted, primary, c) && quieter(metadata, primary, c)
+}
+
+// A mode may lift primary ink too, so legible secondary ink never becomes the primary rung.
+function primaryInk(c, a, need, muted, metadata) {
+    if (primaryHolds(c.foreground, c, a, need, muted, metadata)) return String(c.foreground)
+    var from = Contrast.parse(String(c.foreground)), to = direction(c), lo = 0, hi = 1
+    for (var i = 0; i < LIGHTNESS_SEARCH_STEPS; i++) {
+        var mid = (lo + hi) / 2
+        if (primaryHolds(Contrast.hexOf(Contrast.mix(from, to, mid)), c, a, need, muted, metadata)) hi = mid
+        else lo = mid
+    }
+    for (var t = hi; t <= 1; t += 1 / ROUNDING_REPAIR_STEPS) {
+        var hex = Contrast.hexOf(Contrast.mix(from, to, t))
+        if (primaryHolds(hex, c, a, need, muted, metadata)) return hex
+    }
+    return Contrast.hexOf(to)
+}
+
+function inks(c, a, need) {
+    var muted = liftInk(c.muted, c, a, need), metadata = liftInk(c.metadata, c, a, need)
+    var meta = Contrast.parse(metadata), fg = Contrast.parse(String(c.foreground))
+    var lm = Contrast.luminance(meta[0], meta[1], meta[2]), lf = Contrast.luminance(fg[0], fg[1], fg[2])
+    // Darkening a light palette's foreground put metadata beyond primary, or on it in White; reuse its muted rung.
+    if (direction(c)[0] === 1 ? lm >= lf : lm <= lf) metadata = muted
+    var primary = primaryInk(c, a, need, muted, metadata)
+    return {foreground: primary, muted: muted, metadata: metadata}
+}
+
+// One alpha for every main plane in A, raised only if its ink cannot hold the two text rungs.
+function floor(c, need) {
+    for (var a = MIN_ALPHA; a < STEPS; a++) {
+        var ink = inks(c, a, need)
+        if (primaryHolds(ink.foreground, c, a, need, ink.muted, ink.metadata)
+                && worst(ink.muted, c, a) >= need && worst(ink.metadata, c, a) >= need) return a
+    }
+    return STEPS
+}
+
+// B keeps the unlifted listing text legible on its own background plane, never thinner than A.
+function listFloor(c, need) {
+    var a = STEPS
+    while (a > 0 && Math.min(worst(c.muted, c, a - 1, [c.background]), worst(c.metadata, c, a - 1, [c.background])) >= need) a--
+    return a
+}