flea-qml 0.0.0-stage → 0.2.0

package/ui/js/MdParagraphs.js

@@ -0,0 +1,138 @@
+.pragma library
+
+// MdParagraphs: cut one run's lines into paragraphs; a blank ends the paragraph unless HTML spans it.
+.import "MdHtml.js" as MdHtml
+
+// Tags that never pair across a blank line: void elements carry no content, so an unclosed one never joins paragraphs.
+var VOID_TAGS = { area: 1, base: 1, br: 1, col: 1, hr: 1, img: 1, link: 1, meta: 1, source: 1, track: 1, wbr: 1 }
+
+// A backtick run closed by a run of the same length is a code span, as CommonMark reads it; an unclosed run stays literal.
+function codeRanges(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 - 1][0] > open)
+                out.length -= 1
+            out.push([open, j])
+            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
+}
+
+// A backslash escapes the punctuation after it, so "\<" opens no tag; an even run escapes only itself.
+function isEscaped(text, tag) {
+    var back = 0
+    for (var b = tag - 1; b >= 0 && text.charAt(b) === "\\"; b--)
+        back++
+    return back % 2 === 1
+}
+
+// Sample input: ["a", "", "b"] cuts after the blank; ["<div>", "", "x"] never cuts inside the open tag.
+// One forward pass, so hostile input stays linear: tag depth and comments ride along, and a later paragraph never rescans an earlier one.
+function cutAfter(lines) {
+    var cut = []
+    for (var i = 0; i < lines.length; i++)
+        cut.push(false)
+    var laterText = []
+    var seen = false
+    for (var w = lines.length - 1; w >= 0; w--) {
+        laterText[w] = seen
+        if (lines[w].trim().length > 0)
+            seen = true
+    }
+    var depth = 0
+    var comment = false
+    // An unterminated tag may complete on a later line; past readTag's own cap it never classifies, so it is dropped.
+    var carry = ""
+    var hasText = false
+    for (var l = 0; l < lines.length; l++) {
+        var line = lines[l]
+        if (line.trim().length === 0) {
+            if (hasText && laterText[l] && depth === 0 && !comment) {
+                cut[l] = true
+                hasText = false
+                depth = 0
+                comment = false
+                carry = ""
+            }
+            continue
+        }
+        hasText = true
+        // A tag may wrap at whitespace, so the carried fragment rejoins with the newline it was split on.
+        var text = carry === "" ? line : carry + "\n" + line
+        carry = ""
+        // Tags inside a closed code span are literal text, the same rule the inline parser pairs by.
+        var code = codeRanges(text)
+        var span = 0
+        var at = 0
+        // A ">" search that reaches the end proves no later tag on this text can close, so each pays once.
+        var noClose = -1
+        while (at < text.length) {
+            if (comment) {
+                var end = text.indexOf("-->", at)
+                if (end < 0)
+                    break
+                comment = false
+                at = end + 3
+                continue
+            }
+            var tag = text.indexOf("<", at)
+            if (tag < 0)
+                break
+            while (span < code.length && code[span][1] <= tag)
+                span += 1
+            if (span < code.length && code[span][0] <= tag && tag < code[span][1]) {
+                at = code[span][1]
+                continue
+            }
+            if (isEscaped(text, tag)) {
+                at = tag + 1
+                continue
+            }
+            if (text.slice(tag, tag + 4) === "<!--") {
+                comment = true
+                at = tag + 4
+                continue
+            }
+            var found = null
+            if (noClose < 0 || tag <= noClose)
+                found = MdHtml.readTag(text, tag, null)
+            if (found === null) {
+                if (noClose < 0 && text.indexOf(">", tag + 1) < 0)
+                    noClose = tag
+                at = tag + 1
+                continue
+            }
+            var head = MdHtml.tagHead(found.tag)
+            if (head.name !== "" && !VOID_TAGS.hasOwnProperty(head.name)) {
+                if (head.closing) {
+                    if (depth > 0)
+                        depth--
+                } else if (!head.selfClose)
+                    depth++
+            }
+            at = found.end
+        }
+        var lastLt = text.lastIndexOf("<")
+        if (lastLt > text.lastIndexOf(">") && text.length - lastLt <= MdHtml.MAX_TAG_LENGTH)
+            carry = text.slice(lastLt)
+    }
+    return cut
+}

package/ui/js/MdRefs.js

@@ -0,0 +1,232 @@
+.pragma library
+
+// Parse one definition's text; MdBlocks alone decides where definitions are allowed.
+.import "MdLink.js" as Link
+.import "MdHtml.js" as MdHtml
+.import "MdContainer.js" as Container
+
+var hasOwn = Object.prototype.hasOwnProperty
+
+// Sample: [pic]: image.png "Title"; an empty destination can continue on the next container line.
+function readDefinition(line) {
+    var indent = 0
+    while (indent < MAX_INDENT && line.charAt(indent) === " ")
+        indent++
+    var found = Link.readLabelRef(line, indent)
+    if (found === null || found.label.trim().length === 0 || found.label.charAt(0) === "^" || line.charAt(found.end) !== ":")
+        return null
+    var rest = line.slice(found.end + 1)
+    if (rest.trim().length === 0)
+        return { key: Link.normalizeLabel(found.label), target: "", titled: false }
+    var body = readBodyAt(rest, 0)
+    if (body === null)
+        return null
+    return { key: Link.normalizeLabel(found.label), target: body.target, titled: body.titled }
+}
+
+// Sample: <my pic.png> "Title" or pic.png; one destination grammar for top level and containers.
+function readDefinitionParts(text) {
+    var body = readBodyAt(text, 0)
+    if (body === null)
+        return { target: "", titled: false }
+    return { target: body.target, titled: body.titled }
+}
+
+function readDefinitionTarget(text) {
+    return readDefinitionParts(text).target
+}
+
+var MAX_INDENT = 3
+var TITLE_CLOSER = { '"': '"', "'": "'", "(": ")" }
+
+// Sample input: "\n  x" read from 0 answers { at: 4, newline: true }; spaces, tabs and at most one line ending are skipped.
+function skipGap(text, from) {
+    var at = from
+    var newline = false
+    while (at < text.length && (text.charAt(at) === " " || text.charAt(at) === "\t" || (!newline && text.charAt(at) === "\n"))) {
+        newline = newline || text.charAt(at) === "\n"
+        at++
+    }
+    return { at: at, newline: newline }
+}
+
+// Sample input: '<a b> "t"' read from 0 answers { target: "a b", end: 5 }; "/u x" answers { target: "/u", end: 2 }; "<a" answers null.
+function readDestinationAt(text, from) {
+    var at = from
+    if (text.charAt(at) === "<") {
+        at = Link.angleClose(text, from + 1, text.length, true)
+        return at >= 0 ? { target: text.slice(from + 1, at), end: at + 1 } : null
+    }
+    var depth = 0
+    while (at < text.length && !/[\s\x00-\x1f]/.test(text.charAt(at))) {
+        var c = text.charAt(at)
+        depth += c === "(" ? 1 : c === ")" ? -1 : 0
+        at += c === "\\" && at + 1 < text.length && !/\s/.test(text.charAt(at + 1)) ? 2 : 1
+    }
+    return at > from && depth === 0 ? { target: text.slice(from, at), end: at } : null
+}
+
+// Sample input: `"a\nb" x` read from 0 answers 6, the index after the closing quote; a title needs its closer, and "(" titles hold no "(".
+function readTitleEnd(text, from) {
+    var opener = text.charAt(from)
+    var closer = TITLE_CLOSER.hasOwnProperty(opener) ? TITLE_CLOSER[opener] : ""
+    for (var at = from + 1; closer !== "" && at < text.length; at++) {
+        var c = text.charAt(at)
+        if (c === closer)
+            return at + 1
+        if (opener === "(" && c === "(")
+            return -1
+        at += c === "\\" && text.charAt(at + 1) !== "\n" ? 1 : 0
+    }
+    return -1
+}
+
+// Sample input: "a  \nb" at 1 answers true, only blanks remain on the line; "a b" at 1 answers false.
+function endsLine(text, from) {
+    var at = from
+    while (text.charAt(at) === " " || text.charAt(at) === "\t")
+        at++
+    return at >= text.length || text.charAt(at) === "\n"
+}
+
+// Sample input: '<a b> "t"' read from 0 answers { target: "a b", titled: true, end: 9 }; "/u x" answers null, junk follows the destination.
+function readBodyAt(text, from) {
+    var lead = skipGap(text, from)
+    var dest = readDestinationAt(text, lead.at)
+    if (dest === null)
+        return null
+    var gap = skipGap(text, dest.end)
+    var close = gap.at > dest.end ? readTitleEnd(text, gap.at) : -1
+    var titled = close >= 0 && endsLine(text, close)
+    if (!titled && !endsLine(text, dest.end))
+        return null
+    return { target: dest.target, titled: titled, end: titled ? close : dest.end }
+}
+
+// Sample input: lines "[Foo\n  bar]: /url\n'a\nb'" answer { key: "foo bar", titled: true, end: 3 }; "[a]: /u x" answers null.
+function definitionAt(lines, from) {
+    var stop = from + 1
+    while (stop < lines.length && lines[stop].trim().length > 0 && !Container.startsBlock(lines[stop]))
+        stop++
+    var text = lines.slice(from, stop).join("\n")
+    var indent = 0
+    while (indent < MAX_INDENT && text.charAt(indent) === " ")
+        indent++
+    var label = Link.readLabelRef(text, indent)
+    if (label === null || label.label.trim().length === 0 || label.label.charAt(0) === "^" || text.charAt(label.end) !== ":")
+        return null
+    var body = readBodyAt(text, label.end + 1)
+    if (body === null)
+        return null
+    // A title that does not close its own line is dropped when it sits on the next line, and spoils the definition when it follows the destination.
+    return { key: Link.normalizeLabel(label.label), target: body.target, titled: body.titled,
+        end: from + text.slice(0, body.end).split("\n").length - 1 }
+}
+
+// Sample input: '    > "t"' under frames list (contentCol 4) then quote answers '"t"'; '"t"' with no indent stays a lazy continuation; a line that opens its own quote answers null.
+function replayed(line, frames) {
+    var view = { at: 0, padding: 0, column: 0 }
+    for (var f = 0; f < frames.length; f++) {
+        var quote = Container.quoteAt(line, view)
+        if (frames[f].type === "quote" && quote >= 0)
+            Container.takeQuote(line, view, quote)
+        else if (frames[f].type === "list" && Container.indentationAt(line, view, frames[f].contentCol).width >= frames[f].contentCol)
+            Container.takeIndent(line, view, frames[f].contentCol)
+        else
+            break
+    }
+    return Container.quoteAt(line, view) >= 0 ? null : Container.textAt(line, view)
+}
+
+// Sample input: lines "'a" over "b'" at 0 with no frames answer 1, the line that closes the title; "'open" with no closer, or junk after it, answers -1.
+function titleEnd(lines, at, frames) {
+    var first = at < lines.length ? replayed(lines[at], frames) : null
+    var open = first === null ? "" : first.trim().charAt(0)
+    if (open !== "\"" && open !== "'" && open !== "(")
+        return -1
+    var close = open === "(" ? ")" : open
+    for (var k = at; k < lines.length; k++) {
+        var text = replayed(lines[k], frames)
+        if (text === null || text.trim().length === 0)
+            return -1
+        for (var c = k === at ? text.indexOf(open) + 1 : 0; c < text.length; c++) {
+            if (text.charAt(c) === "\\")
+                c++
+            else if (text.charAt(c) === close)
+                return text.slice(c + 1).trim().length === 0 ? k : -1
+        }
+    }
+    return -1
+}
+
+// The first definition of a label wins.
+function storeDefinition(defs, key, target) {
+    if (!hasOwn.call(defs, key))
+        defs[key] = target
+}
+
+// A title on the lines after a finished definition belongs to it: its lines hide with the definition; allowed says it has none yet, frames are its containers.
+function hideTitle(lines, from, state, allowed, frames) {
+    var end = allowed ? titleEnd(lines, from, frames) : -1
+    if (end < 0)
+        return
+    for (var k = from; k <= end; k++)
+        state.hidden[k] = true
+    state.dropped.push([from, end])
+}
+
+// Sample: [^id]: note body; the block reader supplies any indented continuation lines.
+function readFootnoteDefinition(line) {
+    var match = /^ {0,3}\[\^([^\]\n]+)\]:\s*(.*)$/.exec(line)
+    return match === null ? null : { id: match[1], text: match[2] }
+}
+
+// Escape a definition-shaped leaf refused by the block reader before handing it to md4c.
+function killDefinition(line) {
+    if (!/^ {0,3}\[(?:\\.|[^\[\]\\\n])+\]:/.test(line))
+        return line
+    var at = line.indexOf("[")
+    return line.slice(0, at) + "\\[" + line.slice(at + 1)
+}
+
+// Sample input: "[^note]" at its "[" yields id "note" and the index after "]".
+function readFootnoteRef(text, i) {
+    var j = i + 2
+    while (j < text.length && text.charAt(j) !== "]" && text.charAt(j) !== "\n")
+        j++
+    if (j >= text.length || text.charAt(j) !== "]" || j === i + 2)
+        return null
+    return { id: text.slice(i + 2, j), end: j + 1 }
+}
+
+
+// Skip DROP_CONTENT bodies with same-name nesting; share the dead-tag flag to keep unmatched runs linear.
+function skipDropContent(body, i, name, dead) {
+    var depth = 1
+    while (i < body.length && depth > 0) {
+        var o = body.indexOf("<", i)
+        if (o < 0)
+            return body.length
+        var inner = MdHtml.readTag(body, o, dead)
+        if (inner === null) {
+            i = o + 1
+            continue
+        }
+        var head = MdHtml.tagHead(inner.tag)
+        if (head.name === name) {
+            if (head.closing)
+                depth--
+            else if (!head.selfClose)
+                depth++
+        }
+        i = inner.end
+    }
+    return i
+}
+
+// Sample input: lines 2 to 3 hide both and record the span as dropped, so no line of the definition reaches the renderer.
+function hideDefinition(state, from, to) {
+    for (var i = from; i <= to; i++)
+        state.hidden[i] = true
+    state.dropped.push([from, to])
+}

package/ui/js/MdResolve.js

@@ -0,0 +1,226 @@
+.pragma library
+
+// MdResolve: resolve bracket pairs into held local images, escaped placeholders, safe links or literal text.
+.import "MdUrl.js" as MdUrl
+.import "MdHtml.js" as MdHtml
+.import "MdInline.js" as Md
+.import "MdLink.js" as Link
+.import "MdRefs.js" as Refs
+.import "MdEntity.js" as Ent
+
+var MAX_STYLED_SPANS = 1024
+var hasOwn = Object.prototype.hasOwnProperty
+// The bytes a markdown destination cannot hold as written, as percent escapes.
+var PERCENT_ESCAPE = { " ": "%20", "(": "%28", ")": "%29" }
+// The characters the renderer decodes in a destination, written so it reads back the text it was given.
+var DESTINATION_ESCAPE = { "\\": "\\\\", "&": "&amp;", "<": "&lt;", ">": "&gt;" }
+
+// A destination as the markdown the renderer reads back to exactly this text: it decodes references and escapes once more.
+function markdownDestination(target) {
+    return String(target).replace(/[ ()\\&<>]/g, function (c) {
+        return PERCENT_ESCAPE.hasOwnProperty(c) ? PERCENT_ESCAPE[c] : DESTINATION_ESCAPE[c]
+    })
+}
+
+// Sample input: "https://a.example" and "mailto:a@b.example" are external; "./x.md", "#top" and "ftp://h/f" are not.
+function isExternalLink(url) {
+    var seen = MdHtml.normalizedTarget(MdUrl.canonicalUrl(url))
+    return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(seen) && MdUrl.targetAllowed(url)
+}
+
+// Sample input: "(/u)" after a label answers { url: "/u", end: 4 }; "[ref]" and "[]" read a definition, as does a bare label (raw).
+function readDestination(body, j, raw, defs) {
+    var found = readRawDestination(body, j, raw, defs)
+    return found === null ? null : { url: Ent.decodeReferences(found.url), end: found.end }
+}
+
+function readRawDestination(body, j, raw, defs) {
+    var inline = body.charAt(j) === "(" ? Link.readInlineTarget(body, j) : null
+    if (inline !== null)
+        return { url: inline.url, end: inline.end }
+    if (body.charAt(j) === "[") {
+        var ref = Link.readLabelRef(body, j)
+        var label = ref === null ? "" : ref.label.length > 0 ? ref.label : raw
+        if (label.length > 0 && hasOwn.call(defs, Link.normalizeLabel(label)))
+            return { url: defs[Link.normalizeLabel(label)], end: ref.end }
+        return null
+    }
+    if (raw.length > 0 && hasOwn.call(defs, Link.normalizeLabel(raw)))
+        return { url: defs[Link.normalizeLabel(raw)], end: j }
+    return null
+}
+
+// An alt text is the label's text alone: tags go, numeric entities turn back into characters.
+function plainText(html) {
+    return String(html).replace(/<[^>]*>/g, "").replace(/&#(\d+);/g, function (m, n) {
+        return String.fromCharCode(parseInt(n, 10))
+    })
+}
+
+// Resolve one bracket pair into text, a -1-i token reference or null; raw is its label, label() its resolved markup and target its destination.
+function resolvePair(raw, target, bang, dir, ink, tokens, label) {
+    // A backslash before punctuation is consumed by the backslash: the alt and the label display the punctuation, never the escape.
+    var clean = String(raw).replace(/\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g, "$1")
+    if (bang) {
+        clean = label === undefined ? clean : plainText(label())
+        var cls = MdUrl.classifyImage(target, dir)
+        if (cls.kind === "remote")
+            return "\n\n" + MdUrl.placeholder(Md.escapeHtmlText(cls.host)) + "\n\n"
+        if (cls.kind === "local") {
+            var alt = Md.escapeHtmlText(clean)
+            tokens.push("![" + alt + "](" + markdownDestination(cls.url) + ")")
+            return -1 - (tokens.length - 1)
+        }
+        return Md.escapeHtmlText(clean)
+    }
+    target = MdHtml.normalizedTarget(target)
+    // Only http, https, mailto, relative and #anchor targets link, checked through every decoding, so no javascript: href is emitted.
+    if (!MdUrl.targetAllowed(target))
+        return Md.escapeHtmlText("[" + clean + "](" + target + ")")
+    var shown = label === undefined ? clean : label()
+    // Inside an html link the renderer would draw a linked image's alt text beside it, so its own link syntax carries that label.
+    var html = label !== undefined && shown.indexOf("![") >= 0
+        ? "[" + shown + "](" + markdownDestination(target) + ")"
+        : Md.linkHtml(shown, target, ink, label !== undefined)
+    if (html === null)
+        return Md.escapeHtmlText("[" + clean + "](" + target + ")")
+    tokens.push(html)
+    return -1 - (tokens.length - 1)
+}
+
+// Push sanitizer output, splitting any held-span markers it carries into token references. Tags are short, so this walk is bounded by the tag length.
+function pushEmitted(out, tokens, emit) {
+    var open = MdHtml.openToken()
+    if (emit.indexOf(open) < 0) {
+        out.push(emit)
+        return
+    }
+    var close = MdHtml.closeToken()
+    var plain = ""
+    var i = 0
+    while (i < emit.length) {
+        if (emit.charAt(i) !== open) {
+            plain += emit.charAt(i)
+            i++
+            continue
+        }
+        var j = i + 1
+        var num = ""
+        while (j < emit.length && emit.charAt(j) !== close) {
+            num += emit.charAt(j)
+            j++
+        }
+        var idx = parseInt(num, 10)
+        if (j < emit.length && idx >= 0 && idx < tokens.length) {
+            if (plain !== "") {
+                out.push(plain)
+                plain = ""
+            }
+            out.push(-1 - idx)
+            i = j + 1
+        } else {
+            plain += emit.charAt(i)
+            i++
+        }
+    }
+    if (plain !== "")
+        out.push(plain)
+}
+
+// One styled span, cached by content: dense documents repeat the same spans thousands of times, and each rebuild costs a regex the cache pays once.
+function styledSpan(kind, content, chrome, cache) {
+    var key = kind + "\n" + content
+    if (cache.hasOwnProperty(key))
+        return cache[key]
+    var held = Md.codeHtml(content, chrome, kind)
+    var count = 0
+    for (var existing in cache)
+        count++
+    if (count < MAX_STYLED_SPANS)
+        cache[key] = held
+    return held
+}
+
+// Sample input: '<img src="pic.png">' at its "<" resolves a tag; '<https://a.example>' resolves an autolink.
+function parseAngle(body, i, dir, ink, styleLinks, dead, tokens, out, chrome, inked) {
+    var auto = Link.readAutolink(body, i)
+    if (auto !== null && !MdUrl.targetAllowed(auto.href))
+        auto = null
+    if (auto !== null) {
+        if (!styleLinks) {
+            out.push(Md.escapeHtmlText(auto.url))
+            i = auto.end
+            return i
+        }
+        var ahtml = Md.linkHtml(auto.url, auto.href, ink)
+        if (ahtml === null)
+            out.push(Md.escapeHtmlText(auto.url))
+        else {
+            tokens.push(ahtml)
+            out.push(-1 - (tokens.length - 1))
+        }
+        i = auto.end
+        return i
+    }
+    if (body.slice(i, i + 4) === "<!--") {
+        if (dead.commentDead) {
+            out.push("&#60;")
+            i++
+            return i
+        }
+        var ce = body.indexOf("-->", i + 4)
+        if (ce < 0) {
+            dead.commentDead = true
+            out.push("&#60;")
+            i++
+        } else {
+            i = ce + 3
+        }
+        return i
+    }
+    if (body.charAt(i + 1) === "!" || body.charAt(i + 1) === "?") {
+        var decl = MdHtml.readTag(body, i, dead)
+        if (decl === null) {
+            out.push("&#60;")
+            i++
+        } else {
+            i = decl.end
+        }
+        return i
+    }
+    var found = MdHtml.readTag(body, i, dead)
+    if (found === null || MdHtml.tagHead(found.tag).name.length === 0) {
+        out.push("&#60;")
+        i++
+        return i
+    }
+    var san = MdHtml.sanitizeTag(found.tag, dir, tokens, chrome, ink, inked)
+    pushEmitted(out, tokens, san.emit)
+    i = found.end
+    if (san.drop !== null)
+        i = Refs.skipDropContent(body, i, san.drop, dead)
+    return i
+}
+
+// Sample input: "see https://a.example/x now" at the "h" answers the index after the address; no bare address answers -1.
+function bareAt(body, i, ink, styleLinks, tokens, out) {
+    var bare = Link.readBarelink(body, i)
+    if (bare === null || !MdUrl.targetAllowed(bare.href))
+        return -1
+    var url = bare.url
+    var href = bare.href
+    // GFM leaves a trailing entity reference such as "&hl;" out of the address.
+    var entity = body.charAt(bare.end) === ";" ? /&[A-Za-z0-9]+$/.exec(url) : null
+    if (entity !== null) {
+        url = url.slice(0, entity.index)
+        href = href.slice(0, href.length - (bare.url.length - url.length))
+    }
+    var html = styleLinks ? Md.linkHtml(url, href, ink) : null
+    if (html === null) {
+        out.push(Md.escapeHtmlText(url))
+    } else {
+        tokens.push(html)
+        out.push(-1 - (tokens.length - 1))
+    }
+    return bare.end - (bare.url.length - url.length)
+}