uview-ultra 4.5.46

package/libs/marked-uts/common/Parser.uts

@@ -0,0 +1,367 @@
+import { Renderer } from './Renderer';
+import { TextRenderer } from './TextRenderer';
+import { _defaults } from './defaults';
+import { MarkedToken, Token, MarkedOptions, I_Parser, I_Renderer, I_TextRenderer, RendererExtensionFunction, RendererThis, Generic, Text, Paragraph, Space, Hr, Code, Table, Blockquote, List, HTML, Tag, Escape, Link, Image, Strong, Em, Codespan, Br, Del, TableCell, ListItem, Heading, NodesToken } from '../utssdk/interface';
+
+/**
+ * Parsing & Compiling
+ */
+export class Parser implements I_Parser {
+	options: MarkedOptions;
+	renderer: I_Renderer;
+	textRenderer: I_TextRenderer;
+	
+	constructor(options?: MarkedOptions) {
+	    this.options = options ?? _defaults;
+		this.options.renderer = this.options.renderer ?? new Renderer(null);
+		this.renderer = this.options.renderer!;
+		this.renderer.options = this.options;
+		this.renderer.parser = this;
+		this.textRenderer = new TextRenderer();
+	}
+	
+	/**
+	   * Static Parse Method
+	   */
+	static parse(tokens: NodesToken[], options: MarkedOptions | null = null): string {
+		const parser = new Parser(options);
+		return parser.parse(tokens, null);
+	}
+	
+	/**
+	   * Static Parse Inline Method
+	   */
+	static parseInline(tokens: NodesToken[], options: MarkedOptions | null = null): string {
+		const parser = new Parser(options);
+		return parser.parseInline(tokens, null);
+	}
+	
+	/**
+	   * Parse Loop
+	   */
+	parse(tokens: NodesToken[], top?: boolean): string {
+		let out = '';
+		for (let i = 0; i < tokens.length; i++) {
+			const anyToken = tokens[i];
+			
+			// Run any renderer extensions
+			if (this.options.extensions != null && this.options.extensions!.renderers[anyToken.type!] != null) {
+				const genericToken = anyToken;
+				const ret = (this.options.extensions!.renderers[anyToken.type!] as RendererExtensionFunction)({ parser: this } as RendererThis, genericToken);
+				if (ret != false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(genericToken.type as string)) {
+					out += ret ?? '';
+					continue;
+				}
+			}
+			
+			const token = anyToken;
+			
+			switch (token.type!) {
+				case 'space':
+					out = out + this.renderer.space({
+						type:'space',
+						raw: token.raw as string,
+						tokens: [] as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'hr':
+					out += this.renderer.hr({
+						type: 'hr',
+						raw: token.raw as string,
+						tokens: [] as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'heading':
+					out += this.renderer.heading({
+						type: 'heading',
+						raw: token.raw as string,
+						text: token.text as string,
+						depth: token.depth as number,
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'code':
+					out += this.renderer.code({
+						type: 'code',
+						raw: token.raw as string,
+						codeBlockStyle: token.codeBlockStyle != null ? (token.codeBlockStyle as 'indented' | null) : null,
+						lang: token.lang != null ? (token.lang as string) : null,
+						text: token.text as string,
+						escaped: token.escaped != null ? (token.escaped as boolean) : null,
+						tokens: [] as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'table':
+					out += this.renderer.table({
+						type: 'table',
+						raw: token.raw as string,
+						align: token.align as Array<'center' | 'left' | 'right' | null>,
+						header: token.header as TableCell[],
+						rows: token.rows as TableCell[][],
+						tokens: [] as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'blockquote':
+					out += this.renderer.blockquote({
+						type: 'blockquote',
+						raw: token.raw as string,
+						text: token.text as string,
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'list':
+					out += this.renderer.list({
+						type: 'list',
+						raw: token.raw as string,
+						ordered: token.ordered as boolean,
+						start: token.start as number | string,
+						loose: token.loose as boolean,
+						items: token.items as NodesToken[],
+						tokens: [] as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'html':
+					out += this.renderer.html({
+						type: 'html',
+						raw: token.raw as string,
+						text: token.text as string,
+						block: token.block as boolean,
+						pre: token.pre as boolean,
+						tokens: [] as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'paragraph':
+					out += this.renderer.paragraph({
+						type: 'paragraph',
+						raw: token.raw as string,
+						text: token.text as string,
+						pre: token.pre == null ? null : (token.pre as boolean),
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken);
+					break;
+				case 'text':
+					let textToken = token;
+					let body = this.renderer.text({
+						type: 'text',
+						raw: textToken.raw as string,
+						text: textToken.text as string,
+						tokens: textToken.tokens != null ? (textToken.tokens as NodesToken[]) : null,
+						escaped: textToken.escaped != null ? (textToken.escaped as boolean) : null
+					} as NodesToken);
+					while (i + 1 < tokens.length && tokens[i + 1].type == 'text') {
+						textToken = tokens[++i];
+						body += '\n' + this.renderer.text({
+							type: 'text',
+							raw: textToken.raw as string,
+							text: textToken.text as string,
+							tokens: textToken.tokens != null ? (textToken.tokens as NodesToken[]) : null,
+							escaped: textToken.escaped != null ? (textToken.escaped as boolean) : null
+						} as NodesToken);
+					}
+					if (top == true) {
+						out += this.renderer.paragraph({
+							type: 'paragraph',
+							raw: body,
+							text: body,
+							tokens: [
+								{
+									type: 'text',
+									raw: body,
+									text: body,
+									escaped: true,
+									tokens: [] as NodesToken[]
+								}
+							] as NodesToken[]
+						} as NodesToken);
+					} else {
+						out += body;
+					}
+					break;
+				
+				default:
+					const errMsg = 'Token with "' + token.type + '" type was not found.';
+					if (this.options['slient'] != null) {
+						console.error(errMsg);
+						return '';
+					} else {
+						throw new Error(errMsg);
+					}
+			}
+		}
+		
+		return out;
+	}
+	
+	/**
+	   * Parse Inline Tokens
+	   */
+	parseInline(tokens: NodesToken[], rendererSource?: I_Renderer | I_TextRenderer): string {
+		let renderer = rendererSource;
+		let out = '';
+		renderer = renderer ?? this.renderer;
+		
+		for (let i = 0; i < tokens.length; i++) {
+			const anyToken = tokens[i];
+			
+			// Run any renderer extensions
+			if (this.options.extensions != null && this.options.extensions!.renderers[anyToken.type!] != null) {
+				const ret = (this.options.extensions!.renderers[anyToken.type!] as RendererExtensionFunction)({ parser: this } as RendererThis, anyToken!);
+				if (ret != false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(`${anyToken.type}`)) {
+					out += ret ?? '';
+					continue;
+				}
+			}
+			
+			const token = anyToken;
+			
+			switch (token.type) {
+				case 'escape':
+					const escapeTokenData = {
+						type: 'escape',
+						raw: token.raw as string,
+						text: token.text as string,
+						tokens: [] as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).text(escapeTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).text(escapeTokenData);
+					}
+					break;
+				case 'html':
+					const htmlTokenData = {
+						type: 'html',
+						raw: token.raw as string,
+						pre: token.pre as boolean,
+						text: token.text as string,
+						block: token.block as boolean,
+						tokens: [] as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).html(htmlTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).html(htmlTokenData); 
+					}
+					break;
+				case 'link':
+					const linkTokenData = {
+						type: 'link',
+						raw: token.raw as string,
+						href: token.href as string,
+						title:token.title == null ? null : token.title as string,
+						text: token.text as string,
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).link(linkTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).link(linkTokenData);
+					}
+					break;
+				case 'image':
+					const imageTokenData = {
+						type: 'image',
+						raw: token.raw as string,
+						href: token.href as string,
+						title: token.title == null ? null : token.title as string,
+						text: token.text as string,
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).image(imageTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).image(imageTokenData);
+					}
+					break;
+				case'strong':
+					const strongTokenData = {
+						type:'strong',
+						raw: token.raw as string,
+						text: token.text as string,
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).strong(strongTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).strong(strongTokenData);
+					}
+					break;
+				case 'em':
+					const emTokenData = {
+						type: 'em',
+						raw: token.raw as string,
+						text: token.text as string,
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).em(emTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).em(emTokenData);
+					}
+					break;
+				case 'codespan':
+					const codespanTokenData = {
+						type: 'codespan',
+						raw: token.raw as string,
+						text: token.text as string,
+						tokens: [] as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).codespan(codespanTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).codespan(codespanTokenData);
+					}
+					break;
+				case 'br':
+					const brTokenData = {
+						type: 'br',
+						raw: token.raw as string,
+						tokens: [] as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).br(brTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).br();
+					}
+					break;
+				case 'del':
+					const delTokenData = {
+						type: 'del',
+						raw: token.raw as string,
+						text: token.text as string,
+						tokens: token.tokens as NodesToken[]
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).del(delTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).del(delTokenData);
+					}
+					break;
+				case 'text':
+					const textTokenData = {
+						type: 'text',
+						raw: token.raw as string,
+						text: token.text as string,
+						tokens: token.tokens == null ? null : token.tokens as NodesToken[],
+						escaped: token.escaped == null ? null : token.escaped as boolean
+					} as NodesToken;
+					if (renderer instanceof Renderer) {
+						out += (renderer as I_Renderer).text(textTokenData);
+					} else {
+						out += (renderer as I_TextRenderer).text(textTokenData);
+					}
+					break;
+				default:
+					const errMsg = 'Token with "' + token.type + '" type was not found.';
+					if (this.options.silent == true) {
+						console.error(errMsg);
+						return '';
+					} else {
+						throw new Error(errMsg);
+					}
+			}
+		}
+		
+		return out;
+	}
+}

package/libs/marked-uts/common/Renderer.uts

@@ -0,0 +1,244 @@
+import { _defaults } from './defaults';
+import {
+	cleanUrl,
+	escape
+} from './helpers';
+import { getOther } from './rules';
+import { MarkedOptions, Tokens, I_Parser, I_Renderer, Token, Space, Code, Blockquote, HTML, Tag, Hr, List, ListItem, Checkbox, Paragraph, Table, TableRow, TableCell, Strong, Em, Codespan, Br, Del, Link, Image, Text, Escape, MarkedToken, Heading, NodesToken } from '../utssdk/interface';
+
+/**
+ * Renderer
+ */
+export class Renderer implements I_Renderer {
+	options: MarkedOptions;
+	parser: I_Parser | null = null;
+	
+	constructor(options?: MarkedOptions) {
+	    this.options = options ?? _defaults;
+	}
+	
+	space(token: NodesToken): string {
+		return '';
+	}
+	
+	code(option: NodesToken): string {
+		const { text, lang, escaped } = option;
+		const langString = (lang ?? '').match(getOther().notSpaceStart)?.[0];
+		
+		const code = text!.replace(getOther().endingNewline, '') + '\n';
+		
+		if (langString == null) {
+			return '<pre><code>' + (escaped == true ? code : escape(code, true)) + '</code></pre>\n';
+		}
+		
+		return '<pre><code class="language-'
+			+ escape(langString, null)
+			+ '">'
+			+ (escaped == true? code : escape(code, true))
+			+ '</code></pre>\n';
+	}
+	
+	blockquote(option: NodesToken): string {
+		const { tokens } = option;
+		const body = this.parser!.parse(tokens!, null);
+		return `<blockquote>\n${body}</blockquote>\n`;
+	}
+	
+	html(option: NodesToken): string {
+		// let text = '';
+		// option = option as NodesToken;
+		// if (option.type == 'html') {
+		// 	option = option;
+		// 	text = option.text!;
+		// } else {
+		// 	option = option;
+		// 	text = option.text!;
+		// }
+		// return '';
+		return option.text == null ? '' : option.text;
+	}
+	
+	heading(option: NodesToken): string {
+		const { depth, tokens } = option;
+		return `<h${depth}>${this.parser!.parseInline(tokens!, null)}</h${depth}>\n`;
+	}
+	
+	hr(token: NodesToken): string {
+		return '<hr />\n';
+	}
+	
+	list(token: NodesToken): string {
+		const ordered = token.ordered;
+		const start = token.start;
+		
+		let body = '';
+		for (let j = 0; j < token!.items!.length; j++) {
+			const item = token!.items![j];
+			body += this.listitem(item!);
+		}
+		
+		const type = ordered == true ? 'ol' : 'ul';
+		const startAttr = (ordered == true && start != 1) ? (' start="' + start + '"') : '';
+		return '<' + type + startAttr + '>\n' + body + '</' + type + '>\n';
+	}
+	
+	listitem(item: NodesToken): string {
+		let itemBody = '';
+		if (item.task == true) {
+			const checkbox = this.checkbox({ checked: item.checked == null ? false : item.checked! } as NodesToken);
+			if (item.loose == true) {
+				item.tokens![0] = item.tokens![0];
+				if (item.tokens![0].type == 'paragraph') {
+					item.tokens![0] = item.tokens![0];
+					item.tokens![0].text = checkbox + ' ' + item.tokens![0].text;
+					if (item.tokens![0].tokens != null && item.tokens![0].tokens!.length > 0 && item!.tokens![0]!.tokens![0].type == 'text') {
+						item.tokens![0].tokens![0].text = checkbox + ' ' + escape(item.tokens![0].tokens![0].text!, null);
+						item.tokens![0].tokens![0].escaped = true;
+					}
+				} else {
+					item.tokens!.unshift({
+						type: 'text',
+						raw: checkbox + ' ',
+						text: checkbox + ' ',
+						escaped: true
+					} as NodesToken);
+				}
+			} else {
+				itemBody += checkbox + ' ';
+			}
+		}
+		
+		itemBody += this.parser!.parse(item.tokens!, item.loose == null ? false : item.loose!);
+		
+		return `<li>${itemBody}</li>\n`;
+	}
+	
+	checkbox(option: NodesToken): string {
+		const { checked } = option;
+		return '<input '
+		    + (checked == true ? 'checked="" ' : '')
+		    + 'disabled="" type="checkbox">';
+	}
+	
+	paragraph(option: NodesToken): string {
+		const { tokens } = option;
+		return `<p>${this.parser!.parseInline(tokens!, null)}</p>\n`;
+	}
+	
+	table(optionSource: NodesToken): string {
+		const token = optionSource;
+		let header = '';
+		
+		// header
+		let cell = '';
+		for (let j = 0; j < token.header!.length; j++) {
+		  cell += this.tablecell(token.header![j]);
+		}
+		header += this.tablerow({ text: cell } as NodesToken);
+		
+		let body = '';
+		for (let j = 0; j < token.rows!.length; j++) {
+		  const row = token.rows![j];
+	
+		  cell = '';
+		  for (let k = 0; k < row.length; k++) {
+			cell += this.tablecell(row[k]);
+		  }
+	
+		  body += this.tablerow({ text: cell } as NodesToken);
+		}
+		if (body.length > 0) body = `<tbody>${body}</tbody>`;
+		
+		return '<table>\n'
+		  + '<thead>\n'
+		  + header
+		  + '</thead>\n'
+		  + body
+		  + '</table>\n';
+	}
+	
+	tablerow(option: NodesToken): string {
+		const { text } = option;
+		return `<tr>${text}</tr>\n`;
+	}
+	
+	tablecell(optionSource: TableCell): string {
+		const token = optionSource;
+		const content = this.parser!.parseInline(token.tokens, null);
+		const type = token.header ? 'th' : 'td';
+		const tag = token.align != null
+		  ? `<${type} align="${token.align}">`
+		  : `<${type}>`;
+		  
+		return tag + content + `</${type}>\n`;
+	}
+	
+	 /**
+	   * span level renderer
+	   */
+	strong(option: NodesToken): string {
+		const { tokens } = option;
+		return `<strong>${this.parser!.parseInline(tokens!, null)}</strong>`;
+	}
+	
+	em(option: NodesToken): string {
+		const { tokens } = option;
+		return `<em>${this.parser!.parseInline(tokens!, null)}</em>`;
+	}
+	
+	codespan(option: NodesToken): string {
+		const { text } = option;
+		return `<code>${escape(text!, true)}</code>`;
+	}
+	
+	br(optionSource: NodesToken): string {
+		return '<br>';
+	}
+	
+	del(option: NodesToken): string {
+		const { tokens } = option;
+		return `<del>${this.parser!.parseInline(tokens!, null)}</del>`;
+	}
+	
+	link(option: NodesToken): string {
+		let { href, title, tokens } = option;
+		const text = this.parser!.parseInline(tokens!, null);
+		const cleanHref = cleanUrl(href!);
+		
+		if (cleanHref == null) {
+			return text;
+		}
+		href = cleanHref;
+		let out = '<a href="' + href + '"';
+		if (title != null) {
+			out += ' title="' + (escape(title, null)) + '"';
+		}
+		out += '>' + text + '</a>';
+		return out;
+	}
+	
+	image(option: NodesToken): string {
+		let { href, title, text } = option;
+		const cleanHref = cleanUrl(href!);
+		if (cleanHref == null) {
+			return escape(text!, null);
+		}
+		href = cleanHref;
+		
+		let out = `<img src="${href}" alt="${text}"`;
+		if (title != null) {
+			out += ` title="${escape(title, null)}"`;
+		}
+		out += '>';
+		return out;
+	}
+	
+	text(option: NodesToken): string {
+		const obj = option;
+		if (obj.tokens != null && obj.tokens!.length > 0) {
+			return this.parser!.parseInline(obj.tokens as NodesToken[], null);
+		} else {
+			return (obj.escaped != null ? `${obj.text}` : escape(`${obj.text}`, null));
+		}
+	}
+}

package/libs/marked-uts/common/TextRenderer.uts

@@ -0,0 +1,74 @@
+import { I_TextRenderer, Strong, Em, Codespan, Del, HTML, Tag, Text, Escape, Link, Image, NodesToken } from '../utssdk/interface';
+
+/**
+ * TextRenderer
+ * returns only the textual part of the token
+ */
+export class TextRenderer implements I_TextRenderer {
+	// no need for block level renderers
+	strong(option: NodesToken): string {
+		const { text } = option;
+		return text!;
+	}
+	
+	em(option: NodesToken): string {
+		const { text } = option;
+		return text!;
+	}
+	
+	codespan(option: NodesToken): string {
+		const { text } = option;
+		return text!;
+	}
+	
+	del(option: NodesToken): string {
+		const { text } = option;
+		return text!;
+	}
+	
+	html(option: NodesToken): string {
+		// option = option as HTML | Tag;
+		return option.text!;
+		let text: string = '';
+		if (option.type == 'html') {
+			// option = option as HTML;
+			text = option.text!;
+		} else {
+			// option = option as Tag;
+			text = option.text!;
+		}
+		return text;
+	}
+	
+	text(option: NodesToken): string {
+		// console.log(option);
+		// option = option as Text | Escape | Tag
+		return option.text!;
+		let text = '';
+		if (option.type == 'text') {
+			// option = option as Text;
+			text = option.text!;
+		} else if (option.type == 'escape') {
+			// option = option as Escape;
+			text = option.text!;
+		} else {
+			// option = option as Tag;
+			text = option.text!;
+		}
+		return text;
+	}
+	
+	link(option: NodesToken): string {
+		const { text } = option;
+		return text!;
+	}
+	
+	image(option: NodesToken): string {
+		const { text } = option;
+		return text!;
+	}
+	
+	br(): string {
+		return '';
+	}
+}