flea-qml 0.0.0-stage → 0.2.0

package/ui/js/LocalSend.js

@@ -0,0 +1,39 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "Ops.js" as Ops
+
+// The sentences that carry a name or a reason, each filled by Format.fill.
+var WORDS = {
+    sending: "Sending %1 to %2 with LocalSend",
+    reason: "LocalSend · %1"
+}
+
+// Directive 71's three sentences, kept out of the QML so the wording is tested rather than read off
+// a screenshot. The dispatch, the verdict the CLI came back with, and the one refusal Flea itself
+// can hit: a row whose binary left between the menu opening and the peer being chosen.
+// The one call ui/Pane.qml makes: the service either took the send or the CLI is gone.
+function send(pane, service, provider, peer, paths) {
+    // A refusal is one of two things and they are not the same sentence: nothing to send, or no CLI
+    // to send it with. Blaming the CLI for an empty pick told the user a binary was gone while it sat on PATH.
+    if (paths.length === 0) { pane.message("There is nothing to send.", true); return }
+    if (!service.send(peer, paths)) { pane.message(missing(provider), true); return }
+    pane.message(sending(peer, paths), false)
+}
+
+function sending(peer, paths) {
+    if (paths.length === 1)
+        return Format.fill(WORDS.sending, Ops.leaf(paths[0]), peer)
+    return Format.fill(WORDS.sending, Ops.items(paths.length), peer)
+}
+
+// The CLI ends its own run when the transfer does, so this is the only result Flea ever knows.
+function verdict(ok, reason) {
+    if (ok) return "LocalSend finished the transfer."
+    return reason && reason.length > 0 ? Format.fill(WORDS.reason, reason) : "LocalSend could not finish the transfer."
+}
+
+function missing(provider) {
+    return provider && provider.reason ? Format.fill(WORDS.reason, provider.reason)
+                                       : "localsend-cli is no longer installed."
+}

package/ui/js/LockedMenu.js

@@ -0,0 +1,63 @@
+.pragma library
+
+.import "Menu.js" as Menu
+.import "Errors.js" as Errors
+.import "StateWords.js" as StateWords
+
+// The Locked tile's own menu, issue 193 follow-up (2026-09-24). A right click on the
+// tile names the locked folder itself, never the parent behind it, so only rows that act
+// on that folder without listing it are offered: terminal, permissions and path. Kept in
+// ui/js/Menu.js INVENTORY order, one group, so the menu never reorders under its caller.
+// For 0.3.8: the tile keeps its single Copy path row, acting as before,
+// while its visibility follows the Copy as switch that replaced Copy path in Settings > Menus.
+// A Places row's menu keeps the flat row the same way (ui/js/Menu.js availableEntry).
+var LOCKED_IDS = ["openTerminal", "permissions", "copyAs"]
+
+// The bar's sentence when every locked id is hidden, naming the switch that brings them back.
+var LOCKED_REFUSAL = "Open in terminal, Permissions and Copy as are hidden in Settings > Menus."
+
+// Sample input: { lockedMode: 0o040700, hiddenActions: [] }
+function lockedEntries(p) {
+    var out = [], group = ""
+    var scoped = { rowMode: p.lockedMode, selectionCount: 1, hiddenActions: p.hiddenActions }
+    for (var i = 0; i < Menu.INVENTORY.length; i++) {
+        var spec = Menu.INVENTORY[i]
+        if (LOCKED_IDS.indexOf(spec[0]) < 0 || Menu.isHidden(p.hiddenActions, spec[0])) continue
+        // The Copy as spec lends its inventory slot and its hidden switch; the row it draws
+        // is still the flat Copy path row, which ui/Pane.qml performLocked answers with copyText.
+        var id = spec[0] === "copyAs" ? "copypath" : spec[0]
+        var entry = { id: id, action: id, label: spec[0] === "copyAs" ? "Copy path" : spec[1], glyph: spec[2] }
+        if (!Menu.availableEntry(entry, scoped, "F")) continue
+        if (entry.action === "permissions") {
+            var permission = lockedPermissions(p.lockedMode)
+            entry.disabled = permission.disabled
+            if (permission.errored) { entry.errored = true; if (permission.hint) entry.hint = permission.hint }
+            else { delete entry.errored; delete entry.hint }
+        }
+        if (out.length && group !== spec[4]) out.push({ separator: true })
+        group = spec[4]
+        out.push(entry)
+    }
+    return out
+}
+
+// Sample input: { lockedMode: 0o040700, hiddenActions: ["openTerminal", "permissions", "copyAs"] }
+function lockedRefusal(p) {
+    return lockedEntries(p).length === 0 ? LOCKED_REFUSAL : ""
+}
+
+// The mode is the locked directory's own, so ownership decides: a denial on owner-readable
+// owner-executable proves somebody else owns it, and nobody but the owner can chmod it back,
+// which reads red with its state word, the way a provider that cannot answer does. An owner
+// locked out too may still be the owner, so that row stays plain: it is the way back in.
+function lockedPermissions(mode) {
+    var kind = (Number(mode) || 0) & 0o170000
+    if (kind !== 0o100000 && kind !== 0o040000) {
+        var bad = { disabled: true, errored: true }
+        var word = StateWords.permissions(mode)
+        if (word) bad.hint = word
+        return bad
+    }
+    if (Errors.notYours(mode)) return { disabled: true, errored: true, hint: StateWords.WORDS.permissionsNotYours }
+    return { disabled: false }
+}

package/ui/js/MakeDefault.js

@@ -0,0 +1,186 @@
+.pragma library
+
+// Settings > About's Make Flea the default: which state the row is in, the note under it and what a press runs; ui/DefaultClaim.qml runs the processes.
+
+.import "Format.js" as Format
+
+// Whole sentences with "%1" for the program that never started, its name and not its command line.
+var WORDS = {
+    unstarted: "%1 could not start"
+}
+
+// The row's id, which ui/SettingsPanel.qml routes to the run instead of writing it into ui.json.
+var ROW_ID = "makeDefault"
+// The entry flea --default points the desktop at; the box is ticked exactly when xdg-mime answers it.
+var DESKTOP_ID = "com.thisisgm.flea.desktop"
+// src/main.rs claim_both() says this and still exits 0 when a build has no flea.portal to route file dialogs to.
+var SKIPPED = "no file chooser service is installed, so Flea could not become the file chooser"
+// src/defaults.rs EXIT_UNINSTALLED: the status claim() exits with when the running binary has no desktop entry to point at.
+var UNINSTALLED_STATUS = 3
+// The portal reads its routing once, at startup; try-restart leaves a portal that is not running alone.
+var RESTART = ["systemctl", "--user", "try-restart", "xdg-desktop-portal.service"]
+// flea's own stderr lines start with its name, which the note drops.
+var OWN_PREFIX = "flea: "
+
+// Nothing run in this process yet; an entry is assumed until the probe or a refusal says otherwise.
+function idle() {
+    return { running: false, claiming: false, reading: false, readFrom: 0, restarting: false, outcome: "", error: "", packaged: true }
+}
+
+// A run in flight, or a build with no entry, takes no press.
+function inert(claim) {
+    return claim.running || claim.packaged === false
+}
+
+// flea's arguments for a press, or null while the row is inert.
+function press(handler, claim) {
+    if (inert(claim))
+        return null
+    return handler === DESKTOP_ID ? ["--default", "off"] : ["--default"]
+}
+
+// A new run drops the last one's outcome; which way it goes picks the working note.
+function started(claim, args) {
+    return { running: true, claiming: args.length === 1, reading: false, readFrom: 0, restarting: false, outcome: "", error: "",
+             packaged: claim.packaged }
+}
+
+// Still running until a handler read numbered nextRead or later lands and a switch that went through has restarted the portal.
+// Sample stderr: "flea: no file chooser service is installed, so Flea could not become the file chooser\n"
+function finished(claim, code, stderr, nextRead) {
+    var text = stderr || ""
+    var next = Object.assign({}, claim, { reading: true, readFrom: nextRead, restarting: code === 0 })
+    if (code === 0) {
+        next.outcome = text.indexOf(SKIPPED) >= 0 ? "partly" : ""
+        return next
+    }
+    if (code === UNINSTALLED_STATUS) {
+        next.packaged = false
+        return next
+    }
+    next.outcome = "failed"
+    next.error = errorLine(text, code, claim.claiming)
+    return next
+}
+
+// xdg-mime's stderr reaches flea's own, so flea's line is the one that starts with its name.
+// Sample stderr: "xdg-mime: no method available\nflea: xdg-mime default exited 3\n"
+function errorLine(stderr, code, claiming) {
+    var lines = stderr.split("\n").map(function (line) { return line.trim() })
+    var own = lines.filter(function (line) { return line.indexOf(OWN_PREFIX) === 0 })[0]
+    if (own !== undefined)
+        return own.substring(OWN_PREFIX.length)
+    var first = lines.filter(function (line) { return line.length > 0 })[0]
+    return first !== undefined ? first : (claiming ? "flea --default" : "flea --default off") + " exited " + code
+}
+
+// The handler read numbered read has landed; only one begun after the run exited ends it, and only once the portal restart has answered too.
+function settled(claim, read) {
+    if (!claim.reading || read < claim.readFrom)
+        return claim
+    return Object.assign({}, claim, { reading: false, running: claim.restarting })
+}
+
+// A Process's exit and its collector's text land in either order (AGENTS.md "The state file"), so an answer is read once it holds both.
+// Sample: landed(landed({}, { code: 0 }), { text: "com.thisisgm.flea.desktop\n" }) is { code: 0, text: "com.thisisgm.flea.desktop\n" }
+function landed(answer, half) {
+    return Object.assign({}, answer, half)
+}
+
+// An empty text is an answer too: a run that says nothing has still finished saying it.
+function whole(answer) {
+    return answer.code !== undefined && answer.text !== undefined
+}
+
+// The whole answer a program that never started is given: no real exit status is negative.
+var NEVER_RAN = { code: -1, text: "" }
+
+// ui/ViewState.qml's writer rule, measured on Quickshell 0.3.1: a program that cannot start raises no exited, only running going false, and a real exit lands its status before that false.
+function neverRan(answer, running) {
+    return !running && answer.code === undefined
+}
+
+// The handler an answer states; any other status, a read that never ran among them, states none, which About shows as Not reported.
+function handlerOf(answer) {
+    return answer.code === 0 ? answer.text.trim() : ""
+}
+
+// A run whose program never started wrote nothing, so it is over at once, failed, naming what could not start.
+// Sample command: ["/usr/bin/flea", "--default"]
+function unstarted(claim, command) {
+    return Object.assign({}, claim, { running: false, reading: false, restarting: false, outcome: "failed",
+                                      error: Format.fill(WORDS.unstarted, String(command[0]).split("/").pop()) })
+}
+
+// A portal that would not restart keeps the switch as it went; partly keeps its own note, whose dialogs never follow.
+function restarted(claim, ok) {
+    var outcome = !ok && claim.outcome === "" ? "portal" : claim.outcome
+    return Object.assign({}, claim, { restarting: false, running: claim.reading, outcome: outcome })
+}
+
+// restarted() clears restarting on a real exit before running goes false, so a stop that finds it still set is a systemctl that never ran.
+function restartStopped(claim, running) {
+    return !running && claim.restarting ? restarted(claim, false) : claim
+}
+
+function probed(claim, found) {
+    return Object.assign({}, claim, { packaged: found })
+}
+
+// One of off, on, working, partly, portal, failed, unpackaged.
+function state(handler, claim) {
+    if (claim.packaged === false)
+        return "unpackaged"
+    if (claim.running)
+        return "working"
+    if (claim.outcome === "failed")
+        return "failed"
+    if (handler === DESKTOP_ID && claim.outcome === "partly")
+        return "partly"
+    if (claim.outcome === "portal")
+        return "portal"
+    return handler === DESKTOP_ID ? "on" : "off"
+}
+
+// [words, role] for the one line under the row, or null when off says nothing.
+function note(handler, claim) {
+    var now = state(handler, claim)
+    if (now === "on")
+        return ["Folders, Show in folder and file dialogs open Flea.", "foreground"]
+    if (now === "working")
+        return [claim.claiming ? "Making Flea the default" : "Handing folders back", "muted"]
+    if (now === "partly")
+        return ["File dialogs need the flea package's portal files.", "foreground"]
+    if (now === "portal")
+        return ["File dialogs follow after xdg-desktop-portal restarts.", "foreground"]
+    if (now === "failed")
+        return [claim.error, "error"]
+    if (now === "unpackaged")
+        return ["Install a Flea package to make it the default.", "foreground"]
+    return null
+}
+
+// The check row and its note for About's This box group; the note elides on one line rather than wrapping.
+function rows(handler, claim) {
+    var live = claim || idle()
+    var out = [{ kind: "check", id: ROW_ID, label: "Make Flea the default", on: handler === DESKTOP_ID, inert: inert(live) }]
+    var line = note(handler, live)
+    if (line !== null)
+        out.push({ kind: "hint", label: line[0], role: line[1], elide: "right" })
+    return out
+}
+
+// src/userfile.rs data_file()'s ladder: the data home, then every data dir, an empty variable read as unset.
+// Sample env: { HOME: "/home/gm", XDG_DATA_HOME: "", XDG_DATA_DIRS: "/usr/local/share:/usr/share" }
+function entryPaths(env) {
+    var home = env.XDG_DATA_HOME || (env.HOME ? env.HOME + "/.local/share" : "")
+    var dirs = (env.XDG_DATA_DIRS || "/usr/local/share:/usr/share").split(":")
+    return [home].concat(dirs)
+        .filter(function (dir) { return dir.length > 0 })
+        .map(function (dir) { return dir + "/applications/" + DESKTOP_ID })
+}
+
+// data_file()'s regular-file test; each path is an argument, so no path reaches the shell as code.
+function probeCommand(paths) {
+    return ["sh", "-c", "for f; do [ -f \"$f\" ] && exit 0; done; exit 1", "sh"].concat(paths)
+}

package/ui/js/MarkBox.js

@@ -0,0 +1,7 @@
+.pragma library
+
+// The picker's mark box: bodySmall plus a hairline inside a two-hairline border, which a Rectangle's size includes.
+// Sample input: outer(13, 1) === 18.
+function inner(bodySmall, hairline) { return bodySmall + hairline }
+function border(hairline) { return 2 * hairline }
+function outer(bodySmall, hairline) { return inner(bodySmall, hairline) + 2 * border(hairline) }

package/ui/js/Markdown.js

@@ -0,0 +1,119 @@
+.pragma library
+
+.import "Format.js" as Format
+.import "MdUrl.js" as MdUrl
+.import "MdHtml.js" as MdHtml
+.import "MdResolve.js" as Resolve
+.import "MdBlocks.js" as Blocks
+
+// Markdown's stable API: remote images become a placeholder, only files inside the document folder load.
+
+// Whole sentences with "%1" for a value, filled by fill so each translates as one.
+var WORDS = {
+    deepNotice: "This file nests deeper than %1 levels, so Flea shows its source."
+}
+
+var RENDERED = "rendered"
+var SOURCE = "source"
+
+// Deeper nesting than this shows the source behind one notice.
+var NESTING_LIMIT = Blocks.NESTING_LIMIT
+
+function deepNotice() {
+    return Format.fill(WORDS.deepNotice, NESTING_LIMIT)
+}
+
+// Only these three schemes open in the default application; relative links, anchors and every other scheme open nothing.
+function isExternalLink(url) {
+    return Resolve.isExternalLink(url)
+}
+
+function dirOf(path) {
+    return MdUrl.dirOf(path)
+}
+
+function placeholder(host) {
+    return MdUrl.placeholder(host)
+}
+
+function lineCount(text) {
+    var body = String(text)
+    // Match src/backend/linecount.rs: a trailing LF ends a line; only an unterminated tail adds one.
+    return body.length === 0 ? 0 : body.split("\n").length - (body.endsWith("\n") ? 1 : 0)
+}
+
+function countLine(n) {
+    return n === 1 ? "1 line" : Format.count(n) + " lines"
+}
+
+// A big document's first screen draws from this many blocks, which the worker sends ahead of the rest.
+var HEAD_BLOCKS = 96
+
+function blocks(source, dir, chrome, ink) {
+    return Blocks.blocks(source, dir, chrome, ink)
+}
+
+// The deep verdict reads this many bytes of the head at most: the pass is forward only, so a head that nests too deep is deep in the whole text.
+var DEEP_HEAD_BYTES = 16384
+
+// Sample: "> ".repeat(400) + "x" answers { deep: true, scanned: 801 }; a head that never nests too deep answers deep false.
+function deepHead(source) {
+    var head = String(source)
+    if (head.length > DEEP_HEAD_BYTES)
+        head = head.slice(0, Math.max(0, head.lastIndexOf("\n", DEEP_HEAD_BYTES)))
+    var state = Blocks.referenceState()
+    Blocks.blockPass(MdHtml.documentText(head).split("\n"), state, undefined, true)
+    return { deep: state.deep === true, scanned: head.length }
+}
+
+// The one block a document nested too deep parses to, so a deep head lands it with no parse of the text.
+function deepBlocks() {
+    return [{ type: "deep", limit: NESTING_LIMIT }]
+}
+
+// The Source view lays out chunks of whole lines about this many characters long, so a screenful of a large file costs a few chunks.
+var SOURCE_CHUNK_CHARS = 4096
+// No chunk is longer than this: a line that runs past it is cut at its last space past SOURCE_CHUNK_CHARS, or at the limit when it has none.
+var SOURCE_CHUNK_MAX = 2 * SOURCE_CHUNK_CHARS
+
+// A high surrogate that ends a hard cut steps the cut back one unit, so no chunk splits an astral pair.
+var HIGH_FIRST = 0xD800
+var HIGH_LAST = 0xDBFF
+
+// Sample: 20000 chars in lines of 100 answers [0, 4100, 8200, 12300]; a short line straddling the window ends before it, an 8192-char line ends at its newline, a spaceless astral run steps back off a split pair.
+function sourceChunkStarts(text) {
+    var starts = [0]
+    var from = 0
+    while (text.length - from > SOURCE_CHUNK_MAX) {
+        var cut = text.indexOf("\n", from + SOURCE_CHUNK_CHARS)
+        var next
+        if (cut >= 0 && cut <= from + SOURCE_CHUNK_MAX) {
+            next = cut + 1
+        } else {
+            var back = text.lastIndexOf("\n", from + SOURCE_CHUNK_CHARS - 1)
+            if (back > from) {
+                next = back + 1
+            } else {
+                var space = text.lastIndexOf(" ", from + SOURCE_CHUNK_MAX - 1)
+                next = space >= from + SOURCE_CHUNK_CHARS ? space + 1 : from + SOURCE_CHUNK_MAX
+                if (next === from + SOURCE_CHUNK_MAX) {
+                    var unit = text.charCodeAt(next - 1)
+                    if (unit >= HIGH_FIRST && unit <= HIGH_LAST) {
+                        next--
+                    }
+                }
+            }
+        }
+        starts.push(next)
+        from = next
+    }
+    return starts
+}
+
+// Chunk i without the newline that ends it, if one does; a cut inside a line drops nothing, so the chunks are the text again.
+function sourceChunk(text, starts, i) {
+    var end = i + 1 < starts.length ? starts[i + 1] : text.length
+    if (i + 1 < starts.length && text.charAt(end - 1) === "\n")
+        end--
+    return text.slice(starts[i], end)
+}

package/ui/js/MarkdownLists.js

@@ -0,0 +1,86 @@
+.pragma library
+
+// MarkdownLists: where each entry of a list block draws, from the parser's depths, markers and gaps.
+
+// Unordered markers by depth are disc, circle, square (U+2022, U+25E6, U+25AA), then square for deeper levels.
+var BULLETS = ["•", "◦", "▪"]
+var ORDERED_START = /^\d/
+
+function bulletAt(depth) {
+    return BULLETS[Math.min(depth, BULLETS.length - 1)]
+}
+
+// Sample input: a "-" entry at depth 0 under an open ordered run changes the marker kind, so fresh(false, 0) opens the run it joins.
+// The answer is the run the entry joins, stored at open[depth] with open cut to that depth; fresh builds each caller's own run record.
+function runStep(open, previous, depth, given, listOrdered, fresh) {
+    var run = open[depth]
+    var ordered = given === "" ? (run !== undefined ? run.ordered : listOrdered) : ORDERED_START.test(given)
+    // A deeper entry opens a list under the item above, and a changed marker kind starts a list beside the old one.
+    if (run === undefined || depth > previous || ordered !== run.ordered)
+        run = fresh(ordered, depth)
+    open.length = depth
+    open[depth] = run
+    return run
+}
+
+// Sample input: items a (depth 0) and b (depth 1) answer cells at x 0 and at a's marker width plus spacing.
+// advance(text) is the marker font's advance width; spacing is the gap between a marker and its text.
+function layout(block, advance, spacing) {
+    var count = block.items.length
+    var out = []
+    var runs = []
+    var open = []
+    var previous = -1
+    var bullet = advance(BULLETS[0])
+    // The marker a run's column is sized by: the parser's own for an ordered run, the depth's bullet for the rest.
+    function widest(held, depth) {
+        return held.ordered ? held.marker : bulletAt(depth)
+    }
+    // A run opens under the run one depth up, and is listed so the column pass below can place it.
+    function opened(ordered, depth) {
+        var run = { depth: depth, ordered: ordered, width: 0, parent: depth > 0 ? open[depth - 1] : undefined, x: 0 }
+        runs.push(run)
+        return run
+    }
+    // A chunk opens under the runs the list had open before it, each at the column the whole list gives it.
+    var carry = block.carry !== undefined ? block.carry : []
+    for (var c = 0; c < carry.length; c++) {
+        var held = { depth: c, ordered: carry[c].ordered, width: advance(widest(carry[c], c)), parent: c > 0 ? open[c - 1] : undefined, x: 0 }
+        runs.push(held)
+        open[c] = held
+        previous = c
+    }
+    for (var k = 0; k < count; k++) {
+        var depth = block.depths !== undefined ? block.depths[k] : 0
+        var given = block.markers !== undefined ? block.markers[k] : block.ordered ? (block.start + k) + "." : BULLETS[0]
+        var run = runStep(open, previous, depth, given, block.ordered, opened)
+        var ordered = run.ordered
+        var marker = given === "" ? "" : ordered ? given : bulletAt(depth)
+        run.width = Math.max(run.width, advance(marker))
+        // A long list's later chunks keep the first chunk's marker column width, so a chunk's text stays in line with its neighbours.
+        if (depth === 0 && ordered && block.last !== undefined)
+            run.width = Math.max(run.width, advance(block.last + "."))
+        // A joined chunk lies flush under its predecessor, so its first entry keeps the gap the whole list gave it.
+        var gap = (k > 0 || block.joined === true) && block.gaps !== undefined && (block.gaps[k] || (k > 0 && depth > previous && block.gaps[k - 1]))
+        out.push({ x: 0, w: 0, marker: marker, gap: gap === true, run: run })
+        previous = depth
+    }
+    // The runs still open at the chunk's end take the column the whole list gives them, which a later entry may widen.
+    var tail = block.tail !== undefined ? block.tail : []
+    for (var t = 0; t < tail.length; t++) {
+        if (open[t] !== undefined && open[t].ordered === tail[t].ordered)
+            open[t].width = Math.max(open[t].width, advance(widest(tail[t], t)))
+    }
+    // Parents come before their children in runs, so a run's own column is known when its children read it.
+    for (var r = 0; r < runs.length; r++) {
+        var at = runs[r]
+        // A chunk that opens inside a nested list with nothing carried has no parent here, so each missing level counts one disc column.
+        at.x = at.parent !== undefined ? at.parent.x + at.parent.width + spacing : at.depth * (bullet + spacing)
+    }
+    for (var e = 0; e < out.length; e++) {
+        out[e].x = out[e].run.x
+        out[e].w = out[e].run.width
+        delete out[e].run
+    }
+    return out
+}

package/ui/js/MarkdownMaths.js

@@ -0,0 +1,58 @@
+.pragma library
+
+// MarkdownMaths: an inline formula's SVG as a picture inside a line of Qt rich text, and the code span it replaces.
+var SPAN = /<code data-math="inline"[^>]*>[\s\S]*?<\/code>/g
+var ROOT = /<svg\b[^>]*>/
+// Marks encodeURIComponent leaves bare that break an attribute or a Markdown destination, so they are percent-encoded too.
+var URL_MARKS = /[()'!*~]/g
+var HEX_RADIX = 16
+// A transparent 1 by 1 PNG, and the height a calibration picture of it is laid out at.
+var CLEAR = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+var CALIBRATION_HEIGHT = 100
+
+// Sample input: 'a <code data-math="inline" style="background-color:#222">x&#94;2</code> b' holds one span.
+function spans(html) {
+    return String(html).match(SPAN) || []
+}
+
+// Sample input: ('a <code data-math="inline">x</code> b', ['<img src="p">']) answers 'a <img src="p"> b'; an empty picture keeps its code span.
+function compose(html, pictures) {
+    var at = 0
+    return String(html).replace(SPAN, function (span) {
+        var picture = pictures[at++]
+        return picture !== undefined && picture !== "" ? picture : span
+    })
+}
+
+function attr(root, name) {
+    var m = new RegExp("\\s" + name + "=\"([^\"]*)\"").exec(root)
+    return m === null ? null : m[1]
+}
+
+function percent(c) {
+    return "%" + c.charCodeAt(0).toString(HEX_RADIX).toUpperCase()
+}
+
+// Sample input: svg '<svg width="30px" height="20px" viewBox="0 -15 60 20">' answers an <img> that sits that formula's baseline on the text's, or "" when the root carries no size or svg is "".
+// anchor is how far above the baseline Qt centres a middle-aligned picture in this font; a picture shorter than minTall is padded to it, since a short one is placed otherwise.
+function picture(svg, anchor, minTall) {
+    var root = ROOT.exec(svg)
+    if (root === null)
+        return ""
+    var width = parseFloat(attr(root[0], "width"))
+    var height = parseFloat(attr(root[0], "height"))
+    var box = (attr(root[0], "viewBox") || "").trim().split(/\s+/).map(Number)
+    if (!(width > 0) || !(height > 0) || box.length !== 4 || box.some(isNaN) || !(box[3] > 0))
+        return ""
+    var unit = height / box[3]
+    var above = -box[1] * unit
+    var below = (box[1] + box[3]) * unit
+    var tall = Math.ceil(Math.max(2 * Math.max(above - anchor, below + anchor, 0), minTall))
+    // The formula's baseline sits at the picture's centre plus the anchor, whatever its depth.
+    var top = tall / 2 + anchor
+    var padded = svg.replace(ROOT, root[0]
+        .replace(/\sheight="[^"]*"/, " height=\"" + tall + "px\"")
+        .replace(/\sviewBox="[^"]*"/, " viewBox=\"" + box[0] + " " + (-top / unit) + " " + box[2] + " " + (tall / unit) + "\""))
+    var url = "data:image/svg+xml," + encodeURIComponent(padded).replace(URL_MARKS, percent)
+    return "<img src=\"" + url + "\" width=\"" + width + "\" height=\"" + tall + "\" style=\"vertical-align: middle\" />"
+}

package/ui/js/MarkdownPictures.js

@@ -0,0 +1,32 @@
+.pragma library
+
+// MarkdownPictures: a Markdown text's inline pictures, read for their addresses and capped at the width the text has.
+var PICTURE = /!\[[^\]]*\]\(([^)\s]*)[^)]*\)/g
+
+// Sample input: "`![t](https://tracker.example/p.png)` and ![l](file:///d/p.png)" answers ["file:///d/p.png"].
+// Only file: addresses load (the parser leaves every other picture as a placeholder), so a remote address never reaches an Image.
+function urls(source) {
+    var found = []
+    String(source).replace(PICTURE, function (whole, url) {
+        if (/^file:/i.test(url))
+            found.push(url)
+        return whole
+    })
+    return found
+}
+
+// Sample input: ("a ![x](file:///p.png) b", { "file:///p.png": { w: 160, h: 40 } }, 100) answers text 'a <img src="file:///p.png" width="100" height="25" /> b' and tallest 25.
+// A picture wider than the limit is written as an img tag scaled to it with its ratio kept, and one that fits (or is not decoded yet) stays as it is.
+function fit(source, sizes, limit) {
+    var tallest = 0
+    var text = String(source).replace(PICTURE, function (whole, url) {
+        var size = sizes[url]
+        if (size === undefined || size.w <= 0)
+            return whole
+        var capped = limit > 0 && size.w > limit
+        var tall = capped ? Math.max(1, Math.round(size.h * limit / size.w)) : size.h
+        tallest = Math.max(tallest, tall)
+        return capped ? '<img src="' + url.replace(/"/g, "%22").replace(/&/g, "&amp;") + '" width="' + limit + '" height="' + tall + '" />' : whole
+    })
+    return { text: text, tallest: tallest }
+}