flea-qml 0.0.0-stage → 0.1.0

package/ui/js/MdContainer.js

@@ -0,0 +1,137 @@
+.pragma library
+
+.import "MdLeaf.js" as Leaf
+
+// Prefix readers use byte offsets and absolute tab columns, without copying the remaining line.
+var CODE_INDENT = 4
+var MAX_MARKER_INDENT = 3
+var MAX_MARKER_DIGITS = 9
+var DECIMAL_RADIX = 10
+var MAX_GAP_SCAN = CODE_INDENT + 1
+var MIN_MARKER_GAP = 1
+
+// Sample: a tab after two spaces advances to column four.
+function indentationAt(line, view, limit) {
+    var stop = limit === undefined ? CODE_INDENT : limit
+    var at = view.at
+    var width = view.padding
+    while (at < line.length && width < stop) {
+        var c = line.charAt(at)
+        if (c !== " " && c !== "\t")
+            break
+        width += c === "\t" ? CODE_INDENT - (view.column + width) % CODE_INDENT : 1
+        at++
+    }
+    return { end: at, width: width }
+}
+
+function takeIndent(line, view, wanted) {
+    var width = Math.min(view.padding, wanted)
+    view.padding -= width
+    while (view.at < line.length && width < wanted) {
+        var c = line.charAt(view.at)
+        if (c !== " " && c !== "\t")
+            break
+        var step = c === "\t" ? CODE_INDENT - (view.column + width) % CODE_INDENT : 1
+        view.at++
+        width += step
+    }
+    view.padding += Math.max(0, width - wanted)
+    view.column += Math.min(width, wanted)
+}
+
+// Sample: ">\ttext" consumes one column after > and retains the tab's remaining columns.
+function quoteAt(line, view) {
+    var indent = indentationAt(line, view)
+    return indent.width <= MAX_MARKER_INDENT && line.charAt(indent.end) === ">" ? indent.width : -1
+}
+
+function takeQuote(line, view, indent) {
+    takeIndent(line, view, indent)
+    view.at++
+    view.column++
+    if (line.charAt(view.at) === " " || line.charAt(view.at) === "\t")
+        takeIndent(line, view, 1)
+}
+
+// Sample: "10.\ttext" starts content at column four, and five gap columns leave indented code.
+function listAt(line, view) {
+    var indentation = indentationAt(line, view)
+    var at = indentation.end
+    var indent = indentation.width
+    if (indent > MAX_MARKER_INDENT)
+        return null
+    var start = at
+    var c = line.charAt(at)
+    var ordered = c >= "0" && c <= "9"
+    if (ordered) {
+        while (at - start < MAX_MARKER_DIGITS && line.charAt(at) >= "0" && line.charAt(at) <= "9")
+            at++
+        if (line.charAt(at) !== "." && line.charAt(at) !== ")")
+            return null
+    } else if (c !== "-" && c !== "*" && c !== "+") {
+        return null
+    }
+    var mark = line.charAt(at)
+    at++
+    if (at < line.length && line.charAt(at) !== " " && line.charAt(at) !== "\t")
+        return null
+    var markerWidth = at - start
+    var gapView = { at: at, padding: 0, column: view.column + indent + markerWidth }
+    var gap = line.slice(at).trim().length === 0 ? MIN_MARKER_GAP : indentationAt(line, gapView, MAX_GAP_SCAN).width
+    var consumedGap = gap > CODE_INDENT ? MIN_MARKER_GAP : gap
+    return { indent: indent, ordered: ordered, mark: mark,
+        start: ordered ? parseInt(line.slice(start, at - 1), DECIMAL_RADIX) : 0,
+        contentCol: indent + markerWidth + consumedGap, markerEnd: at,
+        markerColumn: gapView.column, gap: consumedGap }
+}
+
+function takeList(line, view, marker) {
+    view.at = marker.markerEnd
+    view.padding = 0
+    view.column = marker.markerColumn
+    takeIndent(line, view, marker.gap)
+}
+
+// Sample input: "\tbar" read at column 2 answers "  bar": the leading tab expands to its own stop, so no importer miscounts it.
+function expandLead(text, column) {
+    var out = ""
+    var at = 0
+    var col = column
+    while (at < text.length && (text.charAt(at) === " " || text.charAt(at) === "\t")) {
+        var step = text.charAt(at) === "\t" ? CODE_INDENT - col % CODE_INDENT : 1
+        out += " ".repeat(step)
+        col += step
+        at++
+    }
+    return out + text.slice(at)
+}
+
+function textAt(line, view) {
+    return " ".repeat(view.padding) + line.slice(view.at)
+}
+
+function readListMarker(line) {
+    var view = { at: 0, padding: 0, column: 0 }
+    var marker = listAt(String(line), view)
+    if (marker === null)
+        return null
+    takeList(line, view, marker)
+    return { indent: marker.indent, ordered: marker.ordered, start: marker.start,
+        contentCol: marker.contentCol, text: textAt(line, view) }
+}
+
+// Sample input: "  aaa" with 1 answers " aaa"; a fence opened at that indent drops up to as many spaces from each body line.
+function unindent(text, width) {
+    var at = 0
+    while (at < width && text.charAt(at) === " ")
+        at++
+    return text.slice(at)
+}
+
+// Sample input: "> q", "- item", "```", "# h" and "***" start a block, so a table stops before them; "bar" does not.
+function startsBlock(line) {
+    var view = { at: 0, padding: 0, column: 0 }
+    return quoteAt(line, view) >= 0 || listAt(line, view) !== null || Leaf.fenceOpen(line) !== null
+        || Leaf.atxHeading(line) !== null || Leaf.isThematic(line)
+}

package/ui/js/MdDocument.js

@@ -0,0 +1,337 @@
+.pragma library
+
+// Serialize the block reader's events; all container and code decisions belong to MdBlocks.
+.import "MdLeaf.js" as Leaf
+.import "MdContainer.js" as Container
+.import "MdRun.js" as Run
+.import "MdHtmlImage.js" as HtmlImage
+.import "MdParagraphs.js" as MdParagraphs
+.import "MdHtmlBlock.js" as HtmlBlock
+.import "MdHtmlHeading.js" as HtmlHeading
+.import "MdItems.js" as Items
+.import "MdChunks.js" as Chunks
+.import "MdResolve.js" as Res
+.import "MdMath.js" as Maths
+.import "MdEntity.js" as Ent
+
+// The importer joins an HTML block onto the paragraph above it, so a block-level raw tag after a blank line starts its own run.
+// Sample input: "Body.\n\n<div>x</div>" splits before the div; "<table>\n<tr>" keeps its rows together.
+var HTML_BLOCK_AFTER_BLANK = /\n[ \t]*\n+(?= {0,3}<(?:p|div|h[1-6]|hr|table|ul|ol|blockquote|pre)(?=[\s>\/]))/i
+
+// Sample input: "one<br />\n  two" collapses to "one<br />two"; a blank line after the break stays a paragraph break.
+var BREAK_SOFT_NEWLINE = /(<br \/>)[ \t]*\n(?![ \t]*\n)[ \t]*/g
+
+// Items and quotes hold their blocks as parts down to this many levels; deeper text stays one markdown text, which keeps a deep chain linear.
+var NEST_LIMIT = 8
+
+// shared is set for the writer of an item's or a quote's parts, which numbers footnotes and tokens with the document's.
+function writer(state, dir, chrome, ink, pass, shared) {
+    var out = []
+    var run = []
+    var tokens = shared !== undefined ? shared.tokens : []
+    var cited = shared !== undefined ? shared.cited : []
+    var level = shared !== undefined ? shared.level : 0
+    function inlineOf(text, citations, literalPlain, bareText, fragment) {
+        return Run.parseInline(text, dir, state.defs, state.numbers, chrome, ink, tokens,
+            citations === false ? undefined : cited, literalPlain, bareText, fragment)
+    }
+    // Prose outside every container: a ">" in it, even after a formula's figure, is text and never a quote mark.
+    function pushPiece(lines) {
+        var text = HtmlBlock.separateBlocks(lines).join("\n")
+        // A soft break after a line break collapses, as in a browser, so the next line starts at the text column.
+        var pieces = inlineOf(text, undefined, false, true).replace(BREAK_SOFT_NEWLINE, "$1").split(HTML_BLOCK_AFTER_BLANK)
+        var maths = Maths.inlineSources(text)
+        for (var p = 0; p < pieces.length; p++) {
+            if (pieces[p].trim().length === 0)
+                continue
+            var block = { type: "run", text: pieces[p] }
+            // The text's formulas are listed on its first block, so a split never lists one twice.
+            if (maths.length > 0)
+                block.maths = maths
+            maths = []
+            out.push(block)
+        }
+    }
+    // An image inside an HTML block leaves it as an image block, since the importer draws no Markdown there.
+    function pushImages(lines) {
+        var parts = HtmlBlock.splitHtmlImages(lines, dir)
+        for (var p = 0; p < parts.length; p++) {
+            if (parts[p].block !== undefined)
+                out.push(parts[p].block)
+            else
+                pushPiece(parts[p].lines)
+        }
+    }
+    // A display formula inside a paragraph stands on its own as a figure, the way a display block does.
+    function pushRun(lines) {
+        var pieces = Maths.splitDisplay(lines.join("\n"))
+        if (pieces === null)
+            return pushImages(lines)
+        for (var p = 0; p < pieces.length; p++) {
+            if (pieces[p].math === undefined)
+                pushImages(pieces[p].text.split("\n"))
+            else if (pieces[p].math !== "")
+                out.push({ type: "figure", kind: "math", source: pieces[p].math, display: true })
+        }
+    }
+    // Sample input: the lines "a", "```", "x", "```" answer a run and a fence; null past NEST_LIMIT, where the lines stay one text.
+    function partsOf(lines) {
+        if (level >= NEST_LIMIT)
+            return null
+        var own = { defs: state.defs, notes: state.notes, numbers: state.numbers, hidden: {}, escaped: {}, code: {}, dropped: [] }
+        var inner = writer(own, dir, chrome, ink, pass, { tokens: tokens, cited: cited, level: level + 1 })
+        pass(lines, own, inner.project, false, true)
+        return inner.finish()
+    }
+    function pushAll(blocks) {
+        for (var b = 0; b < blocks.length; b++)
+            out.push(blocks[b])
+    }
+    // The blocks an HTML heading draws as, its leading picture an image block; null when its drawn text, references resolved, still holds a picture.
+    function headingBlocks(head) {
+        var blocks = []
+        var inner = head.inner
+        var logo = head.align === "right" ? null : HtmlHeading.headingPicture(inner, dir)
+        if (logo !== null) {
+            if (head.align === "center")
+                logo.block.align = "center"
+            blocks.push(logo.block)
+            inner = logo.rest
+            if (inner.trim().length === 0)
+                return blocks
+        }
+        var text = inlineOf(Leaf.headingSafe(inner))
+        if (HtmlHeading.DRAWN_PICTURE.test(text))
+            return null
+        var headBlock = { type: "heading", level: head.level, text: text }
+        if (head.align !== null)
+            headBlock.align = head.align
+        blocks.push(headBlock)
+        return blocks
+    }
+    function flushRun() {
+        var plain = []
+        var depth = 0
+        // cutAfter says after which blanks the paragraph ends; open HTML across the blank joins it instead.
+        var cut = MdParagraphs.cutAfter(run)
+        function flushPlain() {
+            if (plain.length > 0)
+                pushRun(plain)
+            plain = []
+            depth = 0
+        }
+        for (var i = 0; i < run.length; i++) {
+            if (run[i].trim().length === 0) {
+                if (cut[i])
+                    flushPlain()
+                else
+                    plain.push(run[i])
+                continue
+            }
+            // A heading in a lone wrapper lifts with it; one in other open HTML stays in its run, so no wrapper is ever split.
+            var lifted = depth === 0 ? HtmlHeading.headingUnit(run, i) : null
+            var htmlHead = lifted !== null ? lifted.head : depth === 0 ? HtmlBlock.htmlHeading(run[i]) : null
+            var drawn = htmlHead !== null ? headingBlocks(htmlHead) : null
+            if (drawn !== null) {
+                flushPlain()
+                pushAll(drawn)
+                if (lifted !== null) {
+                    i = lifted.end
+                    plain = lifted.wrapper.slice()
+                }
+                continue
+            }
+            var solo = (i === 0 || run[i - 1].trim().length === 0)
+                && (i + 1 === run.length || run[i + 1].trim().length === 0)
+            var image = solo ? Leaf.standaloneImage(run[i], dir, state.defs) : null
+            // A raw image inside its own paragraph or div, on one line or three, is an image block too.
+            var unit = image === null ? HtmlImage.imageUnit(run, i, dir) : null
+            if (image !== null || unit !== null) {
+                if (image !== null)
+                    image.alt = Res.plainText(inlineOf(image.alt, false, false, false, true))
+                flushPlain()
+                out.push(image !== null ? image : unit.block)
+                if (unit !== null) {
+                    i = unit.end
+                    // What its wrapper held under the image is drawn centred under it.
+                    plain = unit.wrapper.slice()
+                }
+            } else {
+                plain.push(run[i])
+                depth = HtmlHeading.nestDepth(run[i], depth)
+            }
+        }
+        flushPlain()
+        run = []
+    }
+    // The underline of a setext heading takes the paragraph above it out of the pending run and draws it as a heading.
+    function setext(event) {
+        var at = run.length
+        while (at > 0 && run[at - 1].trim().length > 0 && !Leaf.isThematic(run[at - 1]))
+            at--
+        var paragraph = run.slice(at)
+        run.length = at
+        flushRun()
+        var text = Leaf.headingSafe(paragraph.join("\n").trim())
+        if (text !== "")
+            out.push({ type: "heading", level: Leaf.setextLevel(event.text), text: inlineOf(text) })
+    }
+    function emit(event) {
+        if (event.type === "setext")
+            return setext(event)
+        if (event.type === "run") {
+            var lines = Items.visibleLines(event.lines, state)
+            for (var l = 0; l < lines.length; l++)
+                run.push(lines[l])
+            return
+        }
+        flushRun()
+        if (event.type === "fence") {
+            var source = event.lines.map(function (line) { return line.text }).join("\n")
+            if (event.figureKind !== "")
+                out.push({ type: "figure", kind: event.figureKind, source: source, display: true })
+            else
+                out.push({ type: "fence", text: source, info: Ent.decodeReferences(event.info) })
+        } else if (event.type === "heading") {
+            out.push({ type: "heading", level: event.level, text: inlineOf(Leaf.headingSafe(event.text)) })
+        } else if (event.type === "table") {
+            pushAll(Leaf.chunkTable(Leaf.tableBlock(event.head, event.aligns, event.rows,
+                function (text) { return inlineOf(text, true, true) })))
+        } else if (event.type === "quote") {
+            pushAll(Items.quoteBlocks(event.lines, state, inlineOf, partsOf))
+        } else if (event.type === "list") {
+            var list = Items.listBlock(event, state, inlineOf, partsOf)
+            if (list.items.length > 0)
+                pushAll(Chunks.chunkList(list))
+        } else {
+            out.push(event)
+        }
+    }
+    // The line's text once the list markers and indents around it are gone; a lazy line has none to remove.
+    function leadText(event) {
+        var lead = event.lead
+        return lead.here === lead.n && !lead.lazy
+            ? " ".repeat(lead.pad) + Container.expandLead(lead.raw.slice(lead.at), lead.col + lead.pad) : event.text
+    }
+    // A delimiter row the block reader refused as a table keeps its first dash from the renderer, which would make a table of it.
+    function tableless(text) {
+        return text.indexOf("|") >= 0 && Leaf.delimAligns(text) !== null ? text.replace("-", "\\-") : text
+    }
+    var outer = null
+    var code = null
+    function flushOuter() {
+        if (outer !== null)
+            emit(outer)
+        outer = null
+    }
+    function flushCode() {
+        if (code === null)
+            return
+        if (code.indented) {
+            while (code.lines.length > 0 && code.lines[code.lines.length - 1].text.trim().length === 0)
+                code.lines.pop()
+        }
+        emit(code)
+        code = null
+    }
+    function project(event) {
+        if (event.type !== "line") {
+            flushOuter()
+            flushCode()
+            emit(event)
+            return
+        }
+        var top = event.outer
+        var group = top === null ? null : top.type === "list" ? top.group : top.id
+        if (outer !== null && outer.group !== group)
+            flushOuter()
+        if (top !== null) {
+            flushCode()
+            if (outer === null)
+                outer = { type: top.type, group: group, lines: [], ordered: top.ordered, start: top.start,
+                    builder: top.type === "list" ? Items.builder() : null }
+            if (event.kind === "codeEnd")
+                return
+            if (top.type === "quote")
+                outer.lines.push({ text: leadText(event), index: event.index, depth: event.lead.n, raw: Items.isRaw(event.kind) })
+            else
+                outer.builder.add(event, leadText(event))
+            return
+        }
+        if (event.kind === "hidden")
+            return
+        if (event.kind === "fenceOpen") {
+            flushCode()
+            code = { type: "fence", lines: [], info: event.info, figureKind: event.figureKind, indented: false }
+        } else if (event.kind === "fenceBody" || event.kind === "codeLine") {
+            if (code === null)
+                code = { type: "fence", lines: [], info: "", figureKind: "", indented: true }
+            code.lines.push({ text: event.text, index: event.index })
+        } else if (event.kind === "fenceClose" || event.kind === "codeEnd") {
+            flushCode()
+        } else if (event.kind === "setext") {
+            flushCode()
+            emit({ type: "setext", text: event.text })
+        } else {
+            flushCode()
+            emit({ type: "run", lines: [{ text: tableless(event.text), index: event.index }] })
+        }
+    }
+    function finish() {
+        flushOuter()
+        // A fence left open at the end of the text holds no line for the final newline.
+        if (code !== null && !code.indented && code.lines.length > 0 && code.lines[code.lines.length - 1].text === "")
+            code.lines.pop()
+        flushCode()
+        flushRun()
+        var footItems = []
+        // Only the document's own writer lists the notes cited anywhere, parts included.
+        for (var i = 0; shared === undefined && i < cited.length; i++) {
+            var id = cited[i]
+            footItems.push("<sup>" + state.numbers[id] + "</sup> " + inlineOf(state.notes[id].text, false))
+        }
+        if (footItems.length > 0) {
+            out.push({ type: "run", text: "---" })
+            out.push({ type: "list", ordered: false, start: 0, items: footItems })
+        }
+        return out
+    }
+    // The projection that hands onHead the first n blocks once they are written; written blocks are final, so finish starts with them.
+    function headed(n, onHead) {
+        var sent = false
+        return function (event) {
+            project(event)
+            if (!sent && out.length >= n) {
+                sent = true
+                onHead(out.slice(0, n))
+            }
+        }
+    }
+    return { project: project, finish: finish, headed: headed }
+}
+
+function preparedText(lines, state, dir, defs, chrome, ink) {
+    var out = []
+    var prose = []
+    var tokens = []
+    var cited = []
+    function flush() {
+        if (prose.length > 0)
+            out.push(Run.parseInline(prose.join("\n"), dir, defs || state.defs,
+                state.numbers, chrome, ink, tokens, cited))
+        prose = []
+    }
+    for (var i = 0; i < lines.length; i++) {
+        var line = { text: lines[i], index: i }
+        if (state.hidden.hasOwnProperty(line.index))
+            continue
+        if (state.code.hasOwnProperty(line.index)) {
+            flush()
+            out.push(line.text)
+        } else {
+            prose.push(Items.visibleLines([line], state)[0])
+        }
+    }
+    flush()
+    return out.join("\n")
+}

package/ui/js/MdEmph.js

@@ -0,0 +1,97 @@
+.pragma library
+
+// MdEmph: CommonMark delimiter runs, resolved after the inline scan; a mark that pairs becomes a tag, any other stays text.
+.import "MdEscape.js" as Esc
+
+var RULE_OF_THREE = 3
+var STRONG_LENGTH = 2
+var MAX_RUN_LENGTH = 1024
+// Unicode P and S approximated by the blocks that hold them: Latin-1, general punctuation, currency, symbols, CJK, fullwidth.
+var UNICODE_PUNCT = /[¡-©«-±´¶-¸»¿×÷˂-˅˒-˟‐-‧‰-⁞₠-⃀℀-⅏←-⯿⸀-⹿、-〃〈-〠〰・︐-︙︰-﹫！-／：-＠［-｀｛-･￠-￮\ud83c-\ud83e]/
+var SPACE = /\s/
+
+function isPunctChar(c) {
+    return Esc.isAsciiPunct(c.charCodeAt(0)) || UNICODE_PUNCT.test(c)
+}
+
+// Sample input: "foo*bar*" at index 3 reads a run of one star, flanked by letters, which can open and close.
+function runAt(body, i, at) {
+    var ch = body.charAt(i)
+    var j = i + 1
+    while (j < body.length && j - i < MAX_RUN_LENGTH && body.charAt(j) === ch)
+        j++
+    var before = i > 0 ? body.charAt(i - 1) : "\n"
+    var after = j < body.length ? body.charAt(j) : "\n"
+    var spaceBefore = SPACE.test(before)
+    var spaceAfter = SPACE.test(after)
+    var punctBefore = isPunctChar(before)
+    var punctAfter = isPunctChar(after)
+    var left = !spaceAfter && (!punctAfter || spaceBefore || punctBefore)
+    var right = !spaceBefore && (!punctBefore || spaceAfter || punctAfter)
+    var under = ch === "_"
+    return { ch: ch, n: j - i, orig: j - i, at: at, end: j,
+        open: under ? left && (!right || punctBefore) : left,
+        close: under ? right && (!left || punctAfter) : right,
+        before: "", after: "", opens: 0, closes: 0 }
+}
+
+// The delimiters from index from on pair as the reference algorithm does, over a linked list so a nested pair never rescans its inside.
+function process(delims, from) {
+    var total = delims.length
+    var prev = []
+    var next = []
+    var bottoms = {}
+    for (var k = from; k < total; k++) {
+        prev[k] = k - 1
+        next[k] = k + 1
+    }
+    var ci = from
+    while (ci < total) {
+        var closer = delims[ci]
+        if (!closer.close || closer.n === 0) {
+            ci = next[ci]
+            continue
+        }
+        var key = closer.ch + (closer.orig % RULE_OF_THREE) + (closer.open ? "o" : "c")
+        var bottom = bottoms.hasOwnProperty(key) ? bottoms[key] : from - 1
+        var oi = prev[ci]
+        while (oi > bottom) {
+            var cand = delims[oi]
+            if (cand.open && cand.n > 0 && cand.ch === closer.ch
+                    && !((closer.open || cand.close) && (cand.orig + closer.orig) % RULE_OF_THREE === 0
+                        && !(cand.orig % RULE_OF_THREE === 0 && closer.orig % RULE_OF_THREE === 0)))
+                break
+            oi = prev[oi]
+        }
+        if (oi <= bottom) {
+            bottoms[key] = prev[ci]
+            ci = next[ci]
+            continue
+        }
+        var opener = delims[oi]
+        var strong = closer.n >= STRONG_LENGTH && opener.n >= STRONG_LENGTH
+        var use = strong ? STRONG_LENGTH : 1
+        opener.n -= use
+        closer.n -= use
+        opener.after = (strong ? "<strong>" : "<em>") + opener.after
+        closer.before = closer.before + (strong ? "</strong>" : "</em>")
+        opener.opens++
+        closer.closes++
+        // Everything between the pair can no longer pair: unlink it, and the opener too once it has no marks left.
+        next[oi] = ci
+        prev[ci] = oi
+        if (opener.n === 0) {
+            next[prev[oi]] = ci
+            prev[ci] = prev[oi]
+        }
+        if (closer.n === 0)
+            ci = next[ci]
+    }
+}
+
+// Sample input: an unpaired "**" that could open reads "&#42;&#42;", which no renderer pairs again; the "_" in "a_b" stays plain.
+function literal(d) {
+    if (d.n === 0)
+        return ""
+    return d.open || d.close ? Esc.escapeText(d.ch).repeat(d.n) : d.ch.repeat(d.n)
+}

package/ui/js/MdEntity.js

@@ -0,0 +1,108 @@
+.pragma library
+
+// MdEntity: backslash escapes and character references in destinations, info strings and running text, decoded here.
+.import "MdEntityTable.js" as Names
+
+var REPLACEMENT_CHARACTER = 0xfffd
+var MAX_CODE_POINT = 0x10ffff
+var SURROGATE_START = 0xd800
+var SURROGATE_END = 0xdfff
+// The longest reference is "&CounterClockwiseContourIntegral;" (33 characters), so a window this long holds any one.
+var REFERENCE_WINDOW = 34
+var REFERENCE = /\\([!-\/:-@\[-`{-~])|&(?:#([0-9]{1,7})|#[xX]([0-9a-fA-F]{1,6})|([A-Za-z][A-Za-z0-9]{1,31}));/g
+var REFERENCE_HERE = /^&(?:#([0-9]{1,7})|#[xX]([0-9a-fA-F]{1,6})|([A-Za-z][A-Za-z0-9]{1,31}));/
+
+// Sample input: 10 and 0x1F600 answer their characters; 0, a surrogate and a value past U+10FFFF answer U+FFFD.
+function codePointText(code) {
+    var valid = code > 0 && code <= MAX_CODE_POINT && (code < SURROGATE_START || code > SURROGATE_END)
+    return String.fromCodePoint(valid ? code : REPLACEMENT_CHARACTER)
+}
+
+// Sample input: "f&ouml;o\\*" answers "f\u00f6o*"; an unknown name such as "&nosuch;" stays as written.
+function decodeReferences(text) {
+    if (text.indexOf("\\") < 0 && text.indexOf("&") < 0)
+        return text
+    return text.replace(REFERENCE, function (all, escaped, dec, hex, name) {
+        if (escaped !== undefined)
+            return escaped
+        if (name !== undefined) {
+            var named = Names.namedValue(name)
+            return named === null ? all : named
+        }
+        return codePointText(dec !== undefined ? parseInt(dec, 10) : parseInt(hex, 16))
+    })
+}
+
+// Sample input: "a &copy; b" at index 2 answers { text: "\u00a9", end: 8 }; "&nosuch;" and a bare "&" answer null.
+function referenceAt(text, i) {
+    var hit = REFERENCE_HERE.exec(text.slice(i, i + REFERENCE_WINDOW))
+    if (hit === null)
+        return null
+    var decoded = hit[3] !== undefined ? Names.namedValue(hit[3])
+        : codePointText(hit[1] !== undefined ? parseInt(hit[1], 10) : parseInt(hit[2], 16))
+    return decoded === null ? null : { text: decoded, end: i + hit[0].length }
+}
+
+// Sample input: "", " " or "  " is a piece with nothing drawn on its line.
+var BLANK_PIECE = /^ *$/
+var WHITESPACE_REFERENCE = /[\t\n\r\f]/g
+var HARD_BREAK_PIECE = "<br />"
+// What a line holding only space references keeps, so Qt reads text and the paragraph stays whole.
+var WHOLE_LINE_REFERENCE = "&#32;"
+
+// Sample input: after "a" and "\n" a line is blank, after " " it stays blank, after "b" or a token (a number) it is not; "<br />" ends a line.
+function blankAfter(blank, piece) {
+    if (typeof piece !== "string")
+        return false
+    var cut = piece.lastIndexOf("\n")
+    if (cut >= 0)
+        return BLANK_PIECE.test(piece.slice(cut + 1))
+    return piece === HARD_BREAK_PIECE || (blank && BLANK_PIECE.test(piece))
+}
+
+// Sample input: lineBlank(lineState(true), ["a", "\n", " "]) answers true; ["a", " "] on a fresh state answers false; lineState(false), a fragment, starts not blank.
+// The state folds each piece once, so it stays linear; lineRestart sets it afresh after a label's pieces were replaced by one.
+function lineState(startsBlank) {
+    return { scanned: 0, blank: startsBlank }
+}
+
+function lineBlank(state, out) {
+    state.scanned = Math.min(state.scanned, out.length)
+    for (; state.scanned < out.length; state.scanned++)
+        state.blank = blankAfter(state.blank, out[state.scanned])
+    return state.blank
+}
+
+function lineRestart(state, out, piece) {
+    state.blank = blankAfter(false, piece)
+    state.scanned = out.length
+}
+
+// Sample input: a tab or a newline (the decoded text of "&#9;" and "&#10;") is drawn as one space, any other text is unchanged.
+function drawnText(text) {
+    return text.replace(WHITESPACE_REFERENCE, " ")
+}
+
+// Sample input: "x  &#32;\ny" at 3 answers { text: "", end: 8, trim: 2 }; "x&#32;  \ny" at 1 answers { text: "", end: 6, trim: 0 }; "a\n&#32;\nb" at 2 with blank true answers { text: "&#32;", end: 7, trim: 0 }; "&copy;" answers null.
+// A run of space references with the literal spaces inside and after it is one unit: dropped at a line end (the literal spaces after it stay to decide a hard break) and at a line start, else one raw space; a whole-line run stays one reference so Qt sees a non-blank line.
+function spaceRunAt(text, i, out, blank, endsLine) {
+    var end = i
+    var lastReference = i
+    var hit = referenceAt(text, end)
+    while (hit !== null && drawnText(hit.text) === " ") {
+        end = hit.end
+        lastReference = end
+        while (text.charAt(end) === " ")
+            end++
+        hit = referenceAt(text, end)
+    }
+    if (lastReference === i)
+        return null
+    if ((end >= text.length && endsLine) || text.charAt(end) === "\n") {
+        var trim = 0
+        while (trim < out.length && out[out.length - 1 - trim] === " ")
+            trim++
+        return { text: blank ? WHOLE_LINE_REFERENCE : "", end: lastReference, trim: trim }
+    }
+    return { text: blank ? "" : " ", end: end, trim: 0 }
+}