buninu-browser 0.3.0 → 0.4.0

package/test/fixtures/qml/flea-theme/ui/js/Format.js

@@ -0,0 +1,305 @@
+.pragma library
+
+// SI, because a file's size on disk has no power-of-two basis; GLib's own rule and the whole GUI group.
+var BYTES_PER_UNIT = 1000
+var UNITS = ["B", "kB", "MB", "GB", "TB"]
+// GNOME renders a narrow no-break space before the unit, and Flea's neighbours are GLib-formatted.
+var UNIT_SPACE = " "
+
+// Below one kilobyte a fraction is noise, so bytes print whole.
+// Counts reach six figures on a real directory, so they are grouped the way the canvas draws them.
+function count(n) {
+    var digits = String(n)
+    var out = ""
+    for (var i = 0; i < digits.length; i++) {
+        if (i > 0 && (digits.length - i) % 3 === 0)
+            out += ","
+        out += digits.charAt(i)
+    }
+    return out
+}
+
+function size(bytes) {
+    if (bytes < BYTES_PER_UNIT) {
+        return bytes + UNIT_SPACE + UNITS[0]
+    }
+    var value = bytes
+    var unit = 0
+    while (value >= BYTES_PER_UNIT && unit < UNITS.length - 1) {
+        value = value / BYTES_PER_UNIT
+        unit += 1
+    }
+    return value.toFixed(1) + UNIT_SPACE + UNITS[unit]
+}
+
+// Fills %1 to %9 in one pass: a value prints as given, a dollar sign or placeholder in it included; an unfilled one stays.
+function fill(template) {
+    var values = arguments
+    return String(template).replace(/%([1-9])/g, function (token, at) { return at < values.length ? String(values[at]) : token })
+}
+
+function pad(n) {
+    return n < 10 ? "0" + n : "" + n
+}
+
+// "2026-09-12 15:29", the one form every surface prints, in the machine's local wall clock.
+function stamp(d) {
+    return d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate())
+        + " " + pad(d.getHours()) + ":" + pad(d.getMinutes())
+}
+
+// One form, sortable and unambiguous, so no surface has to invent a relative word for a time.
+function date(mtime) {
+    return stamp(new Date(mtime * 1000))
+}
+
+// The send picker's column is SendPicker.html's 80 and not the window's 125, which holds about ten
+// characters: the one place the full stamp does not fit. It drops the time and keeps the date, so it
+// is still sortable and still unambiguous. Preview board, "One function, four surfaces".
+function compactDate(mtime) {
+    var d = new Date(mtime * 1000)
+    return d.getFullYear() + "-" + pad(d.getMonth() + 1) + "-" + pad(d.getDate())
+}
+
+// The low nine bits of st_mode, read three at a time.
+var PERMISSION_BITS = 9
+var TRIAD = "rwx"
+
+function permissions(mode) {
+    var out = ""
+    for (var i = 0; i < PERMISSION_BITS; i++) {
+        var bit = 1 << (PERMISSION_BITS - 1 - i)
+        out += (mode & bit) ? TRIAD[i % TRIAD.length] : "-"
+    }
+    return out
+}
+
+// The file type lives in the top four bits of st_mode, as S_IFMT masks it.
+var S_IFMT = 0o170000
+var S_IFREG = 0o100000
+var S_IFDIR = 0o040000
+// The owner execute bit, the one Make executable adds.
+var S_IXUSR = 0o100
+var S_IFLNK = 0o120000
+var ANY_EXECUTE_BIT = 0o111
+
+function isSymlink(mode) {
+    return (mode & S_IFMT) === S_IFLNK
+}
+
+function isExecutable(mode) {
+    return (mode & ANY_EXECUTE_BIT) !== 0
+}
+
+// Shared by Row.qml's iconSource and PreviewMedia.qml's player source: encodeURI leaves # and ?
+// literal, which Qt then reads as a URL fragment or query rather than path bytes.
+function fileUri(path) {
+    return "file://" + encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")
+}
+
+// "3:05", or "1:03:05" once an hour is on the clock; mm/ss are always two digits, matching a media player's own clock rather than Format.date's prose.
+function duration(ms) {
+    var totalSeconds = Math.max(0, Math.floor(ms / 1000))
+    var hours = Math.floor(totalSeconds / 3600)
+    var minutes = Math.floor((totalSeconds % 3600) / 60)
+    var seconds = totalSeconds % 60
+    if (hours > 0) {
+        return hours + ":" + pad(minutes) + ":" + pad(seconds)
+    }
+    return minutes + ":" + pad(seconds)
+}
+
+// The scope reads as the user writes it, so the home prefix comes back as a tilde. Both the search
+// strip and the window chrome draw a path through this, so the rule has one definition.
+// Issue 95, nixfred: a bare prefix made /home/gmx into "~x", a sibling wearing home's name. The test
+// is home itself or home and a separator, the one ui/js/Nav.js crumbs and Search.scopeRoot both make.
+function tilde(path, home) {
+    var text = String(path)
+    if (home.length > 0 && (text === home || text.indexOf(home + "/") === 0)) {
+        return "~" + text.substring(home.length)
+    }
+    return text
+}
+
+// A tab is named after the directory it is standing in, so the label is the path's last segment.
+function leafPart(display) {
+    var text = String(display)
+    var cut = text.lastIndexOf("/")
+    if (cut < 0) {
+        return text
+    }
+    // "/" itself has no leaf, and its own separator is the whole label.
+    return cut === text.length - 1 ? text : text.substring(cut + 1)
+}
+
+// "44.1 kHz", the way the canvas writes an audio row's Rate; a zero is not a rate and reads empty.
+function sampleRate(hz) {
+    var n = Number(hz)
+    if (!n || n <= 0) {
+        return ""
+    }
+    var khz = n / 1000
+    // A whole number of kilohertz reads without a decimal, so 48000 is "48 kHz" and not "48.0 kHz".
+    return (khz === Math.round(khz) ? khz : khz.toFixed(1)) + " kHz"
+}
+
+// Issue 67, jesedv: a yanked path is quoted unless a shell reads every character of it as itself.
+function shellQuoted(path) {
+    var text = String(path)
+    if (/^[A-Za-z0-9_@%+=:,.\/-]+$/.test(text)) {
+        return text
+    }
+    return "'" + text.split("'").join("'\\''") + "'"
+}
+
+// One window-level day boundary, so no Date is built and no timer ticks per row.
+
+// Sample input: Date.now() on the board date, 2026-09-23 11:40 local.
+var DAY_MS = 24 * 60 * 60 * 1000
+// The midnight timer's minute step, so a suspend still lands the day within a minute of resume.
+var MINUTE_MS = 60 * 1000
+
+// Local midnight starting the day nowMs falls in, in ms since the epoch.
+function dayStart(nowMs) {
+    var now = new Date(nowMs)
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime()
+}
+
+// True when the stamp is on or after today's local midnight.
+function isRecent(mtimeSec, todayStartMs) {
+    if (typeof mtimeSec !== "number" || !isFinite(mtimeSec))
+        return false
+    return mtimeSec * 1000 >= todayStartMs
+}
+
+// Built from components, so a daylight-saving night still lands on midnight.
+function msUntilMidnight(nowMs) {
+    var now = new Date(nowMs)
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).getTime() - nowMs
+}
+
+// Elides in the middle so the extension stays visible; truncation costs a slice, never a relayout.
+// Sample input: "screenshot-2026-08-30-final-review-for-gm-after-the-bench-v3.png", 49.
+
+// The walk pairs surrogates by hand, so a cut never splits a code point.
+function charsOf(text) {
+    var out = []
+    for (var i = 0; i < text.length; i++) {
+        var lead = text.charCodeAt(i)
+        if (lead >= 0xD800 && lead <= 0xDBFF && i + 1 < text.length) {
+            var trail = text.charCodeAt(i + 1)
+            if (trail >= 0xDC00 && trail <= 0xDFFF) {
+                out.push(text.substring(i, i + 2))
+                i += 1
+                continue
+            }
+        }
+        // A combining mark rides with the char before it, so an NFD accent never orphans.
+        if (lead >= 0x0300 && lead <= 0x036F && out.length > 0) {
+            out[out.length - 1] += text.charAt(i)
+            continue
+        }
+        out.push(text.charAt(i))
+    }
+    return out
+}
+
+// Every fast unit sits below U+0300, so a fast name holds no surrogate, no combining mark and no wide glyph.
+var FAST_LIMIT = 0x0300
+
+// True when every UTF-16 unit is fast: each char paints one cell and slices never split a point.
+function isFastText(text) {
+    for (var i = 0; i < text.length; i++)
+        if (text.charCodeAt(i) >= FAST_LIMIT) return false
+    return true
+}
+
+function middleElide(name, maxCells) {
+    var text = String(name), max = Math.max(0, Math.floor(maxCells))
+    // A non-finite budget names no width, so the name goes through untouched.
+    if (!isFinite(max)) return text
+    // One scan serves the fit check and the store below, so a fitting fast name builds nothing.
+    var fast = isFastText(text)
+    // A fast name counts one cell a char, so a short one already fits untouched.
+    if (fast && text.length <= max) return text
+    var st = fast ? fastStoreOf(text) : storeOf(charsOf(text))
+    if (rangeCells(st, 0, st.n) <= max) return text
+    // The head takes the odd cell, so a 49-wide board keeps 24 and 24.
+    var h = spanFrom(st, 0, Math.ceil((max - 1) / 2)), t = tailSpan(st, Math.floor((max - 1) / 2))
+    return pieceOf(st, 0, h) + "…" + pieceOf(st, st.n - t, st.n)
+}
+
+// Display cells: East Asian Wide and Fullwidth paint two columns, emoji paint two, all else one.
+// Sample input: cellWidthOf("🎉") is 2, cellWidthOf("A") is 1.
+var WIDE_RANGES = [[0x1100, 0x115F], [0x2E80, 0x303E], [0x3041, 0x33FF], [0x3400, 0x4DBF], [0x4E00, 0xA4CF], [0xAC00, 0xD7A3], [0xF900, 0xFAFF], [0xFE10, 0xFE19], [0xFE30, 0xFE4F], [0xFF00, 0xFF60], [0xFFE0, 0xFFE6], [0x20000, 0x3FFFD]]
+var EMOJI_RANGES = [[0x2600, 0x26FF], [0x2700, 0x27BF], [0x2B00, 0x2BFF], [0x1F000, 0x1FAFF]]
+
+// True when a code point paints two columns rather than one.
+function isWideCode(cp) {
+    // Every wide range starts at U+1100, so a smaller code point never scans.
+    if (cp < 0x1100) return false
+    for (var i = 0; i < WIDE_RANGES.length; i++)
+        if (cp >= WIDE_RANGES[i][0] && cp <= WIDE_RANGES[i][1]) return true
+    for (var j = 0; j < EMOJI_RANGES.length; j++)
+        if (cp >= EMOJI_RANGES[j][0] && cp <= EMOJI_RANGES[j][1]) return true
+    return false
+}
+
+// The code point one charsOf element starts with, read without wrapping it in a string.
+// Sample input: codeOf("🎉") is 0x1F389, codeOf("A") is 0x41.
+function codeOf(ch) {
+    var s = String(ch), lead = s.charCodeAt(0)
+    if (lead >= 0xD800 && lead <= 0xDBFF && s.length > 1) {
+        var trail = s.charCodeAt(1)
+        if (trail >= 0xDC00 && trail <= 0xDFFF) return 0x10000 + ((lead - 0xD800) << 10) + (trail - 0xDC00)
+    }
+    return lead
+}
+
+// Cells one char paints: 2 for a wide code point, 1 for all else.
+function cellWidthOf(ch) {
+    return isWideCode(codeOf(ch)) ? 2 : 1
+}
+
+// One layout per call: widths plus prefix sums, so every range below is one subtraction.
+// Sample input: storeOf(["a", "🎉"]) carries widths [1, 2].
+function storeOf(chars) {
+    var widths = new Array(chars.length), prefix = new Array(chars.length + 1)
+    prefix[0] = 0
+    for (var i = 0; i < chars.length; i++) {
+        widths[i] = isWideCode(codeOf(chars[i])) ? 2 : 1
+        prefix[i + 1] = prefix[i] + widths[i]
+    }
+    return { seq: chars, widths: widths, prefix: prefix, n: chars.length }
+}
+
+// The same layout over a fast string: no arrays, every range counts chars as cells.
+function fastStoreOf(text) {
+    return { seq: text, widths: null, prefix: null, n: text.length }
+}
+
+// Cells of elements [a..b).
+function rangeCells(st, a, b) {
+    return st.widths === null ? b - a : st.prefix[b] - st.prefix[a]
+}
+
+// Elements from pos fitting in this many cells.
+function spanFrom(st, pos, budget) {
+    if (st.widths === null) return Math.min(Math.max(budget, 0), st.n - pos)
+    var used = 0, i = pos
+    while (i < st.widths.length && used + st.widths[i] <= budget) { used += st.widths[i]; i += 1 }
+    return i - pos
+}
+
+// Trailing elements fitting in this many cells.
+function tailSpan(st, budget) {
+    if (st.widths === null) return Math.min(Math.max(budget, 0), st.n)
+    var used = 0, i = st.widths.length
+    while (i > 0 && used + st.widths[i - 1] <= budget) { used += st.widths[i - 1]; i -= 1 }
+    return st.widths.length - i
+}
+
+// Text of elements [a..b): a slice for a fast string, a join for a char array.
+function pieceOf(st, a, b) {
+    return st.widths === null ? st.seq.slice(a, b) : st.seq.slice(a, b).join("")
+}

package/test/fixtures/qml/flea-theme/ui/js/Icons.js

@@ -0,0 +1,206 @@
+.pragma library
+
+.import "Format.js" as Format
+
+// The backend sends a freedesktop icon name per row; this is the only place Flea maps one to a mark.
+// Counts re-derived 2026-08-31 from /usr/share/mime/generic-icons on this box, see AGENTS.md "Icons in the row":
+// x-office-document 106, package-x-generic 89, application-x-executable 57, text-x-generic 46,
+// image-x-generic 40, x-office-spreadsheet 38, text-x-script 36, font-x-generic 23, x-office-presentation 21,
+// video-x-generic 15, text-html 11, then a tail of five or fewer each.
+var GLYPHS = {
+    "folder": "folder",
+    "inode-directory": "folder",
+    "text-x-generic": "file-text",
+    "text-plain": "file-text",
+    // text-x-script, text-html and application-xml are 49 types a generic file mark would hide.
+    "text-x-script": "code",
+    "text-html": "code",
+    "application-xml": "code",
+    "image-x-generic": "image",
+    "video-x-generic": "film",
+    "audio-x-generic": "music",
+    "package-x-generic": "archive",
+    "font-x-generic": "type",
+    "application-x-executable": "terminal",
+    "application-x-generic": "file",
+    "x-office-document": "file-text",
+    "x-office-spreadsheet": "table",
+    "x-office-presentation": "presentation"
+}
+
+var FALLBACK = "file"
+
+function glyphFor(iconName) {
+    var g = GLYPHS[String(iconName)]
+    return g ? g : FALLBACK
+}
+
+// A row's mark. The backend resolves a symlink's icon to its target's, so a link to a directory
+// arrives as "folder"; every board draws such a row with the link mark instead, so the mode decides
+// here and the icon name only answers for what the row really is.
+function glyphForRow(iconName, mode) {
+    if (Format.isSymlink(mode))
+        return "symlink"
+    return glyphFor(iconName)
+}
+
+// The sidebar's own set, keyed on the favourite's label (Places.js leaf() or bookmark label),
+// the operator's overnight ask; any bookmark outside this set draws the plain folder mark.
+var SIDEBAR_GLYPHS = {
+    "Home": "house",
+    "Downloads": "download",
+    "Documents": "file-text",
+    "Pictures": "image",
+    "Videos": "film",
+    "Music": "music",
+    "Projects": "folder-git-2"
+}
+
+var SIDEBAR_FALLBACK = "folder"
+
+function sidebarGlyphFor(label) {
+    var g = SIDEBAR_GLYPHS[String(label)]
+    return g ? g : SIDEBAR_FALLBACK
+}
+
+// Lucide-static 1.38.0 geometry, ISC licence, https://github.com/lucide-icons/lucide, one "d"
+// per mark on its native 24 unit grid, recut to the Omarchy edge: baked rounded corners became
+// hard corners, real curves stayed; see AGENTS.md "Lucide path data", "The Omarchy cut".
+var PATHS = {
+    "info": "M12 11v6 M12 7h.01 M22 12a10 10 0 1 1-20 0a10 10 0 1 1 20 0",
+    "shelf": "M21 21H3V3h18v14H7V7h10v6h-6",
+    "pin": "M9 3h6v6l3 3v2H6v-2l3-3z M12 14v7",
+    "star": "M12 2l2.9 6.6 7.1.6-5.4 4.7 1.6 7L12 17.3l-6.2 3.6 1.6-7L2 9.2l7.1-.6z",
+    "globe": "M2 12h20 M12 2a15 15 0 0 1 0 20 M12 2a15 15 0 0 0 0 20 M22 12a10 10 0 1 1-20 0a10 10 0 1 1 20 0",
+
+    "file": "M4 22V2h10l6 6v14H4z M14 2v6h6",
+    "folder": "M2 20V3h6l2 3h12v14H2z",
+    "folders-first": "M2 12V4h6l2 2h12v6H2z M2 17h20 M2 21h20",
+    "file-text": "M4 22V2h10l6 6v14H4z M14 2v6h6 M8 9h2 M8 13h8 M8 17h8",
+    // LanguageMarks' Markdown mark, Flea's cut of dcurtis/markdown-mark (CC0): the frame, the M and the down arrow in one stroke.
+    "markdown": "M2 5h20v14H2z M5.5 15V9l3 3.5 3-3.5v6 M17 9v6 M14.5 12.5 17 15l2.5-2.5",
+    "html": "M4 2h16l-1.5 17L12 22l-6.5-3z M15.5 6.5h-7V11h7v5L12 17.5 8.5 16",
+    "code": "M16 18l6-6-6-6 M8 6l-6 6 6 6",
+    "image": "M3 3h18v18H3z M7 9A2 2 0 1 0 11 9A2 2 0 1 0 7 9Z M21 15l-3-3L6 21",
+    "film": "M3 3h18v18H3z M7 3v18 M3 7.5h4 M3 12h18 M3 16.5h4 M17 3v18 M17 7.5h4 M17 16.5h4",
+    // Note heads squared instead of lucide's circles: the set's brand tell.
+    "music": "M9 18V5l12-2v13 M3 15h6v6H3z M15 13h6v6h-6z",
+    "archive": "M2 3h20v5H2z M4 8v13h16V8 M10 12h4",
+    "type": "M12 4v16 M4 7V4h16v3 M9 20h6",
+    "terminal": "M12 19h8 M4 17l6-6-6-6",
+    "table": "M3 3h18v18H3z M12 3v18 M3 9h18 M3 15h18",
+    "presentation": "M2 3h20 M3 3v13h18V3 M7 21l5-5 5 5",
+    "house": "M3 21V10l9-7 9 7v11h-6v-8H9v8H3z",
+    "download": "M12 15V3 M7 10l5 5 5-5 M3 15v6h18v-6",
+    "folder-git-2": "M18 19a5 5 0 0 1-5-5v8 M9 20H2V3h6l2 2h12v5 M11 12A2 2 0 1 0 15 12A2 2 0 1 0 11 12Z M18 19A2 2 0 1 0 22 19A2 2 0 1 0 18 19Z",
+    // The two near-zero-length lines are lucide's own technique for the rack unit's LED dots; SquareCap draws them as square dots, matching the cut.
+    "server": "M2 2h20v8H2z M2 14h20v8H2z M6 6L6.01 6 M6 18L6.01 18",
+    // The Network group's add mark, replacing a Text "+" the operator read as a Christian cross.
+    "plus": "M5 12h14 M12 5v14",
+    // The picker rail's Recent mark, lucide rotate-ccw, the one SendPicker.html itself draws; the
+    // circle is a real curve and stays, and the arrow head is already square on lucide's own grid.
+    "history": "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8 M3 3v5h5",
+    // Lucide's hard-drive with its four baked 2 unit corner arcs cut square, which lands the body on
+    // (6,4) (18,4) (22,12) (22,20) (2,20) (2,12); the divider and the two LED dots are lucide's own.
+    "drive": "M6 4h12l4 8v8H2v-8z M2 12h20 M6 16L6.01 16 M10 16L10.01 16",
+    // The DEVICES rail's phone mark, lucide's smartphone with its rx=2 body rect cut square the way
+    // drive's arcs were; the home-button dot is lucide's own near-zero line, drawn as server's are.
+    "smartphone": "M5 2h14v20H5z M12 18L12.01 18",
+    // Its GPhoto2 sibling, per the PhoneMark board: lucide's camera with the four a2 2 body arcs cut
+    // to (2,7) (22,7) (22,20) (2,20), the pentaprism kept, and the lens a genuine circle, cut rule 4.
+    "camera": "M14.5 4h-5L7 7H2v13h20V7h-5z M15 13a3 3 0 1 1-6 0a3 3 0 1 1 6 0",
+    // The rail menu's release mark, the shelf's "for: unmount": lucide's triangle corner arcs
+    // extend to (12, 2.09) (22.32, 13) (1.68, 13) and snap to grid, its rx=1 bar rect squares off.
+    "eject": "M12 2 22 13H2z M3 17h18v4H3z",
+    // Task 22's transport strip, recut sharp like the rest of the set.
+    "play": "M6 4l14 8-14 8z",
+    "pause": "M14 3h5v18h-5z M5 3h5v18H5z",
+    // The search strip's mark; the lens is a real curve, so it stays a circle under the cut.
+    "search": "M16.7 16.7 21 21 M3 11A8 8 0 1 0 19 11A8 8 0 1 0 3 11Z",
+    // The filter strip's mark, the funnel the icon spec already shelves and the Main board draws.
+    "filter": "M3 4h18l-7 8v7l-4 2v-9z",
+    // The context menu's own seven marks, added with the operations surface that draws them.
+    // The canvas's own open folder, which keeps the closed folder's back panel byte for byte.
+    "folder-open": "M2 20V3h6l2 3h12v3 M22 11l-2.5 9H2l2.5-9z",
+    // OpenWith.html draws this window for the Open with row, its tail row and an app the theme cannot name.
+    "app-window": "M3 4h18v16H3z M3 9h18 M6 6.5h.01 M9 6.5h.01",
+    "undo": "M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8 M3 3v5h5",
+    "rename": "M3 21l1-4L17 4l3 3L7 20l-4 1z M14 7l3 3",
+    "file-plus": "M6 22V2h8l4 4v16H6z M14 2v4h4 M12 11v6 M9 14h6",
+    // lucide's own folder-plus is the folder body byte for byte plus these two strokes, so the recut
+    // body is reused verbatim and only the plus is new; the specimen sheet's 5 unit plus is not it.
+    "folder-plus": "M2 20V3h6l2 3h12v14H2z M12 10v6 M9 13h6",
+    "trash": "M3 6h18 M8 6V3h8v3 M6 6l1.2 15h9.6L18 6 M10 10v7 M14 10v7",
+    // A diamond eye with a square pupil: lucide's own eye is two arcs meeting at points, which the cut squares off.
+    "eye": "M12 5 22 12 12 19 2 12z M10 10h4v4h-4z",
+    "eye-off": "M12 5 22 12 12 19 2 12z M10 10h4v4h-4z M4 4l16 16",
+    // Replaces the "▸" Text the menu used to draw, so it stops mixing a font dingbat into a path language.
+    "chevron-right": "M9 18l6-6-6-6",
+    "chevron-down": "M6 9l6 6 6-6",
+    "chevron-left": "M15 18l-6-6 6-6",
+    // The window chrome's own five marks, added with the bar that draws them.
+    "arrow-left": "M19 12H5 M12 19l-7-7 7-7",
+    "arrow-up": "M12 19V5 M5 12l7-7 7 7",
+    // The bullets are lucide's own zero-length-line technique, which SquareCap draws as square dots.
+    "list": "M8 6h13 M8 12h13 M8 18h13 M3 6L3.01 6 M3 12L3.01 12 M3 18L3.01 18",
+    "columns": "M3 3h18v18H3z M9 3v18 M15 3v18",
+    "preview": "M3 3h18v18H3z M15 3v18",
+    "dual": "M3 4h8v16H3z M13 4h8v16h-8z",
+    "grid": "M3 3h8v8H3z M13 3h8v8h-8z M3 13h8v8H3z M13 13h8v8h-8z",
+    // The preview column's own two, taken from the canvas's icon table rather than recut from lucide.
+    "symlink": "M7 17L17 7 M8 7h9v9",
+    // The dot is the zero-length-line technique again, which SquareCap draws square.
+    "alert": "M12 2 23 21H1z M12 10v4 M12 18L12.01 18",
+    // The Locked pane state draws this beside it: the shackle is a real curve so it stays an arc, and the keyhole is the same dot technique.
+    "lock": "M4 11h16v10H4z M8 11V7a4 4 0 0 1 8 0v4 M12 15h.01",
+    // The compress submenu's With-password row: a bow ring, a shaft and two teeth; the bow is a true circle under the cut.
+    "key": "M3 7a4 4 0 1 0 8 0a4 4 0 1 0-8 0 M10.5 10.5l8 8 M16 16l2.5-2.5 M18.5 18.5l1.5-1.5",
+    // The operations rows the archive and convert subsystems draw, from the spec's own glyph shelf.
+    "archive-out": "M2 3h20v5H2z M4 8v13h16V8 M12 18v-6 M9 15l3-3 3 3",
+    // The Move to Dropbox row, which the canvas draws with the network mark.
+    "network": "M9 2h6v6H9z M2 16h6v6H2z M16 16h6v6h-6z M12 8v4 M5 16v-4h14v4",
+    // The convert popup's checkbox mark.
+    "check": "M4 12l6 6L20 6",
+    // The Tags row's mark: a square-cornered price tag with its hole as a SquareCap dot.
+    "tag": "M3 3h7l11 11-7 7L3 10z M7.5 7.5L7.51 7.5",
+    // The PDF viewer's own three, recut sharp like the rest of the set; "maximize" is lucide's
+    // name for the mark the canvas calls expand.
+    "minus": "M5 12h14",
+    "maximize": "M8 3H3v5 M16 3h5v5 M8 21H3v-5 M16 21h5v-5",
+    "x": "M6 6l12 12 M18 6 6 18",
+    "sliders": "M4 21v-7 M4 10V3 M12 21v-9 M12 8V3 M20 21v-5 M20 12V3 M2 14h4 M10 8h4 M18 16h4",
+    // Grid zoom's own mark, the SettingsGrammar board's arrows, lucide's move-horizontal recut sharp.
+    "move-horizontal": "M4 12h16 M8 8l-4 4 4 4 M16 8l4 4-4 4",
+    // The background menu's Sort by row, Menus.html's own geometry: three rules shortening to the
+    // right of a bare down arrow. IconSets.html names this mark when it caps the corner radius.
+    "sort": "M11 5h10 M11 9h7 M11 13h4 M7 5v14 M7 19l-3-3 M7 19l3-3",
+    // MediaMute rule 2: lucide's speaker polygon is already hard-cornered, and the two waves are
+    // genuine arcs that stay arcs under cut rule 4; the cross is two lines.
+    "volume": "M11 5L6 9H2v6h4l5 4z M15.5 8.5a5 5 0 0 1 0 7 M19 5a10 10 0 0 1 0 14",
+    "volume-x": "M11 5L6 9H2v6h4l5 4z M22 9l-6 6 M16 9l6 6",
+    // The three basic clipboard rows the context menu grew with its visibility settings. Lucide's
+    // scissors and clipboard both carry arcs; these are the cut's own square handles and square tray.
+    "scissors": "M5 3l14 14 M19 3L5 17 M2 17h5v5H2z M17 17h5v5h-5z",
+    "copy": "M9 8h12v13H9z M4 16V3h13",
+    "clipboard": "M9 2h6v4H9z M6 4H3v18h18V4h-3 M8 12h8 M8 16h5",
+    // The Keys section's rail mark: the key caps are the same zero-length-line dots the list mark uses.
+    "keyboard": "M2 6h20v12H2z M6 10L6.01 10 M10 10L10.01 10 M14 10L14.01 10 M18 10L18.01 10 M8 14h8",
+    // Invert selection's mark, lucide's contrast, its outer ring kept a true curve.
+    "contrast": "M12 2a10 10 0 1 0 0 20a10 10 0 1 0 0-20 M12 18a6 6 0 0 0 0-12v12z",
+    // Settings > Click and refresh's Open items with mark: the arrow head and its tail, as Icons040 cuts it.
+    "pointer": "M4 4l16 6.5-7 2-2 7z M13 13l6 6"
+}
+
+// The sub-paths a mark fills as well as strokes, by name; ui/Glyph.qml draws them in the mark's own ink.
+var FILLED = {
+    // MenuAdditions040: Invert selection's right half disc is solid, lucide's contrast.
+    "contrast": "M12 18a6 6 0 0 0 0-12v12z"
+}
+
+function filledPathFor(name) {
+    return FILLED[name] || ""
+}
+
+function pathFor(name) {
+    return PATHS[name] || PATHS[FALLBACK]
+}

package/test/fixtures/qml/flea-theme/ui/js/Input.js

@@ -0,0 +1,39 @@
+.pragma library
+
+// Delete carries DEL through libxkbcommon; retain SheetQuery's single-character semantics.
+function isPrintable(text) {
+    var s = String(text || "")
+    return s.length === 1 && s >= " " && s !== "\u007f"
+}
+
+// Issue 287's paste chords, matched on the four real modifiers the way ui/js/Keymap.js matches keys.
+function isPasteKey(event) {
+    var mods = event.modifiers & (Qt.ControlModifier | Qt.ShiftModifier | Qt.AltModifier | Qt.MetaModifier)
+    return (event.key === Qt.Key_V && mods === Qt.ControlModifier)
+        || (event.key === Qt.Key_Insert && mods === Qt.ShiftModifier)
+}
+
+// The clipboard's first line, keeping printable characters and whole surrogate pairs only.
+function cleanPaste(text) {
+    var line = String(text || "").split(/\r\n|[\r\n]/)[0]
+    var out = ""
+    for (var i = 0; i < line.length; i++) {
+        var code = line.charCodeAt(i)
+        var low = i + 1 < line.length ? line.charCodeAt(i + 1) : 0
+        if (code >= 0xd800 && code <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) {
+            out += line.substr(i, 2)
+            i++
+        } else if ((code < 0xd800 || code > 0xdfff) && isPrintable(line.charAt(i))) {
+            out += line.charAt(i)
+        }
+    }
+    return out
+}
+
+// Hands a query line's paste to its own typing route; the chord is consumed even when nothing is left to type.
+function pasteInto(host, typeText) {
+    var pasted = cleanPaste(host.clipboardText())
+    if (pasted.length > 0)
+        typeText(pasted)
+    return true
+}

package/test/fixtures/qml/flea-theme/ui/js/KeyName.js

@@ -0,0 +1,64 @@
+.pragma library
+
+.import "Keymap.js" as Keymap
+.import "Format.js" as Format
+
+// A key the way the running preset binds it, spelled for a sentence; the sentences stay in their own modules with a "%1" for the key.
+
+// The names keys.toml gives a key that a person would write as a mark.
+var MARKS = { plus: "+", minus: "-", equal: "=", underscore: "_", greater: ">", less: "<", slash: "/", period: ".", comma: "," }
+var MODIFIERS = { ctrl: "Ctrl", shift: "Shift", alt: "Alt", super: "Super" }
+
+// Sample input: "ctrl-shift-n" answers "Ctrl+Shift+N"; "delete" answers "Delete"; "ctrl-shift-plus" answers "Ctrl+Shift++".
+function spelled(keys) {
+    var parts = String(keys).split("-")
+    var out = []
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i]
+        if (i < parts.length - 1 && MODIFIERS[part] !== undefined) { out.push(MODIFIERS[part]); continue }
+        if (MARKS[part] !== undefined) out.push(MARKS[part])
+        else if (part.length === 1) out.push(out.length > 0 ? part.toUpperCase() : part)
+        else out.push(part.charAt(0).toUpperCase() + part.substring(1))
+    }
+    return out.join("+")
+}
+
+// The row the running preset binds to an action in the listing, the first of the given modifier kind when one is asked for.
+function rowFor(action, mods) {
+    var rows = Keymap.bindingRows(Keymap.preset, "gui", Keymap.actionGroup(action))
+    for (var i = 0; i < rows.length; i++) {
+        if (rows[i].action === action && (mods === undefined || rows[i].mods === mods)) return rows[i]
+    }
+    return null
+}
+
+// The key to press for an action: the plain key the menus draw, else the first chord. "" when the preset binds none.
+function keyFor(action) {
+    var plain = Keymap.hintFor(action)
+    if (plain.length > 0) return plain
+    var row = rowFor(action)
+    return row === null ? "" : spelled(row.keys)
+}
+
+// The key of one modifier kind ("none" for a key pressed alone), "" when the preset binds none.
+function keyOf(action, mods) {
+    var row = rowFor(action, mods)
+    return row === null ? "" : spelled(row.keys)
+}
+
+// A whole sentence with "%1" for the key bound to an action, "" when the preset binds none so no hint names a missing key.
+function hinted(template, action) {
+    var key = keyFor(action)
+    return key.length > 0 ? Format.fill(template, key) : ""
+}
+
+// The same with "%1", "%2" and on for the keys bound to several actions, "" when the preset leaves any one of them unbound.
+function hintedAll(template, actions) {
+    var keys = [template]
+    for (var i = 0; i < actions.length; i++) {
+        var key = keyFor(actions[i])
+        if (key.length === 0) return ""
+        keys.push(key)
+    }
+    return Format.fill.apply(null, keys)
+}