/** * CommonMark Phase 2 inline parser with linked delimiter stack, bracket stack * for links and images, and `DelimiterProcessor` / `InlineContentParser` * plugin dispatch. */ import {FixedArray, GrowableArray} from 'zena:core'; import {StringBuilder, StringReader, isAsciiWhitespace, isAsciiPunctuation, isAsciiAlpha, isAsciiAlphanumeric, isUnicodeWhitespace, isUnicodePunctuation} from 'zena:string'; import {HashMap} from 'zena:collections'; import {Inline, LinkDef, Span, Text, CodeSpan, Emphasis, Strong, Link, Image, Autolink, HtmlInline, SoftBreak, HardBreak} from './ast.zena'; import {DelimiterProcessor, DelimiterRunInfo, InlineContentParser, InlineMatch, InlineParserRunner, MarkdownExtension} from './plugin.zena'; import {skipSpacesAndOneLineEnd, normalizeLinkLabel, tryDecodeEntity, scanLinkDestination, scanLinkTitle, scanLinkLabel} from './scanner.zena'; /** * Internal doubly-linked list node holding an `Inline` during Phase 2 parsing * so delimiter and link resolution can splice ranges in O(1) without * invalidating references held by outer delimiters or brackets. */ final class InlineEntry { var node: Inline; var prev: InlineEntry | null = null; var next: InlineEntry | null = null; /** How deep `node` nests other inlines: 0 when it holds none. */ var depth = 0; new(this.node) {} } /** * How deep emphasis, links and images may nest. A run of delimiters or * brackets that would nest deeper stays text: every walk over the tree * recurses through the inlines, and a deeper one would overflow the stack. */ let MAX_INLINE_NESTING = 100; /** The deepest of the entries from `first` up to `end`, not including it. */ function deepestBetween(first: InlineEntry | null, end: InlineEntry | null) { var deepest = 0; var curr = first; while (curr != null && curr != end) { if (curr.depth > deepest) { deepest = curr.depth; } curr = curr.next; } return deepest; } /** * An active run of delimiter characters (`*`, `_`, or a custom * `DelimiterProcessor` character) on the delimiter stack. */ final class Delimiter { entry: InlineEntry; delimiterByte: i32; var length: i32; originalLength: i32; canOpen: boolean; canClose: boolean; startOffset: i32; var prev: Delimiter | null = null; var next: Delimiter | null = null; new(this.entry, this.delimiterByte, this.length, this.originalLength, this.canOpen, this.canClose, this.startOffset) {} } /** * An open `[` or `![` bracket on the bracket stack waiting for a matching `]`. */ final class Bracket { entry: InlineEntry; index: i32; startOffset: i32; isImage: boolean; previousDelimiter: Delimiter | null; prev: Bracket | null; var active: boolean = true; var bracketAfter: boolean = false; new(this.entry, this.index, this.startOffset, this.isImage, this.previousDelimiter, this.prev) {} } /** * CommonMark Phase 2 inline parser. */ export final class InlineParser implements InlineParserRunner { links: HashMap; #delimiterProcessors = new HashMap(); #inlineParsersByByte = new FixedArray | null>( 128, null ); #specialBytes = new FixedArray(128, false); var #firstEntry: InlineEntry | null = null; var #lastEntry: InlineEntry | null = null; var #lastDelimiter: Delimiter | null = null; var #lastBracket: Bracket | null = null; new(links: HashMap, extensions: GrowableArray) : links = links { // Mark built-in special ASCII bytes: // \n (10), \r (13), ! (33), & (38), * (42), < (60), [ (91), \ (92), ] (93), _ (95), ` (96) this.#specialBytes[0x0A] = true; this.#specialBytes[0x0D] = true; this.#specialBytes[0x21] = true; this.#specialBytes[0x26] = true; this.#specialBytes[0x2A] = true; this.#specialBytes[0x3C] = true; this.#specialBytes[0x5B] = true; this.#specialBytes[0x5C] = true; this.#specialBytes[0x5D] = true; this.#specialBytes[0x5F] = true; this.#specialBytes[0x60] = true; for (let ext in extensions) { for (let dp in ext.delimiterProcessors) { let openByte = dp.openingByte(); let closeByte = dp.closingByte(); if (openByte >= 0 && openByte < 128) { this.#delimiterProcessors[openByte] = dp; this.#specialBytes[openByte] = true; } if (closeByte >= 0 && closeByte < 128) { this.#delimiterProcessors[closeByte] = dp; this.#specialBytes[closeByte] = true; } } for (let ip in ext.inlineParsers) { let triggers = ip.triggerBytes(); for (let b in triggers) { if (b >= 0 && b < 128) { var bucket = this.#inlineParsersByByte[b]; if (bucket == null) { bucket = new GrowableArray(2); this.#inlineParsersByByte[b] = bucket; } bucket.push(ip); this.#specialBytes[b] = true; } } } } } /** * Parses `text` (located at `baseOffset` in the document) into a list of * `Inline` AST nodes. */ parse(text: String, baseOffset: i32): GrowableArray { this.#firstEntry = null; this.#lastEntry = null; this.#lastDelimiter = null; this.#lastBracket = null; let r = new StringReader(text); while (!r.isAtEnd) { let i = r.mark(); let b = r.peek(); // 1. Check registered InlineContentParser plugins triggered by `b` var pluginMatched = false; if (b >= 0 && b < 128) { let bucket = this.#inlineParsersByByte[b]; if (bucket != null) { let prevCp = r.peekBefore(); for (let parser in bucket) { let matchResult = parser.tryParse( text, baseOffset, i, prevCp, this ); if (matchResult != null && matchResult.nextIndex > i) { this.#appendNode(matchResult.node); r.reset(matchResult.nextIndex); pluginMatched = true; break; } } } } if (pluginMatched) { continue; } // 2. Built-in CommonMark inline constructs and registered DelimiterProcessors if (b == 0x0A || b == 0x0D) { // \n or \r this.#parseNewline(r, baseOffset); } else if (b == 0x5C) { // \ this.#parseBackslash(r, baseOffset); } else if (b == 0x60) { // ` this.#parseBackticks(r, baseOffset); } else if (b == 0x2A || b == 0x5F || b < 128 && this.#delimiterProcessors.has(b)) { // *, _, or custom delimiter this.#parseDelimiterRun(r, baseOffset, b); } else if (b == 0x5B) { // [ r.advance(); let startOff = baseOffset + i; let entry = this.#appendNode( new Text('[', new Span(startOff, baseOffset + r.mark())) ); this.#addBracket(entry, i, startOff, false); } else if (b == 0x21) { // ! r.advance(); let bracketPos = r.mark(); if (r.matchCodePoint(0x5B)) { // ![ let startOff = baseOffset + i; let entry = this.#appendNode( new Text('![', new Span(startOff, baseOffset + r.mark())) ); this.#addBracket(entry, bracketPos, startOff, true); } else { let startOff = baseOffset + i; this.#appendNode( new Text('!', new Span(startOff, baseOffset + bracketPos)) ); } } else if (b == 0x5D) { // ] this.#parseCloseBracket(r, baseOffset); } else if (b == 0x3C) { // < if (!this.#parseAutolinkOrHtml(r, baseOffset)) { r.advance(); let startOff = baseOffset + i; this.#appendNode( new Text('<', new Span(startOff, baseOffset + r.mark())) ); } } else if (b == 0x26) { // & let sb = new StringBuilder(8); if (tryDecodeEntity(r, sb)) { this.#appendNode( new Text( sb.toString(), new Span(baseOffset + i, baseOffset + r.mark()) ) ); } else { r.advance(); let startOff = baseOffset + i; this.#appendNode( new Text('&', new Span(startOff, baseOffset + r.mark())) ); } } else { // Consume a run of plain text code points until the next special ASCII character r.advance(); while (!r.isAtEnd) { let nb = r.peek(); if (nb >= 0 && nb < 128 && this.#specialBytes[nb]) { break; } r.advance(); } let end = r.mark(); this.#appendNode( new Text( r.sliceRange(i, end), new Span(baseOffset + i, baseOffset + end) ) ); } } this.#processDelimiters(null); return this.#collectAndMergeText(); } #appendNode(node: Inline): InlineEntry { let entry = new InlineEntry(node); let last = this.#lastEntry; if (last == null) { this.#firstEntry = entry; this.#lastEntry = entry; } else { last.next = entry; entry.prev = last; this.#lastEntry = entry; } return entry; } #unlinkEntry(entry: InlineEntry): void { let prev = entry.prev; let next = entry.next; if (prev != null) { prev.next = next; } else { this.#firstEntry = next; } if (next != null) { next.prev = prev; } else { this.#lastEntry = prev; } entry.prev = null; entry.next = null; } #insertEntryBefore(target: InlineEntry, newEntry: InlineEntry): void { let prev = target.prev; newEntry.prev = prev; newEntry.next = target; target.prev = newEntry; if (prev != null) { prev.next = newEntry; } else { this.#firstEntry = newEntry; } } #parseNewline(r: StringReader, baseOffset: i32): void { let index = r.mark(); if (r.matchCodePoint(0x0D)) { r.matchCodePoint(0x0A); } else { r.advance(); } let afterNewline = r.mark(); // Check trailing spaces in the previous Text node var trailingSpaces = 0; let last = this.#lastEntry; if (last != null) { if (let Text {literal} = last.node) { let lr = new StringReader(literal); var end = lr.remaining; while (end > 0) { lr.reset(end); if (lr.peekBefore() == 0x20) { trailingSpaces += 1; end -= 1; } else { break; } } if (trailingSpaces > 0) { if (end == 0) { this.#unlinkEntry(last); } else { last.node = new Text( lr.sliceRange(0, end), new Span(last.node.span.start, last.node.span.start + end) ); } } } } let span = new Span(baseOffset + index, baseOffset + afterNewline); if (trailingSpaces >= 2) { this.#appendNode(new HardBreak(span)); } else { this.#appendNode(new SoftBreak(span)); } // Skip leading spaces on the next line while (r.matchCodePoint(0x20)) {} } #parseBackslash(r: StringReader, baseOffset: i32): void { let index = r.mark(); r.advance(); // consume '\' if (!r.isAtEnd) { let next = r.peek(); if (next == 0x0A || next == 0x0D) { if (r.matchCodePoint(0x0D)) { r.matchCodePoint(0x0A); } else { r.advance(); } this.#appendNode( new HardBreak(new Span(baseOffset + index, baseOffset + r.mark())) ); while (r.matchCodePoint(0x20)) {} return; } if (isAsciiPunctuation(next)) { let charStart = r.mark(); r.advance(); let charEnd = r.mark(); this.#appendNode( new Text( r.sliceRange(charStart, charEnd), new Span(baseOffset + index, baseOffset + charEnd) ) ); return; } } this.#appendNode( new Text('\\', new Span(baseOffset + index, baseOffset + r.mark())) ); } #parseBackticks(r: StringReader, baseOffset: i32): void { let index = r.mark(); var tickCount = 0; while (r.matchCodePoint(0x60)) { tickCount += 1; } let openEnd = r.mark(); while (!r.isAtEnd) { if (r.peek() == 0x60) { let closeStart = r.mark(); var closeCount = 0; while (r.matchCodePoint(0x60)) { closeCount += 1; } if (closeCount == tickCount) { let closeEnd = r.mark(); // Normalize code span interior: convert line endings to spaces let raw = r.sliceRange(openEnd, closeStart); let rawReader = new StringReader(raw); let sb = new StringBuilder(); var hasNonSpace = false; while (!rawReader.isAtEnd) { let cp = rawReader.advance(); if (cp == 0x0D) { sb.appendByte(0x20); rawReader.matchCodePoint(0x0A); } else if (cp == 0x0A) { sb.appendByte(0x20); } else { if (cp != 0x20) { hasNonSpace = true; } sb.appendCodePoint(cp); } } var normalized = sb.toString(); if (hasNonSpace && normalized.startsWith(' ') && normalized.endsWith(' ')) { let nr = new StringReader(normalized); let normEnd = nr.remaining; if (normEnd >= 2) { normalized = nr.sliceRange(1, normEnd - 1); } } this.#appendNode( new CodeSpan( normalized, new Span(baseOffset + index, baseOffset + closeEnd) ) ); return; } } else { r.advance(); } } // Unmatched backtick run becomes literal text r.reset(openEnd); this.#appendNode( new Text( r.sliceRange(index, openEnd), new Span(baseOffset + index, baseOffset + openEnd) ) ); } #parseDelimiterRun(r: StringReader, baseOffset: i32, delimByte: i32): void { let index = r.mark(); let prevCp = r.peekBefore(); let beforeCp = if (prevCp < 0) 0x20 else prevCp; var count = 0; while (r.matchCodePoint(delimByte)) { count += 1; } let end = r.mark(); let nextCp = r.peek(); let afterCp = if (nextCp < 0) 0x20 else nextCp; let beforeIsWhitespace = isUnicodeWhitespace(beforeCp); let beforeIsPunctuation = isUnicodePunctuation(beforeCp); let afterIsWhitespace = isUnicodeWhitespace(afterCp); let afterIsPunctuation = isUnicodePunctuation(afterCp); let leftFlanking = !afterIsWhitespace && (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation); let rightFlanking = !beforeIsWhitespace && (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation); var canOpen = false; var canClose = false; if (delimByte == 0x5F) { // '_' canOpen = leftFlanking && (!rightFlanking || beforeIsPunctuation); canClose = rightFlanking && (!leftFlanking || afterIsPunctuation); } else { canOpen = leftFlanking; canClose = rightFlanking; } let startOff = baseOffset + index; let entry = this.#appendNode( new Text(r.sliceRange(index, end), new Span(startOff, baseOffset + end)) ); if (canOpen || canClose) { let delim = new Delimiter( entry, delimByte, count, count, canOpen, canClose, startOff ); let prev = this.#lastDelimiter; delim.prev = prev; if (prev != null) { prev.next = delim; } this.#lastDelimiter = delim; } } #addBracket(entry: InlineEntry, index: i32, startOffset: i32, isImage: boolean): void { let prev = this.#lastBracket; if (prev != null) { prev.bracketAfter = true; } this.#lastBracket = new Bracket( entry, index, startOffset, isImage, this.#lastDelimiter, prev ); } #removeLastBracket(): void { let b = this.#lastBracket; if (b != null) { this.#lastBracket = b.prev; } } #parseCloseBracket(r: StringReader, baseOffset: i32): void { let index = r.mark(); r.advance(); // consume ']' let afterClose = r.mark(); let opener = this.#lastBracket; if (opener == null) { this.#appendNode( new Text(']', new Span(baseOffset + index, baseOffset + afterClose)) ); return; } if (!opener.active) { this.#removeLastBracket(); this.#appendNode( new Text(']', new Span(baseOffset + index, baseOffset + afterClose)) ); return; } var dest = ''; var title = ''; var nextPos = afterClose; var matched = false; // 1. Inline link/image: `[text](dest "title")` if (r.matchCodePoint(0x28)) { // '(' skipSpacesAndOneLineEnd(r); if (r.matchCodePoint(0x29)) { // empty `()` matched = true; nextPos = r.mark(); } else { let (destOk, parsedDest) = scanLinkDestination(r); if (destOk) { let afterDest = r.mark(); skipSpacesAndOneLineEnd(r); let p = r.mark(); if (r.matchCodePoint(0x29)) { dest = parsedDest; matched = true; nextPos = r.mark(); } else if (p > afterDest) { let (titleOk, parsedTitle) = scanLinkTitle(r); if (titleOk) { skipSpacesAndOneLineEnd(r); if (r.matchCodePoint(0x29)) { dest = parsedDest; title = parsedTitle; matched = true; nextPos = r.mark(); } } } } } if (!matched) { r.reset(afterClose); } } // 2. Reference link: full `[text][ref]`, collapsed `[text][]`, or shortcut `[text]` if (!matched) { var refLabel: String | null = null; var refEnd = afterClose; if (r.peek() == 0x5B) { // '[' if (r.matchString('[]')) { // Collapsed reference `[text][]` if (!opener.bracketAfter && index - (opener.index + 1) <= 999) { refLabel = r.sliceRange(opener.index + 1, index); refEnd = r.mark(); } } else { let (labelOk, rawLabel) = scanLinkLabel(r); if (labelOk) { refLabel = rawLabel; refEnd = r.mark(); } } } else if (!opener.bracketAfter && index - (opener.index + 1) <= 999) { // Shortcut reference `[text]` refLabel = r.sliceRange(opener.index + 1, index); } if (refLabel != null) { let normalized = normalizeLinkLabel(refLabel); if (!normalized.isEmpty && this.links.has(normalized)) { let def = this.links[normalized]; dest = def.destination; title = def.title; matched = true; nextPos = refEnd; } } } if (!matched) { r.reset(afterClose); this.#removeLastBracket(); this.#appendNode( new Text(']', new Span(baseOffset + index, baseOffset + afterClose)) ); return; } // Resolve delimiters strictly inside the bracketed text this.#processDelimiters(opener.previousDelimiter); // Text inside it too deep to wrap again, as a bracket that matches // nothing is. let deepest = deepestBetween(opener.entry.next, null); if (deepest >= MAX_INLINE_NESTING) { r.reset(afterClose); this.#removeLastBracket(); this.#appendNode( new Text(']', new Span(baseOffset + index, baseOffset + afterClose)) ); return; } r.reset(nextPos); // Collect children after opener.entry let children = new GrowableArray(4); var curr = opener.entry.next; while (curr != null) { let nextEntry = curr.next; children.push(curr.node); this.#unlinkEntry(curr); curr = nextEntry; } let span = new Span(opener.startOffset, baseOffset + nextPos); opener.entry.depth = deepest + 1; if (opener.isImage) { opener.entry.node = new Image(dest, title, children, span); } else { opener.entry.node = new Link(dest, title, children, span); // Deactivate earlier `[` link openers so links cannot contain links var b = opener.prev; while (b != null) { if (!b.isImage) { b.active = false; } b = b.prev; } } this.#removeLastBracket(); } #parseAutolinkOrHtml(r: StringReader, baseOffset: i32): boolean { let index = r.mark(); if (!r.matchCodePoint(0x3C)) { // '<' return false; } let contentStart = r.mark(); if (r.isAtEnd) { r.reset(index); return false; } // 1. Check for `<...>`: URI autolink or email autolink var hasSpaceOrAngle = false; var colonPos = -1; var atPos = -1; while (!r.isAtEnd && r.peek() != 0x3E) { let pos = r.mark(); let cp = r.advance(); if (cp <= 0x20 || cp == 0x3C) { hasSpaceOrAngle = true; break; } if (cp == 0x3A && colonPos < 0) { colonPos = pos; } if (cp == 0x40 && atPos < 0) { atPos = pos; } } if (!hasSpaceOrAngle && r.peek() == 0x3E) { let closeAngle = r.mark(); r.advance(); // consume '>' let afterAngle = r.mark(); // Check URI autolink: scheme of 2..32 chars starting with letter followed by ':' if (colonPos >= contentStart + 2 && colonPos - contentStart <= 32) { r.reset(contentStart); var validScheme = isAsciiAlpha(r.advance()); while (validScheme && r.mark() < colonPos) { let sb = r.advance(); validScheme = isAsciiAlphanumeric(sb) || sb == 0x2B || sb == 0x2D || sb == 0x2E; } if (validScheme) { r.reset(afterAngle); let uri = r.sliceRange(contentStart, closeAngle); this.#appendNode( new Autolink( uri, uri, false, new Span(baseOffset + index, baseOffset + afterAngle) ) ); return true; } } // Check email autolink: local@domain if (atPos > contentStart && atPos + 1 < closeAngle && colonPos < 0) { r.reset(contentStart); var validEmail = true; while (r.mark() < atPos) { let eb = r.advance(); let ok = isAsciiAlphanumeric(eb) || eb == 0x2E || eb == 0x2D || eb == 0x5F || eb == 0x2B; if (!ok) { validEmail = false; break; } } var hasDot = false; var labelLen = 0; r.reset(atPos + 1); while (validEmail && r.mark() < closeAngle) { let prev = r.peekBefore(); let db = r.advance(); if (db == 0x2E) { if (labelLen == 0 || prev == 0x2D) { validEmail = false; } hasDot = true; labelLen = 0; } else if (isAsciiAlphanumeric(db) || db == 0x2D && labelLen > 0) { labelLen += 1; } else { validEmail = false; } } r.reset(closeAngle); if (validEmail && hasDot && labelLen > 0 && r.peekBefore() != 0x2D) { r.reset(afterAngle); let email = r.sliceRange(contentStart, closeAngle); this.#appendNode( new Autolink( `mailto:${email}`, email, true, new Span(baseOffset + index, baseOffset + afterAngle) ) ); return true; } } } // 2. Check for inline HTML tag, comment, processing instruction, declaration, or CDATA r.reset(index); if (scanInlineHtmlTag(r)) { let htmlEnd = r.mark(); this.#appendNode( new HtmlInline( r.sliceRange(index, htmlEnd), new Span(baseOffset + index, baseOffset + htmlEnd) ) ); return true; } r.reset(index); return false; } #removeDelimiter(delim: Delimiter): void { let prev = delim.prev; let next = delim.next; if (prev != null) { prev.next = next; } if (next != null) { next.prev = prev; } else { this.#lastDelimiter = prev; } } #removeDelimitersBetween(opener: Delimiter, closer: Delimiter): void { var d = closer.prev; while (d != null && d != opener) { let prev = d.prev; this.#removeDelimiter(d); d = prev; } } #processDelimiters(stackBottom: Delimiter | null): void { let openersBottom = new HashMap(); // Find the first closer above `stackBottom` var closer = this.#lastDelimiter; while (closer != null && closer.prev != stackBottom) { closer = closer.prev; } while (closer != null) { let c = closer; if (!c.canClose) { closer = c.next; continue; } let delimByte = c.delimiterByte; let customProc = if (this.#delimiterProcessors.has( delimByte )) this.#delimiterProcessors[delimByte] else null; let minLen = if (customProc != null) customProc.minLength() else 1; if (c.length < minLen) { closer = c.next; continue; } let lenKey = if (customProc != null) c.length % 16 else c.originalLength % 3; let bottomKey = delimByte * 32 + (if (c.canOpen) 16 else 0) + lenKey; let lowerBound = if (openersBottom.has( bottomKey )) openersBottom[bottomKey] else stackBottom; var opener = c.prev; var matchedOpener: Delimiter | null = null; var usedDelims = 0; var wrappedNode: Inline | null = null; var wrappedDepth = 0; while (opener != null && opener != stackBottom && opener != lowerBound) { let o = opener; if (o.canOpen && o.delimiterByte == delimByte && o.length >= minLen) { // CommonMark Rule 9/10 interior multiple-of-3 rule for `*` and `_` if (customProc == null && (o.canClose || c.canOpen) && c.originalLength % 3 != 0 && (o.originalLength + c.originalLength) % 3 == 0) { opener = o.prev; continue; } // What it would wrap is too deep to wrap again, so the closer // matches nothing, and its delimiters stay text. let deepest = deepestBetween(o.entry.next, c.entry); if (deepest >= MAX_INLINE_NESTING) { break; } wrappedDepth = deepest + 1; // Collect children strictly between `o.entry` and `c.entry` let children = new GrowableArray(4); var curr = o.entry.next; while (curr != null && curr != c.entry) { children.push(curr.node); curr = curr.next; } if (customProc != null) { let openerInfo = new DelimiterRunInfo( o.delimiterByte, o.length, o.originalLength, o.canOpen, o.canClose, o.startOffset + (o.originalLength - o.length), o.startOffset + o.originalLength ); let closerInfo = new DelimiterRunInfo( c.delimiterByte, c.length, c.originalLength, c.canOpen, c.canClose, c.startOffset, c.startOffset + c.length ); let (used, customNode) = customProc.process( openerInfo, closerInfo, children ); if (used > 0 && customNode != null) { usedDelims = used; wrappedNode = customNode; matchedOpener = o; break; } } else { usedDelims = if (o.length >= 2 && c.length >= 2) 2 else 1; let spanStart = o.startOffset + (o.length - usedDelims); let spanEnd = c.startOffset + usedDelims; let span = new Span(spanStart, spanEnd); wrappedNode = if (usedDelims == 2) new Strong( delimByte, children, span ) else new Emphasis(delimByte, children, span); matchedOpener = o; break; } } opener = o.prev; } if (matchedOpener == null || wrappedNode == null || usedDelims <= 0) { openersBottom[bottomKey] = c.prev; if (!c.canOpen) { this.#removeDelimiter(c); } closer = c.next; continue; } let o = matchedOpener; // Unlink the child entries that are now inside `wrappedNode` var unlinkCurr = o.entry.next; while (unlinkCurr != null && unlinkCurr != c.entry) { let nextUnlink = unlinkCurr.next; this.#unlinkEntry(unlinkCurr); unlinkCurr = nextUnlink; } // Insert `wrappedNode` before `c.entry` let wrapped = new InlineEntry(wrappedNode); wrapped.depth = wrappedDepth; this.#insertEntryBefore(c.entry, wrapped); // Remove any delimiters strictly between `o` and `c` this.#removeDelimitersBetween(o, c); // Shrink `o` and `c` o.length -= usedDelims; c.length -= usedDelims; if (o.length == 0) { this.#unlinkEntry(o.entry); this.#removeDelimiter(o); } else { o.entry.node = new Text( repeatAsciiChar(o.delimiterByte, o.length), new Span(o.startOffset, o.startOffset + o.length) ); } if (c.length == 0) { let nextCloser = c.next; this.#unlinkEntry(c.entry); this.#removeDelimiter(c); closer = nextCloser; } else { c.entry.node = new Text( repeatAsciiChar(c.delimiterByte, c.length), new Span(c.startOffset, c.startOffset + c.length) ); } } // Clear remaining delimiters above `stackBottom` while (this.#lastDelimiter != null && this.#lastDelimiter != stackBottom) { let lastDelim = this.#lastDelimiter; if (lastDelim != null) { this.#removeDelimiter(lastDelim); } } } #collectAndMergeText(): GrowableArray { let result = new GrowableArray(8); var curr = this.#firstEntry; while (curr != null) { let c = curr; let node = c.node; var nextEntry = c.next; if (let Text {literal} = node) { if (!literal.isEmpty) { if (nextEntry != null && nextEntry.node is Text) { let sb = new StringBuilder(); sb.append(literal); let start = node.span.start; var end = node.span.end; while (nextEntry != null) { let ne = nextEntry; if (let Text {literal as nextLit} = ne.node) { sb.append(nextLit); end = ne.node.span.end; nextEntry = ne.next; } else { break; } } result.push(new Text(sb.toString(), new Span(start, end))); } else { result.push(node); } } } else { result.push(node); } curr = nextEntry; } return result; } } function repeatAsciiChar(ch: i32, count: i32) { let sb = new StringBuilder(count); var i = 0; while (i < count) { sb.appendByte(ch); i += 1; } return sb.toString(); } /** * Scans a CommonMark inline HTML tag, comment, processing instruction, * declaration, or CDATA section starting with `<` at the current position of * `r`. Advances `r` past the closing `>` and returns `true` on match; resets * `r` and returns `false` otherwise. */ function scanInlineHtmlTag(r: StringReader): boolean { let saved = r.mark(); if (!r.matchCodePoint(0x3C)) { // '<' return false; } let second = r.peek(); // 1. Comment ``, declaration ``, or CDATA `` if (second == 0x21) { // '!' r.advance(); if (r.matchString('--')) { if (r.matchCodePoint(0x3E) || r.matchString('->')) { return true; } while (!r.isAtEnd) { if (r.matchString('-->')) { return true; } r.advance(); } r.reset(saved); return false; } if (r.matchString('[CDATA[')) { while (!r.isAtEnd) { if (r.matchString(']]>')) { return true; } r.advance(); } r.reset(saved); return false; } if (isAsciiAlpha(r.peek())) { r.advance(); while (!r.isAtEnd && r.peek() != 0x3E) { r.advance(); } if (r.matchCodePoint(0x3E)) { return true; } r.reset(saved); return false; } r.reset(saved); return false; } // 2. Processing instruction `` if (second == 0x3F) { // '?' r.advance(); while (!r.isAtEnd) { if (r.matchString('?>')) { return true; } r.advance(); } r.reset(saved); return false; } // 3. Closing tag `` if (second == 0x2F) { // '/' r.advance(); if (!isAsciiAlpha(r.peek())) { r.reset(saved); return false; } r.advance(); r.skipWhile((cp) => isAsciiAlphanumeric(cp) || cp == 0x2D); r.skipWhile((cp) => isAsciiWhitespace(cp)); if (r.matchCodePoint(0x3E)) { return true; } r.reset(saved); return false; } // 4. Opening tag `` if (!isAsciiAlpha(second)) { r.reset(saved); return false; } r.advance(); r.skipWhile((cp) => isAsciiAlphanumeric(cp) || cp == 0x2D); while (!r.isAtEnd) { let wsStart = r.mark(); r.skipWhile((cp) => isAsciiWhitespace(cp)); if (r.isAtEnd) { r.reset(saved); return false; } if (r.matchCodePoint(0x3E)) { // '>' return true; } if (r.matchString('/>')) { return true; } // Attribute must be preceded by whitespace if (r.mark() == wsStart) { r.reset(saved); return false; } // Attribute name: `[a-zA-Z_:][a-zA-Z0-9_.:-]*` let attrStart = r.peek(); if (!isAsciiAlpha(attrStart) && attrStart != 0x5F && attrStart != 0x3A) { r.reset(saved); return false; } r.advance(); r.skipWhile( (ab) => isAsciiAlphanumeric(ab) || ab == 0x5F || ab == 0x2E || ab == 0x3A || ab == 0x2D ); // Optional `= value` let afterAttrName = r.mark(); r.skipWhile((cp) => isAsciiWhitespace(cp)); if (r.matchCodePoint(0x3D)) { // '=' r.skipWhile((cp) => isAsciiWhitespace(cp)); if (r.isAtEnd) { r.reset(saved); return false; } let vb = r.peek(); if (vb == 0x22 || vb == 0x27) { // "..." or '...' let quote = r.advance(); while (!r.isAtEnd && r.peek() != quote) { r.advance(); } if (!r.matchCodePoint(quote)) { r.reset(saved); return false; } } else { let valStart = r.mark(); r.skipWhile( (ub) => !isAsciiWhitespace(ub) && ub != 0x22 && ub != 0x27 && ub != 0x3D && ub != 0x3C && ub != 0x3E && ub != 0x60 ); if (r.mark() == valStart) { r.reset(saved); return false; } } } else { r.reset(afterAttrName); } } r.reset(saved); return false; }