flea-qml 0.0.0-stage → 0.2.0

package/ui/js/MdHtmlImage.js

@@ -0,0 +1,179 @@
+.pragma library
+
+// MdHtmlImage: a raw HTML image on its own line, alone or inside a centring paragraph, as an image block.
+.import "MdUrl.js" as MdUrl
+.import "MdHtml.js" as MdHtml
+
+// Sample input: '<p align="center"><a href="https://x"><img src="a.png"></a></p>' splits into wrapper, link, image, link end and closer.
+var IMAGE_LINE = /^(<(?:p|div)\b[^<>]*>)?\s*(<a\b[^<>]*>)?\s*(<img\b[^<>]*>)\s*(<\/a>)?\s*(<\/(?:p|div)>)?$/i
+// Sample input: '<div align="center">' and '<p>' open a wrapper; '<div>text' and '<span>' do not.
+var WRAPPER_OPEN = /^<(?:p|div)\b[^<>]*>$/i
+// Sample input: '</div>' and '</P>' close a wrapper and answer its tag name; '</div> text' does not.
+var WRAPPER_CLOSE = /^<\/(p|div)>$/i
+// Sample input: '<div class="x">' and '</div>' in a line each count once for div, with the slash captured; '<divider>' counts for none.
+var WRAPPER_NESTING = { p: /<(\/?)p(?=[\s>\/])[^<>]*>/gi, div: /<(\/?)div(?=[\s>\/])[^<>]*>/gi }
+// Sample input: '<p>text <img src="b.png"></p>' holds a second image; '<p>text</p>' and '<imgs>' hold none.
+var SECOND_IMAGE = /<img\b/i
+// Sample input: "<br>" or "<br />" at the start of a line; the image above it already ends its line.
+var LEADING_BREAK = /^\s*(?:<br\s*\/?>\s*)+/i
+// Sample input: " 64", "64px" and "64 " are sizes; "50%", "6.4" and "abc" are not.
+var WIDTH_VALUE = /^\s*(\d{1,4})(?:px)?\s*$/i
+
+// Sample input: '<p align="center">' is centred; '<p>' and '<div align="left">' are not.
+function isCentred(open) {
+    var attributes = MdHtml.tagHead(open).attributes
+    for (var i = 0; i < attributes.length; i++) {
+        if (attributes[i].name === "align")
+            return attributes[i].value !== null && attributes[i].value.toLowerCase() === "center"
+    }
+    return false
+}
+
+// Sample input: '<img src="a.png" width="64" height="20" alt="x">' answers an image block with its width and height; null when the tag draws nothing.
+function rawImage(text, dir) {
+    var tag = MdHtml.readTag(text, 0)
+    if (tag === null)
+        return null
+    var head = MdHtml.tagHead(tag.tag)
+    if (head.name !== "img" || head.closing || !head.validAttrs)
+        return null
+    // First attributes win even when their values are empty or absent.
+    var src = null
+    var alt = null
+    var width = null
+    var height = null
+    for (var a = 0; a < head.attributes.length; a++) {
+        var attr = head.attributes[a]
+        var value = attr.value === null ? "" : attr.value
+        if (attr.name === "src" && src === null)
+            src = value
+        if (attr.name === "alt" && alt === null)
+            alt = value
+        if (attr.name === "width" && width === null)
+            width = value
+        if (attr.name === "height" && height === null)
+            height = value
+    }
+    var cls = MdUrl.classifyImage(src === null ? "" : src, dir)
+    if (cls.kind === "remote")
+        return { type: "remote", host: cls.host }
+    if (cls.kind !== "local")
+        return null
+    var block = { type: "image", url: cls.url, alt: alt === null ? "" : alt }
+    var sized = width === null ? null : WIDTH_VALUE.exec(width)
+    if (sized !== null && Number(sized[1]) > 0)
+        block.width = Number(sized[1])
+    var tall = height === null ? null : WIDTH_VALUE.exec(height)
+    if (tall !== null && Number(tall[1]) > 0)
+        block.height = Number(tall[1])
+    return block
+}
+
+// Sample input: { width: 120 } on a 40x30 picture in a 500 pane answers { w: 120, h: 90, stretch: false }; { width: 70, height: 20 } answers { w: 70, h: 20, stretch: true }.
+// One size rule for a lone picture and a row: a width or height attribute is honoured past the natural size, both name the box, none keeps the natural size; the pane width caps it, the ratio kept.
+function pictureSize(spec, naturalW, naturalH, limit) {
+    var w = spec.width > 0 ? spec.width : 0
+    var h = spec.height > 0 ? spec.height : 0
+    var stretch = w > 0 && h > 0
+    if (w === 0 && h === 0) {
+        w = naturalW
+        h = naturalH
+    } else if (h === 0) {
+        h = naturalW > 0 ? w * naturalH / naturalW : 0
+    } else if (w === 0) {
+        w = naturalH > 0 ? h * naturalW / naturalH : 0
+    }
+    if (w > limit && w > 0) {
+        h = h * limit / w
+        w = limit
+    }
+    return { w: w, h: h, stretch: stretch }
+}
+
+// Sample input: '<a href="https://x/y">' answers "https://x/y"; a javascript: or relative target answers null.
+function linkOf(open) {
+    var attributes = MdHtml.tagHead(open).attributes
+    for (var i = 0; i < attributes.length; i++) {
+        if (attributes[i].name === "href" && attributes[i].value !== null) {
+            var url = MdHtml.normalizedTarget(MdUrl.canonicalUrl(attributes[i].value))
+            return /^(?:https?|mailto):/i.test(url) ? url : null
+        }
+    }
+    return null
+}
+
+// Sample input: lines ['<p>', 'note', '</p>', '</div>'] from 0 for "div" answer { rest: ['<p>', 'note', '</p>'], end: 3 }; a blank line or a missing closer answers null.
+// The lines after a wrapper's image up to its own tag's closer, nested openers counted; a line holding another image answers null at once (the splitter draws that row whole).
+function wrapperTail(lines, from, name) {
+    var rest = []
+    var depth = 1
+    for (var j = from; j < lines.length; j++) {
+        var line = lines[j].trim()
+        if (line === "")
+            return null
+        if (SECOND_IMAGE.test(line))
+            return null
+        var closer = WRAPPER_CLOSE.exec(line)
+        if (depth === 1 && closer !== null && closer[1].toLowerCase() === name)
+            return { rest: rest, end: j }
+        line.replace(WRAPPER_NESTING[name], function (tag, slash) {
+            depth += slash === "/" ? -1 : 1
+            return tag
+        })
+        // A closer sharing its line with text, or one with no opener, ends the wrapper where no unit can follow.
+        if (depth < 1)
+            return null
+        rest.push(line)
+    }
+    return null
+}
+
+// Sample input: lines ['<p align="center">', '  <img src="a.png">', '</p>'] at 0 answers { block, end: 2, wrapper: [] }; a line that is no image unit answers null.
+// wrapper holds the opener, the lines between the image and the closer, and the closer on one line, to draw under the image; empty when none.
+function imageUnit(lines, at, dir) {
+    var first = IMAGE_LINE.exec(lines[at].trim())
+    var open = null
+    var parts = null
+    var last = at
+    if (first !== null && first[1] !== undefined) {
+        open = first[1]
+        parts = first
+    } else if (first === null && WRAPPER_OPEN.test(lines[at].trim()) && at + 1 < lines.length) {
+        parts = IMAGE_LINE.exec(lines[at + 1].trim())
+        if (parts === null || parts[1] !== undefined)
+            return null
+        open = lines[at].trim()
+        last = at + 1
+    } else {
+        return null
+    }
+    if ((parts[2] === undefined) !== (parts[4] === undefined))
+        return null
+    var name = MdHtml.tagHead(open).name
+    var rest = []
+    if (parts[5] !== undefined) {
+        if (WRAPPER_CLOSE.exec(parts[5])[1].toLowerCase() !== name)
+            return null
+    } else {
+        var tail = wrapperTail(lines, last + 1, name)
+        if (tail === null)
+            return null
+        rest = tail.rest
+        last = tail.end
+    }
+    var block = rawImage(parts[3], dir)
+    if (block === null)
+        return null
+    if (isCentred(open))
+        block.align = "center"
+    if (parts[2] !== undefined && block.type === "image" && linkOf(parts[2]) !== null)
+        block.link = linkOf(parts[2])
+    if (rest.length > 0)
+        rest[0] = rest[0].replace(LEADING_BREAK, "")
+    var shown = []
+    for (var r = 0; r < rest.length; r++) {
+        if (rest[r].length > 0)
+            shown.push(rest[r])
+    }
+    return { block: block, end: last, wrapper: shown.length === 0 ? [] : [open + shown.join("\n") + "</" + name + ">"] }
+}

package/ui/js/MdInline.js

@@ -0,0 +1,154 @@
+.pragma library
+
+// MdInline: single-pass scanners that never restart, so hostile input stays linear and no unresolved "![", "[" or "<" escapes.
+.import "MdEscape.js" as Esc
+
+var MAX_MATH_RUN_LENGTH = 2
+
+function isSpace(c) {
+    return c === " " || c === "\t" || c === "\n" || c === "\r"
+}
+
+function isPunct(c) {
+    return Esc.isAsciiPunct(c.charCodeAt(0))
+}
+
+// Interval tuple: [from, to, run length, kind]; the kind is CODE_SPAN or MATH_SPAN.
+var INTERVAL_STRIDE = 4
+var CODE_SPAN = 0
+var MATH_SPAN = 1
+
+// Sample input: `` ` `` and `x`, or $x+1$ and $$x^2$$; code pairs before math, never across it.
+function spanIntervals(text) {
+    var hasCode = text.indexOf("`") >= 0
+    if (!hasCode && text.indexOf("$") < 0)
+        return []
+    var code = hasCode ? codeIntervals(text) : []
+    return text.indexOf("$") >= 0 ? mergeIntervals(code, mathIntervals(text, code)) : code
+}
+
+// Sample input: ``a ` b`` and `c`; a closing run drops the openers and spans inside it, which are literal.
+function codeIntervals(text) {
+    var out = []
+    var openByLen = {}
+    var openers = []
+    var i = text.indexOf("`")
+    while (i >= 0) {
+        var j = i + 1
+        while (text.charAt(j) === "`")
+            j++
+        var len = j - i
+        var open = openByLen[len]
+        if (open !== undefined && open !== null) {
+            while (out.length > 0 && out[out.length - INTERVAL_STRIDE] > open)
+                out.length -= INTERVAL_STRIDE
+            out.push(open, j, len, CODE_SPAN)
+            var covered = 0
+            do {
+                covered = openers.pop()
+                openByLen[covered] = null
+            } while (covered !== len)
+        } else {
+            openByLen[len] = i
+            openers.push(len)
+        }
+        i = text.indexOf("`", j)
+    }
+    return out
+}
+
+// Sample input: costs $5 and $10 stays prose; $x+1$ pairs; no space inside an edge, no digit after the closer, no odd backslash run before.
+function mathIntervals(text, code) {
+    var out = []
+    var codeAt = 0
+    var i = text.indexOf("$")
+    var open = -1
+    var openLen = 0
+    while (i >= 0) {
+        while (codeAt < code.length && code[codeAt + 1] <= i) {
+            open = code[codeAt] > open ? -1 : open
+            codeAt += INTERVAL_STRIDE
+        }
+        if (codeAt < code.length && code[codeAt] < i) {
+            open = -1
+            i = text.indexOf("$", code[codeAt + 1])
+            continue
+        }
+        var j = i + 1
+        while (text.charAt(j) === "$")
+            j++
+        var len = j - i
+        var back = 0
+        for (var b = i - 1; b >= 0 && text.charAt(b) === "\\"; b--)
+            back++
+        if (len <= MAX_MATH_RUN_LENGTH && back % 2 === 0) {
+            var after = text.charAt(j)
+            var canClose = i > 0 && !isSpace(text.charAt(i - 1)) && !(after >= "0" && after <= "9")
+            if (open >= 0 && len === openLen && canClose) {
+                out.push(open, j, openLen, MATH_SPAN)
+                open = -1
+            } else if (j < text.length && !isSpace(text.charAt(j))) {
+                open = i
+                openLen = len
+            }
+        }
+        i = text.indexOf("$", j)
+    }
+    return out
+}
+
+// Merge two from-ordered tuple lists in one pass; code and math never share a start.
+function mergeIntervals(a, b) {
+    var out = []
+    var ai = 0
+    var bi = 0
+    while (ai < a.length || bi < b.length) {
+        var fromA = bi >= b.length || (ai < a.length && a[ai] < b[bi])
+        var src = fromA ? a : b
+        var at = fromA ? ai : bi
+        out.push(src[at], src[at + 1], src[at + 2], src[at + 3])
+        ai += fromA ? INTERVAL_STRIDE : 0
+        bi += fromA ? 0 : INTERVAL_STRIDE
+    }
+    return out
+}
+
+// An inline code span as styled HTML, content escaped; math keeps its kind tag for the later figure unit.
+function codeHtml(content, chrome, kind) {
+    if (!/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(String(chrome || "")))
+        return null
+    var tag = kind === "math" ? '<code data-math="inline" style="background-color:' + chrome + '">'
+        : '<code style="background-color:' + chrome + '">'
+    return tag + Esc.chipPad() + escapeHtmlText(content) + Esc.chipPad() + "</code>"
+}
+
+function escapeHtmlText(content) {
+    return Esc.escapeText(content)
+}
+
+// Sample input: "1. ol" answers "&#49;&#46; ol", so a decoded "&#49;. ol" never reaches Qt as an ordered list marker; "a<b" answers "a&#60;b".
+var ASCII_DIGIT_SPLIT = /([0-9])/
+
+// Text a character reference decoded to: punctuation and digits as numeric entities, so no marker, fence or rule forms at a line start.
+function escapeDecodedText(content) {
+    var parts = String(content).split(ASCII_DIGIT_SPLIT)
+    for (var i = 0; i < parts.length; i++)
+        parts[i] = i % 2 === 1 ? "&#" + parts[i].charCodeAt(0) + ";" : escapeHtmlText(parts[i])
+    return parts.join("")
+}
+
+// The tags a link wears: the importer hardcodes its link blue, but a font tag inside the anchor survives it; null when the ink is no colour.
+function linkInk(ink) {
+    if (!/^#[0-9a-f]{6}([0-9a-f]{2})?$/i.test(String(ink || "")))
+        return null
+    return { open: '<font color="' + ink + '">', close: "</font>" }
+}
+
+// A link as an anchor wrapping its label in the ink.
+function linkHtml(label, url, ink, markup) {
+    var wear = linkInk(ink)
+    if (wear === null)
+        return null
+    var safe = String(url).replace(/&/g, "&#38;").replace(/"/g, "&#34;")
+    return '<a href="' + safe + '">' + wear.open + (markup === true ? label : escapeHtmlText(label)) + wear.close + "</a>"
+}

package/ui/js/MdItems.js

@@ -0,0 +1,212 @@
+.pragma library
+
+.import "MdLeaf.js" as Leaf
+
+// MdItems: one top-level list as flat entries (depth, marker, loose flag per list), and the quote and list blocks built from them.
+var BULLET = "•"
+
+// Sample input: "fenceBody" and "codeLine" are lines inside a fence or an indented block; "run" is prose.
+function isRaw(kind) {
+    return kind === "fenceOpen" || kind === "fenceBody" || kind === "fenceClose" || kind === "codeLine"
+}
+
+// Sample input: item "a" holding a nested list "b" answers entries a (depth 0, marker bullet) and b (depth 1).
+function builder() {
+    var entries = []
+    // levels[d] is the list now open at depth d: its parent item, its kind, its item count and whether a blank line loosened it.
+    var levels = []
+    var heads = {}
+    var cur = null
+    var blank = false
+
+    function sibling(depth, chain) {
+        var lv = depth < levels.length ? levels[depth] : null
+        return lv !== null && lv.mark === chain[depth].mark
+    }
+
+    function open(chain, depth) {
+        var frame = chain[depth]
+        var lv = sibling(depth, chain) ? levels[depth] : null
+        if (lv !== null) {
+            lv.count++
+        } else {
+            lv = { mark: frame.mark, start: frame.start, count: 0, loose: false }
+            levels[depth] = lv
+        }
+        levels.length = depth + 1
+        var entry = { depth: depth, lines: [], list: lv, frameId: frame.id, content: 0,
+            marker: frame.ordered ? (lv.start + lv.count) + "." : BULLET }
+        entries.push(entry)
+        heads[frame.id] = entry
+        return entry
+    }
+
+    // A blank line before a new item loosens the list the item joins, or the list whose item it nests in.
+    function loosenOpened(chain, depth) {
+        if (sibling(depth, chain))
+            levels[depth].loose = true
+        else if (depth > 0)
+            levels[depth - 1].loose = true
+    }
+
+    function add(event, text) {
+        var chain = event.chain
+        var lead = event.lead
+        var line = { text: text, index: event.index, raw: isRaw(event.kind) }
+        var last = lead.n - 1
+        var from = Math.min(lead.retained, lead.n)
+        // A blank line opens no item; "-" alone opens an empty one.
+        if (event.kind === "run" && text.trim().length === 0 && from > last) {
+            blank = true
+            if (cur !== null)
+                cur.lines.push(line)
+            return
+        }
+        if (from <= last) {
+            if (blank)
+                loosenOpened(chain, from)
+            for (var depth = from; depth <= last; depth++)
+                cur = open(chain, depth)
+        } else {
+            var head = heads[chain[last].id]
+            if (cur.frameId !== head.frameId) {
+                levels.length = last + 1
+                cur = { depth: last, lines: [], list: head.list, frameId: head.frameId, content: 0, marker: "" }
+                entries.push(cur)
+                if (blank)
+                    head.list.loose = true
+            } else if (blank && cur.content > 0) {
+                cur.list.loose = true
+            }
+        }
+        blank = false
+        cur.content++
+        cur.lines.push(line)
+    }
+
+    return { add: add, entries: entries }
+}
+
+// The text of the lines that draw; kept.raw[k] marks a code line, which the renderer reads as code and the inline pass never sees.
+function visibleLines(lines, state) {
+    var kept = []
+    kept.raw = []
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i]
+        if (state.hidden.hasOwnProperty(line.index))
+            continue
+        var text = line.text
+        if (state.escaped.hasOwnProperty(line.index)) {
+            var at = text.indexOf("[")
+            text = text.slice(0, at) + "\\[" + text.slice(at + 1)
+        }
+        kept.push(text)
+        kept.raw.push(line.raw === true)
+    }
+    return kept
+}
+
+// Prose goes through the inline pass; a fence or indented code in an item or quote stays verbatim for the renderer.
+function inlineLines(kept, inlineOf) {
+    var parts = []
+    var prose = []
+    for (var k = 0; k <= kept.length; k++) {
+        if (k < kept.length && !kept.raw[k]) {
+            prose.push(kept[k])
+            continue
+        }
+        if (prose.length > 0)
+            parts.push(inlineOf(prose.join("\n")))
+        prose = []
+        if (k < kept.length)
+            parts.push(kept[k])
+    }
+    return parts.join("\n")
+}
+
+// Sample input: lines "a" and "```" answer parts, prose alone answers its one text, and nothing to draw answers an empty text.
+function content(lines, inlineOf, partsOf) {
+    if (lines.join("\n").trim().length === 0)
+        return { text: "" }
+    var parts = partsOf(lines)
+    if (parts === null)
+        return { text: inlineLines(lines, inlineOf) }
+    if (parts.length === 0)
+        return { text: "" }
+    if (parts.length === 1 && parts[0].type === "run" && parts[0].maths === undefined)
+        return { text: parts[0].text }
+    return { text: "", parts: parts }
+}
+
+// One quote block per run of lines at one nesting depth; the depth shows past the first level, joined after the first block.
+function quoteBlocks(all, state, inlineOf, partsOf) {
+    var out = []
+    for (var at = 0; at < all.length; ) {
+        var to = at
+        while (to < all.length && all[to].depth === all[at].depth)
+            to++
+        var quote = visibleLines(all.slice(at, to), state)
+        // A quote with nothing to draw is still a block: a browser gives it its margin.
+        var title = at === 0 && quote.length > 0 && !quote.raw[0] ? Leaf.alertTitle(quote[0]) : null
+        if (title !== null)
+            quote[0] = title
+        var held = content(quote, inlineOf, partsOf)
+        var block = { type: "quote", text: held.text }
+        if (held.parts !== undefined)
+            block.parts = held.parts
+        if (all[at].depth > 1)
+            block.depth = all[at].depth
+        if (at > 0)
+            block.joined = true
+        out.push(block)
+        at = to
+    }
+    return out
+}
+
+// One list as a block; depths, markers and gaps only when nesting or looseness needs them, parts when an item holds more than prose.
+function listBlock(event, state, inlineOf, partsOf) {
+    var items = []
+    var depths = []
+    var markers = []
+    var gaps = []
+    var parts = []
+    var nested = false
+    var loose = false
+    var holds = false
+    var entries = event.builder.entries
+    for (var k = 0; k < entries.length; k++) {
+        var entry = entries[k]
+        // An item that opens on a blank line starts at its first line of text.
+        var first = 0
+        while (first < entry.lines.length - 1 && entry.lines[first].text.trim().length === 0)
+            first++
+        var lines = visibleLines(entry.lines.slice(first), state)
+        while (lines.length > 0 && lines[lines.length - 1].trim().length === 0)
+            lines.pop()
+        if (entry.marker !== "" && lines.length > 0 && !lines.raw[0])
+            lines[0] = Leaf.taskText(lines[0])
+        var gap = entry.list.loose
+        nested = nested || entry.depth > 0 || entry.marker === ""
+        loose = loose || gap
+        var held = content(lines, inlineOf, partsOf)
+        held.text = Leaf.pinTaskBox(held.text)
+        if (held.parts !== undefined && held.parts[0].type === "run")
+            held.parts[0].text = Leaf.pinTaskBox(held.parts[0].text)
+        holds = holds || held.parts !== undefined
+        items.push(held.text)
+        parts.push(held.parts !== undefined ? held.parts : null)
+        depths.push(entry.depth)
+        markers.push(entry.marker)
+        gaps.push(gap)
+    }
+    var block = { type: "list", ordered: event.ordered, start: event.start, items: items }
+    if (nested || loose) {
+        block.depths = depths
+        block.markers = markers
+        block.gaps = gaps
+    }
+    if (holds)
+        block.parts = parts
+    return block
+}