No OneTemporary
Actions

Size

49 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/components/rich_content/rich_content.jsx b/src/components/rich_content/rich_content.jsx
	index ad77d61557..ef15aaeba5 100644
	--- a/src/components/rich_content/rich_content.jsx
	+++ b/src/components/rich_content/rich_content.jsx
	@@ -1,324 +1,321 @@
	import Vue from 'vue'
	import { unescape, flattenDeep } from 'lodash'
	-import { convertHtmlToTree, getTagName, processTextForEmoji, getAttrs } from 'src/services/html_converter/html_tree_converter.service.js'
	+import { getTagName, processTextForEmoji, getAttrs } from 'src/services/html_converter/utility.service.js'
	+import { convertHtmlToTree } from 'src/services/html_converter/html_tree_converter.service.js'
	import { convertHtmlToLines } from 'src/services/html_converter/html_line_converter.service.js'
	import StillImage from 'src/components/still-image/still-image.vue'
	import MentionLink from 'src/components/mention_link/mention_link.vue'

	import './rich_content.scss'

	export default Vue.component('RichContent', {
	name: 'RichContent',
	props: {
	// Original html content
	html: {
	required: true,
	type: String
	},
	// Emoji object, as in status.emojis, note the "s" at the end...
	emoji: {
	required: true,
	type: Array
	},
	// Whether to handle links or not (posts: yes, everything else: no)
	handleLinks: {
	required: false,
	type: Boolean,
	default: false
	},
	// Meme arrows
	greentext: {
	required: false,
	type: Boolean,
	default: false
	- },
	- // Whether to hide last mentions (hellthreads)
	- hideMentions: {
	- required: false,
	- type: Boolean,
	- default: false
	}
	},
	// NEVER EVER TOUCH DATA INSIDE RENDER
	render (h) {
	// Pre-process HTML
	- const { newHtml: html, lastMentions } = preProcessPerLine(this.html, this.greentext, this.hideMentions)
	+ const { newHtml: html, lastMentions } = preProcessPerLine(this.html, this.greentext, this.handleLinks)
	const firstMentions = [] // Mentions that appear in the beginning of post body
	const lastTags = [] // Tags that appear at the end of post body
	const writtenMentions = [] // All mentions that appear in post body
	const writtenTags = [] // All tags that appear in post body
	// unique index for vue "tag" property
	let mentionIndex = 0
	let tagsIndex = 0

	const renderImage = (tag) => {
	return <StillImage
	{...{ attrs: getAttrs(tag) }}
	class="img"
	/>
	}

	const renderHashtag = (attrs, children, encounteredTextReverse) => {
	const linkData = getLinkData(attrs, children, tagsIndex++)
	writtenTags.push(linkData)
	attrs.target = '_blank'
	if (!encounteredTextReverse) {
	lastTags.push(linkData)
	attrs['data-parser-last'] = true
	}
	return <a {...{ attrs }}>
	{ children.map(processItem) }
	</a>
	}

	const renderMention = (attrs, children, encounteredText) => {
	const linkData = getLinkData(attrs, children, mentionIndex++)
	writtenMentions.push(linkData)
	if (!encounteredText) {
	firstMentions.push(linkData)
	return ''
	} else {
	return <MentionLink
	url={attrs.href}
	content={flattenDeep(children).join('')}
	/>
	}
	}

	// We stop treating mentions as "first" ones when we encounter
	// non-whitespace text
	let encounteredText = false
	// Processor to use with html_tree_converter
	const processItem = (item, index, array, what) => {
	// Handle text nodes - just add emoji
	if (typeof item === 'string') {
	const emptyText = item.trim() === ''
	if (emptyText) {
	return encounteredText ? item : item.trim()
	}
	let unescapedItem = unescape(item)
	if (!encounteredText) {
	unescapedItem = unescapedItem.trimStart()
	encounteredText = true
	}
	if (item.includes(':')) {
	unescapedItem = processTextForEmoji(
	unescapedItem,
	this.emoji,
	({ shortcode, url }) => {
	return <StillImage
	class="emoji img"
	src={url}
	title={`:${shortcode}:`}
	alt={`:${shortcode}:`}
	/>
	}
	)
	}
	return unescapedItem
	}

	// Handle tag nodes
	if (Array.isArray(item)) {
	const [opener, children] = item
	const Tag = getTagName(opener)
	const attrs = getAttrs(opener)
	switch (Tag) {
	case 'span': // replace images with StillImage
	if (attrs['class'] && attrs['class'].includes('lastMentions')) {
	if (firstMentions.length > 1) {
	break
	} else {
	return ''
	}
	} else {
	break
	}
	case 'img': // replace images with StillImage
	return renderImage(opener)
	case 'a': // replace mentions with MentionLink
	if (!this.handleLinks) break
	if (attrs['class'] && attrs['class'].includes('mention')) {
	return renderMention(attrs, children, encounteredText)
	} else if (attrs['class'] && attrs['class'].includes('hashtag')) {
	encounteredText = true
	return item // We'll handle it later
	} else {
	attrs.target = '_blank'
	return <a {...{ attrs }}>
	{ children.map(processItem) }
	</a>
	}
	}

	// Render tag as is
	if (children !== undefined) {
	return <Tag {...{ attrs: getAttrs(opener) }}>
	{ children.map(processItem) }
	</Tag>
	} else {
	return <Tag/>
	}
	}
	}

	// Processor for back direction (for finding "last" stuff, just easier this way)
	let encounteredTextReverse = false
	const processItemReverse = (item, index, array, what) => {
	// Handle text nodes - just add emoji
	if (typeof item === 'string') {
	const emptyText = item.trim() === ''
	if (emptyText) return item
	if (!encounteredTextReverse) encounteredTextReverse = true
	return item
	} else if (Array.isArray(item)) {
	// Handle tag nodes
	const [opener, children] = item
	const Tag = getTagName(opener)
	switch (Tag) {
	case 'a': // replace mentions with MentionLink
	if (!this.handleLinks) break
	const attrs = getAttrs(opener)
	// should only be this
	if (attrs['class'] && attrs['class'].includes('hashtag')) {
	return renderHashtag(attrs, children, encounteredTextReverse)
	}
	}
	}
	return item
	}

	// DO NOT USE SLOTS they cause a re-render feedback loop here.
	// slots updated -> rerender -> emit -> update up the tree -> rerender -> ...
	// at least until vue3?
	const result = <span class="RichContent">
	{ convertHtmlToTree(html).map(processItem).reverse().map(processItemReverse).reverse() }
	</span>

	const event = {
	firstMentions,
	lastMentions,
	lastTags,
	writtenMentions,
	writtenTags
	}

	// DO NOT MOVE TO UPDATE. BAD IDEA.
	this.$emit('parseReady', event)

	return result
	}
	})

	const getLinkData = (attrs, children, index) => {
	return {
	index,
	url: attrs.href,
	hashtag: attrs['data-tag'],
	content: flattenDeep(children).join('')
	}
	}

	/** Pre-processing HTML
	*
	* Currently this does two things:
	* - add green/cyantexting
	* - wrap and mark last line containing only mentions as ".lastMentionsLine" for
	* more compact hellthreads.
	*
	* @param {String} html - raw HTML to process
	* @param {Boolean} greentext - whether to enable greentexting or not
	+ * @param {Boolean} handleLinks - whether to handle links or not
	*/
	-export const preProcessPerLine = (html, greentext) => {
	+export const preProcessPerLine = (html, greentext, handleLinks) => {
	const lastMentions = []

	let nonEmptyIndex = 0
	const newHtml = convertHtmlToLines(html).reverse().map((item, index, array) => {
	// Going over each line in reverse to detect last mentions,
	// keeping non-text stuff as-is
	if (!item.text) return item
	const string = item.text

	// Greentext stuff
	if (greentext && (string.includes('>') \|\| string.includes('<'))) {
	const cleanedString = string.replace(/<[^>]+?>/gi, '') // remove all tags
	.replace(/@\w+/gi, '') // remove mentions (even failed ones)
	.trim()
	if (cleanedString.startsWith('>')) {
	return `<span class='greentext'>${string}</span>`
	} else if (cleanedString.startsWith('<')) {
	return `<span class='cyantext'>${string}</span>`
	}
	}

	// Converting that line part into tree
	const tree = convertHtmlToTree(string)

	// If line has loose text, i.e. text outside a mention or a tag
	// we won't touch mentions.
	let hasLooseText = false
	let hasMentions = false
	const process = (item) => {
	if (Array.isArray(item)) {
	const [opener, children, closer] = item
	const tag = getTagName(opener)
	// If we have a link we probably have mentions
	if (tag === 'a') {
	+ if (!handleLinks) return [opener, children, closer]
	const attrs = getAttrs(opener)
	if (attrs['class'] && attrs['class'].includes('mention')) {
	// Got mentions
	hasMentions = true
	return [opener, children, closer]
	} else {
	// Not a mention? Means we have loose text or whatever
	hasLooseText = true
	return [opener, children, closer]
	}
	} else if (tag === 'span' \|\| tag === 'p') {
	// For span and p we need to go deeper
	return [opener, [...children].map(process), closer]
	} else {
	// Everything else equals to a loose text
	hasLooseText = true
	return [opener, children, closer]
	}
	}

	if (typeof item === 'string') {
	if (item.trim() !== '') {
	// only meaningful strings are loose text
	hasLooseText = true
	}
	return item
	}
	}

	// We now processed our tree, now we need to mark line as lastMentions
	const result = [...tree].map(process)

	// Only check last (first since list is reversed) line
	- if (hasMentions && !hasLooseText && nonEmptyIndex++ === 0) {
	+ if (handleLinks && hasMentions && !hasLooseText && nonEmptyIndex++ === 0) {
	let mentionIndex = 0
	const process = (item) => {
	if (Array.isArray(item)) {
	const [opener, children] = item
	const tag = getTagName(opener)
	if (tag === 'a') {
	const attrs = getAttrs(opener)
	lastMentions.push(getLinkData(attrs, children, mentionIndex++))
	} else if (children) {
	children.forEach(process)
	}
	}
	}
	result.forEach(process)
	// we DO need mentions here so that we conditionally remove them if don't
	// have first mentions
	return ['<span class="lastMentions">', flattenDeep(result).join(''), '</span>'].join('')
	} else {
	return flattenDeep(result).join('')
	}
	}).reverse().join('')

	return { newHtml, lastMentions }
	}
	diff --git a/src/components/status_body/status_body.vue b/src/components/status_body/status_body.vue
	index b84541d7ac..aac44e42c0 100644
	--- a/src/components/status_body/status_body.vue
	+++ b/src/components/status_body/status_body.vue
	@@ -1,109 +1,108 @@
	<template>
	<div class="StatusBody">
	<div class="body">
	<div
	v-if="status.summary_html"
	class="summary-wrapper"
	:class="{ '-tall': (longSubject && !showingLongSubject) }"
	>
	<RichContent
	class="media-body summary"
	:html="status.summary_raw_html"
	:emoji="status.emojis"
	/>
	<button
	v-if="longSubject && showingLongSubject"
	class="button-unstyled -link tall-subject-hider"
	@click.prevent="showingLongSubject=false"
	>
	{{ $t("status.hide_full_subject") }}
	</button>
	<button
	v-else-if="longSubject"
	class="button-unstyled -link tall-subject-hider"
	@click.prevent="showingLongSubject=true"
	>
	{{ $t("status.show_full_subject") }}
	</button>
	</div>
	<div
	:class="{'-tall-status': hideTallStatus}"
	class="text-wrapper"
	>
	<button
	v-if="hideTallStatus"
	class="button-unstyled -link tall-status-hider"
	:class="{ '-focused': focused }"
	@click.prevent="toggleShowMore"
	>
	{{ $t("general.show_more") }}
	</button>
	<span
	v-if="!hideSubjectStatus && !(singleLine && status.summary_html)"
	class="rich-content-wrapper"
	>
	<MentionsLine
	v-if="!hideMentions && firstMentions && firstMentions.length > 0"
	:mentions="firstMentions"
	/>
	<RichContent
	:class="{ '-single-line': singleLine }"
	class="text media-body"
	:html="status.raw_html"
	:emoji="status.emojis"
	:handle-links="true"
	- :hide-mentions="hideMentions"
	:greentext="mergedConfig.greentext"
	@parseReady="setHeadTailLinks"
	/>
	<MentionsLine
	v-if="!hideMentions && lastMentions.length > 0 && firstMentions.length <= 1"
	:mentions="lastMentions"
	/>
	</span>

	<button
	v-if="hideSubjectStatus"
	class="button-unstyled -link cw-status-hider"
	@click.prevent="toggleShowMore"
	>
	{{ $t("status.show_content") }}
	<FAIcon
	v-if="attachmentTypes.includes('image')"
	icon="image"
	/>
	<FAIcon
	v-if="attachmentTypes.includes('video')"
	icon="video"
	/>
	<FAIcon
	v-if="attachmentTypes.includes('audio')"
	icon="music"
	/>
	<FAIcon
	v-if="attachmentTypes.includes('unknown')"
	icon="file"
	/>
	<FAIcon
	v-if="status.poll && status.poll.options"
	icon="poll-h"
	/>
	<FAIcon
	v-if="status.card"
	icon="link"
	/>
	</button>
	<button
	v-if="showingMore && !fullContent"
	class="button-unstyled -link status-unhider"
	@click.prevent="toggleShowMore"
	>
	{{ tallStatus ? $t("general.show_less") : $t("status.hide_content") }}
	</button>
	</div>
	</div>
	<slot v-if="!hideSubjectStatus" />
	</div>
	</template>
	<script src="./status_body.js" ></script>
	<style lang="scss" src="./status_body.scss" />
	diff --git a/src/services/html_converter/html_line_converter.service.js b/src/services/html_converter/html_line_converter.service.js
	index d8f5ecb867..e448d5cd91 100644
	--- a/src/services/html_converter/html_line_converter.service.js
	+++ b/src/services/html_converter/html_line_converter.service.js
	@@ -1,103 +1,99 @@
	+import { getTagName } from './utility.service.js'
	+
	/**
	* This is a tiny purpose-built HTML parser/processor. This basically detects
	* any type of visual newline and converts entire HTML into a array structure.
	*
	* Text nodes are represented as object with single property - text - containing
	* the visual line. Intended usage is to process the array with .map() in which
	* map function returns a string and resulting array can be converted back to html
	* with a .join('').
	*
	* Generally this isn't very useful except for when you really need to either
	* modify visual lines (greentext i.e. simple quoting) or do something with
	* first/last line.
	*
	* known issue: doesn't handle CDATA so nested CDATA might not work well
	*
	* @param {Object} input - input data
	* @return {(string\|{ text: string })[]} processed html in form of a list.
	*/
	export const convertHtmlToLines = (html) => {
	const ignoredTags = new Set(['code', 'blockquote'])
	const handledTags = new Set(['p', 'br', 'div', 'pre', 'code', 'blockquote'])
	const openCloseTags = new Set(['p', 'div', 'pre', 'code', 'blockquote'])

	let buffer = [] // Current output buffer
	const level = [] // How deep we are in tags and which tags were there
	let textBuffer = '' // Current line content
	let tagBuffer = null // Current tag buffer, if null = we are not currently reading a tag

	- // Extracts tag name from tag, i.e. <span a="b"> => span
	- const getTagName = (tag) => {
	- const result = /(?:<\/(\w+)>\|<(\w+)\s?[^/]*?\/?>)/gi.exec(tag)
	- return result && (result[1] \|\| result[2])
	- }
	-
	const flush = () => { // Processes current line buffer, adds it to output buffer and clears line buffer
	if (textBuffer.trim().length > 0 && !level.some(l => ignoredTags.has(l))) {
	buffer.push({ text: textBuffer })
	} else {
	buffer.push(textBuffer)
	}
	textBuffer = ''
	}

	const handleBr = (tag) => { // handles single newlines/linebreaks/selfclosing
	flush()
	buffer.push(tag)
	}

	const handleOpen = (tag) => { // handles opening tags
	flush()
	buffer.push(tag)
	level.unshift(getTagName(tag))
	}

	const handleClose = (tag) => { // handles closing tags
	flush()
	buffer.push(tag)
	if (level[0] === getTagName(tag)) {
	level.shift()
	}
	}

	for (let i = 0; i < html.length; i++) {
	const char = html[i]
	if (char === '<' && tagBuffer === null) {
	tagBuffer = char
	} else if (char !== '>' && tagBuffer !== null) {
	tagBuffer += char
	} else if (char === '>' && tagBuffer !== null) {
	tagBuffer += char
	const tagFull = tagBuffer
	tagBuffer = null
	const tagName = getTagName(tagFull)
	if (handledTags.has(tagName)) {
	if (tagName === 'br') {
	handleBr(tagFull)
	} else if (openCloseTags.has(tagName)) {
	if (tagFull[1] === '/') {
	handleClose(tagFull)
	} else if (tagFull[tagFull.length - 2] === '/') {
	// self-closing
	handleBr(tagFull)
	} else {
	handleOpen(tagFull)
	}
	}
	} else {
	textBuffer += tagFull
	}
	} else if (char === '\n') {
	handleBr(char)
	} else {
	textBuffer += char
	}
	}
	if (tagBuffer) {
	textBuffer += tagBuffer
	}

	flush()

	return buffer
	}
	diff --git a/src/services/html_converter/html_tree_converter.service.js b/src/services/html_converter/html_tree_converter.service.js
	index badd473a2c..804d35d7b1 100644
	--- a/src/services/html_converter/html_tree_converter.service.js
	+++ b/src/services/html_converter/html_tree_converter.service.js
	@@ -1,146 +1,97 @@
	+import { getTagName } from './utility.service.js'
	+
	/**
	* This is a not-so-tiny purpose-built HTML parser/processor. This parses html
	* and converts it into a tree structure representing tag openers/closers and
	* children.
	*
	* Structure follows this pattern: [opener, [...children], closer] except root
	* node which is just [...children]. Text nodes can only be within children and
	* are represented as strings.
	*
	* Intended use is to convert HTML structure and then recursively iterate over it
	* most likely using a map. Very useful for dynamically rendering html replacing
	* tags with JSX elements in a render function.
	*
	* known issue: doesn't handle CDATA so CDATA might not work well
	* known issue: doesn't handle HTML comments
	*
	* @param {Object} input - input data
	* @return {string} processed html
	*/
	export const convertHtmlToTree = (html) => {
	// Elements that are implicitly self-closing
	// https://developer.mozilla.org/en-US/docs/Glossary/empty_element
	const emptyElements = new Set([
	'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
	'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'
	])
	// TODO For future - also parse HTML5 multi-source components?

	const buffer = [] // Current output buffer
	const levels = [['', buffer]] // How deep we are in tags and which tags were there
	let textBuffer = '' // Current line content
	let tagBuffer = null // Current tag buffer, if null = we are not currently reading a tag

	const getCurrentBuffer = () => {
	return levels[levels.length - 1][1]
	}

	const flushText = () => { // Processes current line buffer, adds it to output buffer and clears line buffer
	if (textBuffer === '') return
	getCurrentBuffer().push(textBuffer)
	textBuffer = ''
	}

	const handleSelfClosing = (tag) => {
	getCurrentBuffer().push([tag])
	}

	const handleOpen = (tag) => {
	const curBuf = getCurrentBuffer()
	const newLevel = [tag, []]
	levels.push(newLevel)
	curBuf.push(newLevel)
	}

	const handleClose = (tag) => {
	const currentTag = levels[levels.length - 1]
	if (getTagName(levels[levels.length - 1][0]) === getTagName(tag)) {
	currentTag.push(tag)
	levels.pop()
	} else {
	getCurrentBuffer().push(tag)
	}
	}

	for (let i = 0; i < html.length; i++) {
	const char = html[i]
	if (char === '<' && tagBuffer === null) {
	flushText()
	tagBuffer = char
	} else if (char !== '>' && tagBuffer !== null) {
	tagBuffer += char
	} else if (char === '>' && tagBuffer !== null) {
	tagBuffer += char
	const tagFull = tagBuffer
	tagBuffer = null
	const tagName = getTagName(tagFull)
	if (tagFull[1] === '/') {
	handleClose(tagFull)
	} else if (emptyElements.has(tagName) \|\| tagFull[tagFull.length - 2] === '/') {
	// self-closing
	handleSelfClosing(tagFull)
	} else {
	handleOpen(tagFull)
	}
	} else {
	textBuffer += char
	}
	}
	if (tagBuffer) {
	textBuffer += tagBuffer
	}

	flushText()
	return buffer
	}
	-
	-// Extracts tag name from tag, i.e. <span a="b"> => span
	-export const getTagName = (tag) => {
	- const result = /(?:<\/(\w+)>\|<(\w+)\s?.*?\/?>)/gi.exec(tag)
	- return result && (result[1] \|\| result[2])
	-}
	-
	-export const processTextForEmoji = (text, emojis, processor) => {
	- const buffer = []
	- let textBuffer = ''
	- for (let i = 0; i < text.length; i++) {
	- const char = text[i]
	- if (char === ':') {
	- const next = text.slice(i + 1)
	- let found = false
	- for (let emoji of emojis) {
	- if (next.slice(0, emoji.shortcode.length + 1) === (emoji.shortcode + ':')) {
	- found = emoji
	- break
	- }
	- }
	- if (found) {
	- buffer.push(textBuffer)
	- textBuffer = ''
	- buffer.push(processor(found))
	- i += found.shortcode.length + 1
	- } else {
	- textBuffer += char
	- }
	- } else {
	- textBuffer += char
	- }
	- }
	- if (textBuffer) buffer.push(textBuffer)
	- return buffer
	-}
	-
	-export const getAttrs = tag => {
	- const innertag = tag
	- .substring(1, tag.length - 1)
	- .replace(new RegExp('^' + getTagName(tag)), '')
	- .replace(/\/?$/, '')
	- .trim()
	- const attrs = Array.from(innertag.matchAll(/([a-z0-9-]+)(?:=("[^"]+?"\|'[^']+?'))?/gi))
	- .map(([trash, key, value]) => [key, value])
	- .map(([k, v]) => {
	- if (!v) return [k, true]
	- return [k, v.substring(1, v.length - 1)]
	- })
	- return Object.fromEntries(attrs)
	-}
	diff --git a/src/services/html_converter/utility.service.js b/src/services/html_converter/utility.service.js
	new file mode 100644
	index 0000000000..4d0c36c2bf
	--- /dev/null
	+++ b/src/services/html_converter/utility.service.js
	@@ -0,0 +1,73 @@
	+/**
	+ * Extract tag name from tag opener/closer.
	+ *
	+ * @param {String} tag - tag string, i.e. '<a href="...">'
	+ * @return {String} - tagname, i.e. "div"
	+ */
	+export const getTagName = (tag) => {
	+ const result = /(?:<\/(\w+)>\|<(\w+)\s?.*?\/?>)/gi.exec(tag)
	+ return result && (result[1] \|\| result[2])
	+}
	+
	+/**
	+ * Extract attributes from tag opener.
	+ *
	+ * @param {String} tag - tag string, i.e. '<a href="...">'
	+ * @return {Object} - map of attributes key = attribute name, value = attribute value
	+ * attributes without values represented as boolean true
	+ */
	+export const getAttrs = tag => {
	+ const innertag = tag
	+ .substring(1, tag.length - 1)
	+ .replace(new RegExp('^' + getTagName(tag)), '')
	+ .replace(/\/?$/, '')
	+ .trim()
	+ const attrs = Array.from(innertag.matchAll(/([a-z0-9-]+)(?:=("[^"]+?"\|'[^']+?'))?/gi))
	+ .map(([trash, key, value]) => [key, value])
	+ .map(([k, v]) => {
	+ if (!v) return [k, true]
	+ return [k, v.substring(1, v.length - 1)]
	+ })
	+ return Object.fromEntries(attrs)
	+}
	+
	+/**
	+ * Finds shortcodes in text
	+ *
	+ * @param {String} text - original text to find emojis in
	+ * @param {{ url: String, shortcode: Sring }[]} emoji - list of shortcodes to find
	+ * @param {Function} processor - function to call on each encountered emoji,
	+ * function is passed single object containing matching emoji ({ url, shortcode })
	+ * return value will be inserted into resulting array instead of :shortcode:
	+ * @return {Array} resulting array with non-emoji parts of text and whatever {processor}
	+ * returned for emoji
	+ */
	+export const processTextForEmoji = (text, emojis, processor) => {
	+ const buffer = []
	+ let textBuffer = ''
	+ for (let i = 0; i < text.length; i++) {
	+ const char = text[i]
	+ if (char === ':') {
	+ const next = text.slice(i + 1)
	+ let found = false
	+ for (let emoji of emojis) {
	+ if (next.slice(0, emoji.shortcode.length + 1) === (emoji.shortcode + ':')) {
	+ found = emoji
	+ break
	+ }
	+ }
	+ if (found) {
	+ buffer.push(textBuffer)
	+ textBuffer = ''
	+ buffer.push(processor(found))
	+ i += found.shortcode.length + 1
	+ } else {
	+ textBuffer += char
	+ }
	+ } else {
	+ textBuffer += char
	+ }
	+ }
	+ if (textBuffer) buffer.push(textBuffer)
	+ return buffer
	+}
	diff --git a/test/unit/specs/components/rich_content.spec.js b/test/unit/specs/components/rich_content.spec.js
	new file mode 100644
	index 0000000000..05c0b25956
	--- /dev/null
	+++ b/test/unit/specs/components/rich_content.spec.js
	@@ -0,0 +1,357 @@
	+import { shallowMount, createLocalVue } from '@vue/test-utils'
	+import RichContent from 'src/components/rich_content/rich_content.jsx'
	+
	+const localVue = createLocalVue()
	+
	+const makeMention = (who) => `<span class="h-card"><a class="u-url mention" href="https://fake.tld/@${who}">@<span>${who}</span></a></span>`
	+const stubMention = (who) => `<span class="h-card"><mentionlink-stub url="https://fake.tld/@${who}" content="@<span>${who}</span>"></mentionlink-stub></span>`
	+const lastMentions = (...data) => `<span class="lastMentions">${data.join('')}</span>`
	+const p = (...data) => `<p>${data.join('')}</p>`
	+const compwrap = (...data) => `<span class="RichContent">${data.join('')}</span>`
	+const removedMentionSpan = '<span class="h-card"></span>'
	+
	+describe('RichContent', () => {
	+ it('renders simple post without exploding', () => {
	+ const html = p('Hello world!')
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(html))
	+ })
	+
	+ it('removes mentions from the beginning of post', () => {
	+ const html = p(
	+ makeMention('John'),
	+ ' how are you doing thoday?'
	+ )
	+ const expected = p(
	+ removedMentionSpan,
	+ 'how are you doing thoday?'
	+ )
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('removes mentions from the end of the hellpost (<p>)', () => {
	+ const html = [
	+ p('How are you doing today, fine gentlemen?'),
	+ p(
	+ makeMention('John'),
	+ makeMention('Josh'),
	+ makeMention('Jeremy')
	+ )
	+ ].join('')
	+ const expected = [
	+ p(
	+ 'How are you doing today, fine gentlemen?'
	+ ),
	+ // TODO fix this extra line somehow?
	+ p()
	+ ].join('')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('removes mentions from the end of the hellpost (<br>)', () => {
	+ const html = [
	+ 'How are you doing today, fine gentlemen?',
	+ [
	+ makeMention('John'),
	+ makeMention('Josh'),
	+ makeMention('Jeremy')
	+ ].join('')
	+ ].join('<br>')
	+ const expected = [
	+ 'How are you doing today, fine gentlemen?',
	+ // TODO fix this extra line somehow?
	+ '<br>'
	+ ].join('')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('removes mentions from the end of the hellpost (\\n)', () => {
	+ const html = [
	+ 'How are you doing today, fine gentlemen?',
	+ [
	+ makeMention('John'),
	+ makeMention('Josh'),
	+ makeMention('Jeremy')
	+ ].join('')
	+ ].join('\n')
	+ const expected = [
	+ 'How are you doing today, fine gentlemen?',
	+ // TODO fix this extra line somehow?
	+ ''
	+ ].join('\n')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('Does not remove mentions in the middle or at the end of text string', () => {
	+ const html = [
	+ [
	+ makeMention('Jack'),
	+ 'let\'s meet up with ',
	+ makeMention('Janet')
	+ ].join(''),
	+ [
	+ 'cc: ',
	+ makeMention('John'),
	+ makeMention('Josh'),
	+ makeMention('Jeremy')
	+ ].join('')
	+ ].join('\n')
	+ const expected = [
	+ [
	+ removedMentionSpan,
	+ 'let\'s meet up with ',
	+ stubMention('Janet')
	+ ].join(''),
	+ [
	+ 'cc: ',
	+ stubMention('John'),
	+ stubMention('Josh'),
	+ stubMention('Jeremy')
	+ ].join('')
	+ ].join('\n')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('removes mentions from the end if there\'s only one first mention', () => {
	+ const html = [
	+ p(
	+ makeMention('Todd'),
	+ 'so anyway you are wrong'
	+ ),
	+ p(
	+ makeMention('Tom'),
	+ makeMention('Trace'),
	+ makeMention('Theodor')
	+ )
	+ ].join('')
	+ const expected = [
	+ p(
	+ removedMentionSpan,
	+ 'so anyway you are wrong'
	+ ),
	+ // TODO fix this extra line somehow?
	+ p()
	+ ].join('')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('does not remove mentions from the end if there\'s more than one first mention', () => {
	+ const html = [
	+ p(
	+ makeMention('Zacharie'),
	+ makeMention('Zinaide'),
	+ 'you guys have cool names, and so do these guys: '
	+ ),
	+ p(
	+ makeMention('Watson'),
	+ makeMention('Wallace'),
	+ makeMention('Wakamoto')
	+ )
	+ ].join('')
	+ const expected = [
	+ p(
	+ removedMentionSpan,
	+ removedMentionSpan,
	+ 'you guys have cool names, and so do these guys: '
	+ ),
	+ p(
	+ lastMentions(
	+ stubMention('Watson'),
	+ stubMention('Wallace'),
	+ stubMention('Wakamoto')
	+ )
	+ )
	+ ].join('')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: true,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('Does not touch links if link handling is disabled', () => {
	+ const html = [
	+ [
	+ makeMention('Jack'),
	+ 'let\'s meet up with ',
	+ makeMention('Janet')
	+ ].join(''),
	+ [
	+ makeMention('John'),
	+ makeMention('Josh'),
	+ makeMention('Jeremy')
	+ ].join('')
	+ ].join('\n')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: false,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(html))
	+ })
	+
	+ it('Adds greentext and cyantext to the post', () => {
	+ const html = [
	+ '>preordering videogames',
	+ '>any year'
	+ ].join('\n')
	+ const expected = [
	+ '<span class="greentext">>preordering videogames</span>',
	+ '<span class="greentext">>any year</span>'
	+ ].join('\n')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: false,
	+ greentext: true,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('Does not add greentext and cyantext if setting is set to false', () => {
	+ const html = [
	+ '>preordering videogames',
	+ '>any year'
	+ ].join('\n')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: false,
	+ greentext: false,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(html))
	+ })
	+
	+ it('Adds emoji to post', () => {
	+ const html = p('Ebin :DDDD :spurdo:')
	+ const expected = p(
	+ 'Ebin :DDDD ',
	+ '<anonymous-stub alt=":spurdo:" src="about:blank" title=":spurdo:" class="emoji img"></anonymous-stub>'
	+ )
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: false,
	+ greentext: false,
	+ emoji: [{ url: 'about:blank', shortcode: 'spurdo' }],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(expected))
	+ })
	+
	+ it('Doesn\'t add nonexistent emoji to post', () => {
	+ const html = p('Lol :lol:')
	+
	+ const wrapper = shallowMount(RichContent, {
	+ localVue,
	+ propsData: {
	+ handleLinks: false,
	+ greentext: false,
	+ emoji: [],
	+ html
	+ }
	+ })
	+
	+ expect(wrapper.html()).to.eql(compwrap(html))
	+ })
	+})
	diff --git a/test/unit/specs/services/html_converter/html_line_converter.spec.js b/test/unit/specs/services/html_converter/html_line_converter.spec.js
	index 532ea187b0..9485233fcc 100644
	--- a/test/unit/specs/services/html_converter/html_line_converter.spec.js
	+++ b/test/unit/specs/services/html_converter/html_line_converter.spec.js
	@@ -1,155 +1,155 @@
	import { convertHtmlToLines } from 'src/services/html_converter/html_line_converter.service.js'

	const mapOnlyText = (processor) => (input) => input.text ? processor(input.text) : input

	-describe('TinyPostHTMLProcessor', () => {
	+describe('html_line_converter', () => {
	describe('with processor that keeps original line should not make any changes to HTML when', () => {
	const processorKeep = (line) => line
	it('fed with regular HTML with newlines', () => {
	const inputOutput = '1<br/>2<p class="lol">3 4</p> 5 \n 6 <p > 7 <br> 8 </p> <br>\n<br/>'
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})

	it('fed with possibly broken HTML with invalid tags/composition', () => {
	const inputOutput = '<feeee dwdwddddddw> <i>ayy<b>lm</i>ao</b> </section>'
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})

	it('fed with very broken HTML with broken composition', () => {
	const inputOutput = '</p> lmao what </div> whats going on <div> wha <p>'
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})

	it('fed with sorta valid HTML but tags aren\'t closed', () => {
	const inputOutput = 'just leaving a <div> hanging'
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})

	it('fed with not really HTML at this point... tags that aren\'t finished', () => {
	const inputOutput = 'do you expect me to finish this <div class='
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})

	it('fed with dubiously valid HTML (p within p and also div inside p)', () => {
	const inputOutput = 'look ma <p> p \nwithin <p> p! </p> and a <br/><div>div!</div></p>'
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})

	it('fed with maybe valid HTML? self-closing divs and ps', () => {
	const inputOutput = 'a <div class="what"/> what now <p aria-label="wtf"/> ?'
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})

	it('fed with valid XHTML containing a CDATA', () => {
	const inputOutput = 'Yes, it is me, <![CDATA[DIO]]>'
	const result = convertHtmlToLines(inputOutput)
	const comparableResult = result.map(mapOnlyText(processorKeep)).join('')
	expect(comparableResult).to.eql(inputOutput)
	})
	})
	describe('with processor that replaces lines with word "_" should match expected line when', () => {
	const processorReplace = (line) => '_'
	it('fed with regular HTML with newlines', () => {
	const input = '1<br/>2<p class="lol">3 4</p> 5 \n 6 <p > 7 <br> 8 </p> <br>\n<br/>'
	const output = '_<br/>_<p class="lol">_</p>_\n_<p >_<br>_</p> <br>\n<br/>'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('fed with possibly broken HTML with invalid tags/composition', () => {
	const input = '<feeee dwdwddddddw> <i>ayy<b>lm</i>ao</b> </section>'
	const output = '_'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('fed with very broken HTML with broken composition', () => {
	const input = '</p> lmao what </div> whats going on <div> wha <p>'
	const output = '</p>_</div>_<div>_<p>'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('fed with sorta valid HTML but tags aren\'t closed', () => {
	const input = 'just leaving a <div> hanging'
	const output = '_<div>_'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('fed with not really HTML at this point... tags that aren\'t finished', () => {
	const input = 'do you expect me to finish this <div class='
	const output = '_'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('fed with dubiously valid HTML (p within p and also div inside p)', () => {
	const input = 'look ma <p> p \nwithin <p> p! </p> and a <br/><div>div!</div></p>'
	const output = '_<p>_\n_<p>_</p>_<br/><div>_</div></p>'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('fed with maybe valid HTML? self-closing divs and ps', () => {
	const input = 'a <div class="what"/> what now <p aria-label="wtf"/> ?'
	const output = '_<div class="what"/>_<p aria-label="wtf"/>_'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('fed with valid XHTML containing a CDATA', () => {
	const input = 'Yes, it is me, <![CDATA[DIO]]>'
	const output = '_'
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})

	it('Testing handling ignored blocks', () => {
	const input = `
	<pre><code>> rei = "0"
	'0'
	> rei == 0
	true
	> rei == null
	false</code></pre><blockquote>That, christian-like JS diagram but it’s evangelion instead.</blockquote>
	`
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(input)
	})
	it('Testing handling ignored blocks 2', () => {
	const input = `
	<blockquote>An SSL error has happened.</blockquote><p>Shakespeare</p>
	`
	const output = `
	<blockquote>An SSL error has happened.</blockquote><p>_</p>
	`
	const result = convertHtmlToLines(input)
	const comparableResult = result.map(mapOnlyText(processorReplace)).join('')
	expect(comparableResult).to.eql(output)
	})
	})
	})
	diff --git a/test/unit/specs/services/html_converter/html_tree_converter.spec.js b/test/unit/specs/services/html_converter/html_tree_converter.spec.js
	index a54745c349..7283021b21 100644
	--- a/test/unit/specs/services/html_converter/html_tree_converter.spec.js
	+++ b/test/unit/specs/services/html_converter/html_tree_converter.spec.js
	@@ -1,166 +1,132 @@
	-import { convertHtmlToTree, processTextForEmoji, getAttrs } from 'src/services/html_converter/html_tree_converter.service.js'
	+import { convertHtmlToTree } from 'src/services/html_converter/html_tree_converter.service.js'

	-describe('MiniHtmlConverter', () => {
	+describe('html_tree_converter', () => {
	describe('convertHtmlToTree', () => {
	it('converts html into a tree structure', () => {
	const input = '1 <p>2</p> <b>3<img src="a">4</b>5'
	expect(convertHtmlToTree(input)).to.eql([
	'1 ',
	[
	'<p>',
	['2'],
	'</p>'
	],
	' ',
	[
	'<b>',
	[
	'3',
	['<img src="a">'],
	'4'
	],
	'</b>'
	],
	'5'
	])
	})
	it('converts html to tree while preserving tag formatting', () => {
	const input = '1 <p >2</p><b >3<img src="a">4</b>5'
	expect(convertHtmlToTree(input)).to.eql([
	'1 ',
	[
	'<p >',
	['2'],
	'</p>'
	],
	[
	'<b >',
	[
	'3',
	['<img src="a">'],
	'4'
	],
	'</b>'
	],
	'5'
	])
	})
	it('converts semi-broken html', () => {
	const input = '1 <br> 2 <p> 42'
	expect(convertHtmlToTree(input)).to.eql([
	'1 ',
	['<br>'],
	' 2 ',
	[
	'<p>',
	[' 42']
	]
	])
	})
	it('realistic case 1', () => {
	const input = '<p><span class="h-card"><a class="u-url mention" data-user="9wRC6T2ZZiKWJ0vUi8" href="https://cawfee.club/users/benis" rel="ugc">@<span>benis</span></a></span> <span class="h-card"><a class="u-url mention" data-user="194" href="https://shigusegubu.club/users/hj" rel="ugc">@<span>hj</span></a></span> nice</p>'
	expect(convertHtmlToTree(input)).to.eql([
	[
	'<p>',
	[
	[
	'<span class="h-card">',
	[
	[
	'<a class="u-url mention" data-user="9wRC6T2ZZiKWJ0vUi8" href="https://cawfee.club/users/benis" rel="ugc">',
	[
	'@',
	[
	'<span>',
	[
	'benis'
	],
	'</span>'
	]
	],
	'</a>'
	]
	],
	'</span>'
	],
	' ',
	[
	'<span class="h-card">',
	[
	[
	'<a class="u-url mention" data-user="194" href="https://shigusegubu.club/users/hj" rel="ugc">',
	[
	'@',
	[
	'<span>',
	[
	'hj'
	],
	'</span>'
	]
	],
	'</a>'
	]
	],
	'</span>'
	],
	' nice'
	],
	'</p>'
	]
	])
	})
	it('realistic case 2', () => {
	const inputOutput = 'Country improv: give me a city<br/>Audience: Memphis<br/>Improv troupe: come on, a better one<br/>Audience: el paso'
	expect(convertHtmlToTree(inputOutput)).to.eql([
	'Country improv: give me a city',
	[
	'<br/>'
	],
	'Audience: Memphis',
	[
	'<br/>'
	],
	'Improv troupe: come on, a better one',
	[
	'<br/>'
	],
	'Audience: el paso'
	])
	})
	})
	-
	- describe('processTextForEmoji', () => {
	- it('processes all emoji in text', () => {
	- const input = 'Hello from finland! :lol: We have best water! :lmao:'
	- const emojis = [
	- { shortcode: 'lol', src: 'LOL' },
	- { shortcode: 'lmao', src: 'LMAO' }
	- ]
	- const processor = ({ shortcode, src }) => ({ shortcode, src })
	- expect(processTextForEmoji(input, emojis, processor)).to.eql([
	- 'Hello from finland! ',
	- { shortcode: 'lol', src: 'LOL' },
	- ' We have best water! ',
	- { shortcode: 'lmao', src: 'LMAO' }
	- ])
	- })
	- it('leaves text as is', () => {
	- const input = 'Number one: that\'s terror'
	- const emojis = []
	- const processor = ({ shortcode, src }) => ({ shortcode, src })
	- expect(processTextForEmoji(input, emojis, processor)).to.eql([
	- 'Number one: that\'s terror'
	- ])
	- })
	- })
	-
	- describe('getAttrs', () => {
	- it('extracts arguments from tag', () => {
	- const input = '<img src="boop" cool ebin=\'true\'>'
	- const output = { src: 'boop', cool: true, ebin: 'true' }
	-
	- expect(getAttrs(input)).to.eql(output)
	- })
	- })
	})
	diff --git a/test/unit/specs/services/html_converter/utility.spec.js b/test/unit/specs/services/html_converter/utility.spec.js
	new file mode 100644
	index 0000000000..cf6fd99b4a
	--- /dev/null
	+++ b/test/unit/specs/services/html_converter/utility.spec.js
	@@ -0,0 +1,37 @@
	+import { processTextForEmoji, getAttrs } from 'src/services/html_converter/utility.service.js'
	+
	+describe('html_converter utility', () => {
	+ describe('processTextForEmoji', () => {
	+ it('processes all emoji in text', () => {
	+ const input = 'Hello from finland! :lol: We have best water! :lmao:'
	+ const emojis = [
	+ { shortcode: 'lol', src: 'LOL' },
	+ { shortcode: 'lmao', src: 'LMAO' }
	+ ]
	+ const processor = ({ shortcode, src }) => ({ shortcode, src })
	+ expect(processTextForEmoji(input, emojis, processor)).to.eql([
	+ 'Hello from finland! ',
	+ { shortcode: 'lol', src: 'LOL' },
	+ ' We have best water! ',
	+ { shortcode: 'lmao', src: 'LMAO' }
	+ ])
	+ })
	+ it('leaves text as is', () => {
	+ const input = 'Number one: that\'s terror'
	+ const emojis = []
	+ const processor = ({ shortcode, src }) => ({ shortcode, src })
	+ expect(processTextForEmoji(input, emojis, processor)).to.eql([
	+ 'Number one: that\'s terror'
	+ ])
	+ })
	+ })
	+
	+ describe('getAttrs', () => {
	+ it('extracts arguments from tag', () => {
	+ const input = '<img src="boop" cool ebin=\'true\'>'
	+ const output = { src: 'boop', cool: true, ebin: 'true' }
	+
	+ expect(getAttrs(input)).to.eql(output)
	+ })
	+ })
	+})

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 9, 1:16 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1724592
Default Alt Text: (49 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions