Watch
1
0
Fork
You've already forked packages
0
packages/markdown/lib/chars.weft
Weft packages 306b143104 packages/ at markup-kit dd1e6eb5270e
A snapshot of packages/ in the Weft repository; the official packages are published from these commits.

Markup-Kit-Commit: dd1e6eb5270e62e0c8b6c202b3d01f0da6e00ddc
2026-11-19 20:43:26 +00:00

242 lines
6.3 KiB
Text

// Character classes and the text transformations CommonMark defines: escapes, entities, URLs.
import { entity } from "./entities"
import { PUNCTUATION } from "./unicode"
/// The code unit at `i`, or -1 past the end.
export fn unit(s: string, i: int): int {
return s.codeUnitAt(i) ?? -1
}
export fn isSpaceOrTab(c: float): boolean {
return c == 32 || c == 9
}
export fn isDigit(c: float): boolean {
return c >= 48 && c <= 57
}
export fn isAlpha(c: float): boolean {
return (c >= 65 && c <= 90) || (c >= 97 && c <= 122)
}
export fn isAlnum(c: float): boolean {
return isAlpha(c) || isDigit(c)
}
export fn isHex(c: float): boolean {
return isDigit(c) || (c >= 65 && c <= 70) || (c >= 97 && c <= 102)
}
/// ASCII punctuation: what a backslash can escape.
export fn isAsciiPunct(c: float): boolean {
return (c >= 33 && c <= 47) ||
(c >= 58 && c <= 64) ||
(c >= 91 && c <= 96) ||
(c >= 123 && c <= 126)
}
/// Unicode whitespace: the `Zs` category, tab, line feed, form feed and carriage return.
export fn isUnicodeSpace(c: float): boolean {
if c < 128 {
return c == 32 || c == 9 || c == 10 || c == 12 || c == 13
}
return c == 0xa0 ||
c == 0x1680 ||
(c >= 0x2000 && c <= 0x200a) ||
c == 0x202f ||
c == 0x205f ||
c == 0x3000
}
/// Unicode punctuation: the `P` and `S` categories.
export fn isUnicodePunct(c: float): boolean {
if c < 128 {
return isAsciiPunct(c)
}
let mut lo = 0
let mut hi = PUNCTUATION.length.div(2) - 1
while lo <= hi {
let mid = (lo + hi) >> 1
if c < PUNCTUATION[mid * 2] {
hi = mid - 1
} else if c > PUNCTUATION[mid * 2 + 1] {
lo = mid + 1
} else {
return true
}
}
return false
}
/// Whether `s` holds only spaces and tabs (or nothing).
export fn isBlank(s: string): boolean {
for i of 0..s.length {
let c = s.codeUnitAt(i) ?? 32
if c != 32 && c != 9 && c != 10 && c != 13 {
return false
}
}
return true
}
/// The code point ending just before `pos`, or a line feed at the start of `s`.
export fn codePointBefore(s: string, pos: int): int {
if pos <= 0 {
return 10
}
let low = s.codeUnitAt(pos - 1) ?? 10
if low >= 0xdc00 && low <= 0xdfff && pos >= 2 {
let high = s.codeUnitAt(pos - 2) ?? 0
if high >= 0xd800 && high <= 0xdbff {
return (high - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000
}
}
return low
}
/// The character reference starting at the `&` at `pos`: its text and where it ends, or `null` when there is none.
export fn scanEntity(s: string, pos: int): [string, int]? {
let mut i = pos + 1
if s.codeUnitAt(i) == 35 {
i += 1
let c = s.codeUnitAt(i) ?? -1
let hex = c == 120 || c == 88
if hex {
i += 1
}
let start = i
while i - start < (hex ? 6 : 7) &&
(hex ? isHex(s.codeUnitAt(i) ?? -1) : isDigit(s.codeUnitAt(i) ?? -1)) {
i += 1
}
if i == start || s.codeUnitAt(i) != 59 {
return null
}
let n = try int(s.slice(start, i), hex ? 16 : 10) else 0
let valid = n != 0 && n <= 0x10ffff && !(n >= 0xd800 && n <= 0xdfff)
return [String.fromCodePoint(valid ? n : 0xfffd), i + 1]
}
let start = i
while i - start < 32 && isAlnum(s.codeUnitAt(i) ?? -1) {
i += 1
}
if i == start || s.codeUnitAt(i) != 59 {
return null
}
let text = entity(s.slice(start, i))
if text == null {
return null
}
return [text, i + 1]
}
/// `s` with its backslash escapes and character references replaced by what they stand for.
export fn unescape(s: string): string {
if !s.includes("\\") && !s.includes("&") {
return s
}
let mut parts: string[] = []
let mut from = 0
let mut i = 0
while i < s.length {
let c = s.codeUnitAt(i) ?? 0
if c == 92 && isAsciiPunct(s.codeUnitAt(i + 1) ?? 0) {
parts.push(s.slice(from, i))
from = i + 1
i += 2
} else if c == 38 {
let found = scanEntity(s, i)
if found != null {
parts.push(s.slice(from, i))
parts.push(found[0])
i = found[1]
from = i
} else {
i += 1
}
} else {
i += 1
}
}
parts.push(s.slice(from))
return parts.join("")
}
/// `s` escaped for HTML text and attribute values.
export fn escapeHtml(s: string): string {
let mut i = 0
while i < s.length {
let c = s.codeUnitAt(i) ?? 0
if c == 38 || c == 60 || c == 62 || c == 34 {
break
}
i += 1
}
if i == s.length {
return s
}
let mut parts: string[] = [s.slice(0, i)]
let mut from = i
while i < s.length {
let c = s.codeUnitAt(i) ?? 0
let rep = c == 38 ? "&amp;" : c == 60 ? "&lt;" : c == 62 ? "&gt;" : c == 34 ? "&quot;" : ""
if rep != "" {
parts.push(s.slice(from, i))
parts.push(rep)
from = i + 1
}
i += 1
}
parts.push(s.slice(from))
return parts.join("")
}
fn keptInUrl(c: int): boolean {
// Letters, digits and what URLs use as syntax; everything else is percent-encoded.
return isAlnum(c) || (c < 128 && ";/?:@&=+$,-_.!~*'()#".includes(String.fromCharCode(c)))
}
/// `url` percent-encoded for an `href`: what is already encoded stays, and a lone surrogate becomes U+FFFD.
export fn normalizeUrl(url: string): string {
let mut parts: string[] = []
let mut from = 0
let mut i = 0
while i < url.length {
let c = url.codeUnitAt(i) ?? 0
if c == 37 && isHex(url.codeUnitAt(i + 1) ?? -1) && isHex(url.codeUnitAt(i + 2) ?? -1) {
i += 3
} else if keptInUrl(c) {
i += 1
} else {
parts.push(url.slice(from, i))
let point = url.codePointAt(i) ?? 0xfffd
let width = point > 0xffff ? 2 : 1
let safe = point >= 0xd800 && point <= 0xdfff ? 0xfffd : point
for b of Bytes.fromUtf8(String.fromCodePoint(safe)).toList() {
parts.push("%" + str(b, { radix: 16 }).toUpperCase().padStart(2, "0"))
}
i += width
from = i
}
}
parts.push(url.slice(from))
return parts.join("")
}
/// A link label as references are matched: case-folded, with whitespace collapsed.
export fn normalizeLabel(label: string): string {
let mut out: string[] = []
let mut space = false
for ch of label.trim() {
if ch == " " || ch == "\t" || ch == "\n" || ch == "\r" {
space = true
} else {
if space {
out.push(" ")
space = false
}
out.push(ch)
}
}
return out.join("").toLowerCase().toUpperCase()
}