No OneTemporary
Actions

Size

279 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index 24c193b98d..ebd0e61399 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,51 +1,72 @@
	# Changelog
	All notable changes to this project will be documented in this file.

	The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
	-
	## [Unreleased]
	+### Changed
	+- Removed the use of with_move parameters when fetching notifications
	+
	+## [2.0.3] - 2020-05-02
	+### Fixed
	+- Show more/less works correctly with auto-collapsed subjects and long posts
	+- RTL characters won't look messed up in notifications
	+
	+### Changed
	+- Emoji autocomplete will match any part of the word and not just start, for example :drool will now helpfully suggest :blobcatdrool: and :blobcatdroolreach:
	+
	+### Add
	+- Follow request notification support
	+
	+## [2.0.2] - 2020-04-08
	+### Fixed
	+- Favorite/Repeat avatars not showing up on private instances/non-public posts
	+- Autocorrect getting triggered in the captcha field
	+- Overflow on long domains in follow/move notifications
	+
	+### Changed
	+- Polish translation updated

	## [2.0.0] - 2020-02-28
	### Added
	- Tons of color slots including ones for hover/pressed/toggled buttons
	- Experimental `--variable[,mod]` syntax support for color slots in themes. the `mod` makes color brighter/darker depending on background color (makes darker color brighter/darker depending on background color)
	- Paper theme by Shpuld
	- Icons in nav panel
	- Private mode support
	- Support for 'Move' type notifications
	- Pleroma AMOLED dark theme
	- User level domain mutes, under User Settings -> Mutes
	- Emoji reactions for statuses
	- MRF keyword policy disclosure
	### Changed
	- Updated Pleroma default themes
	- theme engine update to 3 (themes v2.1 introduction)
	- massive internal changes in theme engine - slowly away from "generate things separately with spaghetti code" towards "feed all data into single 'generateTheme' function and declare slot inheritance and all in a separate file"
	- Breezy theme updates to make it closer to actual Breeze in some aspects
	- when using `--variable` in shadows it no longer uses the actual CSS3 variable, instead it generates color from other slots
	- theme doesn't get saved to local storage when opening FE anonymously
	- Captcha now resets on failed registrations
	- Notifications column now cleans itself up to optimize performance when tab is left open for a long time
	- 403 messaging
	### Fixed
	- Fixed loader-spinner not disappearing when a status preview fails to load
	- anon viewers won't get theme data saved to local storage, so admin changing default theme will have an effect for users coming back to instance.
	- Single notifications left unread when hitting read on another device/tab
	- Registration fixed
	- Deactivation of remote accounts from frontend
	- Fixed NSFW unhiding not working with videos when using one-click unhiding/displaying
	- Improved performance of anything that uses popovers (most notably statuses)

	## [1.1.7 and earlier] - 2019-12-14
	### Added
	- Ability to hide/show repeats from user
	- User profile button clutter organized into a menu
	- Emoji picker
	- Started changelog anew
	- Ability to change user's email
	- About page
	- Added remote user redirect
	### Changed
	- changed the way fading effects for user profile/long statuses works, now uses css-mask instead of gradient background hacks which weren't exactly compatible with semi-transparent themes
	### Fixed
	- improved hotkey behavior on autocomplete popup
	diff --git a/src/boot/after_store.js b/src/boot/after_store.js
	index 1522d4f09e..34f6d6e7c5 100644
	--- a/src/boot/after_store.js
	+++ b/src/boot/after_store.js
	@@ -1,331 +1,334 @@
	import Vue from 'vue'
	import VueRouter from 'vue-router'
	import routes from './routes'
	import App from '../App.vue'
	import { windowWidth } from '../services/window_utils/window_utils'
	import { getOrCreateApp, getClientToken } from '../services/new_api/oauth.js'
	import backendInteractorService from '../services/backend_interactor_service/backend_interactor_service.js'
	import { CURRENT_VERSION } from '../services/theme_data/theme_data.service.js'
	import { applyTheme } from '../services/style_setter/style_setter.js'

	const getStatusnetConfig = async ({ store }) => {
	try {
	const res = await window.fetch('/api/statusnet/config.json')
	if (res.ok) {
	const data = await res.json()
	const { name, closed: registrationClosed, textlimit, uploadlimit, server, vapidPublicKey, safeDMMentionsEnabled } = data.site

	store.dispatch('setInstanceOption', { name: 'name', value: name })
	store.dispatch('setInstanceOption', { name: 'registrationOpen', value: (registrationClosed === '0') })
	store.dispatch('setInstanceOption', { name: 'textlimit', value: parseInt(textlimit) })
	store.dispatch('setInstanceOption', { name: 'server', value: server })
	store.dispatch('setInstanceOption', { name: 'safeDM', value: safeDMMentionsEnabled !== '0' })

	// TODO: default values for this stuff, added if to not make it break on
	// my dev config out of the box.
	if (uploadlimit) {
	store.dispatch('setInstanceOption', { name: 'uploadlimit', value: parseInt(uploadlimit.uploadlimit) })
	store.dispatch('setInstanceOption', { name: 'avatarlimit', value: parseInt(uploadlimit.avatarlimit) })
	store.dispatch('setInstanceOption', { name: 'backgroundlimit', value: parseInt(uploadlimit.backgroundlimit) })
	store.dispatch('setInstanceOption', { name: 'bannerlimit', value: parseInt(uploadlimit.bannerlimit) })
	}

	if (vapidPublicKey) {
	store.dispatch('setInstanceOption', { name: 'vapidPublicKey', value: vapidPublicKey })
	}

	return data.site.pleromafe
	} else {
	throw (res)
	}
	} catch (error) {
	console.error('Could not load statusnet config, potentially fatal')
	console.error(error)
	}
	}

	const getStaticConfig = async () => {
	try {
	const res = await window.fetch('/static/config.json')
	if (res.ok) {
	return res.json()
	} else {
	throw (res)
	}
	} catch (error) {
	console.warn('Failed to load static/config.json, continuing without it.')
	console.warn(error)
	return {}
	}
	}

	const setSettings = async ({ apiConfig, staticConfig, store }) => {
	const overrides = window.___pleromafe_dev_overrides \|\| {}
	const env = window.___pleromafe_mode.NODE_ENV

	// This takes static config and overrides properties that are present in apiConfig
	let config = {}
	if (overrides.staticConfigPreference && env === 'development') {
	console.warn('OVERRIDING API CONFIG WITH STATIC CONFIG')
	config = Object.assign({}, apiConfig, staticConfig)
	} else {
	config = Object.assign({}, staticConfig, apiConfig)
	}

	const copyInstanceOption = (name) => {
	store.dispatch('setInstanceOption', { name, value: config[name] })
	}

	copyInstanceOption('nsfwCensorImage')
	copyInstanceOption('background')
	copyInstanceOption('hidePostStats')
	copyInstanceOption('hideUserStats')
	copyInstanceOption('hideFilteredStatuses')
	copyInstanceOption('logo')

	store.dispatch('setInstanceOption', {
	name: 'logoMask',
	value: typeof config.logoMask === 'undefined'
	? true
	: config.logoMask
	})

	store.dispatch('setInstanceOption', {
	name: 'logoMargin',
	value: typeof config.logoMargin === 'undefined'
	? 0
	: config.logoMargin
	})
	store.commit('authFlow/setInitialStrategy', config.loginMethod)

	copyInstanceOption('redirectRootNoLogin')
	copyInstanceOption('redirectRootLogin')
	copyInstanceOption('showInstanceSpecificPanel')
	copyInstanceOption('minimalScopesMode')
	copyInstanceOption('hideMutedPosts')
	copyInstanceOption('collapseMessageWithSubject')
	copyInstanceOption('scopeCopy')
	copyInstanceOption('subjectLineBehavior')
	copyInstanceOption('postContentType')
	copyInstanceOption('alwaysShowSubjectInput')
	copyInstanceOption('noAttachmentLinks')
	copyInstanceOption('showFeaturesPanel')
	copyInstanceOption('hideSitename')

	return store.dispatch('setTheme', config['theme'])
	}

	const getTOS = async ({ store }) => {
	try {
	const res = await window.fetch('/static/terms-of-service.html')
	if (res.ok) {
	const html = await res.text()
	store.dispatch('setInstanceOption', { name: 'tos', value: html })
	} else {
	throw (res)
	}
	} catch (e) {
	console.warn("Can't load TOS")
	console.warn(e)
	}
	}

	const getInstancePanel = async ({ store }) => {
	try {
	const res = await window.fetch('/instance/panel.html')
	if (res.ok) {
	const html = await res.text()
	store.dispatch('setInstanceOption', { name: 'instanceSpecificPanelContent', value: html })
	} else {
	throw (res)
	}
	} catch (e) {
	console.warn("Can't load instance panel")
	console.warn(e)
	}
	}

	const getStickers = async ({ store }) => {
	try {
	const res = await window.fetch('/static/stickers.json')
	if (res.ok) {
	const values = await res.json()
	const stickers = (await Promise.all(
	Object.entries(values).map(async ([name, path]) => {
	const resPack = await window.fetch(path + 'pack.json')
	var meta = {}
	if (resPack.ok) {
	meta = await resPack.json()
	}
	return {
	pack: name,
	path,
	meta
	}
	})
	)).sort((a, b) => {
	return a.meta.title.localeCompare(b.meta.title)
	})
	store.dispatch('setInstanceOption', { name: 'stickers', value: stickers })
	} else {
	throw (res)
	}
	} catch (e) {
	console.warn("Can't load stickers")
	console.warn(e)
	}
	}

	const getAppSecret = async ({ store }) => {
	const { state, commit } = store
	const { oauth, instance } = state
	return getOrCreateApp({ ...oauth, instance: instance.server, commit })
	.then((app) => getClientToken({ ...app, instance: instance.server }))
	.then((token) => {
	commit('setAppToken', token.access_token)
	commit('setBackendInteractor', backendInteractorService(store.getters.getToken()))
	})
	}

	const resolveStaffAccounts = ({ store, accounts }) => {
	const nicknames = accounts.map(uri => uri.split('/').pop())
	nicknames.map(nickname => store.dispatch('fetchUser', nickname))
	store.dispatch('setInstanceOption', { name: 'staffAccounts', value: nicknames })
	}

	const getNodeInfo = async ({ store }) => {
	try {
	const res = await window.fetch('/nodeinfo/2.0.json')
	if (res.ok) {
	const data = await res.json()
	const metadata = data.metadata
	const features = metadata.features
	store.dispatch('setInstanceOption', { name: 'mediaProxyAvailable', value: features.includes('media_proxy') })
	store.dispatch('setInstanceOption', { name: 'chatAvailable', value: features.includes('chat') })
	store.dispatch('setInstanceOption', { name: 'gopherAvailable', value: features.includes('gopher') })
	store.dispatch('setInstanceOption', { name: 'pollsAvailable', value: features.includes('polls') })
	store.dispatch('setInstanceOption', { name: 'pollLimits', value: metadata.pollLimits })
	store.dispatch('setInstanceOption', { name: 'mailerEnabled', value: metadata.mailerEnabled })

	store.dispatch('setInstanceOption', { name: 'restrictedNicknames', value: metadata.restrictedNicknames })
	store.dispatch('setInstanceOption', { name: 'postFormats', value: metadata.postFormats })

	const suggestions = metadata.suggestions
	store.dispatch('setInstanceOption', { name: 'suggestionsEnabled', value: suggestions.enabled })
	store.dispatch('setInstanceOption', { name: 'suggestionsWeb', value: suggestions.web })

	const software = data.software
	store.dispatch('setInstanceOption', { name: 'backendVersion', value: software.version })
	store.dispatch('setInstanceOption', { name: 'pleromaBackend', value: software.name === 'pleroma' })

	const priv = metadata.private
	store.dispatch('setInstanceOption', { name: 'private', value: priv })

	const frontendVersion = window.___pleromafe_commit_hash
	store.dispatch('setInstanceOption', { name: 'frontendVersion', value: frontendVersion })

	const federation = metadata.federation

	store.dispatch('setInstanceOption', {
	name: 'tagPolicyAvailable',
	value: typeof federation.mrf_policies === 'undefined'
	? false
	: metadata.federation.mrf_policies.includes('TagPolicy')
	})

	store.dispatch('setInstanceOption', { name: 'federationPolicy', value: federation })
	store.dispatch('setInstanceOption', {
	name: 'federating',
	value: typeof federation.enabled === 'undefined'
	? true
	: federation.enabled
	})

	+ const accountActivationRequired = metadata.accountActivationRequired
	+ store.dispatch('setInstanceOption', { name: 'accountActivationRequired', value: accountActivationRequired })
	+
	const accounts = metadata.staffAccounts
	resolveStaffAccounts({ store, accounts })
	} else {
	throw (res)
	}
	} catch (e) {
	console.warn('Could not load nodeinfo')
	console.warn(e)
	}
	}

	const setConfig = async ({ store }) => {
	// apiConfig, staticConfig
	const configInfos = await Promise.all([getStatusnetConfig({ store }), getStaticConfig()])
	const apiConfig = configInfos[0]
	const staticConfig = configInfos[1]

	await setSettings({ store, apiConfig, staticConfig }).then(getAppSecret({ store }))
	}

	const checkOAuthToken = async ({ store }) => {
	return new Promise(async (resolve, reject) => {
	if (store.getters.getUserToken()) {
	try {
	await store.dispatch('loginUser', store.getters.getUserToken())
	} catch (e) {
	console.error(e)
	}
	}
	resolve()
	})
	}

	const afterStoreSetup = async ({ store, i18n }) => {
	const width = windowWidth()
	store.dispatch('setMobileLayout', width <= 800)
	await setConfig({ store })

	const { customTheme, customThemeSource } = store.state.config
	const { theme } = store.state.instance
	const customThemePresent = customThemeSource \|\| customTheme

	if (customThemePresent) {
	if (customThemeSource && customThemeSource.themeEngineVersion === CURRENT_VERSION) {
	applyTheme(customThemeSource)
	} else {
	applyTheme(customTheme)
	}
	} else if (theme) {
	// do nothing, it will load asynchronously
	} else {
	console.error('Failed to load any theme!')
	}

	// Now we can try getting the server settings and logging in
	await Promise.all([
	checkOAuthToken({ store }),
	getTOS({ store }),
	getInstancePanel({ store }),
	getStickers({ store }),
	getNodeInfo({ store })
	])

	// Start fetching things that don't need to block the UI
	store.dispatch('fetchMutes')

	const router = new VueRouter({
	mode: 'history',
	routes: routes(store),
	scrollBehavior: (to, _from, savedPosition) => {
	if (to.matched.some(m => m.meta.dontScroll)) {
	return false
	}
	return savedPosition \|\| { x: 0, y: 0 }
	}
	})

	/* eslint-disable no-new */
	return new Vue({
	router,
	store,
	i18n,
	el: '#app',
	render: h => h(App)
	})
	}

	export default afterStoreSetup
	diff --git a/src/components/emoji_input/suggestor.js b/src/components/emoji_input/suggestor.js
	index aec5c39d83..15a71effa1 100644
	--- a/src/components/emoji_input/suggestor.js
	+++ b/src/components/emoji_input/suggestor.js
	@@ -1,94 +1,106 @@
	import { debounce } from 'lodash'
	/**
	* suggest - generates a suggestor function to be used by emoji-input
	* data: object providing source information for specific types of suggestions:
	* data.emoji - optional, an array of all emoji available i.e.
	* (state.instance.emoji + state.instance.customEmoji)
	* data.users - optional, an array of all known users
	* updateUsersList - optional, a function to search and append to users
	*
	* Depending on data present one or both (or none) can be present, so if field
	* doesn't support user linking you can just provide only emoji.
	*/

	const debounceUserSearch = debounce((data, input) => {
	data.updateUsersList(input)
	}, 500, { leading: true, trailing: false })

	export default data => input => {
	const firstChar = input[0]
	if (firstChar === ':' && data.emoji) {
	return suggestEmoji(data.emoji)(input)
	}
	if (firstChar === '@' && data.users) {
	return suggestUsers(data)(input)
	}
	return []
	}

	export const suggestEmoji = emojis => input => {
	const noPrefix = input.toLowerCase().substr(1)
	return emojis
	- .filter(({ displayText }) => displayText.toLowerCase().startsWith(noPrefix))
	+ .filter(({ displayText }) => displayText.toLowerCase().match(noPrefix))
	.sort((a, b) => {
	let aScore = 0
	let bScore = 0

	- // Make custom emojis a priority
	- aScore += a.imageUrl ? 10 : 0
	- bScore += b.imageUrl ? 10 : 0
	+ // An exact match always wins
	+ aScore += a.displayText.toLowerCase() === noPrefix ? 200 : 0
	+ bScore += b.displayText.toLowerCase() === noPrefix ? 200 : 0

	- // Sort alphabetically
	- const alphabetically = a.displayText > b.displayText ? 1 : -1
	+ // Prioritize custom emoji a lot
	+ aScore += a.imageUrl ? 100 : 0
	+ bScore += b.imageUrl ? 100 : 0
	+
	+ // Prioritize prefix matches somewhat
	+ aScore += a.displayText.toLowerCase().startsWith(noPrefix) ? 10 : 0
	+ bScore += b.displayText.toLowerCase().startsWith(noPrefix) ? 10 : 0
	+
	+ // Sort by length
	+ aScore -= a.displayText.length
	+ bScore -= b.displayText.length
	+
	+ // Break ties alphabetically
	+ const alphabetically = a.displayText > b.displayText ? 0.5 : -0.5

	return bScore - aScore + alphabetically
	})
	}

	export const suggestUsers = data => input => {
	const noPrefix = input.toLowerCase().substr(1)
	const users = data.users

	const newUsers = users.filter(
	user =>
	user.screen_name.toLowerCase().startsWith(noPrefix) \|\|
	user.name.toLowerCase().startsWith(noPrefix)

	/* taking only 20 results so that sorting is a bit cheaper, we display
	* only 5 anyway. could be inaccurate, but we ideally we should query
	* backend anyway
	*/
	).slice(0, 20).sort((a, b) => {
	let aScore = 0
	let bScore = 0

	// Matches on screen name (i.e. user@instance) makes a priority
	aScore += a.screen_name.toLowerCase().startsWith(noPrefix) ? 2 : 0
	bScore += b.screen_name.toLowerCase().startsWith(noPrefix) ? 2 : 0

	// Matches on name takes second priority
	aScore += a.name.toLowerCase().startsWith(noPrefix) ? 1 : 0
	bScore += b.name.toLowerCase().startsWith(noPrefix) ? 1 : 0

	const diff = (bScore - aScore) * 10

	// Then sort alphabetically
	const nameAlphabetically = a.name > b.name ? 1 : -1
	const screenNameAlphabetically = a.screen_name > b.screen_name ? 1 : -1

	return diff + nameAlphabetically + screenNameAlphabetically
	/* eslint-disable camelcase */
	}).map(({ screen_name, name, profile_image_url_original }) => ({
	displayText: screen_name,
	detailText: name,
	imageUrl: profile_image_url_original,
	replacement: '@' + screen_name + ' '
	}))

	// BE search users if there are no matches
	if (newUsers.length === 0 && data.updateUsersList) {
	debounceUserSearch(data, noPrefix)
	}
	return newUsers
	/* eslint-enable camelcase */
	}
	diff --git a/src/components/extra_buttons/extra_buttons.js b/src/components/extra_buttons/extra_buttons.js
	index 3748538322..e4b19d0102 100644
	--- a/src/components/extra_buttons/extra_buttons.js
	+++ b/src/components/extra_buttons/extra_buttons.js
	@@ -1,53 +1,61 @@
	import Popover from '../popover/popover.vue'

	const ExtraButtons = {
	props: [ 'status' ],
	components: { Popover },
	methods: {
	deleteStatus () {
	const confirmed = window.confirm(this.$t('status.delete_confirm'))
	if (confirmed) {
	this.$store.dispatch('deleteStatus', { id: this.status.id })
	}
	},
	pinStatus () {
	this.$store.dispatch('pinStatus', this.status.id)
	.then(() => this.$emit('onSuccess'))
	.catch(err => this.$emit('onError', err.error.error))
	},
	unpinStatus () {
	this.$store.dispatch('unpinStatus', this.status.id)
	.then(() => this.$emit('onSuccess'))
	.catch(err => this.$emit('onError', err.error.error))
	},
	muteConversation () {
	this.$store.dispatch('muteConversation', this.status.id)
	.then(() => this.$emit('onSuccess'))
	.catch(err => this.$emit('onError', err.error.error))
	},
	unmuteConversation () {
	this.$store.dispatch('unmuteConversation', this.status.id)
	.then(() => this.$emit('onSuccess'))
	.catch(err => this.$emit('onError', err.error.error))
	+ },
	+ copyLink () {
	+ navigator.clipboard.writeText(this.statusLink)
	+ .then(() => this.$emit('onSuccess'))
	+ .catch(err => this.$emit('onError', err.error.error))
	}
	},
	computed: {
	currentUser () { return this.$store.state.users.currentUser },
	canDelete () {
	if (!this.currentUser) { return }
	const superuser = this.currentUser.rights.moderator \|\| this.currentUser.rights.admin
	return superuser \|\| this.status.user.id === this.currentUser.id
	},
	ownStatus () {
	return this.status.user.id === this.currentUser.id
	},
	canPin () {
	return this.ownStatus && (this.status.visibility === 'public' \|\| this.status.visibility === 'unlisted')
	},
	canMute () {
	return !!this.currentUser
	+ },
	+ statusLink () {
	+ return `${this.$store.state.instance.server}${this.$router.resolve({ name: 'conversation', params: { id: this.status.id } }).href}`
	}
	}
	}

	export default ExtraButtons
	diff --git a/src/components/extra_buttons/extra_buttons.vue b/src/components/extra_buttons/extra_buttons.vue
	index 3a7f1283ab..bca93ea744 100644
	--- a/src/components/extra_buttons/extra_buttons.vue
	+++ b/src/components/extra_buttons/extra_buttons.vue
	@@ -1,71 +1,80 @@
	<template>
	<Popover
	- v-if="canDelete \|\| canMute \|\| canPin"
	trigger="click"
	placement="top"
	class="extra-button-popover"
	>
	- <div slot="content">
	+ <div
	+ slot="content"
	+ slot-scope="{close}"
	+ >
	<div class="dropdown-menu">
	<button
	v-if="canMute && !status.thread_muted"
	class="dropdown-item dropdown-item-icon"
	@click.prevent="muteConversation"
	>
	<i class="icon-eye-off" /><span>{{ $t("status.mute_conversation") }}</span>
	</button>
	<button
	v-if="canMute && status.thread_muted"
	class="dropdown-item dropdown-item-icon"
	@click.prevent="unmuteConversation"
	>
	<i class="icon-eye-off" /><span>{{ $t("status.unmute_conversation") }}</span>
	</button>
	<button
	v-if="!status.pinned && canPin"
	- v-close-popover
	class="dropdown-item dropdown-item-icon"
	@click.prevent="pinStatus"
	+ @click="close"
	>
	<i class="icon-pin" /><span>{{ $t("status.pin") }}</span>
	</button>
	<button
	v-if="status.pinned && canPin"
	- v-close-popover
	class="dropdown-item dropdown-item-icon"
	@click.prevent="unpinStatus"
	+ @click="close"
	>
	<i class="icon-pin" /><span>{{ $t("status.unpin") }}</span>
	</button>
	<button
	v-if="canDelete"
	- v-close-popover
	class="dropdown-item dropdown-item-icon"
	@click.prevent="deleteStatus"
	+ @click="close"
	>
	<i class="icon-cancel" /><span>{{ $t("status.delete") }}</span>
	</button>
	+ <button
	+ class="dropdown-item dropdown-item-icon"
	+ @click.prevent="copyLink"
	+ @click="close"
	+ >
	+ <i class="icon-share" /><span>{{ $t("status.copy_link") }}</span>
	+ </button>
	</div>
	</div>
	<i
	slot="trigger"
	class="icon-ellipsis button-icon"
	/>
	</Popover>
	</template>

	<script src="./extra_buttons.js" ></script>

	<style lang="scss">
	@import '../../_variables.scss';

	.icon-ellipsis {
	cursor: pointer;

	&:hover,
	.extra-button-popover.open & {
	color: $fallback--text;
	color: var(--text, $fallback--text);
	}
	}
	</style>
	diff --git a/src/components/follow_request_card/follow_request_card.js b/src/components/follow_request_card/follow_request_card.js
	index a893178728..cbd75311e8 100644
	--- a/src/components/follow_request_card/follow_request_card.js
	+++ b/src/components/follow_request_card/follow_request_card.js
	@@ -1,20 +1,40 @@
	import BasicUserCard from '../basic_user_card/basic_user_card.vue'
	+import { notificationsFromStore } from '../../services/notification_utils/notification_utils.js'

	const FollowRequestCard = {
	props: ['user'],
	components: {
	BasicUserCard
	},
	methods: {
	+ findFollowRequestNotificationId () {
	+ const notif = notificationsFromStore(this.$store).find(
	+ (notif) => notif.from_profile.id === this.user.id && notif.type === 'follow_request'
	+ )
	+ return notif && notif.id
	+ },
	approveUser () {
	this.$store.state.api.backendInteractor.approveUser({ id: this.user.id })
	this.$store.dispatch('removeFollowRequest', this.user)
	+
	+ const notifId = this.findFollowRequestNotificationId()
	+ this.$store.dispatch('markSingleNotificationAsSeen', { id: notifId })
	+ this.$store.dispatch('updateNotification', {
	+ id: notifId,
	+ updater: notification => {
	+ notification.type = 'follow'
	+ }
	+ })
	},
	denyUser () {
	+ const notifId = this.findFollowRequestNotificationId()
	this.$store.state.api.backendInteractor.denyUser({ id: this.user.id })
	- this.$store.dispatch('removeFollowRequest', this.user)
	+ .then(() => {
	+ this.$store.dispatch('dismissNotificationLocal', { id: notifId })
	+ this.$store.dispatch('removeFollowRequest', this.user)
	+ })
	}
	}
	}

	export default FollowRequestCard
	diff --git a/src/components/notification/notification.js b/src/components/notification/notification.js
	index ff1c281747..1cf4c9bc7b 100644
	--- a/src/components/notification/notification.js
	+++ b/src/components/notification/notification.js
	@@ -1,64 +1,86 @@
	import Status from '../status/status.vue'
	import UserAvatar from '../user_avatar/user_avatar.vue'
	import UserCard from '../user_card/user_card.vue'
	import Timeago from '../timeago/timeago.vue'
	+import { isStatusNotification } from '../../services/notification_utils/notification_utils.js'
	import { highlightClass, highlightStyle } from '../../services/user_highlighter/user_highlighter.js'
	import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'

	const Notification = {
	data () {
	return {
	userExpanded: false,
	betterShadow: this.$store.state.interface.browserSupport.cssFilter,
	unmuted: false
	}
	},
	props: [ 'notification' ],
	components: {
	Status,
	UserAvatar,
	UserCard,
	Timeago
	},
	methods: {
	toggleUserExpanded () {
	this.userExpanded = !this.userExpanded
	},
	generateUserProfileLink (user) {
	return generateProfileLink(user.id, user.screen_name, this.$store.state.instance.restrictedNicknames)
	},
	getUser (notification) {
	return this.$store.state.users.usersObject[notification.from_profile.id]
	},
	toggleMute () {
	this.unmuted = !this.unmuted
	+ },
	+ approveUser () {
	+ this.$store.state.api.backendInteractor.approveUser({ id: this.user.id })
	+ this.$store.dispatch('removeFollowRequest', this.user)
	+ this.$store.dispatch('markSingleNotificationAsSeen', { id: this.notification.id })
	+ this.$store.dispatch('updateNotification', {
	+ id: this.notification.id,
	+ updater: notification => {
	+ notification.type = 'follow'
	+ }
	+ })
	+ },
	+ denyUser () {
	+ this.$store.state.api.backendInteractor.denyUser({ id: this.user.id })
	+ .then(() => {
	+ this.$store.dispatch('dismissNotificationLocal', { id: this.notification.id })
	+ this.$store.dispatch('removeFollowRequest', this.user)
	+ })
	}
	},
	computed: {
	userClass () {
	return highlightClass(this.notification.from_profile)
	},
	userStyle () {
	const highlight = this.$store.getters.mergedConfig.highlight
	const user = this.notification.from_profile
	return highlightStyle(highlight[user.screen_name])
	},
	user () {
	return this.$store.getters.findUser(this.notification.from_profile.id)
	},
	userProfileLink () {
	return this.generateUserProfileLink(this.user)
	},
	targetUser () {
	return this.$store.getters.findUser(this.notification.target.id)
	},
	targetUserProfileLink () {
	return this.generateUserProfileLink(this.targetUser)
	},
	needMute () {
	return this.$store.getters.relationship(this.user.id).muting
	+ },
	+ isStatusNotification () {
	+ return isStatusNotification(this.notification.type)
	}
	}
	}

	export default Notification
	diff --git a/src/components/notification/notification.vue b/src/components/notification/notification.vue
	index 24d9fe9032..0e46a2a722 100644
	--- a/src/components/notification/notification.vue
	+++ b/src/components/notification/notification.vue
	@@ -1,150 +1,172 @@
	<template>
	<status
	v-if="notification.type === 'mention'"
	:compact="true"
	:statusoid="notification.status"
	/>
	<div v-else>
	<div
	v-if="needMute && !unmuted"
	class="container muted"
	>
	<small>
	<router-link :to="userProfileLink">
	{{ notification.from_profile.screen_name }}
	</router-link>
	</small>
	<a
	href="#"
	class="unmute"
	@click.prevent="toggleMute"
	><i class="button-icon icon-eye-off" /></a>
	</div>
	<div
	v-else
	class="non-mention"
	:class="[userClass, { highlighted: userStyle }]"
	:style="[ userStyle ]"
	>
	<a
	class="avatar-container"
	:href="notification.from_profile.statusnet_profile_url"
	@click.stop.prevent.capture="toggleUserExpanded"
	>
	<UserAvatar
	:compact="true"
	:better-shadow="betterShadow"
	:user="notification.from_profile"
	/>
	</a>
	<div class="notification-right">
	<UserCard
	v-if="userExpanded"
	:user-id="getUser(notification).id"
	:rounded="true"
	:bordered="true"
	/>
	<span class="notification-details">
	<div class="name-and-action">
	<!-- eslint-disable vue/no-v-html -->
	- <span
	+ <bdi
	v-if="!!notification.from_profile.name_html"
	class="username"
	:title="'@'+notification.from_profile.screen_name"
	v-html="notification.from_profile.name_html"
	/>
	<!-- eslint-enable vue/no-v-html -->
	<span
	v-else
	class="username"
	:title="'@'+notification.from_profile.screen_name"
	>{{ notification.from_profile.name }}</span>
	<span v-if="notification.type === 'like'">
	<i class="fa icon-star lit" />
	<small>{{ $t('notifications.favorited_you') }}</small>
	</span>
	<span v-if="notification.type === 'repeat'">
	<i
	class="fa icon-retweet lit"
	:title="$t('tool_tip.repeat')"
	/>
	<small>{{ $t('notifications.repeated_you') }}</small>
	</span>
	<span v-if="notification.type === 'follow'">
	<i class="fa icon-user-plus lit" />
	<small>{{ $t('notifications.followed_you') }}</small>
	</span>
	+ <span v-if="notification.type === 'follow_request'">
	+ <i class="fa icon-user lit" />
	+ <small>{{ $t('notifications.follow_request') }}</small>
	+ </span>
	<span v-if="notification.type === 'move'">
	<i class="fa icon-arrow-curved lit" />
	<small>{{ $t('notifications.migrated_to') }}</small>
	</span>
	<span v-if="notification.type === 'pleroma:emoji_reaction'">
	<small>
	<i18n path="notifications.reacted_with">
	<span class="emoji-reaction-emoji">{{ notification.emoji }}</span>
	</i18n>
	</small>
	</span>
	</div>
	<div
	- v-if="notification.type === 'follow' \|\| notification.type === 'move'"
	+ v-if="isStatusNotification"
	class="timeago"
	>
	- <span class="faint">
	+ <router-link
	+ v-if="notification.status"
	+ :to="{ name: 'conversation', params: { id: notification.status.id } }"
	+ class="faint-link"
	+ >
	<Timeago
	:time="notification.created_at"
	:auto-update="240"
	/>
	- </span>
	+ </router-link>
	</div>
	<div
	v-else
	class="timeago"
	>
	- <router-link
	- v-if="notification.status"
	- :to="{ name: 'conversation', params: { id: notification.status.id } }"
	- class="faint-link"
	- >
	+ <span class="faint">
	<Timeago
	:time="notification.created_at"
	:auto-update="240"
	/>
	- </router-link>
	+ </span>
	</div>
	<a
	v-if="needMute"
	href="#"
	@click.prevent="toggleMute"
	><i class="button-icon icon-eye-off" /></a>
	</span>
	<div
	- v-if="notification.type === 'follow'"
	+ v-if="notification.type === 'follow' \|\| notification.type === 'follow_request'"
	class="follow-text"
	>
	- <router-link :to="userProfileLink">
	+ <router-link
	+ :to="userProfileLink"
	+ class="follow-name"
	+ >
	@{{ notification.from_profile.screen_name }}
	</router-link>
	+ <div
	+ v-if="notification.type === 'follow_request'"
	+ style="white-space: nowrap;"
	+ >
	+ <i
	+ class="icon-ok button-icon follow-request-accept"
	+ :title="$t('tool_tip.accept_follow_request')"
	+ @click="approveUser()"
	+ />
	+ <i
	+ class="icon-cancel button-icon follow-request-reject"
	+ :title="$t('tool_tip.reject_follow_request')"
	+ @click="denyUser()"
	+ />
	+ </div>
	</div>
	<div
	v-else-if="notification.type === 'move'"
	class="move-text"
	>
	<router-link :to="targetUserProfileLink">
	@{{ notification.target.screen_name }}
	</router-link>
	</div>
	<template v-else>
	<status
	class="faint"
	:compact="true"
	:statusoid="notification.action"
	:no-heading="true"
	/>
	</template>
	</div>
	</div>
	</div>
	</template>

	<script src="./notification.js"></script>
	diff --git a/src/components/notifications/notifications.scss b/src/components/notifications/notifications.scss
	index a8f4430f2a..9efcfcf86e 100644
	--- a/src/components/notifications/notifications.scss
	+++ b/src/components/notifications/notifications.scss
	@@ -1,189 +1,223 @@
	@import '../../_variables.scss';

	.notifications {
	&:not(.minimal) {
	// a bit of a hack to allow scrolling below notifications
	padding-bottom: 15em;
	}

	.loadmore-error {
	color: $fallback--text;
	color: var(--text, $fallback--text);
	}

	.notification {
	position: relative;

	.notification-overlay {
	position: absolute;
	top: 0;
	right: 0;
	left: 0;
	bottom: 0;
	pointer-events: none;
	}

	&.unseen {
	.notification-overlay {
	background-image: linear-gradient(135deg, var(--badgeNotification, $fallback--cRed) 4px, transparent 10px)
	}
	}
	}
	}

	.notification {
	box-sizing: border-box;
	border-bottom: 1px solid;
	border-color: $fallback--border;
	border-color: var(--border, $fallback--border);

	&:hover .animated.avatar {
	canvas {
	display: none;
	}
	img {
	visibility: visible;
	}
	}

	.muted {
	padding: .25em .6em;
	}

	.non-mention {
	display: flex;
	flex: 1;
	flex-wrap: nowrap;
	padding: 0.6em;
	min-width: 0;
	.avatar-container {
	width: 32px;
	height: 32px;
	}
	.status-el {
	.status {
	padding: 0.25em 0;
	color: $fallback--faint;
	color: var(--faint, $fallback--faint);
	a {
	color: var(--faintLink);
	}
	.status-content a {
	color: var(--postFaintLink);
	}
	}
	padding: 0;
	.media-body {
	margin: 0;
	}
	}
	}

	+ .follow-request-accept {
	+ cursor: pointer;
	+
	+ &:hover {
	+ color: $fallback--text;
	+ color: var(--text, $fallback--text);
	+ }
	+ }
	+
	+ .follow-request-reject {
	+ cursor: pointer;
	+
	+ &:hover {
	+ color: $fallback--cRed;
	+ color: var(--cRed, $fallback--cRed);
	+ }
	+ }
	+
	+
	.follow-text, .move-text {
	padding: 0.5em 0;
	overflow-wrap: break-word;
	+ display: flex;
	+ justify-content: space-between;
	+
	+ .follow-name {
	+ display: block;
	+ max-width: 100%;
	+ overflow: hidden;
	+ text-overflow: ellipsis;
	+ white-space: nowrap;
	+ }
	}

	.status-el {
	flex: 1;
	}

	time {
	white-space: nowrap;
	}

	.notification-right {
	flex: 1;
	padding-left: 0.8em;
	min-width: 0;
	}

	.emoji-reaction-emoji {
	font-size: 16px;
	}

	.notification-details {
	min-width: 0px;
	word-wrap: break-word;
	line-height:18px;
	position: relative;
	overflow: hidden;
	width: 100%;
	flex: 1 1 0;
	display: flex;
	flex-wrap: nowrap;
	justify-content: space-between;

	.name-and-action {
	flex: 1;
	overflow: hidden;
	text-overflow: ellipsis;
	}

	.username {
	font-weight: bolder;
	max-width: 100%;
	text-overflow: ellipsis;
	white-space: nowrap;

	img {
	width: 14px;
	height: 14px;
	vertical-align: middle;
	object-fit: contain
	}
	}

	.timeago {
	margin-right: .2em;
	}

	.icon-retweet.lit {
	color: $fallback--cGreen;
	color: var(--cGreen, $fallback--cGreen);
	}

	+ .icon-user.lit {
	+ color: $fallback--cBlue;
	+ color: var(--cBlue, $fallback--cBlue);
	+ }
	+
	.icon-user-plus.lit {
	color: $fallback--cBlue;
	color: var(--cBlue, $fallback--cBlue);
	}

	.icon-reply.lit {
	color: $fallback--cBlue;
	color: var(--cBlue, $fallback--cBlue);
	}

	.icon-star.lit {
	color: orange;
	color: $fallback--cOrange;
	color: var(--cOrange, $fallback--cOrange);
	}

	.icon-arrow-curved.lit {
	color: $fallback--cBlue;
	color: var(--cBlue, $fallback--cBlue);
	}

	.status-content {
	margin: 0;
	max-height: 300px;
	}

	h1 {
	word-break: break-all;
	margin: 0 0 0.3em;
	padding: 0;
	font-size: 1em;
	line-height:20px;
	small {
	font-weight: lighter;
	}
	}

	p {
	margin: 0;
	margin-top: 0;
	margin-bottom: 0.3em;
	}
	}
	}
	diff --git a/src/components/react_button/react_button.js b/src/components/react_button/react_button.js
	index 1994956354..abc3bf07d9 100644
	--- a/src/components/react_button/react_button.js
	+++ b/src/components/react_button/react_button.js
	@@ -1,39 +1,39 @@
	import Popover from '../popover/popover.vue'
	import { mapGetters } from 'vuex'

	const ReactButton = {
	- props: ['status', 'loggedIn'],
	+ props: ['status'],
	data () {
	return {
	filterWord: ''
	}
	},
	components: {
	Popover
	},
	methods: {
	addReaction (event, emoji, close) {
	const existingReaction = this.status.emoji_reactions.find(r => r.name === emoji)
	if (existingReaction && existingReaction.me) {
	this.$store.dispatch('unreactWithEmoji', { id: this.status.id, emoji })
	} else {
	this.$store.dispatch('reactWithEmoji', { id: this.status.id, emoji })
	}
	close()
	}
	},
	computed: {
	commonEmojis () {
	return ['❤️', '😠', '👀', '😂', '🔥']
	},
	emojis () {
	if (this.filterWord !== '') {
	return this.$store.state.instance.emoji.filter(emoji => emoji.displayText.includes(this.filterWord))
	}
	return this.$store.state.instance.emoji \|\| []
	},
	...mapGetters(['mergedConfig'])
	}
	}

	export default ReactButton
	diff --git a/src/components/react_button/react_button.vue b/src/components/react_button/react_button.vue
	index ab4b4fcd09..0b34add1e2 100644
	--- a/src/components/react_button/react_button.vue
	+++ b/src/components/react_button/react_button.vue
	@@ -1,111 +1,110 @@
	<template>
	<Popover
	trigger="click"
	placement="top"
	:offset="{ y: 5 }"
	class="react-button-popover"
	>
	<div
	slot="content"
	slot-scope="{close}"
	>
	<div class="reaction-picker-filter">
	<input
	v-model="filterWord"
	:placeholder="$t('emoji.search_emoji')"
	>
	</div>
	<div class="reaction-picker">
	<span
	v-for="emoji in commonEmojis"
	:key="emoji"
	class="emoji-button"
	@click="addReaction($event, emoji, close)"
	>
	{{ emoji }}
	</span>
	<div class="reaction-picker-divider" />
	<span
	v-for="(emoji, key) in emojis"
	:key="key"
	class="emoji-button"
	@click="addReaction($event, emoji.replacement, close)"
	>
	{{ emoji.replacement }}
	</span>
	<div class="reaction-bottom-fader" />
	</div>
	</div>
	<i
	- v-if="loggedIn"
	slot="trigger"
	class="icon-smile button-icon add-reaction-button"
	:title="$t('tool_tip.add_reaction')"
	/>
	</Popover>
	</template>

	<script src="./react_button.js" ></script>

	<style lang="scss">
	@import '../../_variables.scss';

	.reaction-picker-filter {
	padding: 0.5em;
	display: flex;
	input {
	flex: 1;
	}
	}

	.reaction-picker-divider {
	height: 1px;
	width: 100%;
	margin: 0.5em;
	background-color: var(--border, $fallback--border);
	}

	.reaction-picker {
	width: 10em;
	height: 9em;
	font-size: 1.5em;
	overflow-y: scroll;
	display: flex;
	flex-wrap: wrap;
	padding: 0.5em;
	text-align: center;
	align-content: flex-start;
	user-select: none;

	mask: linear-gradient(to top, white 0, transparent 100%) bottom no-repeat,
	linear-gradient(to bottom, white 0, transparent 100%) top no-repeat,
	linear-gradient(to top, white, white);
	transition: mask-size 150ms;
	mask-size: 100% 20px, 100% 20px, auto;
	// Autoprefixed seem to ignore this one, and also syntax is different
	-webkit-mask-composite: xor;
	mask-composite: exclude;

	.emoji-button {
	cursor: pointer;

	flex-basis: 20%;
	line-height: 1.5em;
	align-content: center;

	&:hover {
	transform: scale(1.25);
	}
	}
	}

	.add-reaction-button {
	cursor: pointer;

	&:hover {
	color: $fallback--text;
	color: var(--text, $fallback--text);
	}
	}

	</style>
	diff --git a/src/components/registration/registration.js b/src/components/registration/registration.js
	index ace8cc7ce8..dab06e1ee4 100644
	--- a/src/components/registration/registration.js
	+++ b/src/components/registration/registration.js
	@@ -1,77 +1,80 @@
	import { validationMixin } from 'vuelidate'
	-import { required, sameAs } from 'vuelidate/lib/validators'
	+import { required, requiredIf, sameAs } from 'vuelidate/lib/validators'
	import { mapActions, mapState } from 'vuex'

	const registration = {
	mixins: [validationMixin],
	data: () => ({
	user: {
	email: '',
	fullname: '',
	username: '',
	password: '',
	confirm: ''
	},
	captcha: {}
	}),
	- validations: {
	- user: {
	- email: { required },
	- username: { required },
	- fullname: { required },
	- password: { required },
	- confirm: {
	- required,
	- sameAsPassword: sameAs('password')
	+ validations () {
	+ return {
	+ user: {
	+ email: { required: requiredIf(() => this.accountActivationRequired) },
	+ username: { required },
	+ fullname: { required },
	+ password: { required },
	+ confirm: {
	+ required,
	+ sameAsPassword: sameAs('password')
	+ }
	}
	}
	},
	created () {
	if ((!this.registrationOpen && !this.token) \|\| this.signedIn) {
	this.$router.push({ name: 'root' })
	}

	this.setCaptcha()
	},
	computed: {
	token () { return this.$route.params.token },
	bioPlaceholder () {
	return this.$t('registration.bio_placeholder').replace(/\s\n\s/g, ' \n')
	},
	...mapState({
	registrationOpen: (state) => state.instance.registrationOpen,
	signedIn: (state) => !!state.users.currentUser,
	isPending: (state) => state.users.signUpPending,
	serverValidationErrors: (state) => state.users.signUpErrors,
	- termsOfService: (state) => state.instance.tos
	+ termsOfService: (state) => state.instance.tos,
	+ accountActivationRequired: (state) => state.instance.accountActivationRequired
	})
	},
	methods: {
	...mapActions(['signUp', 'getCaptcha']),
	async submit () {
	this.user.nickname = this.user.username
	this.user.token = this.token

	this.user.captcha_solution = this.captcha.solution
	this.user.captcha_token = this.captcha.token
	this.user.captcha_answer_data = this.captcha.answer_data

	this.$v.$touch()

	if (!this.$v.$invalid) {
	try {
	await this.signUp(this.user)
	this.$router.push({ name: 'friends' })
	} catch (error) {
	console.warn('Registration failed: ', error)
	this.setCaptcha()
	}
	}
	},
	setCaptcha () {
	this.getCaptcha().then(cpt => { this.captcha = cpt })
	}
	}
	}

	export default registration
	diff --git a/src/components/status/status.js b/src/components/status/status.js
	index 890f4b911d..9cd9d61c6d 100644
	--- a/src/components/status/status.js
	+++ b/src/components/status/status.js
	@@ -1,477 +1,292 @@
	-import Attachment from '../attachment/attachment.vue'
	import FavoriteButton from '../favorite_button/favorite_button.vue'
	import ReactButton from '../react_button/react_button.vue'
	import RetweetButton from '../retweet_button/retweet_button.vue'
	-import Poll from '../poll/poll.vue'
	import ExtraButtons from '../extra_buttons/extra_buttons.vue'
	import PostStatusForm from '../post_status_form/post_status_form.vue'
	import UserCard from '../user_card/user_card.vue'
	import UserAvatar from '../user_avatar/user_avatar.vue'
	-import Gallery from '../gallery/gallery.vue'
	-import LinkPreview from '../link-preview/link-preview.vue'
	import AvatarList from '../avatar_list/avatar_list.vue'
	import Timeago from '../timeago/timeago.vue'
	+import StatusContent from '../status_content/status_content.vue'
	import StatusPopover from '../status_popover/status_popover.vue'
	import EmojiReactions from '../emoji_reactions/emoji_reactions.vue'
	import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'
	-import fileType from 'src/services/file_type/file_type.service'
	-import { processHtml } from 'src/services/tiny_post_html_processor/tiny_post_html_processor.service.js'
	import { highlightClass, highlightStyle } from '../../services/user_highlighter/user_highlighter.js'
	-import { mentionMatchesUrl, extractTagFromUrl } from 'src/services/matcher/matcher.service.js'
	import { filter, unescape, uniqBy } from 'lodash'
	import { mapGetters, mapState } from 'vuex'

	const Status = {
	name: 'Status',
	props: [
	'statusoid',
	'expandable',
	'inConversation',
	'focused',
	'highlight',
	'compact',
	'replies',
	'isPreview',
	'noHeading',
	'inlineExpanded',
	'showPinned',
	'inProfile',
	'profileUserId'
	],
	data () {
	return {
	replying: false,
	unmuted: false,
	userExpanded: false,
	- showingTall: this.inConversation && this.focused,
	- showingLongSubject: false,
	- error: null,
	- // not as computed because it sets the initial state which will be changed later
	- expandingSubject: !this.$store.getters.mergedConfig.collapseMessageWithSubject
	+ error: null
	}
	},
	computed: {
	- localCollapseSubjectDefault () {
	- return this.mergedConfig.collapseMessageWithSubject
	- },
	muteWords () {
	return this.mergedConfig.muteWords
	},
	repeaterClass () {
	const user = this.statusoid.user
	return highlightClass(user)
	},
	userClass () {
	const user = this.retweet ? (this.statusoid.retweeted_status.user) : this.statusoid.user
	return highlightClass(user)
	},
	deleted () {
	return this.statusoid.deleted
	},
	repeaterStyle () {
	const user = this.statusoid.user
	const highlight = this.mergedConfig.highlight
	return highlightStyle(highlight[user.screen_name])
	},
	userStyle () {
	if (this.noHeading) return
	const user = this.retweet ? (this.statusoid.retweeted_status.user) : this.statusoid.user
	const highlight = this.mergedConfig.highlight
	return highlightStyle(highlight[user.screen_name])
	},
	- hideAttachments () {
	- return (this.mergedConfig.hideAttachments && !this.inConversation) \|\|
	- (this.mergedConfig.hideAttachmentsInConv && this.inConversation)
	- },
	userProfileLink () {
	return this.generateUserProfileLink(this.status.user.id, this.status.user.screen_name)
	},
	replyProfileLink () {
	if (this.isReply) {
	return this.generateUserProfileLink(this.status.in_reply_to_user_id, this.replyToName)
	}
	},
	retweet () { return !!this.statusoid.retweeted_status },
	retweeter () { return this.statusoid.user.name \|\| this.statusoid.user.screen_name },
	retweeterHtml () { return this.statusoid.user.name_html },
	retweeterProfileLink () { return this.generateUserProfileLink(this.statusoid.user.id, this.statusoid.user.screen_name) },
	status () {
	if (this.retweet) {
	return this.statusoid.retweeted_status
	} else {
	return this.statusoid
	}
	},
	statusFromGlobalRepository () {
	// NOTE: Consider to replace status with statusFromGlobalRepository
	return this.$store.state.statuses.allStatusesObject[this.status.id]
	},
	loggedIn () {
	return !!this.currentUser
	},
	muteWordHits () {
	const statusText = this.status.text.toLowerCase()
	const statusSummary = this.status.summary.toLowerCase()
	const hits = filter(this.muteWords, (muteWord) => {
	return statusText.includes(muteWord.toLowerCase()) \|\| statusSummary.includes(muteWord.toLowerCase())
	})

	return hits
	},
	muted () {
	const relationship = this.$store.getters.relationship(this.status.user.id)
	return !this.unmuted && (
	(!(this.inProfile && this.status.user.id === this.profileUserId) && relationship.muting) \|\|
	(!this.inConversation && this.status.thread_muted) \|\|
	this.muteWordHits.length > 0)
	},
	hideFilteredStatuses () {
	return this.mergedConfig.hideFilteredStatuses
	},
	hideStatus () {
	return (this.hideReply \|\| this.deleted) \|\| (this.muted && this.hideFilteredStatuses)
	},
	isFocused () {
	// retweet or root of an expanded conversation
	if (this.focused) {
	return true
	} else if (!this.inConversation) {
	return false
	}
	// use conversation highlight only when in conversation
	return this.status.id === this.highlight
	},
	- // This is a bit hacky, but we want to approximate post height before rendering
	- // so we count newlines (masto uses <p> for paragraphs, GS uses <br> between them)
	- // as well as approximate line count by counting characters and approximating ~80
	- // per line.
	- //
	- // Using max-height + overflow: auto for status components resulted in false positives
	- // very often with japanese characters, and it was very annoying.
	- tallStatus () {
	- const lengthScore = this.status.statusnet_html.split(/<p\|<br/).length + this.status.text.length / 80
	- return lengthScore > 20
	- },
	- longSubject () {
	- return this.status.summary.length > 900
	- },
	isReply () {
	return !!(this.status.in_reply_to_status_id && this.status.in_reply_to_user_id)
	},
	replyToName () {
	if (this.status.in_reply_to_screen_name) {
	return this.status.in_reply_to_screen_name
	} else {
	const user = this.$store.getters.findUser(this.status.in_reply_to_user_id)
	return user && user.screen_name
	}
	},
	hideReply () {
	if (this.mergedConfig.replyVisibility === 'all') {
	return false
	}
	if (this.inConversation \|\| !this.isReply) {
	return false
	}
	if (this.status.user.id === this.currentUser.id) {
	return false
	}
	if (this.status.type === 'retweet') {
	return false
	}
	const checkFollowing = this.mergedConfig.replyVisibility === 'following'
	for (var i = 0; i < this.status.attentions.length; ++i) {
	if (this.status.user.id === this.status.attentions[i].id) {
	continue
	}
	// There's zero guarantee of this working. If we happen to have that user and their
	// relationship in store then it will work, but there's kinda little chance of having
	// them for people you're not following.
	const relationship = this.$store.state.users.relationships[this.status.attentions[i].id]
	if (checkFollowing && relationship && relationship.following) {
	return false
	}
	if (this.status.attentions[i].id === this.currentUser.id) {
	return false
	}
	}
	return this.status.attentions.length > 0
	},
	- hideSubjectStatus () {
	- if (this.tallStatus && !this.localCollapseSubjectDefault) {
	- return false
	- }
	- return !this.expandingSubject && this.status.summary
	- },
	- hideTallStatus () {
	- if (this.status.summary && this.localCollapseSubjectDefault) {
	- return false
	- }
	- if (this.showingTall) {
	- return false
	- }
	- return this.tallStatus
	- },
	- showingMore () {
	- return (this.tallStatus && this.showingTall) \|\| (this.status.summary && this.expandingSubject)
	- },
	- nsfwClickthrough () {
	- if (!this.status.nsfw) {
	- return false
	- }
	- if (this.status.summary && this.localCollapseSubjectDefault) {
	- return false
	- }
	- return true
	- },
	replySubject () {
	if (!this.status.summary) return ''
	const decodedSummary = unescape(this.status.summary)
	const behavior = this.mergedConfig.subjectLineBehavior
	const startsWithRe = decodedSummary.match(/^re[: ]/i)
	if ((behavior !== 'noop' && startsWithRe) \|\| behavior === 'masto') {
	return decodedSummary
	} else if (behavior === 'email') {
	return 're: '.concat(decodedSummary)
	} else if (behavior === 'noop') {
	return ''
	}
	},
	- attachmentSize () {
	- if ((this.mergedConfig.hideAttachments && !this.inConversation) \|\|
	- (this.mergedConfig.hideAttachmentsInConv && this.inConversation) \|\|
	- (this.status.attachments.length > this.maxThumbnails)) {
	- return 'hide'
	- } else if (this.compact) {
	- return 'small'
	- }
	- return 'normal'
	- },
	- galleryTypes () {
	- if (this.attachmentSize === 'hide') {
	- return []
	- }
	- return this.mergedConfig.playVideosInModal
	- ? ['image', 'video']
	- : ['image']
	- },
	- galleryAttachments () {
	- return this.status.attachments.filter(
	- file => fileType.fileMatchesSomeType(this.galleryTypes, file)
	- )
	- },
	- nonGalleryAttachments () {
	- return this.status.attachments.filter(
	- file => !fileType.fileMatchesSomeType(this.galleryTypes, file)
	- )
	- },
	- hasImageAttachments () {
	- return this.status.attachments.some(
	- file => fileType.fileType(file.mimetype) === 'image'
	- )
	- },
	- hasVideoAttachments () {
	- return this.status.attachments.some(
	- file => fileType.fileType(file.mimetype) === 'video'
	- )
	- },
	- maxThumbnails () {
	- return this.mergedConfig.maxThumbnails
	- },
	- postBodyHtml () {
	- const html = this.status.statusnet_html
	-
	- if (this.mergedConfig.greentext) {
	- try {
	- if (html.includes('>')) {
	- // This checks if post has '>' at the beginning, excluding mentions so that @mention >impying works
	- return processHtml(html, (string) => {
	- if (string.includes('>') &&
	- string
	- .replace(/<[^>]+?>/gi, '') // remove all tags
	- .replace(/@\w+/gi, '') // remove mentions (even failed ones)
	- .trim()
	- .startsWith('>')) {
	- return `<span class='greentext'>${string}</span>`
	- } else {
	- return string
	- }
	- })
	- } else {
	- return html
	- }
	- } catch (e) {
	- console.err('Failed to process status html', e)
	- return html
	- }
	- } else {
	- return html
	- }
	- },
	- contentHtml () {
	- if (!this.status.summary_html) {
	- return this.postBodyHtml
	- }
	- return this.status.summary_html + '<br />' + this.postBodyHtml
	- },
	combinedFavsAndRepeatsUsers () {
	// Use the status from the global status repository since favs and repeats are saved in it
	const combinedUsers = [].concat(
	this.statusFromGlobalRepository.favoritedBy,
	this.statusFromGlobalRepository.rebloggedBy
	)
	return uniqBy(combinedUsers, 'id')
	},
	- ownStatus () {
	- return this.status.user.id === this.currentUser.id
	- },
	tags () {
	return this.status.tags.filter(tagObj => tagObj.hasOwnProperty('name')).map(tagObj => tagObj.name).join(' ')
	},
	hidePostStats () {
	return this.mergedConfig.hidePostStats
	},
	...mapGetters(['mergedConfig']),
	...mapState({
	betterShadow: state => state.interface.browserSupport.cssFilter,
	currentUser: state => state.users.currentUser
	})
	},
	components: {
	- Attachment,
	FavoriteButton,
	ReactButton,
	RetweetButton,
	ExtraButtons,
	PostStatusForm,
	- Poll,
	UserCard,
	UserAvatar,
	- Gallery,
	- LinkPreview,
	AvatarList,
	Timeago,
	StatusPopover,
	- EmojiReactions
	+ EmojiReactions,
	+ StatusContent
	},
	methods: {
	visibilityIcon (visibility) {
	switch (visibility) {
	case 'private':
	return 'icon-lock'
	case 'unlisted':
	return 'icon-lock-open-alt'
	case 'direct':
	return 'icon-mail-alt'
	default:
	return 'icon-globe'
	}
	},
	showError (error) {
	this.error = error
	},
	clearError () {
	this.error = undefined
	},
	- linkClicked (event) {
	- const target = event.target.closest('.status-content a')
	- if (target) {
	- if (target.className.match(/mention/)) {
	- const href = target.href
	- const attn = this.status.attentions.find(attn => mentionMatchesUrl(attn, href))
	- if (attn) {
	- event.stopPropagation()
	- event.preventDefault()
	- const link = this.generateUserProfileLink(attn.id, attn.screen_name)
	- this.$router.push(link)
	- return
	- }
	- }
	- if (target.rel.match(/(?:^\|\s)tag(?:$\|\s)/) \|\| target.className.match(/hashtag/)) {
	- // Extract tag name from link url
	- const tag = extractTagFromUrl(target.href)
	- if (tag) {
	- const link = this.generateTagLink(tag)
	- this.$router.push(link)
	- return
	- }
	- }
	- window.open(target.href, '_blank')
	- }
	- },
	toggleReplying () {
	this.replying = !this.replying
	},
	gotoOriginal (id) {
	if (this.inConversation) {
	this.$emit('goto', id)
	}
	},
	toggleExpanded () {
	this.$emit('toggleExpanded')
	},
	toggleMute () {
	this.unmuted = !this.unmuted
	},
	toggleUserExpanded () {
	this.userExpanded = !this.userExpanded
	},
	- toggleShowMore () {
	- if (this.showingTall) {
	- this.showingTall = false
	- } else if (this.expandingSubject && this.status.summary) {
	- this.expandingSubject = false
	- } else if (this.hideTallStatus) {
	- this.showingTall = true
	- } else if (this.hideSubjectStatus && this.status.summary) {
	- this.expandingSubject = true
	- }
	- },
	generateUserProfileLink (id, name) {
	return generateProfileLink(id, name, this.$store.state.instance.restrictedNicknames)
	- },
	- generateTagLink (tag) {
	- return `/tag/${tag}`
	- },
	- setMedia () {
	- const attachments = this.attachmentSize === 'hide' ? this.status.attachments : this.galleryAttachments
	- return () => this.$store.dispatch('setMedia', attachments)
	}
	},
	watch: {
	'highlight': function (id) {
	if (this.status.id === id) {
	let rect = this.$el.getBoundingClientRect()
	if (rect.top < 100) {
	// Post is above screen, match its top to screen top
	window.scrollBy(0, rect.top - 100)
	} else if (rect.height >= (window.innerHeight - 50)) {
	// Post we want to see is taller than screen so match its top to screen top
	window.scrollBy(0, rect.top - 100)
	} else if (rect.bottom > window.innerHeight - 50) {
	// Post is below screen, match its bottom to screen bottom
	window.scrollBy(0, rect.bottom - window.innerHeight + 50)
	}
	}
	},
	'status.repeat_num': function (num) {
	// refetch repeats when repeat_num is changed in any way
	if (this.isFocused && this.statusFromGlobalRepository.rebloggedBy && this.statusFromGlobalRepository.rebloggedBy.length !== num) {
	this.$store.dispatch('fetchRepeats', this.status.id)
	}
	},
	'status.fave_num': function (num) {
	// refetch favs when fave_num is changed in any way
	if (this.isFocused && this.statusFromGlobalRepository.favoritedBy && this.statusFromGlobalRepository.favoritedBy.length !== num) {
	this.$store.dispatch('fetchFavs', this.status.id)
	}
	}
	},
	filters: {
	capitalize: function (str) {
	return str.charAt(0).toUpperCase() + str.slice(1)
	}
	}
	}

	export default Status
	diff --git a/src/components/status/status.vue b/src/components/status/status.vue
	index dd7cd57916..e4c7545bbb 100644
	--- a/src/components/status/status.vue
	+++ b/src/components/status/status.vue
	@@ -1,944 +1,726 @@
	<template>
	<!-- eslint-disable vue/no-v-html -->
	<div
	v-if="!hideStatus"
	class="status-el"
	:class="[{ 'status-el_focused': isFocused }, { 'status-conversation': inlineExpanded }]"
	>
	<div
	v-if="error"
	class="alert error"
	>
	{{ error }}
	<i
	class="button-icon icon-cancel"
	@click="clearError"
	/>
	</div>
	<template v-if="muted && !isPreview">
	<div class="media status container muted">
	<small>
	<router-link :to="userProfileLink">
	{{ status.user.screen_name }}
	</router-link>
	</small>
	<small class="muteWords">{{ muteWordHits.join(', ') }}</small>
	<a
	href="#"
	class="unmute"
	@click.prevent="toggleMute"
	><i class="button-icon icon-eye-off" /></a>
	</div>
	</template>
	<template v-else>
	<div
	v-if="showPinned"
	class="status-pin"
	>
	<i class="fa icon-pin faint" />
	<span class="faint">{{ $t('status.pinned') }}</span>
	</div>
	<div
	v-if="retweet && !noHeading && !inConversation"
	:class="[repeaterClass, { highlighted: repeaterStyle }]"
	:style="[repeaterStyle]"
	class="media container retweet-info"
	>
	<UserAvatar
	v-if="retweet"
	class="media-left"
	:better-shadow="betterShadow"
	:user="statusoid.user"
	/>
	<div class="media-body faint">
	<span class="user-name">
	<router-link
	v-if="retweeterHtml"
	:to="retweeterProfileLink"
	v-html="retweeterHtml"
	/>
	<router-link
	v-else
	:to="retweeterProfileLink"
	>{{ retweeter }}</router-link>
	</span>
	<i
	class="fa icon-retweet retweeted"
	:title="$t('tool_tip.repeat')"
	/>
	{{ $t('timeline.repeated') }}
	</div>
	</div>

	<div
	:class="[userClass, { highlighted: userStyle, 'is-retweet': retweet && !inConversation }]"
	:style="[ userStyle ]"
	class="media status"
	:data-tags="tags"
	>
	<div
	v-if="!noHeading"
	class="media-left"
	>
	<router-link
	:to="userProfileLink"
	@click.stop.prevent.capture.native="toggleUserExpanded"
	>
	<UserAvatar
	:compact="compact"
	:better-shadow="betterShadow"
	:user="status.user"
	/>
	</router-link>
	</div>
	<div class="status-body">
	<UserCard
	v-if="userExpanded"
	:user-id="status.user.id"
	:rounded="true"
	:bordered="true"
	class="status-usercard"
	/>
	<div
	v-if="!noHeading"
	class="media-heading"
	>
	<div class="heading-name-row">
	<div class="name-and-account-name">
	<h4
	v-if="status.user.name_html"
	class="user-name"
	v-html="status.user.name_html"
	/>
	<h4
	v-else
	class="user-name"
	>
	{{ status.user.name }}
	</h4>
	<router-link
	class="account-name"
	:to="userProfileLink"
	>
	{{ status.user.screen_name }}
	</router-link>
	</div>

	<span class="heading-right">
	<router-link
	class="timeago faint-link"
	:to="{ name: 'conversation', params: { id: status.id } }"
	>
	<Timeago
	:time="status.created_at"
	:auto-update="60"
	/>
	</router-link>
	<div
	v-if="status.visibility"
	class="button-icon visibility-icon"
	>
	<i
	:class="visibilityIcon(status.visibility)"
	:title="status.visibility \| capitalize"
	/>
	</div>
	<a
	v-if="!status.is_local && !isPreview"
	:href="status.external_url"
	target="_blank"
	class="source_url"
	title="Source"
	>
	<i class="button-icon icon-link-ext-alt" />
	</a>
	<template v-if="expandable && !isPreview">
	<a
	href="#"
	title="Expand"
	@click.prevent="toggleExpanded"
	>
	<i class="button-icon icon-plus-squared" />
	</a>
	</template>
	<a
	v-if="unmuted"
	href="#"
	@click.prevent="toggleMute"
	><i class="button-icon icon-eye-off" /></a>
	</span>
	</div>

	<div class="heading-reply-row">
	<div
	v-if="isReply"
	class="reply-to-and-accountname"
	>
	<StatusPopover
	v-if="!isPreview"
	:status-id="status.in_reply_to_status_id"
	class="reply-to-popover"
	style="min-width: 0"
	>
	<a
	class="reply-to"
	href="#"
	:aria-label="$t('tool_tip.reply')"
	@click.prevent="gotoOriginal(status.in_reply_to_status_id)"
	>
	<i class="button-icon icon-reply" />
	<span class="faint-link reply-to-text">{{ $t('status.reply_to') }}</span>
	</a>
	</StatusPopover>
	<span
	v-else
	class="reply-to"
	>
	<span class="reply-to-text">{{ $t('status.reply_to') }}</span>
	</span>
	<router-link :to="replyProfileLink">
	{{ replyToName }}
	</router-link>
	<span
	v-if="replies && replies.length"
	class="faint replies-separator"
	>
	-
	</span>
	</div>
	<div
	v-if="inConversation && !isPreview && replies && replies.length"
	class="replies"
	>
	<span class="faint">{{ $t('status.replies_list') }}</span>
	<StatusPopover
	v-for="reply in replies"
	:key="reply.id"
	:status-id="reply.id"
	>
	<a
	href="#"
	class="reply-link"
	@click.prevent="gotoOriginal(reply.id)"
	>{{ reply.name }}</a>
	</StatusPopover>
	</div>
	</div>
	</div>

	- <div
	- v-if="longSubject"
	- class="status-content-wrapper"
	- :class="{ 'tall-status': !showingLongSubject }"
	- >
	- <a
	- v-if="!showingLongSubject"
	- class="tall-status-hider"
	- :class="{ 'tall-status-hider_focused': isFocused }"
	- href="#"
	- @click.prevent="showingLongSubject=true"
	- >{{ $t("general.show_more") }}</a>
	- <div
	- class="status-content media-body"
	- @click.prevent="linkClicked"
	- v-html="contentHtml"
	- />
	- <a
	- v-if="showingLongSubject"
	- href="#"
	- class="status-unhider"
	- @click.prevent="showingLongSubject=false"
	- >{{ $t("general.show_less") }}</a>
	- </div>
	- <div
	- v-else
	- :class="{'tall-status': hideTallStatus}"
	- class="status-content-wrapper"
	- >
	- <a
	- v-if="hideTallStatus"
	- class="tall-status-hider"
	- :class="{ 'tall-status-hider_focused': isFocused }"
	- href="#"
	- @click.prevent="toggleShowMore"
	- >{{ $t("general.show_more") }}</a>
	- <div
	- v-if="!hideSubjectStatus"
	- class="status-content media-body"
	- @click.prevent="linkClicked"
	- v-html="contentHtml"
	- />
	- <div
	- v-else
	- class="status-content media-body"
	- @click.prevent="linkClicked"
	- v-html="status.summary_html"
	- />
	- <a
	- v-if="hideSubjectStatus"
	- href="#"
	- class="cw-status-hider"
	- @click.prevent="toggleShowMore"
	- >
	- {{ $t("general.show_more") }}
	- <span
	- v-if="hasImageAttachments"
	- class="icon-picture"
	- />
	- <span
	- v-if="hasVideoAttachments"
	- class="icon-video"
	- />
	- <span
	- v-if="status.card"
	- class="icon-link"
	- />
	- </a>
	- <a
	- v-if="showingMore"
	- href="#"
	- class="status-unhider"
	- @click.prevent="toggleShowMore"
	- >{{ $t("general.show_less") }}</a>
	- </div>
	-
	- <div v-if="status.poll && status.poll.options">
	- <poll :base-poll="status.poll" />
	- </div>
	-
	- <div
	- v-if="status.attachments && (!hideSubjectStatus \|\| showingLongSubject)"
	- class="attachments media-body"
	- >
	- <attachment
	- v-for="attachment in nonGalleryAttachments"
	- :key="attachment.id"
	- class="non-gallery"
	- :size="attachmentSize"
	- :nsfw="nsfwClickthrough"
	- :attachment="attachment"
	- :allow-play="true"
	- :set-media="setMedia()"
	- />
	- <gallery
	- v-if="galleryAttachments.length > 0"
	- :nsfw="nsfwClickthrough"
	- :attachments="galleryAttachments"
	- :set-media="setMedia()"
	- />
	- </div>
	-
	- <div
	- v-if="status.card && !hideSubjectStatus && !noHeading"
	- class="link-preview media-body"
	- >
	- <link-preview
	- :card="status.card"
	- :size="attachmentSize"
	- :nsfw="nsfwClickthrough"
	- />
	- </div>
	+ <StatusContent
	+ :status="status"
	+ :no-heading="noHeading"
	+ :highlight="highlight"
	+ :focused="isFocused"
	+ />

	<transition name="fade">
	<div
	v-if="!hidePostStats && isFocused && combinedFavsAndRepeatsUsers.length > 0"
	class="favs-repeated-users"
	>
	<div class="stats">
	<div
	v-if="statusFromGlobalRepository.rebloggedBy && statusFromGlobalRepository.rebloggedBy.length > 0"
	class="stat-count"
	>
	<a class="stat-title">{{ $t('status.repeats') }}</a>
	<div class="stat-number">
	{{ statusFromGlobalRepository.rebloggedBy.length }}
	</div>
	</div>
	<div
	v-if="statusFromGlobalRepository.favoritedBy && statusFromGlobalRepository.favoritedBy.length > 0"
	class="stat-count"
	>
	<a class="stat-title">{{ $t('status.favorites') }}</a>
	<div class="stat-number">
	{{ statusFromGlobalRepository.favoritedBy.length }}
	</div>
	</div>
	<div class="avatar-row">
	<AvatarList :users="combinedFavsAndRepeatsUsers" />
	</div>
	</div>
	</div>
	</transition>

	<EmojiReactions
	v-if="(mergedConfig.emojiReactionsOnTimeline \|\| isFocused) && (!noHeading && !isPreview)"
	:status="status"
	/>

	<div
	v-if="!noHeading && !isPreview"
	class="status-actions media-body"
	>
	<div>
	<i
	v-if="loggedIn"
	class="button-icon icon-reply"
	:title="$t('tool_tip.reply')"
	:class="{'button-icon-active': replying}"
	@click.prevent="toggleReplying"
	/>
	<i
	v-else
	class="button-icon button-icon-disabled icon-reply"
	:title="$t('tool_tip.reply')"
	/>
	<span v-if="status.replies_count > 0">{{ status.replies_count }}</span>
	</div>
	<retweet-button
	:visibility="status.visibility"
	:logged-in="loggedIn"
	:status="status"
	/>
	<favorite-button
	:logged-in="loggedIn"
	:status="status"
	/>
	<ReactButton
	- :logged-in="loggedIn"
	+ v-if="loggedIn"
	:status="status"
	/>
	<extra-buttons
	:status="status"
	@onError="showError"
	@onSuccess="clearError"
	/>
	</div>
	</div>
	</div>
	<div
	v-if="replying"
	class="container"
	>
	<PostStatusForm
	class="reply-body"
	:reply-to="status.id"
	:attentions="status.attentions"
	:replied-user="status.user"
	:copy-message-scope="status.visibility"
	:subject="replySubject"
	@posted="toggleReplying"
	/>
	</div>
	</template>
	</div>
	<!-- eslint-enable vue/no-v-html -->
	</template>

	<script src="./status.js" ></script>
	<style lang="scss">
	@import '../../_variables.scss';

	$status-margin: 0.75em;

	.status-body {
	flex: 1;
	min-width: 0;
	}

	.status-pin {
	padding: $status-margin $status-margin 0;
	display: flex;
	align-items: center;
	justify-content: flex-end;
	}

	.media-left {
	margin-right: $status-margin;
	}

	.status-el {
	overflow-wrap: break-word;
	word-wrap: break-word;
	word-break: break-word;
	border-left-width: 0px;
	min-width: 0;
	border-color: $fallback--border;
	border-color: var(--border, $fallback--border);

	border-left: 4px $fallback--cRed;
	border-left: 4px var(--cRed, $fallback--cRed);

	&_focused {
	background-color: $fallback--lightBg;
	background-color: var(--selectedPost, $fallback--lightBg);
	color: $fallback--text;
	color: var(--selectedPostText, $fallback--text);
	--lightText: var(--selectedPostLightText, $fallback--light);
	--faint: var(--selectedPostFaintText, $fallback--faint);
	--faintLink: var(--selectedPostFaintLink, $fallback--faint);
	--postLink: var(--selectedPostPostLink, $fallback--faint);
	--postFaintLink: var(--selectedPostFaintPostLink, $fallback--faint);
	--icon: var(--selectedPostIcon, $fallback--icon);
	}

	.timeline & {
	border-bottom-width: 1px;
	border-bottom-style: solid;
	}

	.media-body {
	flex: 1;
	padding: 0;
	}

	.status-usercard {
	margin-bottom: $status-margin;
	}

	.user-name {
	white-space: nowrap;
	font-size: 14px;
	overflow: hidden;
	flex-shrink: 0;
	max-width: 85%;
	font-weight: bold;

	img {
	width: 14px;
	height: 14px;
	vertical-align: middle;
	object-fit: contain
	}
	}

	.media-heading {
	padding: 0;
	vertical-align: bottom;
	flex-basis: 100%;
	margin-bottom: 0.5em;

	small {
	font-weight: lighter;
	}

	.heading-name-row {
	padding: 0;
	display: flex;
	justify-content: space-between;
	line-height: 18px;

	a {
	display: inline-block;
	word-break: break-all;
	}

	.name-and-account-name {
	display: flex;
	min-width: 0;
	}

	.user-name {
	flex-shrink: 1;
	margin-right: 0.4em;
	overflow: hidden;
	text-overflow: ellipsis;
	}

	.account-name {
	min-width: 1.6em;
	margin-right: 0.4em;
	white-space: nowrap;
	overflow: hidden;
	text-overflow: ellipsis;
	flex: 1 1 0;
	}
	}

	.heading-right {
	display: flex;
	flex-shrink: 0;
	}

	.timeago {
	margin-right: 0.2em;
	}

	.heading-reply-row {
	position: relative;
	align-content: baseline;
	font-size: 12px;
	line-height: 18px;
	max-width: 100%;
	display: flex;
	flex-wrap: wrap;
	align-items: stretch;

	> .reply-to-and-accountname > a {
	overflow: hidden;
	max-width: 100%;
	text-overflow: ellipsis;
	white-space: nowrap;
	word-break: break-all;
	}
	}

	.reply-to-and-accountname {
	display: flex;
	height: 18px;
	margin-right: 0.5em;
	max-width: 100%;
	.icon-reply {
	transform: scaleX(-1);
	}
	}

	.reply-info {
	display: flex;
	}

	.reply-to-popover {
	min-width: 0;
	}

	.reply-to {
	display: flex;
	}

	.reply-to-text {
	overflow: hidden;
	text-overflow: ellipsis;
	white-space: nowrap;
	margin: 0 0.4em 0 0.2em;
	}

	.replies-separator {
	margin-left: 0.4em;
	}

	.replies {
	line-height: 18px;
	font-size: 12px;
	display: flex;
	flex-wrap: wrap;
	& > * {
	margin-right: 0.4em;
	}
	}

	.reply-link {
	height: 17px;
	}
	}

	- .tall-status {
	- position: relative;
	- height: 220px;
	- overflow-x: hidden;
	- overflow-y: hidden;
	- z-index: 1;
	- .status-content {
	- height: 100%;
	- mask: linear-gradient(to top, white, transparent) bottom/100% 70px no-repeat,
	- linear-gradient(to top, white, white);
	- /* Autoprefixed seem to ignore this one, and also syntax is different */
	- -webkit-mask-composite: xor;
	- mask-composite: exclude;
	- }
	- }
	-
	- .tall-status-hider {
	- display: inline-block;
	- word-break: break-all;
	- position: absolute;
	- height: 70px;
	- margin-top: 150px;
	- width: 100%;
	- text-align: center;
	- line-height: 110px;
	- z-index: 2;
	- }
	-
	- .status-unhider, .cw-status-hider {
	- width: 100%;
	- text-align: center;
	- display: inline-block;
	- word-break: break-all;
	- }
	-
	- .status-content {
	- font-family: var(--postFont, sans-serif);
	- line-height: 1.4em;
	- white-space: pre-wrap;
	-
	- a {
	- color: $fallback--link;
	- color: var(--postLink, $fallback--link);
	- }
	-
	- img, video {
	- max-width: 100%;
	- max-height: 400px;
	- vertical-align: middle;
	- object-fit: contain;
	-
	- &.emoji {
	- width: 32px;
	- height: 32px;
	- }
	- }
	-
	- blockquote {
	- margin: 0.2em 0 0.2em 2em;
	- font-style: italic;
	- }
	-
	- pre {
	- overflow: auto;
	- }
	-
	- code, samp, kbd, var, pre {
	- font-family: var(--postCodeFont, monospace);
	- }
	-
	- p {
	- margin: 0 0 1em 0;
	- }
	-
	- p:last-child {
	- margin: 0 0 0 0;
	- }
	-
	- h1 {
	- font-size: 1.1em;
	- line-height: 1.2em;
	- margin: 1.4em 0;
	- }
	-
	- h2 {
	- font-size: 1.1em;
	- margin: 1.0em 0;
	- }
	-
	- h3 {
	- font-size: 1em;
	- margin: 1.2em 0;
	- }
	-
	- h4 {
	- margin: 1.1em 0;
	- }
	- }
	-
	.retweet-info {
	padding: 0.4em $status-margin;
	margin: 0;

	.avatar.still-image {
	border-radius: $fallback--avatarAltRadius;
	border-radius: var(--avatarAltRadius, $fallback--avatarAltRadius);
	margin-left: 28px;
	width: 20px;
	height: 20px;
	}

	.media-body {
	font-size: 1em;
	line-height: 22px;

	display: flex;
	align-content: center;
	flex-wrap: wrap;

	.user-name {
	font-weight: bold;
	overflow: hidden;
	text-overflow: ellipsis;

	img {
	width: 14px;
	height: 14px;
	vertical-align: middle;
	object-fit: contain
	}
	}

	i {
	padding: 0 0.2em;
	}

	a {
	max-width: 100%;
	overflow: hidden;
	text-overflow: ellipsis;
	white-space: nowrap;
	}
	}
	}
	}

	.status-fadein {
	animation-duration: 0.4s;
	animation-name: fadein;
	}

	@keyframes fadein {
	from {
	opacity: 0;
	}
	to {
	opacity: 1;
	}
	}

	-.greentext {
	- color: $fallback--cGreen;
	- color: var(--cGreen, $fallback--cGreen);
	-}
	-
	.status-conversation {
	border-left-style: solid;
	}

	.status-actions {
	position: relative;
	width: 100%;
	display: flex;
	margin-top: $status-margin;

	> * {
	max-width: 4em;
	flex: 1;
	}
	}

	.button-icon.icon-reply {
	&:not(.button-icon-disabled):hover,
	&.button-icon-active {
	color: $fallback--cBlue;
	color: var(--cBlue, $fallback--cBlue);
	}
	}

	.button-icon.icon-reply {
	&:not(.button-icon-disabled) {
	cursor: pointer;
	}
	}

	.status:hover .animated.avatar {
	canvas {
	display: none;
	}
	img {
	visibility: visible;
	}
	}

	.status {
	display: flex;
	padding: $status-margin;
	&.is-retweet {
	padding-top: 0;
	}
	}

	.status-conversation:last-child {
	border-bottom: none;
	}

	.muted {
	padding: 0.25em 0.5em;
	button {
	margin-left: auto;
	}

	.muteWords {
	margin-left: 10px;
	}
	}

	a.unmute {
	display: block;
	margin-left: auto;
	}

	.reply-body {
	flex: 1;
	}

	-.timeline :not(.panel-disabled) > {
	- .status-el:last-child {
	- border-radius: 0 0 $fallback--panelRadius $fallback--panelRadius;
	- border-radius: 0 0 var(--panelRadius, $fallback--panelRadius) var(--panelRadius, $fallback--panelRadius);
	- border-bottom: none;
	- }
	-}
	-
	.favs-repeated-users {
	margin-top: $status-margin;

	.stats {
	width: 100%;
	display: flex;
	line-height: 1em;

	.stat-count {
	margin-right: $status-margin;

	.stat-title {
	color: var(--faint, $fallback--faint);
	font-size: 12px;
	text-transform: uppercase;
	position: relative;
	}

	.stat-number {
	font-weight: bolder;
	font-size: 16px;
	line-height: 1em;
	}
	}

	.avatar-row {
	flex: 1;
	overflow: hidden;
	position: relative;
	display: flex;
	align-items: center;

	&::before {
	content: '';
	position: absolute;
	height: 100%;
	width: 1px;
	left: 0;
	background-color: var(--faint, $fallback--faint);
	}
	}
	}
	}

	@media all and (max-width: 800px) {
	.status-el {
	.retweet-info {
	.avatar.still-image {
	margin-left: 20px;
	}
	}
	}
	.status {
	max-width: 100%;
	}

	.status .avatar.still-image {
	width: 40px;
	height: 40px;

	&.avatar-compact {
	width: 32px;
	height: 32px;
	}
	}
	}

	</style>
	diff --git a/src/components/status_content/status_content.js b/src/components/status_content/status_content.js
	new file mode 100644
	index 0000000000..ccc01b6f96
	--- /dev/null
	+++ b/src/components/status_content/status_content.js
	@@ -0,0 +1,210 @@
	+import Attachment from '../attachment/attachment.vue'
	+import Poll from '../poll/poll.vue'
	+import Gallery from '../gallery/gallery.vue'
	+import LinkPreview from '../link-preview/link-preview.vue'
	+import generateProfileLink from 'src/services/user_profile_link_generator/user_profile_link_generator'
	+import fileType from 'src/services/file_type/file_type.service'
	+import { processHtml } from 'src/services/tiny_post_html_processor/tiny_post_html_processor.service.js'
	+import { mentionMatchesUrl, extractTagFromUrl } from 'src/services/matcher/matcher.service.js'
	+import { mapGetters, mapState } from 'vuex'
	+
	+const StatusContent = {
	+ name: 'StatusContent',
	+ props: [
	+ 'status',
	+ 'focused',
	+ 'noHeading',
	+ 'fullContent'
	+ ],
	+ data () {
	+ return {
	+ showingTall: this.inConversation && this.focused,
	+ showingLongSubject: false,
	+ // not as computed because it sets the initial state which will be changed later
	+ expandingSubject: !this.$store.getters.mergedConfig.collapseMessageWithSubject
	+ }
	+ },
	+ computed: {
	+ localCollapseSubjectDefault () {
	+ return this.mergedConfig.collapseMessageWithSubject
	+ },
	+ hideAttachments () {
	+ return (this.mergedConfig.hideAttachments && !this.inConversation) \|\|
	+ (this.mergedConfig.hideAttachmentsInConv && this.inConversation)
	+ },
	+ // This is a bit hacky, but we want to approximate post height before rendering
	+ // so we count newlines (masto uses <p> for paragraphs, GS uses <br> between them)
	+ // as well as approximate line count by counting characters and approximating ~80
	+ // per line.
	+ //
	+ // Using max-height + overflow: auto for status components resulted in false positives
	+ // very often with japanese characters, and it was very annoying.
	+ tallStatus () {
	+ const lengthScore = this.status.statusnet_html.split(/<p\|<br/).length + this.status.text.length / 80
	+ return lengthScore > 20
	+ },
	+ longSubject () {
	+ return this.status.summary.length > 900
	+ },
	+ // When a status has a subject and is also tall, we should only have one show more/less button. If the default is to collapse statuses with subjects, we just treat it like a status with a subject; otherwise, we just treat it like a tall status.
	+ mightHideBecauseSubject () {
	+ return this.status.summary && (!this.tallStatus \|\| this.localCollapseSubjectDefault)
	+ },
	+ mightHideBecauseTall () {
	+ return this.tallStatus && (!this.status.summary \|\| !this.localCollapseSubjectDefault)
	+ },
	+ hideSubjectStatus () {
	+ return this.mightHideBecauseSubject && !this.expandingSubject
	+ },
	+ hideTallStatus () {
	+ return this.mightHideBecauseTall && !this.showingTall
	+ },
	+ showingMore () {
	+ return (this.mightHideBecauseTall && this.showingTall) \|\| (this.mightHideBecauseSubject && this.expandingSubject)
	+ },
	+ nsfwClickthrough () {
	+ if (!this.status.nsfw) {
	+ return false
	+ }
	+ if (this.status.summary && this.localCollapseSubjectDefault) {
	+ return false
	+ }
	+ return true
	+ },
	+ attachmentSize () {
	+ if ((this.mergedConfig.hideAttachments && !this.inConversation) \|\|
	+ (this.mergedConfig.hideAttachmentsInConv && this.inConversation) \|\|
	+ (this.status.attachments.length > this.maxThumbnails)) {
	+ return 'hide'
	+ } else if (this.compact) {
	+ return 'small'
	+ }
	+ return 'normal'
	+ },
	+ galleryTypes () {
	+ if (this.attachmentSize === 'hide') {
	+ return []
	+ }
	+ return this.mergedConfig.playVideosInModal
	+ ? ['image', 'video']
	+ : ['image']
	+ },
	+ galleryAttachments () {
	+ return this.status.attachments.filter(
	+ file => fileType.fileMatchesSomeType(this.galleryTypes, file)
	+ )
	+ },
	+ nonGalleryAttachments () {
	+ return this.status.attachments.filter(
	+ file => !fileType.fileMatchesSomeType(this.galleryTypes, file)
	+ )
	+ },
	+ hasImageAttachments () {
	+ return this.status.attachments.some(
	+ file => fileType.fileType(file.mimetype) === 'image'
	+ )
	+ },
	+ hasVideoAttachments () {
	+ return this.status.attachments.some(
	+ file => fileType.fileType(file.mimetype) === 'video'
	+ )
	+ },
	+ maxThumbnails () {
	+ return this.mergedConfig.maxThumbnails
	+ },
	+ postBodyHtml () {
	+ const html = this.status.statusnet_html
	+
	+ if (this.mergedConfig.greentext) {
	+ try {
	+ if (html.includes('>')) {
	+ // This checks if post has '>' at the beginning, excluding mentions so that @mention >impying works
	+ return processHtml(html, (string) => {
	+ if (string.includes('>') &&
	+ string
	+ .replace(/<[^>]+?>/gi, '') // remove all tags
	+ .replace(/@\w+/gi, '') // remove mentions (even failed ones)
	+ .trim()
	+ .startsWith('>')) {
	+ return `<span class='greentext'>${string}</span>`
	+ } else {
	+ return string
	+ }
	+ })
	+ } else {
	+ return html
	+ }
	+ } catch (e) {
	+ console.err('Failed to process status html', e)
	+ return html
	+ }
	+ } else {
	+ return html
	+ }
	+ },
	+ contentHtml () {
	+ if (!this.status.summary_html) {
	+ return this.postBodyHtml
	+ }
	+ return this.status.summary_html + '<br />' + this.postBodyHtml
	+ },
	+ ...mapGetters(['mergedConfig']),
	+ ...mapState({
	+ betterShadow: state => state.interface.browserSupport.cssFilter,
	+ currentUser: state => state.users.currentUser
	+ })
	+ },
	+ components: {
	+ Attachment,
	+ Poll,
	+ Gallery,
	+ LinkPreview
	+ },
	+ methods: {
	+ linkClicked (event) {
	+ const target = event.target.closest('.status-content a')
	+ if (target) {
	+ if (target.className.match(/mention/)) {
	+ const href = target.href
	+ const attn = this.status.attentions.find(attn => mentionMatchesUrl(attn, href))
	+ if (attn) {
	+ event.stopPropagation()
	+ event.preventDefault()
	+ const link = this.generateUserProfileLink(attn.id, attn.screen_name)
	+ this.$router.push(link)
	+ return
	+ }
	+ }
	+ if (target.rel.match(/(?:^\|\s)tag(?:$\|\s)/) \|\| target.className.match(/hashtag/)) {
	+ // Extract tag name from link url
	+ const tag = extractTagFromUrl(target.href)
	+ if (tag) {
	+ const link = this.generateTagLink(tag)
	+ this.$router.push(link)
	+ return
	+ }
	+ }
	+ window.open(target.href, '_blank')
	+ }
	+ },
	+ toggleShowMore () {
	+ if (this.mightHideBecauseTall) {
	+ this.showingTall = !this.showingTall
	+ } else if (this.mightHideBecauseSubject) {
	+ this.expandingSubject = !this.expandingSubject
	+ }
	+ },
	+ generateUserProfileLink (id, name) {
	+ return generateProfileLink(id, name, this.$store.state.instance.restrictedNicknames)
	+ },
	+ generateTagLink (tag) {
	+ return `/tag/${tag}`
	+ },
	+ setMedia () {
	+ const attachments = this.attachmentSize === 'hide' ? this.status.attachments : this.galleryAttachments
	+ return () => this.$store.dispatch('setMedia', attachments)
	+ }
	+ }
	+}
	+
	+export default StatusContent
	diff --git a/src/components/status_content/status_content.vue b/src/components/status_content/status_content.vue
	new file mode 100644
	index 0000000000..8c2e87498f
	--- /dev/null
	+++ b/src/components/status_content/status_content.vue
	@@ -0,0 +1,240 @@
	+<template>
	+ <!-- eslint-disable vue/no-v-html -->
	+ <div class="status-body">
	+ <slot name="header" />
	+ <div
	+ v-if="longSubject"
	+ class="status-content-wrapper"
	+ :class="{ 'tall-status': !showingLongSubject }"
	+ >
	+ <a
	+ v-if="!showingLongSubject"
	+ class="tall-status-hider"
	+ :class="{ 'tall-status-hider_focused': focused }"
	+ href="#"
	+ @click.prevent="showingLongSubject=true"
	+ >
	+ {{ $t("general.show_more") }}
	+ <span
	+ v-if="hasImageAttachments"
	+ class="icon-picture"
	+ />
	+ <span
	+ v-if="hasVideoAttachments"
	+ class="icon-video"
	+ />
	+ <span
	+ v-if="status.card"
	+ class="icon-link"
	+ />
	+ </a>
	+ <div
	+ class="status-content media-body"
	+ @click.prevent="linkClicked"
	+ v-html="contentHtml"
	+ />
	+ <a
	+ v-if="showingLongSubject"
	+ href="#"
	+ class="status-unhider"
	+ @click.prevent="showingLongSubject=false"
	+ >{{ $t("general.show_less") }}</a>
	+ </div>
	+ <div
	+ v-else
	+ :class="{'tall-status': hideTallStatus}"
	+ class="status-content-wrapper"
	+ >
	+ <a
	+ v-if="hideTallStatus"
	+ class="tall-status-hider"
	+ :class="{ 'tall-status-hider_focused': focused }"
	+ href="#"
	+ @click.prevent="toggleShowMore"
	+ >{{ $t("general.show_more") }}</a>
	+ <div
	+ v-if="!hideSubjectStatus"
	+ class="status-content media-body"
	+ @click.prevent="linkClicked"
	+ v-html="contentHtml"
	+ />
	+ <div
	+ v-else
	+ class="status-content media-body"
	+ @click.prevent="linkClicked"
	+ v-html="status.summary_html"
	+ />
	+ <a
	+ v-if="hideSubjectStatus"
	+ href="#"
	+ class="cw-status-hider"
	+ @click.prevent="toggleShowMore"
	+ >{{ $t("general.show_more") }}</a>
	+ <a
	+ v-if="showingMore"
	+ href="#"
	+ class="status-unhider"
	+ @click.prevent="toggleShowMore"
	+ >{{ $t("general.show_less") }}</a>
	+ </div>
	+
	+ <div v-if="status.poll && status.poll.options">
	+ <poll :base-poll="status.poll" />
	+ </div>
	+
	+ <div
	+ v-if="status.attachments.length !== 0 && (!hideSubjectStatus \|\| showingLongSubject)"
	+ class="attachments media-body"
	+ >
	+ <attachment
	+ v-for="attachment in nonGalleryAttachments"
	+ :key="attachment.id"
	+ class="non-gallery"
	+ :size="attachmentSize"
	+ :nsfw="nsfwClickthrough"
	+ :attachment="attachment"
	+ :allow-play="true"
	+ :set-media="setMedia()"
	+ />
	+ <gallery
	+ v-if="galleryAttachments.length > 0"
	+ :nsfw="nsfwClickthrough"
	+ :attachments="galleryAttachments"
	+ :set-media="setMedia()"
	+ />
	+ </div>
	+
	+ <div
	+ v-if="status.card && !hideSubjectStatus && !noHeading"
	+ class="link-preview media-body"
	+ >
	+ <link-preview
	+ :card="status.card"
	+ :size="attachmentSize"
	+ :nsfw="nsfwClickthrough"
	+ />
	+ </div>
	+ <slot name="footer" />
	+ </div>
	+ <!-- eslint-enable vue/no-v-html -->
	+</template>
	+
	+<script src="./status_content.js" ></script>
	+<style lang="scss">
	+@import '../../_variables.scss';
	+
	+$status-margin: 0.75em;
	+
	+.status-body {
	+ flex: 1;
	+ min-width: 0;
	+
	+ .tall-status {
	+ position: relative;
	+ height: 220px;
	+ overflow-x: hidden;
	+ overflow-y: hidden;
	+ z-index: 1;
	+ .status-content {
	+ height: 100%;
	+ mask: linear-gradient(to top, white, transparent) bottom/100% 70px no-repeat,
	+ linear-gradient(to top, white, white);
	+ /* Autoprefixed seem to ignore this one, and also syntax is different */
	+ -webkit-mask-composite: xor;
	+ mask-composite: exclude;
	+ }
	+ }
	+
	+ .tall-status-hider {
	+ display: inline-block;
	+ word-break: break-all;
	+ position: absolute;
	+ height: 70px;
	+ margin-top: 150px;
	+ width: 100%;
	+ text-align: center;
	+ line-height: 110px;
	+ z-index: 2;
	+ }
	+
	+ .status-unhider, .cw-status-hider {
	+ width: 100%;
	+ text-align: center;
	+ display: inline-block;
	+ word-break: break-all;
	+ }
	+
	+ .status-content {
	+ font-family: var(--postFont, sans-serif);
	+ line-height: 1.4em;
	+ white-space: pre-wrap;
	+
	+ img, video {
	+ max-width: 100%;
	+ max-height: 400px;
	+ vertical-align: middle;
	+ object-fit: contain;
	+
	+ &.emoji {
	+ width: 32px;
	+ height: 32px;
	+ }
	+ }
	+
	+ blockquote {
	+ margin: 0.2em 0 0.2em 2em;
	+ font-style: italic;
	+ }
	+
	+ pre {
	+ overflow: auto;
	+ }
	+
	+ code, samp, kbd, var, pre {
	+ font-family: var(--postCodeFont, monospace);
	+ }
	+
	+ p {
	+ margin: 0 0 1em 0;
	+ }
	+
	+ p:last-child {
	+ margin: 0 0 0 0;
	+ }
	+
	+ h1 {
	+ font-size: 1.1em;
	+ line-height: 1.2em;
	+ margin: 1.4em 0;
	+ }
	+
	+ h2 {
	+ font-size: 1.1em;
	+ margin: 1.0em 0;
	+ }
	+
	+ h3 {
	+ font-size: 1em;
	+ margin: 1.2em 0;
	+ }
	+
	+ h4 {
	+ margin: 1.1em 0;
	+ }
	+ }
	+}
	+
	+.greentext {
	+ color: $fallback--cGreen;
	+ color: var(--cGreen, $fallback--cGreen);
	+}
	+
	+.timeline :not(.panel-disabled) > {
	+ .status-el:last-child {
	+ border-radius: 0 0 $fallback--panelRadius $fallback--panelRadius;
	+ border-radius: 0 0 var(--panelRadius, $fallback--panelRadius) var(--panelRadius, $fallback--panelRadius);
	+ border-bottom: none;
	+ }
	+}
	+
	+</style>
	diff --git a/src/components/user_settings/user_settings.vue b/src/components/user_settings/user_settings.vue
	index 8b2336b4dd..ad184520a1 100644
	--- a/src/components/user_settings/user_settings.vue
	+++ b/src/components/user_settings/user_settings.vue
	@@ -1,716 +1,728 @@
	<template>
	<div class="settings panel panel-default">
	<div class="panel-heading">
	<div class="title">
	{{ $t('settings.user_settings') }}
	</div>
	<transition name="fade">
	<template v-if="currentSaveStateNotice">
	<div
	v-if="currentSaveStateNotice.error"
	class="alert error"
	@click.prevent
	>
	{{ $t('settings.saving_err') }}
	</div>

	<div
	v-if="!currentSaveStateNotice.error"
	class="alert transparent"
	@click.prevent
	>
	{{ $t('settings.saving_ok') }}
	</div>
	</template>
	</transition>
	</div>
	<div class="panel-body profile-edit">
	<tab-switcher>
	<div :label="$t('settings.profile_tab')">
	<div class="setting-item">
	<h2>{{ $t('settings.name_bio') }}</h2>
	<p>{{ $t('settings.name') }}</p>
	<EmojiInput
	v-model="newName"
	enable-emoji-picker
	:suggest="emojiSuggestor"
	>
	<input
	id="username"
	v-model="newName"
	classname="name-changer"
	>
	</EmojiInput>
	<p>{{ $t('settings.bio') }}</p>
	<EmojiInput
	v-model="newBio"
	enable-emoji-picker
	:suggest="emojiUserSuggestor"
	>
	<textarea
	v-model="newBio"
	classname="bio"
	/>
	</EmojiInput>
	<p>
	<Checkbox v-model="newLocked">
	{{ $t('settings.lock_account_description') }}
	</Checkbox>
	</p>
	<div>
	<label for="default-vis">{{ $t('settings.default_vis') }}</label>
	<div
	id="default-vis"
	class="visibility-tray"
	>
	<scope-selector
	:show-all="true"
	:user-default="newDefaultScope"
	:initial-scope="newDefaultScope"
	:on-scope-change="changeVis"
	/>
	</div>
	</div>
	<p>
	<Checkbox v-model="newNoRichText">
	{{ $t('settings.no_rich_text_description') }}
	</Checkbox>
	</p>
	<p>
	<Checkbox v-model="hideFollows">
	{{ $t('settings.hide_follows_description') }}
	</Checkbox>
	</p>
	<p class="setting-subitem">
	<Checkbox
	v-model="hideFollowsCount"
	:disabled="!hideFollows"
	>
	{{ $t('settings.hide_follows_count_description') }}
	</Checkbox>
	</p>
	<p>
	<Checkbox v-model="hideFollowers">
	{{ $t('settings.hide_followers_description') }}
	</Checkbox>
	</p>
	<p class="setting-subitem">
	<Checkbox
	v-model="hideFollowersCount"
	:disabled="!hideFollowers"
	>
	{{ $t('settings.hide_followers_count_description') }}
	</Checkbox>
	</p>
	<p>
	<Checkbox v-model="allowFollowingMove">
	{{ $t('settings.allow_following_move') }}
	</Checkbox>
	</p>
	<p v-if="role === 'admin' \|\| role === 'moderator'">
	<Checkbox v-model="showRole">
	<template v-if="role === 'admin'">
	{{ $t('settings.show_admin_badge') }}
	</template>
	<template v-if="role === 'moderator'">
	{{ $t('settings.show_moderator_badge') }}
	</template>
	</Checkbox>
	</p>
	<p>
	<Checkbox v-model="discoverable">
	{{ $t('settings.discoverable') }}
	</Checkbox>
	</p>
	<button
	:disabled="newName && newName.length === 0"
	class="btn btn-default"
	@click="updateProfile"
	>
	{{ $t('general.submit') }}
	</button>
	</div>
	<div class="setting-item">
	<h2>{{ $t('settings.avatar') }}</h2>
	<p class="visibility-notice">
	{{ $t('settings.avatar_size_instruction') }}
	</p>
	<p>{{ $t('settings.current_avatar') }}</p>
	<img
	:src="user.profile_image_url_original"
	class="current-avatar"
	>
	<p>{{ $t('settings.set_new_avatar') }}</p>
	<button
	v-show="pickAvatarBtnVisible"
	id="pick-avatar"
	class="btn"
	type="button"
	>
	{{ $t('settings.upload_a_photo') }}
	</button>
	<image-cropper
	trigger="#pick-avatar"
	:submit-handler="submitAvatar"
	@open="pickAvatarBtnVisible=false"
	@close="pickAvatarBtnVisible=true"
	/>
	</div>
	<div class="setting-item">
	<h2>{{ $t('settings.profile_banner') }}</h2>
	<p>{{ $t('settings.current_profile_banner') }}</p>
	<img
	:src="user.cover_photo"
	class="banner"
	>
	<p>{{ $t('settings.set_new_profile_banner') }}</p>
	<img
	v-if="bannerPreview"
	class="banner"
	:src="bannerPreview"
	>
	<div>
	<input
	type="file"
	@change="uploadFile('banner', $event)"
	>
	</div>
	<i
	v-if="bannerUploading"
	class=" icon-spin4 animate-spin uploading"
	/>
	<button
	v-else-if="bannerPreview"
	class="btn btn-default"
	@click="submitBanner"
	>
	{{ $t('general.submit') }}
	</button>
	<div
	v-if="bannerUploadError"
	class="alert error"
	>
	Error: {{ bannerUploadError }}
	<i
	class="button-icon icon-cancel"
	@click="clearUploadError('banner')"
	/>
	</div>
	</div>
	<div class="setting-item">
	<h2>{{ $t('settings.profile_background') }}</h2>
	<p>{{ $t('settings.set_new_profile_background') }}</p>
	<img
	v-if="backgroundPreview"
	class="bg"
	:src="backgroundPreview"
	>
	<div>
	<input
	type="file"
	@change="uploadFile('background', $event)"
	>
	</div>
	<i
	v-if="backgroundUploading"
	class=" icon-spin4 animate-spin uploading"
	/>
	<button
	v-else-if="backgroundPreview"
	class="btn btn-default"
	@click="submitBg"
	>
	{{ $t('general.submit') }}
	</button>
	<div
	v-if="backgroundUploadError"
	class="alert error"
	>
	Error: {{ backgroundUploadError }}
	<i
	class="button-icon icon-cancel"
	@click="clearUploadError('background')"
	/>
	</div>
	</div>
	</div>

	<div :label="$t('settings.security_tab')">
	<div class="setting-item">
	<h2>{{ $t('settings.change_email') }}</h2>
	<div>
	<p>{{ $t('settings.new_email') }}</p>
	<input
	v-model="newEmail"
	type="email"
	autocomplete="email"
	>
	</div>
	<div>
	<p>{{ $t('settings.current_password') }}</p>
	<input
	v-model="changeEmailPassword"
	type="password"
	autocomplete="current-password"
	>
	</div>
	<button
	class="btn btn-default"
	@click="changeEmail"
	>
	{{ $t('general.submit') }}
	</button>
	<p v-if="changedEmail">
	{{ $t('settings.changed_email') }}
	</p>
	<template v-if="changeEmailError !== false">
	<p>{{ $t('settings.change_email_error') }}</p>
	<p>{{ changeEmailError }}</p>
	</template>
	</div>

	<div class="setting-item">
	<h2>{{ $t('settings.change_password') }}</h2>
	<div>
	<p>{{ $t('settings.current_password') }}</p>
	<input
	v-model="changePasswordInputs[0]"
	type="password"
	>
	</div>
	<div>
	<p>{{ $t('settings.new_password') }}</p>
	<input
	v-model="changePasswordInputs[1]"
	type="password"
	>
	</div>
	<div>
	<p>{{ $t('settings.confirm_new_password') }}</p>
	<input
	v-model="changePasswordInputs[2]"
	type="password"
	>
	</div>
	<button
	class="btn btn-default"
	@click="changePassword"
	>
	{{ $t('general.submit') }}
	</button>
	<p v-if="changedPassword">
	{{ $t('settings.changed_password') }}
	</p>
	<p v-else-if="changePasswordError !== false">
	{{ $t('settings.change_password_error') }}
	</p>
	<p v-if="changePasswordError">
	{{ changePasswordError }}
	</p>
	</div>

	<div class="setting-item">
	<h2>{{ $t('settings.oauth_tokens') }}</h2>
	<table class="oauth-tokens">
	<thead>
	<tr>
	<th>{{ $t('settings.app_name') }}</th>
	<th>{{ $t('settings.valid_until') }}</th>
	<th />
	</tr>
	</thead>
	<tbody>
	<tr
	v-for="oauthToken in oauthTokens"
	:key="oauthToken.id"
	>
	<td>{{ oauthToken.appName }}</td>
	<td>{{ oauthToken.validUntil }}</td>
	<td class="actions">
	<button
	class="btn btn-default"
	@click="revokeToken(oauthToken.id)"
	>
	{{ $t('settings.revoke_token') }}
	</button>
	</td>
	</tr>
	</tbody>
	</table>
	</div>
	<mfa />
	<div class="setting-item">
	<h2>{{ $t('settings.delete_account') }}</h2>
	<p v-if="!deletingAccount">
	{{ $t('settings.delete_account_description') }}
	</p>
	<div v-if="deletingAccount">
	<p>{{ $t('settings.delete_account_instructions') }}</p>
	<p>{{ $t('login.password') }}</p>
	<input
	v-model="deleteAccountConfirmPasswordInput"
	type="password"
	>
	<button
	class="btn btn-default"
	@click="deleteAccount"
	>
	{{ $t('settings.delete_account') }}
	</button>
	</div>
	<p v-if="deleteAccountError !== false">
	{{ $t('settings.delete_account_error') }}
	</p>
	<p v-if="deleteAccountError">
	{{ deleteAccountError }}
	</p>
	<button
	v-if="!deletingAccount"
	class="btn btn-default"
	@click="confirmDelete"
	>
	{{ $t('general.submit') }}
	</button>
	</div>
	</div>

	<div
	v-if="pleromaBackend"
	:label="$t('settings.notifications')"
	>
	<div class="setting-item">
	+ <h2>{{ $t('settings.notification_setting_filters') }}</h2>
	<div class="select-multiple">
	<span class="label">{{ $t('settings.notification_setting') }}</span>
	<ul class="option-list">
	<li>
	<Checkbox v-model="notificationSettings.follows">
	{{ $t('settings.notification_setting_follows') }}
	</Checkbox>
	</li>
	<li>
	<Checkbox v-model="notificationSettings.followers">
	{{ $t('settings.notification_setting_followers') }}
	</Checkbox>
	</li>
	<li>
	<Checkbox v-model="notificationSettings.non_follows">
	{{ $t('settings.notification_setting_non_follows') }}
	</Checkbox>
	</li>
	<li>
	<Checkbox v-model="notificationSettings.non_followers">
	{{ $t('settings.notification_setting_non_followers') }}
	</Checkbox>
	</li>
	</ul>
	</div>
	+ </div>
	+
	+ <div class="setting-item">
	+ <h2>{{ $t('settings.notification_setting_privacy') }}</h2>
	+ <p>
	+ <Checkbox v-model="notificationSettings.privacy_option">
	+ {{ $t('settings.notification_setting_privacy_option') }}
	+ </Checkbox>
	+ </p>
	+ </div>
	+ <div class="setting-item">
	<p>{{ $t('settings.notification_mutes') }}</p>
	<p>{{ $t('settings.notification_blocks') }}</p>
	<button
	class="btn btn-default"
	@click="updateNotificationSettings"
	>
	{{ $t('general.submit') }}
	</button>
	</div>
	</div>

	<div
	v-if="pleromaBackend"
	:label="$t('settings.data_import_export_tab')"
	>
	<div class="setting-item">
	<h2>{{ $t('settings.follow_import') }}</h2>
	<p>{{ $t('settings.import_followers_from_a_csv_file') }}</p>
	<Importer
	:submit-handler="importFollows"
	:success-message="$t('settings.follows_imported')"
	:error-message="$t('settings.follow_import_error')"
	/>
	</div>
	<div class="setting-item">
	<h2>{{ $t('settings.follow_export') }}</h2>
	<Exporter
	:get-content="getFollowsContent"
	filename="friends.csv"
	:export-button-label="$t('settings.follow_export_button')"
	/>
	</div>
	<div class="setting-item">
	<h2>{{ $t('settings.block_import') }}</h2>
	<p>{{ $t('settings.import_blocks_from_a_csv_file') }}</p>
	<Importer
	:submit-handler="importBlocks"
	:success-message="$t('settings.blocks_imported')"
	:error-message="$t('settings.block_import_error')"
	/>
	</div>
	<div class="setting-item">
	<h2>{{ $t('settings.block_export') }}</h2>
	<Exporter
	:get-content="getBlocksContent"
	filename="blocks.csv"
	:export-button-label="$t('settings.block_export_button')"
	/>
	</div>
	</div>

	<div :label="$t('settings.blocks_tab')">
	<div class="profile-edit-usersearch-wrapper">
	<Autosuggest
	:filter="filterUnblockedUsers"
	:query="queryUserIds"
	:placeholder="$t('settings.search_user_to_block')"
	>
	<BlockCard
	slot-scope="row"
	:user-id="row.item"
	/>
	</Autosuggest>
	</div>
	<BlockList
	:refresh="true"
	:get-key="identity"
	>
	<template
	slot="header"
	slot-scope="{selected}"
	>
	<div class="profile-edit-bulk-actions">
	<ProgressButton
	v-if="selected.length > 0"
	class="btn btn-default"
	:click="() => blockUsers(selected)"
	>
	{{ $t('user_card.block') }}
	<template slot="progress">
	{{ $t('user_card.block_progress') }}
	</template>
	</ProgressButton>
	<ProgressButton
	v-if="selected.length > 0"
	class="btn btn-default"
	:click="() => unblockUsers(selected)"
	>
	{{ $t('user_card.unblock') }}
	<template slot="progress">
	{{ $t('user_card.unblock_progress') }}
	</template>
	</ProgressButton>
	</div>
	</template>
	<template
	slot="item"
	slot-scope="{item}"
	>
	<BlockCard :user-id="item" />
	</template>
	<template slot="empty">
	{{ $t('settings.no_blocks') }}
	</template>
	</BlockList>
	</div>

	<div :label="$t('settings.mutes_tab')">
	<tab-switcher>
	<div label="Users">
	<div class="profile-edit-usersearch-wrapper">
	<Autosuggest
	:filter="filterUnMutedUsers"
	:query="queryUserIds"
	:placeholder="$t('settings.search_user_to_mute')"
	>
	<MuteCard
	slot-scope="row"
	:user-id="row.item"
	/>
	</Autosuggest>
	</div>
	<MuteList
	:refresh="true"
	:get-key="identity"
	>
	<template
	slot="header"
	slot-scope="{selected}"
	>
	<div class="profile-edit-bulk-actions">
	<ProgressButton
	v-if="selected.length > 0"
	class="btn btn-default"
	:click="() => muteUsers(selected)"
	>
	{{ $t('user_card.mute') }}
	<template slot="progress">
	{{ $t('user_card.mute_progress') }}
	</template>
	</ProgressButton>
	<ProgressButton
	v-if="selected.length > 0"
	class="btn btn-default"
	:click="() => unmuteUsers(selected)"
	>
	{{ $t('user_card.unmute') }}
	<template slot="progress">
	{{ $t('user_card.unmute_progress') }}
	</template>
	</ProgressButton>
	</div>
	</template>
	<template
	slot="item"
	slot-scope="{item}"
	>
	<MuteCard :user-id="item" />
	</template>
	<template slot="empty">
	{{ $t('settings.no_mutes') }}
	</template>
	</MuteList>
	</div>

	<div :label="$t('settings.domain_mutes')">
	<div class="profile-edit-domain-mute-form">
	<input
	v-model="newDomainToMute"
	:placeholder="$t('settings.type_domains_to_mute')"
	type="text"
	@keyup.enter="muteDomain"
	>
	<ProgressButton
	class="btn btn-default"
	:click="muteDomain"
	>
	{{ $t('domain_mute_card.mute') }}
	<template slot="progress">
	{{ $t('domain_mute_card.mute_progress') }}
	</template>
	</ProgressButton>
	</div>
	<DomainMuteList
	:refresh="true"
	:get-key="identity"
	>
	<template
	slot="header"
	slot-scope="{selected}"
	>
	<div class="profile-edit-bulk-actions">
	<ProgressButton
	v-if="selected.length > 0"
	class="btn btn-default"
	:click="() => unmuteDomains(selected)"
	>
	{{ $t('domain_mute_card.unmute') }}
	<template slot="progress">
	{{ $t('domain_mute_card.unmute_progress') }}
	</template>
	</ProgressButton>
	</div>
	</template>
	<template
	slot="item"
	slot-scope="{item}"
	>
	<DomainMuteCard :domain="item" />
	</template>
	<template slot="empty">
	{{ $t('settings.no_mutes') }}
	</template>
	</DomainMuteList>
	</div>
	</tab-switcher>
	</div>
	</tab-switcher>
	</div>
	</div>
	</template>

	<script src="./user_settings.js">
	</script>

	<style lang="scss">
	@import '../../_variables.scss';

	.profile-edit {
	.bio {
	margin: 0;
	}

	.visibility-tray {
	padding-top: 5px;
	}

	input[type=file] {
	padding: 5px;
	height: auto;
	}

	.banner {
	max-width: 100%;
	}

	.uploading {
	font-size: 1.5em;
	margin: 0.25em;
	}

	.name-changer {
	width: 100%;
	}

	.bg {
	max-width: 100%;
	}

	.current-avatar {
	display: block;
	width: 150px;
	height: 150px;
	border-radius: $fallback--avatarRadius;
	border-radius: var(--avatarRadius, $fallback--avatarRadius);
	}

	.oauth-tokens {
	width: 100%;

	th {
	text-align: left;
	}

	.actions {
	text-align: right;
	}
	}

	&-usersearch-wrapper {
	padding: 1em;
	}

	&-bulk-actions {
	text-align: right;
	padding: 0 1em;
	min-height: 28px;

	button {
	width: 10em;
	}
	}

	&-domain-mute-form {
	padding: 1em;
	display: flex;
	flex-direction: column;

	button {
	align-self: flex-end;
	margin-top: 1em;
	width: 10em;
	}
	}

	.setting-subitem {
	margin-left: 1.75em;
	}
	}
	</style>
	diff --git a/src/i18n/en.json b/src/i18n/en.json
	index 54d0608ee1..d5748719b8 100644
	--- a/src/i18n/en.json
	+++ b/src/i18n/en.json
	@@ -1,736 +1,743 @@
	{
	"about": {
	"mrf": {
	"federation": "Federation",
	"keyword": {
	"keyword_policies": "Keyword Policies",
	"ftl_removal": "Removal from \"The Whole Known Network\" Timeline",
	"reject": "Reject",
	"replace": "Replace",
	"is_replaced_by": "→"
	},
	"mrf_policies": "Enabled MRF Policies",
	"mrf_policies_desc": "MRF policies manipulate the federation behaviour of the instance. The following policies are enabled:",
	"simple": {
	"simple_policies": "Instance-specific Policies",
	"accept": "Accept",
	"accept_desc": "This instance only accepts messages from the following instances:",
	"reject": "Reject",
	"reject_desc": "This instance will not accept messages from the following instances:",
	"quarantine": "Quarantine",
	"quarantine_desc": "This instance will send only public posts to the following instances:",
	"ftl_removal": "Removal from \"The Whole Known Network\" Timeline",
	"ftl_removal_desc": "This instance removes these instances from \"The Whole Known Network\" timeline:",
	"media_removal": "Media Removal",
	"media_removal_desc": "This instance removes media from posts on the following instances:",
	"media_nsfw": "Media Force-set As Sensitive",
	"media_nsfw_desc": "This instance forces media to be set sensitive in posts on the following instances:"
	}
	},
	"staff": "Staff"
	},
	"chat": {
	"title": "Chat"
	},
	"domain_mute_card": {
	"mute": "Mute",
	"mute_progress": "Muting...",
	"unmute": "Unmute",
	"unmute_progress": "Unmuting..."
	},
	"exporter": {
	"export": "Export",
	"processing": "Processing, you'll soon be asked to download your file"
	},
	"features_panel": {
	"chat": "Chat",
	"gopher": "Gopher",
	"media_proxy": "Media proxy",
	"scope_options": "Scope options",
	"text_limit": "Text limit",
	"title": "Features",
	"who_to_follow": "Who to follow"
	},
	"finder": {
	"error_fetching_user": "Error fetching user",
	"find_user": "Find user"
	},
	"general": {
	"apply": "Apply",
	"submit": "Submit",
	"more": "More",
	"generic_error": "An error occured",
	"optional": "optional",
	"show_more": "Show more",
	"show_less": "Show less",
	"dismiss": "Dismiss",
	"cancel": "Cancel",
	"disable": "Disable",
	"enable": "Enable",
	"confirm": "Confirm",
	"verify": "Verify"
	},
	"image_cropper": {
	"crop_picture": "Crop picture",
	"save": "Save",
	"save_without_cropping": "Save without cropping",
	"cancel": "Cancel"
	},
	"importer": {
	"submit": "Submit",
	"success": "Imported successfully.",
	"error": "An error occured while importing this file."
	},
	"login": {
	"login": "Log in",
	"description": "Log in with OAuth",
	"logout": "Log out",
	"password": "Password",
	"placeholder": "e.g. lain",
	"register": "Register",
	"username": "Username",
	"hint": "Log in to join the discussion",
	"authentication_code": "Authentication code",
	"enter_recovery_code": "Enter a recovery code",
	"enter_two_factor_code": "Enter a two-factor code",
	"recovery_code": "Recovery code",
	"heading" : {
	"totp" : "Two-factor authentication",
	"recovery" : "Two-factor recovery"
	}
	},
	"media_modal": {
	"previous": "Previous",
	"next": "Next"
	},
	"nav": {
	"about": "About",
	"administration": "Administration",
	"back": "Back",
	"chat": "Local Chat",
	"friend_requests": "Follow Requests",
	"mentions": "Mentions",
	"interactions": "Interactions",
	"dms": "Direct Messages",
	"public_tl": "Public Timeline",
	"timeline": "Timeline",
	"twkn": "The Whole Known Network",
	"user_search": "User Search",
	"search": "Search",
	"who_to_follow": "Who to follow",
	"preferences": "Preferences"
	},
	"notifications": {
	"broken_favorite": "Unknown status, searching for it...",
	"favorited_you": "favorited your status",
	"followed_you": "followed you",
	+ "follow_request": "wants to follow you",
	"load_older": "Load older notifications",
	"notifications": "Notifications",
	"read": "Read!",
	"repeated_you": "repeated your status",
	"no_more_notifications": "No more notifications",
	"migrated_to": "migrated to",
	"reacted_with": "reacted with {0}"
	},
	"polls": {
	"add_poll": "Add Poll",
	"add_option": "Add Option",
	"option": "Option",
	"votes": "votes",
	"vote": "Vote",
	"type": "Poll type",
	"single_choice": "Single choice",
	"multiple_choices": "Multiple choices",
	"expiry": "Poll age",
	"expires_in": "Poll ends in {0}",
	"expired": "Poll ended {0} ago",
	"not_enough_options": "Too few unique options in poll"
	},
	"emoji": {
	"stickers": "Stickers",
	"emoji": "Emoji",
	"keep_open": "Keep picker open",
	"search_emoji": "Search for an emoji",
	"add_emoji": "Insert emoji",
	"custom": "Custom emoji",
	"unicode": "Unicode emoji",
	"load_all_hint": "Loaded first {saneAmount} emoji, loading all emoji may cause performance issues.",
	"load_all": "Loading all {emojiAmount} emoji"
	},
	"interactions": {
	"favs_repeats": "Repeats and Favorites",
	"follows": "New follows",
	"moves": "User migrates",
	"load_older": "Load older interactions"
	},
	"post_status": {
	"new_status": "Post new status",
	"account_not_locked_warning": "Your account is not {0}. Anyone can follow you to view your follower-only posts.",
	"account_not_locked_warning_link": "locked",
	"attachments_sensitive": "Mark attachments as sensitive",
	"content_type": {
	"text/plain": "Plain text",
	"text/html": "HTML",
	"text/markdown": "Markdown",
	"text/bbcode": "BBCode"
	},
	"content_warning": "Subject (optional)",
	"default": "Just landed in L.A.",
	"direct_warning_to_all": "This post will be visible to all the mentioned users.",
	"direct_warning_to_first_only": "This post will only be visible to the mentioned users at the beginning of the message.",
	"posting": "Posting",
	"scope_notice": {
	"public": "This post will be visible to everyone",
	"private": "This post will be visible to your followers only",
	"unlisted": "This post will not be visible in Public Timeline and The Whole Known Network"
	},
	"scope": {
	"direct": "Direct - Post to mentioned users only",
	"private": "Followers-only - Post to followers only",
	"public": "Public - Post to public timelines",
	"unlisted": "Unlisted - Do not post to public timelines"
	}
	},
	"registration": {
	"bio": "Bio",
	"email": "Email",
	"fullname": "Display name",
	"password_confirm": "Password confirmation",
	"registration": "Registration",
	"token": "Invite token",
	"captcha": "CAPTCHA",
	"new_captcha": "Click the image to get a new captcha",
	"username_placeholder": "e.g. lain",
	"fullname_placeholder": "e.g. Lain Iwakura",
	"bio_placeholder": "e.g.\nHi, I'm Lain.\nI’m an anime girl living in suburban Japan. You may know me from the Wired.",
	"validations": {
	"username_required": "cannot be left blank",
	"fullname_required": "cannot be left blank",
	"email_required": "cannot be left blank",
	"password_required": "cannot be left blank",
	"password_confirmation_required": "cannot be left blank",
	"password_confirmation_match": "should be the same as password"
	}
	},
	"remote_user_resolver": {
	"remote_user_resolver": "Remote user resolver",
	"searching_for": "Searching for",
	"error": "Not found."
	},
	"selectable_list": {
	"select_all": "Select all"
	},
	"settings": {
	"app_name": "App name",
	"security": "Security",
	"enter_current_password_to_confirm": "Enter your current password to confirm your identity",
	"mfa": {
	"otp" : "OTP",
	"setup_otp" : "Setup OTP",
	"wait_pre_setup_otp" : "presetting OTP",
	"confirm_and_enable" : "Confirm & enable OTP",
	"title": "Two-factor Authentication",
	"generate_new_recovery_codes" : "Generate new recovery codes",
	"warning_of_generate_new_codes" : "When you generate new recovery codes, your old codes won’t work anymore.",
	"recovery_codes" : "Recovery codes.",
	"waiting_a_recovery_codes": "Receiving backup codes...",
	"recovery_codes_warning" : "Write the codes down or save them somewhere secure - otherwise you won't see them again. If you lose access to your 2FA app and recovery codes you'll be locked out of your account.",
	"authentication_methods" : "Authentication methods",
	"scan": {
	"title": "Scan",
	"desc": "Using your two-factor app, scan this QR code or enter text key:",
	"secret_code": "Key"
	},
	"verify": {
	"desc": "To enable two-factor authentication, enter the code from your two-factor app:"
	}
	},
	"allow_following_move": "Allow auto-follow when following account moves",
	"attachmentRadius": "Attachments",
	"attachments": "Attachments",
	"autoload": "Enable automatic loading when scrolled to the bottom",
	"avatar": "Avatar",
	"avatarAltRadius": "Avatars (Notifications)",
	"avatarRadius": "Avatars",
	"background": "Background",
	"bio": "Bio",
	"block_export": "Block export",
	"block_export_button": "Export your blocks to a csv file",
	"block_import": "Block import",
	"block_import_error": "Error importing blocks",
	"blocks_imported": "Blocks imported! Processing them will take a while.",
	"blocks_tab": "Blocks",
	"btnRadius": "Buttons",
	"cBlue": "Blue (Reply, follow)",
	"cGreen": "Green (Retweet)",
	"cOrange": "Orange (Favorite)",
	"cRed": "Red (Cancel)",
	"change_email": "Change Email",
	"change_email_error": "There was an issue changing your email.",
	"changed_email": "Email changed successfully!",
	"change_password": "Change Password",
	"change_password_error": "There was an issue changing your password.",
	"changed_password": "Password changed successfully!",
	"collapse_subject": "Collapse posts with subjects",
	"composing": "Composing",
	"confirm_new_password": "Confirm new password",
	"current_avatar": "Your current avatar",
	"current_password": "Current password",
	"current_profile_banner": "Your current profile banner",
	"data_import_export_tab": "Data Import / Export",
	"default_vis": "Default visibility scope",
	"delete_account": "Delete Account",
	"delete_account_description": "Permanently delete your account and all your messages.",
	"delete_account_error": "There was an issue deleting your account. If this persists please contact your instance administrator.",
	"delete_account_instructions": "Type your password in the input below to confirm account deletion.",
	"discoverable": "Allow discovery of this account in search results and other services",
	"domain_mutes": "Domains",
	"avatar_size_instruction": "The recommended minimum size for avatar images is 150x150 pixels.",
	"pad_emoji": "Pad emoji with spaces when adding from picker",
	"emoji_reactions_on_timeline": "Show emoji reactions on timeline",
	"export_theme": "Save preset",
	"filtering": "Filtering",
	"filtering_explanation": "All statuses containing these words will be muted, one per line",
	"follow_export": "Follow export",
	"follow_export_button": "Export your follows to a csv file",
	"follow_import": "Follow import",
	"follow_import_error": "Error importing followers",
	"follows_imported": "Follows imported! Processing them will take a while.",
	"accent": "Accent",
	"foreground": "Foreground",
	"general": "General",
	"hide_attachments_in_convo": "Hide attachments in conversations",
	"hide_attachments_in_tl": "Hide attachments in timeline",
	"hide_muted_posts": "Hide posts of muted users",
	"max_thumbnails": "Maximum amount of thumbnails per post",
	"hide_isp": "Hide instance-specific panel",
	"preload_images": "Preload images",
	"use_one_click_nsfw": "Open NSFW attachments with just one click",
	"hide_post_stats": "Hide post statistics (e.g. the number of favorites)",
	"hide_user_stats": "Hide user statistics (e.g. the number of followers)",
	"hide_filtered_statuses": "Hide filtered statuses",
	"import_blocks_from_a_csv_file": "Import blocks from a csv file",
	"import_followers_from_a_csv_file": "Import follows from a csv file",
	"import_theme": "Load preset",
	"inputRadius": "Input fields",
	"checkboxRadius": "Checkboxes",
	"instance_default": "(default: {value})",
	"instance_default_simple": "(default)",
	"interface": "Interface",
	"interfaceLanguage": "Interface language",
	"invalid_theme_imported": "The selected file is not a supported Pleroma theme. No changes to your theme were made.",
	"limited_availability": "Unavailable in your browser",
	"links": "Links",
	"lock_account_description": "Restrict your account to approved followers only",
	"loop_video": "Loop videos",
	"loop_video_silent_only": "Loop only videos without sound (i.e. Mastodon's \"gifs\")",
	"mutes_tab": "Mutes",
	"play_videos_in_modal": "Play videos in a popup frame",
	"use_contain_fit": "Don't crop the attachment in thumbnails",
	"name": "Name",
	"name_bio": "Name & Bio",
	"new_email": "New Email",
	"new_password": "New password",
	"notification_visibility": "Types of notifications to show",
	"notification_visibility_follows": "Follows",
	"notification_visibility_likes": "Likes",
	"notification_visibility_mentions": "Mentions",
	"notification_visibility_repeats": "Repeats",
	"notification_visibility_moves": "User Migrates",
	"notification_visibility_emoji_reactions": "Reactions",
	"no_rich_text_description": "Strip rich text formatting from all posts",
	"no_blocks": "No blocks",
	"no_mutes": "No mutes",
	"hide_follows_description": "Don't show who I'm following",
	"hide_followers_description": "Don't show who's following me",
	"hide_follows_count_description": "Don't show follow count",
	"hide_followers_count_description": "Don't show follower count",
	"show_admin_badge": "Show Admin badge in my profile",
	"show_moderator_badge": "Show Moderator badge in my profile",
	"nsfw_clickthrough": "Enable clickthrough NSFW attachment hiding",
	"oauth_tokens": "OAuth tokens",
	"token": "Token",
	"refresh_token": "Refresh Token",
	"valid_until": "Valid Until",
	"revoke_token": "Revoke",
	"panelRadius": "Panels",
	"pause_on_unfocused": "Pause streaming when tab is not focused",
	"presets": "Presets",
	"profile_background": "Profile Background",
	"profile_banner": "Profile Banner",
	"profile_tab": "Profile",
	"radii_help": "Set up interface edge rounding (in pixels)",
	"replies_in_timeline": "Replies in timeline",
	"reply_link_preview": "Enable reply-link preview on mouse hover",
	"reply_visibility_all": "Show all replies",
	"reply_visibility_following": "Only show replies directed at me or users I'm following",
	"reply_visibility_self": "Only show replies directed at me",
	"autohide_floating_post_button": "Automatically hide New Post button (mobile)",
	"saving_err": "Error saving settings",
	"saving_ok": "Settings saved",
	"search_user_to_block": "Search whom you want to block",
	"search_user_to_mute": "Search whom you want to mute",
	"security_tab": "Security",
	"scope_copy": "Copy scope when replying (DMs are always copied)",
	"minimal_scopes_mode": "Minimize post scope selection options",
	"set_new_avatar": "Set new avatar",
	"set_new_profile_background": "Set new profile background",
	"set_new_profile_banner": "Set new profile banner",
	"settings": "Settings",
	"subject_input_always_show": "Always show subject field",
	"subject_line_behavior": "Copy subject when replying",
	"subject_line_email": "Like email: \"re: subject\"",
	"subject_line_mastodon": "Like mastodon: copy as is",
	"subject_line_noop": "Do not copy",
	"post_status_content_type": "Post status content type",
	"stop_gifs": "Play-on-hover GIFs",
	"streaming": "Enable automatic streaming of new posts when scrolled to the top",
	"user_mutes": "Users",
	"useStreamingApi": "Receive posts and notifications real-time",
	"useStreamingApiWarning": "(Not recommended, experimental, known to skip posts)",
	"text": "Text",
	"theme": "Theme",
	"theme_help": "Use hex color codes (#rrggbb) to customize your color theme.",
	"theme_help_v2_1": "You can also override certain component's colors and opacity by toggling the checkbox, use \"Clear all\" button to clear all overrides.",
	"theme_help_v2_2": "Icons underneath some entries are background/text contrast indicators, hover over for detailed info. Please keep in mind that when using transparency contrast indicators show the worst possible case.",
	"tooltipRadius": "Tooltips/alerts",
	"type_domains_to_mute": "Type in domains to mute",
	"upload_a_photo": "Upload a photo",
	"user_settings": "User Settings",
	"values": {
	"false": "no",
	"true": "yes"
	},
	"fun": "Fun",
	"greentext": "Meme arrows",
	"notifications": "Notifications",
	+ "notification_setting_filters": "Filters",
	"notification_setting": "Receive notifications from:",
	"notification_setting_follows": "Users you follow",
	"notification_setting_non_follows": "Users you do not follow",
	"notification_setting_followers": "Users who follow you",
	"notification_setting_non_followers": "Users who do not follow you",
	+ "notification_setting_privacy": "Privacy",
	+ "notification_setting_privacy_option": "Hide the sender and contents of push notifications",
	"notification_mutes": "To stop receiving notifications from a specific user, use a mute.",
	"notification_blocks": "Blocking a user stops all notifications as well as unsubscribes them.",
	"enable_web_push_notifications": "Enable web push notifications",
	"style": {
	"switcher": {
	"keep_color": "Keep colors",
	"keep_shadows": "Keep shadows",
	"keep_opacity": "Keep opacity",
	"keep_roundness": "Keep roundness",
	"keep_fonts": "Keep fonts",
	"save_load_hint": "\"Keep\" options preserve currently set options when selecting or loading themes, it also stores said options when exporting a theme. When all checkboxes unset, exporting theme will save everything.",
	"reset": "Reset",
	"clear_all": "Clear all",
	"clear_opacity": "Clear opacity",
	"load_theme": "Load theme",
	"keep_as_is": "Keep as is",
	"use_snapshot": "Old version",
	"use_source": "New version",
	"help": {
	"upgraded_from_v2": "PleromaFE has been upgraded, theme could look a little bit different than you remember.",
	"v2_imported": "File you imported was made for older FE. We try to maximize compatibility but there still could be inconsitencies.",
	"future_version_imported": "File you imported was made in newer version of FE.",
	"older_version_imported": "File you imported was made in older version of FE.",
	"snapshot_present": "Theme snapshot is loaded, so all values are overriden. You can load theme's actual data instead.",
	"snapshot_missing": "No theme snapshot was in the file so it could look different than originally envisioned.",
	"fe_upgraded": "PleromaFE's theme engine upgraded after version update.",
	"fe_downgraded": "PleromaFE's version rolled back.",
	"migration_snapshot_ok": "Just to be safe, theme snapshot loaded. You can try loading theme data.",
	"migration_napshot_gone": "For whatever reason snapshot was missing, some stuff could look different than you remember.",
	"snapshot_source_mismatch": "Versions conflict: most likely FE was rolled back and updated again, if you changed theme using older version of FE you most likely want to use old version, otherwise use new version."
	}
	},
	"common": {
	"color": "Color",
	"opacity": "Opacity",
	"contrast": {
	"hint": "Contrast ratio is {ratio}, it {level} {context}",
	"level": {
	"aa": "meets Level AA guideline (minimal)",
	"aaa": "meets Level AAA guideline (recommended)",
	"bad": "doesn't meet any accessibility guidelines"
	},
	"context": {
	"18pt": "for large (18pt+) text",
	"text": "for text"
	}
	}
	},
	"common_colors": {
	"_tab_label": "Common",
	"main": "Common colors",
	"foreground_hint": "See \"Advanced\" tab for more detailed control",
	"rgbo": "Icons, accents, badges"
	},
	"advanced_colors": {
	"_tab_label": "Advanced",
	"alert": "Alert background",
	"alert_error": "Error",
	"alert_warning": "Warning",
	"alert_neutral": "Neutral",
	"post": "Posts/User bios",
	"badge": "Badge background",
	"popover": "Tooltips, menus, popovers",
	"badge_notification": "Notification",
	"panel_header": "Panel header",
	"top_bar": "Top bar",
	"borders": "Borders",
	"buttons": "Buttons",
	"inputs": "Input fields",
	"faint_text": "Faded text",
	"underlay": "Underlay",
	"poll": "Poll graph",
	"icons": "Icons",
	"highlight": "Highlighted elements",
	"pressed": "Pressed",
	"selectedPost": "Selected post",
	"selectedMenu": "Selected menu item",
	"disabled": "Disabled",
	"toggled": "Toggled",
	"tabs": "Tabs"
	},
	"radii": {
	"_tab_label": "Roundness"
	},
	"shadows": {
	"_tab_label": "Shadow and lighting",
	"component": "Component",
	"override": "Override",
	"shadow_id": "Shadow #{value}",
	"blur": "Blur",
	"spread": "Spread",
	"inset": "Inset",
	"hintV3": "For shadows you can also use the {0} notation to use other color slot.",
	"filter_hint": {
	"always_drop_shadow": "Warning, this shadow always uses {0} when browser supports it.",
	"drop_shadow_syntax": "{0} does not support {1} parameter and {2} keyword.",
	"avatar_inset": "Please note that combining both inset and non-inset shadows on avatars might give unexpected results with transparent avatars.",
	"spread_zero": "Shadows with spread > 0 will appear as if it was set to zero",
	"inset_classic": "Inset shadows will be using {0}"
	},
	"components": {
	"panel": "Panel",
	"panelHeader": "Panel header",
	"topBar": "Top bar",
	"avatar": "User avatar (in profile view)",
	"avatarStatus": "User avatar (in post display)",
	"popup": "Popups and tooltips",
	"button": "Button",
	"buttonHover": "Button (hover)",
	"buttonPressed": "Button (pressed)",
	"buttonPressedHover": "Button (pressed+hover)",
	"input": "Input field"
	}
	},
	"fonts": {
	"_tab_label": "Fonts",
	"help": "Select font to use for elements of UI. For \"custom\" you have to enter exact font name as it appears in system.",
	"components": {
	"interface": "Interface",
	"input": "Input fields",
	"post": "Post text",
	"postCode": "Monospaced text in a post (rich text)"
	},
	"family": "Font name",
	"size": "Size (in px)",
	"weight": "Weight (boldness)",
	"custom": "Custom"
	},
	"preview": {
	"header": "Preview",
	"content": "Content",
	"error": "Example error",
	"button": "Button",
	"text": "A bunch of more {0} and {1}",
	"mono": "content",
	"input": "Just landed in L.A.",
	"faint_link": "helpful manual",
	"fine_print": "Read our {0} to learn nothing useful!",
	"header_faint": "This is fine",
	"checkbox": "I have skimmed over terms and conditions",
	"link": "a nice lil' link"
	}
	},
	"version": {
	"title": "Version",
	"backend_version": "Backend Version",
	"frontend_version": "Frontend Version"
	}
	},
	"time": {
	"day": "{0} day",
	"days": "{0} days",
	"day_short": "{0}d",
	"days_short": "{0}d",
	"hour": "{0} hour",
	"hours": "{0} hours",
	"hour_short": "{0}h",
	"hours_short": "{0}h",
	"in_future": "in {0}",
	"in_past": "{0} ago",
	"minute": "{0} minute",
	"minutes": "{0} minutes",
	"minute_short": "{0}min",
	"minutes_short": "{0}min",
	"month": "{0} month",
	"months": "{0} months",
	"month_short": "{0}mo",
	"months_short": "{0}mo",
	"now": "just now",
	"now_short": "now",
	"second": "{0} second",
	"seconds": "{0} seconds",
	"second_short": "{0}s",
	"seconds_short": "{0}s",
	"week": "{0} week",
	"weeks": "{0} weeks",
	"week_short": "{0}w",
	"weeks_short": "{0}w",
	"year": "{0} year",
	"years": "{0} years",
	"year_short": "{0}y",
	"years_short": "{0}y"
	},
	"timeline": {
	"collapse": "Collapse",
	"conversation": "Conversation",
	"error_fetching": "Error fetching updates",
	"load_older": "Load older statuses",
	"no_retweet_hint": "Post is marked as followers-only or direct and cannot be repeated",
	"repeated": "repeated",
	"show_new": "Show new",
	"up_to_date": "Up-to-date",
	"no_more_statuses": "No more statuses",
	"no_statuses": "No statuses"
	},
	"status": {
	"favorites": "Favorites",
	"repeats": "Repeats",
	"delete": "Delete status",
	"pin": "Pin on profile",
	"unpin": "Unpin from profile",
	"pinned": "Pinned",
	"delete_confirm": "Do you really want to delete this status?",
	"reply_to": "Reply to",
	"replies_list": "Replies:",
	"mute_conversation": "Mute conversation",
	"unmute_conversation": "Unmute conversation",
	- "status_unavailable": "Status unavailable"
	+ "status_unavailable": "Status unavailable",
	+ "copy_link": "Copy link to status"
	},
	"user_card": {
	"approve": "Approve",
	"block": "Block",
	"blocked": "Blocked!",
	"deny": "Deny",
	"favorites": "Favorites",
	"follow": "Follow",
	"follow_sent": "Request sent!",
	"follow_progress": "Requesting…",
	"follow_again": "Send request again?",
	"follow_unfollow": "Unfollow",
	"followees": "Following",
	"followers": "Followers",
	"following": "Following!",
	"follows_you": "Follows you!",
	"hidden": "Hidden",
	"its_you": "It's you!",
	"media": "Media",
	"mention": "Mention",
	"mute": "Mute",
	"muted": "Muted",
	"per_day": "per day",
	"remote_follow": "Remote follow",
	"report": "Report",
	"statuses": "Statuses",
	"subscribe": "Subscribe",
	"unsubscribe": "Unsubscribe",
	"unblock": "Unblock",
	"unblock_progress": "Unblocking...",
	"block_progress": "Blocking...",
	"unmute": "Unmute",
	"unmute_progress": "Unmuting...",
	"mute_progress": "Muting...",
	"hide_repeats": "Hide repeats",
	"show_repeats": "Show repeats",
	"admin_menu": {
	"moderation": "Moderation",
	"grant_admin": "Grant Admin",
	"revoke_admin": "Revoke Admin",
	"grant_moderator": "Grant Moderator",
	"revoke_moderator": "Revoke Moderator",
	"activate_account": "Activate account",
	"deactivate_account": "Deactivate account",
	"delete_account": "Delete account",
	"force_nsfw": "Mark all posts as NSFW",
	"strip_media": "Remove media from posts",
	"force_unlisted": "Force posts to be unlisted",
	"sandbox": "Force posts to be followers-only",
	"disable_remote_subscription": "Disallow following user from remote instances",
	"disable_any_subscription": "Disallow following user at all",
	"quarantine": "Disallow user posts from federating",
	"delete_user": "Delete user",
	"delete_user_confirmation": "Are you absolutely sure? This action cannot be undone."
	}
	},
	"user_profile": {
	"timeline_title": "User Timeline",
	"profile_does_not_exist": "Sorry, this profile does not exist.",
	"profile_loading_error": "Sorry, there was an error loading this profile."
	},
	"user_reporting": {
	"title": "Reporting {0}",
	"add_comment_description": "The report will be sent to your instance moderators. You can provide an explanation of why you are reporting this account below:",
	"additional_comments": "Additional comments",
	"forward_description": "The account is from another server. Send a copy of the report there as well?",
	"forward_to": "Forward to {0}",
	"submit": "Submit",
	"generic_error": "An error occurred while processing your request."
	},
	"who_to_follow": {
	"more": "More",
	"who_to_follow": "Who to follow"
	},
	"tool_tip": {
	"media_upload": "Upload Media",
	"repeat": "Repeat",
	"reply": "Reply",
	"favorite": "Favorite",
	"add_reaction": "Add Reaction",
	- "user_settings": "User Settings"
	+ "user_settings": "User Settings",
	+ "accept_follow_request": "Accept follow request",
	+ "reject_follow_request": "Reject follow request"
	},
	"upload":{
	"error": {
	"base": "Upload failed.",
	"file_too_big": "File too big [{filesize}{filesizeunit} / {allowedsize}{allowedsizeunit}]",
	"default": "Try again later"
	},
	"file_size_units": {
	"B": "B",
	"KiB": "KiB",
	"MiB": "MiB",
	"GiB": "GiB",
	"TiB": "TiB"
	}
	},
	"search": {
	"people": "People",
	"hashtags": "Hashtags",
	"person_talking": "{count} person talking",
	"people_talking": "{count} people talking",
	"no_results": "No results"
	},
	"password_reset": {
	"forgot_password": "Forgot password?",
	"password_reset": "Password reset",
	"instruction": "Enter your email address or username. We will send you a link to reset your password.",
	"placeholder": "Your email or username",
	"check_email": "Check your email for a link to reset your password.",
	"return_home": "Return to the home page",
	"not_found": "We couldn't find that email or username.",
	"too_many_requests": "You have reached the limit of attempts, try again later.",
	"password_reset_disabled": "Password reset is disabled. Please contact your instance administrator.",
	"password_reset_required": "You must reset your password to log in.",
	"password_reset_required_but_mailer_is_disabled": "You must reset your password, but password reset is disabled. Please contact your instance administrator."
	}
	}
	diff --git a/src/i18n/pl.json b/src/i18n/pl.json
	index 51cadfb686..4a4b1e31b1 100644
	--- a/src/i18n/pl.json
	+++ b/src/i18n/pl.json
	@@ -1,435 +1,735 @@
	{
	+ "about": {
	+ "mrf": {
	+ "federation": "Federacja",
	+ "keyword": {
	+ "keyword_policies": "Zasady słów kluczowych",
	+ "ftl_removal": "Usunięcie z \"Całej znanej sieci\"",
	+ "reject": "Odrzucanie",
	+ "replace": "Zastąpienie",
	+ "is_replaced_by": "→"
	+ },
	+ "mrf_policies": "Włączone zasady MRF",
	+ "mrf_policies_desc": "Zasady MRF zmieniają zachowanie federowania instancji. Następujące zasady są włączone:",
	+ "simple": {
	+ "simple_policies": "Zasady specyficzne dla instancji",
	+ "accept": "Akceptowanie",
	+ "accept_desc": "Ta instancja akceptuje tylko posty z wymienionych instancji:",
	+ "reject": "Odrzucanie",
	+ "reject_desc": "Ta instancja odrzuca posty z wymienionych instancji:",
	+ "quarantine": "Kwarantanna",
	+ "quarantine_desc": "Ta instancja wysyła tylko publiczne posty do wymienionych instancji:",
	+ "ftl_removal": "Usunięcie z \"Całej znanej sieci\"",
	+ "ftl_removal_desc": "Ta instancja usuwa te instancje z \"Całej znanej sieci\"",
	+ "media_removal": "Usuwanie multimediów",
	+ "media_removal_desc": "Ta instancja usuwa multimedia z postów od wymienionych instancji:",
	+ "media_nsfw": "Multimedia ustawione jako wrażliwe",
	+ "media_nsfw_desc": "Ta instancja wymusza, by multimedia z wymienionych instancji były ustawione jako wrażliwe:"
	+ }
	+ },
	+ "staff": "Obsługa"
	+ },
	"chat": {
	"title": "Czat"
	},
	+ "domain_mute_card": {
	+ "mute": "Wycisz",
	+ "mute_progress": "Wyciszam...",
	+ "unmute": "Odcisz",
	+ "unmute_progress": "Odciszam..."
	+ },
	+ "exporter": {
	+ "export": "Eksportuj",
	+ "processing": "Przetwarzam, za chwilę zostaniesz zapytany o ściągnięcie pliku"
	+ },
	"features_panel": {
	"chat": "Czat",
	"gopher": "Gopher",
	"media_proxy": "Proxy mediów",
	"scope_options": "Ustawienia zakresu",
	"text_limit": "Limit tekstu",
	"title": "Funkcje",
	"who_to_follow": "Propozycje obserwacji"
	},
	"finder": {
	"error_fetching_user": "Błąd przy pobieraniu profilu",
	"find_user": "Znajdź użytkownika"
	},
	"general": {
	"apply": "Zastosuj",
	"submit": "Wyślij",
	"more": "Więcej",
	"generic_error": "Wystąpił błąd",
	- "optional": "nieobowiązkowe"
	+ "optional": "nieobowiązkowe",
	+ "show_more": "Pokaż więcej",
	+ "show_less": "Pokaż mniej",
	+ "dismiss": "Odrzuć",
	+ "cancel": "Anuluj",
	+ "disable": "Wyłącz",
	+ "enable": "Włącz",
	+ "confirm": "Potwierdź",
	+ "verify": "Zweryfikuj"
	},
	"image_cropper": {
	"crop_picture": "Przytnij obrazek",
	"save": "Zapisz",
	"save_without_cropping": "Zapisz bez przycinania",
	"cancel": "Anuluj"
	},
	+ "importer": {
	+ "submit": "Wyślij",
	+ "success": "Zaimportowano pomyślnie",
	+ "error": "Wystąpił błąd podczas importowania pliku."
	+ },
	"login": {
	"login": "Zaloguj",
	"description": "Zaloguj używając OAuth",
	"logout": "Wyloguj",
	"password": "Hasło",
	"placeholder": "n.p. lain",
	"register": "Zarejestruj",
	"username": "Użytkownik",
	- "hint": "Zaloguj się, aby dołączyć do dyskusji"
	+ "hint": "Zaloguj się, aby dołączyć do dyskusji",
	+ "authentication_code": "Kod weryfikacyjny",
	+ "enter_recovery_code": "Wprowadź kod zapasowy",
	+ "enter_two_factor_code": "Wprowadź kod weryfikacyjny",
	+ "recovery_code": "Kod zapasowy",
	+ "heading" : {
	+ "totp" : "Weryfikacja dwuetapowa",
	+ "recovery" : "Zapasowa weryfikacja dwuetapowa"
	+ }
	},
	"media_modal": {
	"previous": "Poprzednie",
	"next": "Następne"
	},
	"nav": {
	"about": "O nas",
	+ "administration": "Administracja",
	"back": "Wróć",
	"chat": "Lokalny czat",
	"friend_requests": "Prośby o możliwość obserwacji",
	"mentions": "Wzmianki",
	+ "interactions": "Interakcje",
	"dms": "Wiadomości prywatne",
	"public_tl": "Publiczna oś czasu",
	"timeline": "Oś czasu",
	"twkn": "Cała znana sieć",
	"user_search": "Wyszukiwanie użytkowników",
	+ "search": "Wyszukiwanie",
	"who_to_follow": "Sugestie obserwacji",
	"preferences": "Preferencje"
	},
	"notifications": {
	"broken_favorite": "Nieznany status, szukam go…",
	"favorited_you": "dodał(-a) twój status do ulubionych",
	"followed_you": "obserwuje cię",
	"load_older": "Załaduj starsze powiadomienia",
	"notifications": "Powiadomienia",
	"read": "Przeczytane!",
	"repeated_you": "powtórzył(-a) twój status",
	- "no_more_notifications": "Nie masz więcej powiadomień"
	+ "no_more_notifications": "Nie masz więcej powiadomień",
	+ "migrated_to": "wyemigrował do",
	+ "reacted_with": "zareagował z {0}"
	+ },
	+ "polls": {
	+ "add_poll": "Dodaj ankietę",
	+ "add_option": "Dodaj opcję",
	+ "option": "Opcja",
	+ "votes": "głosów",
	+ "vote": "Głosuj",
	+ "type": "Typ ankiety",
	+ "single_choice": "jednokrotnego wyboru",
	+ "multiple_choices": "wielokrotnego wyboru",
	+ "expiry": "Czas trwania ankiety",
	+ "expires_in": "Ankieta kończy się za{0}",
	+ "expired": "Ankieta skończyła się {0} temu",
	+ "not_enough_options": "Zbyt mało unikalnych opcji w ankiecie"
	+ },
	+ "emoji": {
	+ "stickers": "Naklejki",
	+ "emoji": "Emoji",
	+ "keep_open": "Zostaw selektor otwarty",
	+ "search_emoji": "Wyszukaj emoji",
	+ "add_emoji": "Wstaw emoji",
	+ "custom": "Niestandardowe emoji",
	+ "unicode": "Emoji unicode",
	+ "load_all_hint": "Załadowano pierwsze {saneAmount} emoji, Załadowanie wszystkich emoji może spowodować problemy z wydajnością.",
	+ "load_all": "Ładuję wszystkie {emojiAmount} emoji"
	+ },
	+ "interactions": {
	+ "favs_repeats": "Powtórzenia i ulubione",
	+ "follows": "Nowi obserwujący",
	+ "moves": "Użytkownik migruje",
	+ "load_older": "Załaduj starsze interakcje"
	},
	"post_status": {
	"new_status": "Dodaj nowy status",
	"account_not_locked_warning": "Twoje konto nie jest {0}. Każdy może cię zaobserwować aby zobaczyć wpisy tylko dla obserwujących.",
	"account_not_locked_warning_link": "zablokowane",
	"attachments_sensitive": "Oznacz załączniki jako wrażliwe",
	"content_type": {
	"text/plain": "Czysty tekst",
	"text/html": "HTML",
	"text/markdown": "Markdown",
	"text/bbcode": "BBCode"
	},
	"content_warning": "Temat (nieobowiązkowy)",
	"default": "Właśnie wróciłem z kościoła",
	- "direct_warning": "Ten wpis zobaczą tylko osoby, o których wspomniałeś(-aś).",
	+ "direct_warning_to_all": "Ten wpis zobaczą wszystkie osoby, o których wspomniałeś(-aś).",
	+ "direct_warning_to_first_only": "Ten wpis zobaczą tylko te osoby, o których wspomniałeś(-aś) na początku wiadomości.",
	"posting": "Wysyłanie",
	+ "scope_notice": {
	+ "public": "Ten post będzie widoczny dla każdego",
	+ "private": "Ten post będzie widoczny tylko dla twoich obserwujących",
	+ "unlisted": "Ten post nie będzie widoczny na publicznej osi czasu i całej znanej sieci"
	+ },
	"scope": {
	"direct": "Bezpośredni – Tylko dla wspomnianych użytkowników",
	"private": "Tylko dla obserwujących – Umieść dla osób, które cię obserwują",
	"public": "Publiczny – Umieść na publicznych osiach czasu",
	"unlisted": "Niewidoczny – Nie umieszczaj na publicznych osiach czasu"
	}
	},
	"registration": {
	"bio": "Bio",
	"email": "E-mail",
	"fullname": "Wyświetlana nazwa profilu",
	"password_confirm": "Potwierdzenie hasła",
	"registration": "Rejestracja",
	"token": "Token zaproszenia",
	"captcha": "CAPTCHA",
	"new_captcha": "Naciśnij na obrazek, aby dostać nowy kod captcha",
	"username_placeholder": "np. lain",
	"fullname_placeholder": "np. Lain Iwakura",
	"bio_placeholder": "e.g.\nCześć, jestem Lain.\nJestem dziewczynką z anime żyjącą na peryferiach Japonii. Możesz znać mnie z Wired.",
	"validations": {
	"username_required": "nie może być pusta",
	"fullname_required": "nie może być pusta",
	"email_required": "nie może być pusty",
	"password_required": "nie może być puste",
	"password_confirmation_required": "nie może być puste",
	"password_confirmation_match": "musi być takie jak hasło"
	}
	},
	+ "remote_user_resolver": {
	+ "remote_user_resolver": "Wyszukiwarka użytkowników nietutejszych",
	+ "searching_for": "Szukam",
	+ "error": "Nie znaleziono."
	+ },
	+ "selectable_list": {
	+ "select_all": "Zaznacz wszystko"
	+ },
	"settings": {
	"app_name": "Nazwa aplikacji",
	+ "security": "Bezpieczeństwo",
	+ "enter_current_password_to_confirm": "Wprowadź obecne hasło, by potwierdzić twoją tożsamość",
	+ "mfa": {
	+ "otp" : "OTP",
	+ "setup_otp" : "Ustaw OTP",
	+ "wait_pre_setup_otp" : "początkowe ustawianie OTP",
	+ "confirm_and_enable" : "Potwierdź i włącz OTP",
	+ "title": "Weryfikacja dwuetapowa",
	+ "generate_new_recovery_codes" : "Wygeneruj nowe kody zapasowe",
	+ "warning_of_generate_new_codes" : "Po tym gdy generujesz nowe kody zapasowe, stare przestaną działać.",
	+ "recovery_codes" : "Kody zapasowe.",
	+ "waiting_a_recovery_codes": "Otrzymuję kody zapasowe...",
	+ "recovery_codes_warning" : "Spisz kody na kartce papieru, albo zapisz je w bezpiecznym miejscu - inaczej nie zobaczysz ich już nigdy. Jeśli stracisz dostęp do twojej aplikacji 2FA i kodów zapasowych, nie będziesz miał dostępu do swojego konta.",
	+ "authentication_methods" : "Metody weryfikacji",
	+ "scan": {
	+ "title": "Skanuj",
	+ "desc": "Zeskanuj ten kod QR używając twojej aplikacji 2FA albo wpisz ten klucz:",
	+ "secret_code": "Klucz"
	+ },
	+ "verify": {
	+ "desc": "By włączyć weryfikację dwuetapową, wpisz kod z twojej aplikacji 2FA:"
	+ }
	+ },
	+ "allow_following_move": "Zezwalaj na automatyczną obserwację gdy obserwowane konto migruje",
	"attachmentRadius": "Załączniki",
	"attachments": "Załączniki",
	"autoload": "Włącz automatyczne ładowanie po przewinięciu do końca strony",
	"avatar": "Awatar",
	"avatarAltRadius": "Awatary (powiadomienia)",
	"avatarRadius": "Awatary",
	"background": "Tło",
	"bio": "Bio",
	+ "block_export": "Eksport blokad",
	+ "block_export_button": "Eksportuj twoje blokady do pliku .csv",
	+ "block_import": "Import blokad",
	+ "block_import_error": "Wystąpił błąd podczas importowania blokad",
	+ "blocks_imported": "Zaimportowano blokady, przetwarzanie może zająć trochę czasu.",
	"blocks_tab": "Bloki",
	"btnRadius": "Przyciski",
	"cBlue": "Niebieski (odpowiedz, obserwuj)",
	"cGreen": "Zielony (powtórzenia)",
	"cOrange": "Pomarańczowy (ulubione)",
	"cRed": "Czerwony (anuluj)",
	+ "change_email": "Zmień email",
	+ "change_email_error": "Wystąpił problem podczas zmiany emaila.",
	+ "changed_email": "Pomyślnie zmieniono email!",
	"change_password": "Zmień hasło",
	"change_password_error": "Podczas zmiany hasła wystąpił problem.",
	"changed_password": "Pomyślnie zmieniono hasło!",
	"collapse_subject": "Zwijaj posty z tematami",
	"composing": "Pisanie",
	"confirm_new_password": "Potwierdź nowe hasło",
	"current_avatar": "Twój obecny awatar",
	"current_password": "Obecne hasło",
	"current_profile_banner": "Twój obecny banner profilu",
	"data_import_export_tab": "Import/eksport danych",
	"default_vis": "Domyślny zakres widoczności",
	"delete_account": "Usuń konto",
	"delete_account_description": "Trwale usuń konto i wszystkie posty.",
	"delete_account_error": "Wystąpił problem z usuwaniem twojego konta. Jeżeli problem powtarza się, poinformuj administratora swojej instancji.",
	"delete_account_instructions": "Wprowadź swoje hasło w poniższe pole aby potwierdzić usunięcie konta.",
	+ "discoverable": "Zezwól na odkrywanie tego konta w wynikach wyszukiwania i innych usługa.",
	+ "domain_mutes": "Domeny",
	"avatar_size_instruction": "Zalecany minimalny rozmiar awatarów to 150x150 pikseli.",
	+ "pad_emoji": "Dodaj odstęp z obu stron emoji podczas dodawania selektorem",
	+ "emoji_reactions_on_timeline": "Pokaż reakcje emoji na osi czasu",
	"export_theme": "Zapisz motyw",
	"filtering": "Filtrowanie",
	"filtering_explanation": "Wszystkie statusy zawierające te słowa będą wyciszone. Jedno słowo na linijkę.",
	"follow_export": "Eksport obserwowanych",
	"follow_export_button": "Eksportuj swoją listę obserwowanych do pliku CSV",
	- "follow_export_processing": "Przetwarzanie, wkrótce twój plik zacznie się ściągać.",
	"follow_import": "Import obserwowanych",
	"follow_import_error": "Błąd przy importowaniu obserwowanych",
	"follows_imported": "Obserwowani zaimportowani! Przetwarzanie może trochę potrwać.",
	+ "accent": "Akcent",
	"foreground": "Pierwszy plan",
	"general": "Ogólne",
	"hide_attachments_in_convo": "Ukrywaj załączniki w rozmowach",
	"hide_attachments_in_tl": "Ukrywaj załączniki w osi czasu",
	"hide_muted_posts": "Ukrywaj wpisy wyciszonych użytkowników",
	"max_thumbnails": "Maksymalna liczba miniatur w poście",
	"hide_isp": "Ukryj panel informacji o instancji",
	"preload_images": "Ładuj wstępnie obrazy",
	"use_one_click_nsfw": "Otwieraj załączniki NSFW jednym kliknięciem",
	"hide_post_stats": "Ukrywaj statysyki postów (np. liczbę polubień)",
	"hide_user_stats": "Ukrywaj statysyki użytkowników (np. liczbę obserwujących)",
	"hide_filtered_statuses": "Ukrywaj filtrowane statusy",
	+ "import_blocks_from_a_csv_file": "Importuj blokady z pliku CSV",
	"import_followers_from_a_csv_file": "Importuj obserwowanych z pliku CSV",
	"import_theme": "Załaduj motyw",
	"inputRadius": "Pola tekstowe",
	"checkboxRadius": "Pola wyboru",
	"instance_default": "(domyślny: {value})",
	"instance_default_simple": "(domyślny)",
	"interface": "Interfejs",
	"interfaceLanguage": "Język interfejsu",
	"invalid_theme_imported": "Wybrany plik nie jest obsługiwanym motywem Pleromy. Nie dokonano zmian w twoim motywie.",
	"limited_availability": "Niedostępne w twojej przeglądarce",
	"links": "Łącza",
	"lock_account_description": "Ogranicz swoje konto dla zatwierdzonych obserwowanych",
	"loop_video": "Zapętlaj filmy",
	"loop_video_silent_only": "Zapętlaj tylko filmy bez dźwięku (np. mastodonowe „gify”)",
	"mutes_tab": "Wyciszenia",
	"play_videos_in_modal": "Odtwarzaj filmy bezpośrednio w przeglądarce mediów",
	"use_contain_fit": "Nie przycinaj załączników na miniaturach",
	"name": "Imię",
	"name_bio": "Imię i bio",
	+ "new_email": "Nowy email",
	"new_password": "Nowe hasło",
	"notification_visibility": "Rodzaje powiadomień do wyświetlania",
	"notification_visibility_follows": "Obserwacje",
	"notification_visibility_likes": "Ulubione",
	"notification_visibility_mentions": "Wzmianki",
	"notification_visibility_repeats": "Powtórzenia",
	+ "notification_visibility_moves": "Użytkownik migruje",
	+ "notification_visibility_emoji_reactions": "Reakcje",
	"no_rich_text_description": "Usuwaj formatowanie ze wszystkich postów",
	"no_blocks": "Bez blokad",
	"no_mutes": "Bez wyciszeń",
	"hide_follows_description": "Nie pokazuj kogo obserwuję",
	"hide_followers_description": "Nie pokazuj kto mnie obserwuje",
	+ "hide_follows_count_description": "Nie pokazuj licznika obserwowanych",
	+ "hide_followers_count_description": "Nie pokazuj licznika obserwujących",
	"show_admin_badge": "Pokazuj odznakę Administrator na moim profilu",
	"show_moderator_badge": "Pokazuj odznakę Moderator na moim profilu",
	"nsfw_clickthrough": "Włącz domyślne ukrywanie załączników o treści nieprzyzwoitej (NSFW)",
	"oauth_tokens": "Tokeny OAuth",
	"token": "Token",
	"refresh_token": "Odśwież token",
	"valid_until": "Ważne do",
	"revoke_token": "Odwołać",
	"panelRadius": "Panele",
	"pause_on_unfocused": "Wstrzymuj strumieniowanie kiedy karta nie jest aktywna",
	"presets": "Gotowe motywy",
	"profile_background": "Tło profilu",
	"profile_banner": "Banner profilu",
	"profile_tab": "Profil",
	"radii_help": "Ustaw zaokrąglenie krawędzi interfejsu (w pikselach)",
	"replies_in_timeline": "Odpowiedzi na osi czasu",
	"reply_link_preview": "Włącz dymek z podglądem postu po najechaniu na znak odpowiedzi",
	"reply_visibility_all": "Pokazuj wszystkie odpowiedzi",
	"reply_visibility_following": "Pokazuj tylko odpowiedzi skierowane do mnie i osób które obserwuję",
	"reply_visibility_self": "Pokazuj tylko odpowiedzi skierowane do mnie",
	+ "autohide_floating_post_button": "Ukryj automatycznie przycisk \"Nowy post\" (mobile)",
	"saving_err": "Nie udało się zapisać ustawień",
	"saving_ok": "Zapisano ustawienia",
	+ "search_user_to_block": "Wyszukaj kogo chcesz zablokować",
	+ "search_user_to_mute": "Wyszukaj kogo chcesz wyciszyć",
	"security_tab": "Bezpieczeństwo",
	"scope_copy": "Kopiuj zakres podczas odpowiadania (DM-y zawsze są kopiowane)",
	+ "minimal_scopes_mode": "Zminimalizuj opcje wyboru zakresu postów",
	"set_new_avatar": "Ustaw nowy awatar",
	"set_new_profile_background": "Ustaw nowe tło profilu",
	"set_new_profile_banner": "Ustaw nowy banner profilu",
	"settings": "Ustawienia",
	"subject_input_always_show": "Zawsze pokazuj pole tematu",
	"subject_line_behavior": "Kopiuj temat podczas odpowiedzi",
	"subject_line_email": "Jak w mailach – „re: temat”",
	"subject_line_mastodon": "Jak na Mastodonie – po prostu kopiuj",
	"subject_line_noop": "Nie kopiuj",
	"post_status_content_type": "Post status content type",
	"stop_gifs": "Odtwarzaj GIFy po najechaniu kursorem",
	"streaming": "Włącz automatycznie strumieniowanie nowych postów gdy jesteś na początku strony",
	+ "user_mutes": "Users",
	+ "useStreamingApi": "Otrzymuj posty i powiadomienia w czasie rzeczywistym",
	+ "useStreamingApiWarning": "(Niezalecane, eksperymentalne, pomija posty)",
	"text": "Tekst",
	"theme": "Motyw",
	"theme_help": "Użyj kolorów w notacji szesnastkowej (#rrggbb), by stworzyć swój motyw.",
	"theme_help_v2_1": "Możesz też zastąpić kolory i widoczność poszczególnych komponentów przełączając pola wyboru, użyj „Wyczyść wszystko” aby usunąć wszystkie zastąpienia.",
	"theme_help_v2_2": "Ikony pod niektórych wpisami są wskaźnikami kontrastu pomiędzy tłem a tekstem, po najechaniu na nie otrzymasz szczegółowe informacje. Zapamiętaj, że jeżeli używasz przezroczystości, wskaźniki pokazują najgorszy możliwy przypadek.",
	"tooltipRadius": "Etykiety/alerty",
	+ "type_domains_to_mute": "Wpisz domeny, które chcesz wyciszyć",
	"upload_a_photo": "Wyślij zdjęcie",
	"user_settings": "Ustawienia użytkownika",
	"values": {
	"false": "nie",
	"true": "tak"
	},
	+ "fun": "Zabawa",
	+ "greentext": "Memiczne strzałki",
	"notifications": "Powiadomienia",
	+ "notification_setting": "Otrzymuj powiadomienia od:",
	+ "notification_setting_follows": "Ludzi których obserwujesz",
	+ "notification_setting_non_follows": "Ludzi których nie obserwujesz",
	+ "notification_setting_followers": "Ludzi którzy obserwują ciebie",
	+ "notification_setting_non_followers": "Ludzi którzy nie obserwują ciebie",
	+ "notification_mutes": "By przestać otrzymywać powiadomienia od jednego użytkownika, wycisz go",
	+ "notification_blocks": "Blokowanie uzytkownika zatrzymuje wszystkie powiadomienia i odsubskrybowuje go.",
	"enable_web_push_notifications": "Włącz powiadomienia push",
	"style": {
	"switcher": {
	"keep_color": "Zachowaj kolory",
	"keep_shadows": "Zachowaj cienie",
	"keep_opacity": "Zachowaj widoczność",
	"keep_roundness": "Zachowaj zaokrąglenie",
	"keep_fonts": "Zachowaj czcionki",
	"save_load_hint": "Opcje „zachowaj” pozwalają na pozostanie przy obecnych opcjach po wybraniu lub załadowaniu motywu, jak i przechowywanie ich podczas eksportowania motywu. Jeżeli wszystkie są odznaczone, eksportowanie motywu spowoduje zapisanie wszystkiego.",
	"reset": "Wyzeruj",
	"clear_all": "Wyczyść wszystko",
	- "clear_opacity": "Wyczyść widoczność"
	+ "clear_opacity": "Wyczyść widoczność",
	+ "load_theme": "Załaduj motyw",
	+ "keep_as_is": "Zostaw po staremu",
	+ "use_snapshot": "Stara wersja",
	+ "use_source": "Nowa wersja",
	+ "help": {
	+ "upgraded_from_v2": "PleromaFE zostało zaaktualizowane, motyw może wyglądać nieco inaczej niż sobie zapamiętałeś.",
	+ "v2_imported": "Plik który zaimportowałeś został stworzony dla starszego FE. Próbujemy zwiększyć kompatybiliność, lecz wciąż mogą występować rozbieżności.",
	+ "future_version_imported": "Plik który zaimportowałeś został stworzony w nowszej wersji FE.",
	+ "older_version_imported": "Plik który zaimportowałeś został stworzony w starszej wersji FE.",
	+ "snapshot_present": "Migawka motywu jest załadowana, więc wszystkie wartości zostały nadpisane. Zamiast tego, możesz załadować właściwe dane motywu",
	+ "snapshot_missing": "Nie znaleziono migawki motywu w pliku, więc motyw może wyglądać inaczej niż pierwotnie zaplanowano.",
	+ "fe_upgraded": "Silnik motywów PleromaFE został zaaktualizowany.",
	+ "fe_downgraded": "Wersja PleromaFE została cofnięta.",
	+ "migration_snapshot_ok": "Żeby być bezpiecznym, migawka motywu została załadowana. Możesz spróbować załadować dane motywu.",
	+ "migration_napshot_gone": "Z jakiegoś powodu migawka zniknęła, niektóre rzeczy mogą wyglądać inaczej niż sobie zapamiętałeś.",
	+ "snapshot_source_mismatch": "Konflikt wersji: najprawdopodobniej FE zostało cofnięte do poprzedniej wersji i zaaktualizowane ponownie, jeśli zmieniłeś motyw używając starszej wersji FE, najprawdopodobniej chcesz używać starszej wersji, w przeciwnym razie użyj nowej wersji."
	+ }
	},
	"common": {
	"color": "Kolor",
	"opacity": "Widoczność",
	"contrast": {
	"hint": "Współczynnik kontrastu wynosi {ratio}, {level} {context}",
	"level": {
	"aa": "spełnia wymogi poziomu AA (minimalne)",
	"aaa": "spełnia wymogi poziomu AAA (zalecane)",
	"bad": "nie spełnia żadnych wymogów dostępności"
	},
	"context": {
	"18pt": "dla dużego tekstu (18pt+)",
	"text": "dla tekstu"
	}
	}
	},
	"common_colors": {
	"_tab_label": "Ogólne",
	"main": "Ogólne kolory",
	"foreground_hint": "Zajrzyj do karty „Zaawansowane”, aby uzyskać dokładniejszą kontrolę",
	"rgbo": "Ikony, wyróżnienia, odznaki"
	},
	"advanced_colors": {
	"_tab_label": "Zaawansowane",
	"alert": "Tło alertu",
	"alert_error": "Błąd",
	+ "alert_warning": "Ostrzeżenie",
	+ "alert_neutral": "Neutralne",
	+ "post": "Posty/Bio użytkowników",
	"badge": "Tło odznaki",
	+ "popover": "Etykiety, menu, popovery",
	"badge_notification": "Powiadomienie",
	"panel_header": "Nagłówek panelu",
	"top_bar": "Górny pasek",
	"borders": "Granice",
	"buttons": "Przyciski",
	"inputs": "Pola wejścia",
	- "faint_text": "Zanikający tekst"
	+ "faint_text": "Zanikający tekst",
	+ "underlay": "Podkład",
	+ "poll": "Wykres ankiety",
	+ "icons": "Ikony",
	+ "highlight": "Podświetlone elementy",
	+ "pressed": "Naciśnięte",
	+ "selectedPost": "Wybrany post",
	+ "selectedMenu": "Wybrany element menu",
	+ "disabled": "Wyłączone",
	+ "toggled": "Przełączone",
	+ "tabs": "Karty"
	},
	"radii": {
	"_tab_label": "Zaokrąglenie"
	},
	"shadows": {
	"_tab_label": "Cień i podświetlenie",
	"component": "Komponent",
	"override": "Zastąp",
	"shadow_id": "Cień #{value}",
	"blur": "Rozmycie",
	"spread": "Szerokość",
	"inset": "Inset",
	- "hint": "Możesz też używać --zmiennych jako kolorów, aby wykorzystać zmienne CSS3. Pamiętaj, że ustawienie widoczności nie będzie wtedy działać.",
	+ "hintV3": "Dla cieni możesz również użyć notacji {0} by użyć inny slot koloru.",
	"filter_hint": {
	"always_drop_shadow": "Ostrzeżenie, ten cień zawsze używa {0} jeżeli to obsługiwane przez przeglądarkę.",
	"drop_shadow_syntax": "{0} nie obsługuje parametru {1} i słowa kluczowego {2}.",
	"avatar_inset": "Pamiętaj że użycie jednocześnie cieni inset i nie inset na awatarach może daćnieoczekiwane wyniki z przezroczystymi awatarami.",
	"spread_zero": "Cienie o ujemnej szerokości będą widoczne tak, jakby wynosiła ona zero",
	"inset_classic": "Cienie inset będą używały {0}"
	},
	"components": {
	"panel": "Panel",
	"panelHeader": "Nagłówek panelu",
	"topBar": "Górny pasek",
	"avatar": "Awatar użytkownika (w widoku profilu)",
	"avatarStatus": "Awatar użytkownika (w widoku wpisu)",
	"popup": "Wyskakujące okna i podpowiedzi",
	"button": "Przycisk",
	"buttonHover": "Przycisk (po najechaniu)",
	"buttonPressed": "Przycisk (naciśnięty)",
	"buttonPressedHover": "Przycisk(naciśnięty+najechany)",
	"input": "Pole wejścia"
	}
	},
	"fonts": {
	"_tab_label": "Czcionki",
	"help": "Wybierz czcionkę używaną przez elementy UI. Jeżeli wybierzesz niestandardową, musisz wpisać dokładnie tę nazwę, pod którą pojawia się w systemie.",
	"components": {
	"interface": "Interfejs",
	"input": "Pola wejścia",
	"post": "Tekst postu",
	"postCode": "Tekst o stałej szerokości znaków w sformatowanym poście"
	},
	"family": "Nazwa czcionki",
	"size": "Rozmiar (w pikselach)",
	"weight": "Grubość",
	"custom": "Niestandardowa"
	},
	"preview": {
	"header": "Podgląd",
	"content": "Zawartość",
	"error": "Przykładowy błąd",
	"button": "Przycisk",
	"text": "Trochę więcej {0} i {1}",
	"mono": "treści",
	"input": "Właśnie wróciłem z kościoła",
	"faint_link": "pomocny podręcznik",
	"fine_print": "Przeczytaj nasz {0}, aby nie nauczyć się niczego przydatnego!",
	"header_faint": "W porządku",
	"checkbox": "Przeleciałem przez zasady użytkowania",
	"link": "i fajny mały odnośnik"
	}
	},
	"version": {
	"title": "Wersja",
	"backend_version": "Wersja back-endu",
	"frontend_version": "Wersja front-endu"
	}
	},
	+ "time": {
	+ "day": "{0} dzień",
	+ "days": "{0} dni",
	+ "day_short": "{0}d",
	+ "days_short": "{0}d",
	+ "hour": "{0} godzina",
	+ "hours": "{0} godzin",
	+ "hour_short": "{0} godz.",
	+ "hours_short": "{0} godz.",
	+ "in_future": "za {0}",
	+ "in_past": "{0} temu",
	+ "minute": "{0} minuta",
	+ "minutes": "{0} minut",
	+ "minute_short": "{0}min",
	+ "minutes_short": "{0}min",
	+ "month": "{0} miesiąc",
	+ "months": "{0} miesięcy",
	+ "month_short": "{0} mies.",
	+ "months_short": "{0} mies.",
	+ "now": "teraz",
	+ "now_short": "teraz",
	+ "second": "{0} sekunda",
	+ "seconds": "{0} sekund",
	+ "second_short": "{0}s",
	+ "seconds_short": "{0}s",
	+ "week": "{0} tydzień",
	+ "weeks": "{0} tygodni",
	+ "week_short": "{0} tydz.",
	+ "weeks_short": "{0} tyg.",
	+ "year": "{0} rok",
	+ "years": "{0} lata",
	+ "year_short": "{0} r.",
	+ "years_short": "{0} lata"
	+ },
	"timeline": {
	"collapse": "Zwiń",
	"conversation": "Rozmowa",
	"error_fetching": "Błąd pobierania",
	"load_older": "Załaduj starsze statusy",
	"no_retweet_hint": "Wpis oznaczony jako tylko dla obserwujących lub bezpośredni nie może zostać powtórzony",
	"repeated": "powtórzył(-a)",
	"show_new": "Pokaż nowe",
	"up_to_date": "Na bieżąco",
	"no_more_statuses": "Brak kolejnych statusów",
	"no_statuses": "Brak statusów"
	},
	"status": {
	+ "favorites": "Ulubione",
	+ "repeats": "Powtórzenia",
	+ "delete": "Usuń status",
	+ "pin": "Przypnij na profilu",
	+ "unpin": "Odepnij z profilu",
	+ "pinned": "Przypnięte",
	+ "delete_confirm": "Czy naprawdę chcesz usunąć ten status?",
	"reply_to": "Odpowiedź dla",
	- "replies_list": "Odpowiedzi:"
	+ "replies_list": "Odpowiedzi:",
	+ "mute_conversation": "Wycisz konwersację",
	+ "unmute_conversation": "Odcisz konwersację"
	},
	"user_card": {
	"approve": "Przyjmij",
	"block": "Zablokuj",
	"blocked": "Zablokowany!",
	"deny": "Odrzuć",
	"favorites": "Ulubione",
	"follow": "Obserwuj",
	"follow_sent": "Wysłano prośbę!",
	"follow_progress": "Wysyłam prośbę…",
	"follow_again": "Wysłać prośbę ponownie?",
	"follow_unfollow": "Przestań obserwować",
	"followees": "Obserwowani",
	"followers": "Obserwujący",
	"following": "Obserwowany!",
	"follows_you": "Obserwuje cię!",
	+ "hidden": "Ukryte",
	"its_you": "To ty!",
	"media": "Media",
	+ "mention": "Wspomnienie",
	"mute": "Wycisz",
	"muted": "Wyciszony(-a)",
	"per_day": "dziennie",
	"remote_follow": "Zdalna obserwacja",
	+ "report": "Raportuj",
	"statuses": "Statusy",
	+ "subscribe": "Subskrybuj",
	+ "unsubscribe": "Odsubskrybuj",
	"unblock": "Odblokuj",
	"unblock_progress": "Odblokowuję…",
	"block_progress": "Blokuję…",
	"unmute": "Cofnij wyciszenie",
	"unmute_progress": "Cofam wyciszenie…",
	- "mute_progress": "Wyciszam…"
	+ "mute_progress": "Wyciszam…",
	+ "hide_repeats": "Ukryj powtórzenia",
	+ "show_repeats": "Pokaż powtórzenia",
	+ "admin_menu": {
	+ "moderation": "Moderacja",
	+ "grant_admin": "Przyznaj admina",
	+ "revoke_admin": "Odwołaj admina",
	+ "grant_moderator": "Przyznaj moderatora",
	+ "revoke_moderator": "Odwołaj moderatora",
	+ "activate_account": "Aktywuj konto",
	+ "deactivate_account": "Dezaktywuj konto",
	+ "delete_account": "Usuń konto",
	+ "force_nsfw": "Oznacz wszystkie posty jako NSFW",
	+ "strip_media": "Usuń multimedia z postów",
	+ "force_unlisted": "Wymuś posty na niepubliczne",
	+ "sandbox": "Wymuś by posty były tylko dla obserwujących",
	+ "disable_remote_subscription": "Zakaż obserwowania użytkownika ze zdalnych instancji",
	+ "disable_any_subscription": "Zakaż całkowicie obserwowania użytkownika",
	+ "quarantine": "Zakaż federowania postów od tego użytkownika",
	+ "delete_user": "Usuń użytkownika",
	+ "delete_user_confirmation": "Czy jesteś absolutnie pewny? Ta operacja nie może być cofnięta."
	+ }
	},
	"user_profile": {
	"timeline_title": "Oś czasu użytkownika",
	"profile_does_not_exist": "Przepraszamy, ten profil nie istnieje.",
	"profile_loading_error": "Przepraszamy, wystąpił błąd podczas ładowania tego profilu."
	},
	+ "user_reporting": {
	+ "title": "Raportowanie {0}",
	+ "add_comment_description": "Raport zostanie wysłany do moderatorów instancji. Możesz dodać powód dlaczego raportujesz to konto poniżej:",
	+ "additional_comments": "Dodatkowe komentarze",
	+ "forward_description": "To konto jest z innego serwera. Wysłać również tam kopię raportu?",
	+ "forward_to": "Przekaż do{0}",
	+ "submit": "Wyślij",
	+ "generic_error": "Wystąpił błąd podczas przetwarzania twojej prośby."
	+ },
	"who_to_follow": {
	"more": "Więcej",
	"who_to_follow": "Propozycje obserwacji"
	},
	"tool_tip": {
	"media_upload": "Wyślij media",
	"repeat": "Powtórz",
	"reply": "Odpowiedz",
	"favorite": "Dodaj do ulubionych",
	+ "add_reaction": "Dodaj reakcję",
	"user_settings": "Ustawienia użytkownika"
	},
	"upload":{
	"error": {
	"base": "Wysyłanie nie powiodło się.",
	"file_too_big": "Zbyt duży plik [{filesize}{filesizeunit} / {allowedsize}{allowedsizeunit}]",
	"default": "Spróbuj ponownie później"
	},
	"file_size_units": {
	"B": "B",
	"KiB": "KiB",
	"MiB": "MiB",
	"GiB": "GiB",
	"TiB": "TiB"
	}
	+ },
	+ "search": {
	+ "people": "Ludzie",
	+ "hashtags": "Hasztagi",
	+ "person_talking": "{count} osoba rozmawia o tym",
	+ "people_talking": "{count} osób rozmawia o tym",
	+ "no_results": "Brak wyników"
	+ },
	+ "password_reset": {
	+ "forgot_password": "Zapomniałeś hasła?",
	+ "password_reset": "Reset hasła",
	+ "instruction": "Wprowadź swój adres email lub nazwę użytkownika. Wyślemy ci link z którym możesz zresetować hasło.",
	+ "placeholder": "Twój email lub nazwa użytkownika",
	+ "check_email": "Sprawdź pocztę, aby uzyskać link do zresetowania hasła.",
	+ "return_home": "Wróć do strony głównej",
	+ "not_found": "Nie mogliśmy znaleźć tego emaila lub nazwy użytkownika.",
	+ "too_many_requests": "Przekroczyłeś limit prób, spróbuj ponownie później.",
	+ "password_reset_disabled": "Resetowanie hasła jest wyłączone. Proszę skontaktuj się z administratorem tej instancji.",
	+ "password_reset_required": "Musisz zresetować hasło, by się zalogować.",
	+ "password_reset_required_but_mailer_is_disabled": "Musisz zresetować hasło, ale resetowanie hasła jest wyłączone. Proszę skontaktuj się z administratorem tej instancji."
	}
	}
	diff --git a/src/modules/config.js b/src/modules/config.js
	index 7997521daf..8f4638f525 100644
	--- a/src/modules/config.js
	+++ b/src/modules/config.js
	@@ -1,112 +1,113 @@
	import { set, delete as del } from 'vue'
	import { setPreset, applyTheme } from '../services/style_setter/style_setter.js'

	const browserLocale = (window.navigator.language \|\| 'en').split('-')[0]

	export const defaultState = {
	colors: {},
	theme: undefined,
	customTheme: undefined,
	customThemeSource: undefined,
	hideISP: false,
	// bad name: actually hides posts of muted USERS
	hideMutedPosts: undefined, // instance default
	collapseMessageWithSubject: undefined, // instance default
	padEmoji: true,
	hideAttachments: false,
	hideAttachmentsInConv: false,
	maxThumbnails: 16,
	hideNsfw: true,
	preloadImage: true,
	loopVideo: true,
	loopVideoSilentOnly: true,
	autoLoad: true,
	streaming: false,
	hoverPreview: true,
	emojiReactionsOnTimeline: true,
	autohideFloatingPostButton: false,
	pauseOnUnfocused: true,
	stopGifs: false,
	replyVisibility: 'all',
	notificationVisibility: {
	follows: true,
	mentions: true,
	likes: true,
	repeats: true,
	moves: true,
	- emojiReactions: false
	+ emojiReactions: false,
	+ followRequest: true
	},
	webPushNotifications: false,
	muteWords: [],
	highlight: {},
	interfaceLanguage: browserLocale,
	hideScopeNotice: false,
	useStreamingApi: false,
	scopeCopy: undefined, // instance default
	subjectLineBehavior: undefined, // instance default
	alwaysShowSubjectInput: undefined, // instance default
	postContentType: undefined, // instance default
	minimalScopesMode: undefined, // instance default
	// This hides statuses filtered via a word filter
	hideFilteredStatuses: undefined, // instance default
	playVideosInModal: false,
	useOneClickNsfw: false,
	useContainFit: false,
	greentext: undefined, // instance default
	hidePostStats: undefined, // instance default
	hideUserStats: undefined // instance default
	}

	// caching the instance default properties
	export const instanceDefaultProperties = Object.entries(defaultState)
	.filter(([key, value]) => value === undefined)
	.map(([key, value]) => key)

	const config = {
	state: defaultState,
	getters: {
	mergedConfig (state, getters, rootState, rootGetters) {
	const { instance } = rootState
	return {
	...state,
	...instanceDefaultProperties
	.map(key => [key, state[key] === undefined
	? instance[key]
	: state[key]
	])
	.reduce((acc, [key, value]) => ({ ...acc, [key]: value }), {})
	}
	}
	},
	mutations: {
	setOption (state, { name, value }) {
	set(state, name, value)
	},
	setHighlight (state, { user, color, type }) {
	const data = this.state.config.highlight[user]
	if (color \|\| type) {
	set(state.highlight, user, { color: color \|\| data.color, type: type \|\| data.type })
	} else {
	del(state.highlight, user)
	}
	}
	},
	actions: {
	setHighlight ({ commit, dispatch }, { user, color, type }) {
	commit('setHighlight', { user, color, type })
	},
	setOption ({ commit, dispatch }, { name, value }) {
	commit('setOption', { name, value })
	switch (name) {
	case 'theme':
	setPreset(value)
	break
	case 'customTheme':
	case 'customThemeSource':
	applyTheme(value)
	}
	}
	}
	}

	export default config
	diff --git a/src/modules/statuses.js b/src/modules/statuses.js
	index f1b7dcbda6..cd8c1dba66 100644
	--- a/src/modules/statuses.js
	+++ b/src/modules/statuses.js
	@@ -1,741 +1,774 @@
	import {
	remove,
	slice,
	each,
	findIndex,
	find,
	maxBy,
	minBy,
	merge,
	first,
	last,
	isArray,
	omitBy
	} from 'lodash'
	import { set } from 'vue'
	+import { isStatusNotification } from '../services/notification_utils/notification_utils.js'
	import apiService from '../services/api/api.service.js'
	// import parse from '../services/status_parser/status_parser.js'

	const emptyTl = (userId = 0) => ({
	statuses: [],
	statusesObject: {},
	faves: [],
	visibleStatuses: [],
	visibleStatusesObject: {},
	newStatusCount: 0,
	maxId: 0,
	minId: 0,
	minVisibleId: 0,
	loading: false,
	followers: [],
	friends: [],
	userId,
	flushMarker: 0
	})

	const emptyNotifications = () => ({
	desktopNotificationSilence: true,
	maxId: 0,
	minId: Number.POSITIVE_INFINITY,
	data: [],
	idStore: {},
	loading: false,
	error: false
	})

	export const defaultState = () => ({
	allStatuses: [],
	allStatusesObject: {},
	conversationsObject: {},
	maxId: 0,
	notifications: emptyNotifications(),
	favorites: new Set(),
	error: false,
	errorData: null,
	timelines: {
	mentions: emptyTl(),
	public: emptyTl(),
	user: emptyTl(),
	favorites: emptyTl(),
	media: emptyTl(),
	publicAndExternal: emptyTl(),
	friends: emptyTl(),
	tag: emptyTl(),
	dms: emptyTl()
	}
	})

	export const prepareStatus = (status) => {
	// Set deleted flag
	status.deleted = false

	// To make the array reactive
	status.attachments = status.attachments \|\| []

	return status
	}

	const visibleNotificationTypes = (rootState) => {
	return [
	rootState.config.notificationVisibility.likes && 'like',
	rootState.config.notificationVisibility.mentions && 'mention',
	rootState.config.notificationVisibility.repeats && 'repeat',
	rootState.config.notificationVisibility.follows && 'follow',
	rootState.config.notificationVisibility.moves && 'move',
	rootState.config.notificationVisibility.emojiReactions && 'pleroma:emoji_reactions'
	].filter(_ => _)
	}

	const mergeOrAdd = (arr, obj, item) => {
	const oldItem = obj[item.id]

	if (oldItem) {
	// We already have this, so only merge the new info.
	// We ignore null values to avoid overwriting existing properties with missing data
	// we also skip 'user' because that is handled by users module
	merge(oldItem, omitBy(item, (v, k) => v === null \|\| k === 'user'))
	// Reactivity fix.
	oldItem.attachments.splice(oldItem.attachments.length)
	return { item: oldItem, new: false }
	} else {
	// This is a new item, prepare it
	prepareStatus(item)
	arr.push(item)
	set(obj, item.id, item)
	return { item, new: true }
	}
	}

	const sortById = (a, b) => {
	const seqA = Number(a.id)
	const seqB = Number(b.id)
	const isSeqA = !Number.isNaN(seqA)
	const isSeqB = !Number.isNaN(seqB)
	if (isSeqA && isSeqB) {
	return seqA > seqB ? -1 : 1
	} else if (isSeqA && !isSeqB) {
	return 1
	} else if (!isSeqA && isSeqB) {
	return -1
	} else {
	return a.id > b.id ? -1 : 1
	}
	}

	const sortTimeline = (timeline) => {
	timeline.visibleStatuses = timeline.visibleStatuses.sort(sortById)
	timeline.statuses = timeline.statuses.sort(sortById)
	timeline.minVisibleId = (last(timeline.visibleStatuses) \|\| {}).id
	return timeline
	}

	// Add status to the global storages (arrays and objects maintaining statuses) except timelines
	const addStatusToGlobalStorage = (state, data) => {
	const result = mergeOrAdd(state.allStatuses, state.allStatusesObject, data)
	if (result.new) {
	// Add to conversation
	const status = result.item
	const conversationsObject = state.conversationsObject
	const conversationId = status.statusnet_conversation_id
	if (conversationsObject[conversationId]) {
	conversationsObject[conversationId].push(status)
	} else {
	set(conversationsObject, conversationId, [status])
	}
	}
	return result
	}

	// Remove status from the global storages (arrays and objects maintaining statuses) except timelines
	const removeStatusFromGlobalStorage = (state, status) => {
	remove(state.allStatuses, { id: status.id })

	// TODO: Need to remove from allStatusesObject?

	// Remove possible notification
	remove(state.notifications.data, ({ action: { id } }) => id === status.id)

	// Remove from conversation
	const conversationId = status.statusnet_conversation_id
	if (state.conversationsObject[conversationId]) {
	remove(state.conversationsObject[conversationId], { id: status.id })
	}
	}

	const addNewStatuses = (state, { statuses, showImmediately = false, timeline, user = {},
	noIdUpdate = false, userId }) => {
	// Sanity check
	if (!isArray(statuses)) {
	return false
	}

	const allStatuses = state.allStatuses
	const timelineObject = state.timelines[timeline]

	const maxNew = statuses.length > 0 ? maxBy(statuses, 'id').id : 0
	const minNew = statuses.length > 0 ? minBy(statuses, 'id').id : 0
	const newer = timeline && (maxNew > timelineObject.maxId \|\| timelineObject.maxId === 0) && statuses.length > 0
	const older = timeline && (minNew < timelineObject.minId \|\| timelineObject.minId === 0) && statuses.length > 0

	if (!noIdUpdate && newer) {
	timelineObject.maxId = maxNew
	}
	if (!noIdUpdate && older) {
	timelineObject.minId = minNew
	}

	// This makes sure that user timeline won't get data meant for other
	// user. I.e. opening different user profiles makes request which could
	// return data late after user already viewing different user profile
	if ((timeline === 'user' \|\| timeline === 'media') && timelineObject.userId !== userId) {
	return
	}

	const addStatus = (data, showImmediately, addToTimeline = true) => {
	const result = addStatusToGlobalStorage(state, data)
	const status = result.item

	if (result.new) {
	// We are mentioned in a post
	if (status.type === 'status' && find(status.attentions, { id: user.id })) {
	const mentions = state.timelines.mentions

	// Add the mention to the mentions timeline
	if (timelineObject !== mentions) {
	mergeOrAdd(mentions.statuses, mentions.statusesObject, status)
	mentions.newStatusCount += 1

	sortTimeline(mentions)
	}
	}
	if (status.visibility === 'direct') {
	const dms = state.timelines.dms

	mergeOrAdd(dms.statuses, dms.statusesObject, status)
	dms.newStatusCount += 1

	sortTimeline(dms)
	}
	}

	// Decide if we should treat the status as new for this timeline.
	let resultForCurrentTimeline
	// Some statuses should only be added to the global status repository.
	if (timeline && addToTimeline) {
	resultForCurrentTimeline = mergeOrAdd(timelineObject.statuses, timelineObject.statusesObject, status)
	}

	if (timeline && showImmediately) {
	// Add it directly to the visibleStatuses, don't change
	// newStatusCount
	mergeOrAdd(timelineObject.visibleStatuses, timelineObject.visibleStatusesObject, status)
	} else if (timeline && addToTimeline && resultForCurrentTimeline.new) {
	// Just change newStatuscount
	timelineObject.newStatusCount += 1
	}

	return status
	}

	const favoriteStatus = (favorite, counter) => {
	const status = find(allStatuses, { id: favorite.in_reply_to_status_id })
	if (status) {
	// This is our favorite, so the relevant bit.
	if (favorite.user.id === user.id) {
	status.favorited = true
	} else {
	status.fave_num += 1
	}
	}
	return status
	}

	const processors = {
	'status': (status) => {
	addStatus(status, showImmediately)
	},
	'retweet': (status) => {
	// RetweetedStatuses are never shown immediately
	const retweetedStatus = addStatus(status.retweeted_status, false, false)

	let retweet
	// If the retweeted status is already there, don't add the retweet
	// to the timeline.
	if (timeline && find(timelineObject.statuses, (s) => {
	if (s.retweeted_status) {
	return s.id === retweetedStatus.id \|\| s.retweeted_status.id === retweetedStatus.id
	} else {
	return s.id === retweetedStatus.id
	}
	})) {
	// Already have it visible (either as the original or another RT), don't add to timeline, don't show.
	retweet = addStatus(status, false, false)
	} else {
	retweet = addStatus(status, showImmediately)
	}

	retweet.retweeted_status = retweetedStatus
	},
	'favorite': (favorite) => {
	// Only update if this is a new favorite.
	// Ignore our own favorites because we get info about likes as response to like request
	if (!state.favorites.has(favorite.id)) {
	state.favorites.add(favorite.id)
	favoriteStatus(favorite)
	}
	},
	'deletion': (deletion) => {
	const uri = deletion.uri
	const status = find(allStatuses, { uri })
	if (!status) {
	return
	}

	removeStatusFromGlobalStorage(state, status)

	if (timeline) {
	remove(timelineObject.statuses, { uri })
	remove(timelineObject.visibleStatuses, { uri })
	}
	},
	'follow': (follow) => {
	// NOOP, it is known status but we don't do anything about it for now
	},
	'default': (unknown) => {
	console.log('unknown status type')
	console.log(unknown)
	}
	}

	each(statuses, (status) => {
	const type = status.type
	const processor = processors[type] \|\| processors['default']
	processor(status)
	})

	// Keep the visible statuses sorted
	if (timeline) {
	sortTimeline(timelineObject)
	}
	}

	const addNewNotifications = (state, { dispatch, notifications, older, visibleNotificationTypes, rootGetters }) => {
	each(notifications, (notification) => {
	- if (notification.type !== 'follow' && notification.type !== 'move') {
	+ if (isStatusNotification(notification.type)) {
	notification.action = addStatusToGlobalStorage(state, notification.action).item
	notification.status = notification.status && addStatusToGlobalStorage(state, notification.status).item
	}

	if (notification.type === 'pleroma:emoji_reaction') {
	dispatch('fetchEmojiReactionsBy', notification.status.id)
	}

	// Only add a new notification if we don't have one for the same action
	if (!state.notifications.idStore.hasOwnProperty(notification.id)) {
	state.notifications.maxId = notification.id > state.notifications.maxId
	? notification.id
	: state.notifications.maxId
	state.notifications.minId = notification.id < state.notifications.minId
	? notification.id
	: state.notifications.minId

	state.notifications.data.push(notification)
	state.notifications.idStore[notification.id] = notification

	if ('Notification' in window && window.Notification.permission === 'granted') {
	const notifObj = {}
	const status = notification.status
	const title = notification.from_profile.name
	notifObj.icon = notification.from_profile.profile_image_url
	let i18nString
	switch (notification.type) {
	case 'like':
	i18nString = 'favorited_you'
	break
	case 'repeat':
	i18nString = 'repeated_you'
	break
	case 'follow':
	i18nString = 'followed_you'
	break
	case 'move':
	i18nString = 'migrated_to'
	break
	+ case 'follow_request':
	+ i18nString = 'follow_request'
	+ break
	}

	if (notification.type === 'pleroma:emoji_reaction') {
	notifObj.body = rootGetters.i18n.t('notifications.reacted_with', [notification.emoji])
	} else if (i18nString) {
	notifObj.body = rootGetters.i18n.t('notifications.' + i18nString)
	- } else {
	+ } else if (isStatusNotification(notification.type)) {
	notifObj.body = notification.status.text
	}

	// Shows first attached non-nsfw image, if any. Should add configuration for this somehow...
	if (status && status.attachments && status.attachments.length > 0 && !status.nsfw &&
	status.attachments[0].mimetype.startsWith('image/')) {
	notifObj.image = status.attachments[0].url
	}

	if (!notification.seen && !state.notifications.desktopNotificationSilence && visibleNotificationTypes.includes(notification.type)) {
	let desktopNotification = new window.Notification(title, notifObj)
	// Chrome is known for not closing notifications automatically
	// according to MDN, anyway.
	setTimeout(desktopNotification.close.bind(desktopNotification), 5000)
	}
	}
	} else if (notification.seen) {
	state.notifications.idStore[notification.id].seen = true
	}
	})
	}

	const removeStatus = (state, { timeline, userId }) => {
	const timelineObject = state.timelines[timeline]
	if (userId) {
	remove(timelineObject.statuses, { user: { id: userId } })
	remove(timelineObject.visibleStatuses, { user: { id: userId } })
	timelineObject.minVisibleId = timelineObject.visibleStatuses.length > 0 ? last(timelineObject.visibleStatuses).id : 0
	timelineObject.maxId = timelineObject.statuses.length > 0 ? first(timelineObject.statuses).id : 0
	}
	}

	export const mutations = {
	addNewStatuses,
	addNewNotifications,
	removeStatus,
	showNewStatuses (state, { timeline }) {
	const oldTimeline = (state.timelines[timeline])

	oldTimeline.newStatusCount = 0
	oldTimeline.visibleStatuses = slice(oldTimeline.statuses, 0, 50)
	oldTimeline.minVisibleId = last(oldTimeline.visibleStatuses).id
	oldTimeline.minId = oldTimeline.minVisibleId
	oldTimeline.visibleStatusesObject = {}
	each(oldTimeline.visibleStatuses, (status) => { oldTimeline.visibleStatusesObject[status.id] = status })
	},
	resetStatuses (state) {
	const emptyState = defaultState()
	Object.entries(emptyState).forEach(([key, value]) => {
	state[key] = value
	})
	},
	clearTimeline (state, { timeline, excludeUserId = false }) {
	const userId = excludeUserId ? state.timelines[timeline].userId : undefined
	state.timelines[timeline] = emptyTl(userId)
	},
	clearNotifications (state) {
	state.notifications = emptyNotifications()
	},
	setFavorited (state, { status, value }) {
	const newStatus = state.allStatusesObject[status.id]

	if (newStatus.favorited !== value) {
	if (value) {
	newStatus.fave_num++
	} else {
	newStatus.fave_num--
	}
	}

	newStatus.favorited = value
	},
	setFavoritedConfirm (state, { status, user }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.favorited = status.favorited
	newStatus.fave_num = status.fave_num
	const index = findIndex(newStatus.favoritedBy, { id: user.id })
	if (index !== -1 && !newStatus.favorited) {
	newStatus.favoritedBy.splice(index, 1)
	} else if (index === -1 && newStatus.favorited) {
	newStatus.favoritedBy.push(user)
	}
	},
	setMutedStatus (state, status) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.thread_muted = status.thread_muted

	if (newStatus.thread_muted !== undefined) {
	state.conversationsObject[newStatus.statusnet_conversation_id].forEach(status => { status.thread_muted = newStatus.thread_muted })
	}
	},
	setRetweeted (state, { status, value }) {
	const newStatus = state.allStatusesObject[status.id]

	if (newStatus.repeated !== value) {
	if (value) {
	newStatus.repeat_num++
	} else {
	newStatus.repeat_num--
	}
	}

	newStatus.repeated = value
	},
	setRetweetedConfirm (state, { status, user }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.repeated = status.repeated
	newStatus.repeat_num = status.repeat_num
	const index = findIndex(newStatus.rebloggedBy, { id: user.id })
	if (index !== -1 && !newStatus.repeated) {
	newStatus.rebloggedBy.splice(index, 1)
	} else if (index === -1 && newStatus.repeated) {
	newStatus.rebloggedBy.push(user)
	}
	},
	setDeleted (state, { status }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.deleted = true
	},
	setManyDeleted (state, condition) {
	Object.values(state.allStatusesObject).forEach(status => {
	if (condition(status)) {
	status.deleted = true
	}
	})
	},
	setLoading (state, { timeline, value }) {
	state.timelines[timeline].loading = value
	},
	setNsfw (state, { id, nsfw }) {
	const newStatus = state.allStatusesObject[id]
	newStatus.nsfw = nsfw
	},
	setError (state, { value }) {
	state.error = value
	},
	setErrorData (state, { value }) {
	state.errorData = value
	},
	setNotificationsLoading (state, { value }) {
	state.notifications.loading = value
	},
	setNotificationsError (state, { value }) {
	state.notifications.error = value
	},
	setNotificationsSilence (state, { value }) {
	state.notifications.desktopNotificationSilence = value
	},
	markNotificationsAsSeen (state) {
	each(state.notifications.data, (notification) => {
	notification.seen = true
	})
	},
	+ markSingleNotificationAsSeen (state, { id }) {
	+ const notification = find(state.notifications.data, n => n.id === id)
	+ if (notification) notification.seen = true
	+ },
	+ dismissNotification (state, { id }) {
	+ state.notifications.data = state.notifications.data.filter(n => n.id !== id)
	+ },
	+ updateNotification (state, { id, updater }) {
	+ const notification = find(state.notifications.data, n => n.id === id)
	+ notification && updater(notification)
	+ },
	queueFlush (state, { timeline, id }) {
	state.timelines[timeline].flushMarker = id
	},
	addRepeats (state, { id, rebloggedByUsers, currentUser }) {
	const newStatus = state.allStatusesObject[id]
	newStatus.rebloggedBy = rebloggedByUsers.filter(_ => _)
	// repeats stats can be incorrect based on polling condition, let's update them using the most recent data
	newStatus.repeat_num = newStatus.rebloggedBy.length
	newStatus.repeated = !!newStatus.rebloggedBy.find(({ id }) => currentUser.id === id)
	},
	addFavs (state, { id, favoritedByUsers, currentUser }) {
	const newStatus = state.allStatusesObject[id]
	newStatus.favoritedBy = favoritedByUsers.filter(_ => _)
	// favorites stats can be incorrect based on polling condition, let's update them using the most recent data
	newStatus.fave_num = newStatus.favoritedBy.length
	newStatus.favorited = !!newStatus.favoritedBy.find(({ id }) => currentUser.id === id)
	},
	addEmojiReactionsBy (state, { id, emojiReactions, currentUser }) {
	const status = state.allStatusesObject[id]
	set(status, 'emoji_reactions', emojiReactions)
	},
	addOwnReaction (state, { id, emoji, currentUser }) {
	const status = state.allStatusesObject[id]
	const reactionIndex = findIndex(status.emoji_reactions, { name: emoji })
	const reaction = status.emoji_reactions[reactionIndex] \|\| { name: emoji, count: 0, accounts: [] }

	const newReaction = {
	...reaction,
	count: reaction.count + 1,
	me: true,
	accounts: [
	...reaction.accounts,
	currentUser
	]
	}

	// Update count of existing reaction if it exists, otherwise append at the end
	if (reactionIndex >= 0) {
	set(status.emoji_reactions, reactionIndex, newReaction)
	} else {
	set(status, 'emoji_reactions', [...status.emoji_reactions, newReaction])
	}
	},
	removeOwnReaction (state, { id, emoji, currentUser }) {
	const status = state.allStatusesObject[id]
	const reactionIndex = findIndex(status.emoji_reactions, { name: emoji })
	if (reactionIndex < 0) return

	const reaction = status.emoji_reactions[reactionIndex]
	const accounts = reaction.accounts \|\| []

	const newReaction = {
	...reaction,
	count: reaction.count - 1,
	me: false,
	accounts: accounts.filter(acc => acc.id !== currentUser.id)
	}

	if (newReaction.count > 0) {
	set(status.emoji_reactions, reactionIndex, newReaction)
	} else {
	set(status, 'emoji_reactions', status.emoji_reactions.filter(r => r.name !== emoji))
	}
	},
	updateStatusWithPoll (state, { id, poll }) {
	const status = state.allStatusesObject[id]
	status.poll = poll
	}
	}

	const statuses = {
	state: defaultState(),
	actions: {
	addNewStatuses ({ rootState, commit }, { statuses, showImmediately = false, timeline = false, noIdUpdate = false, userId }) {
	commit('addNewStatuses', { statuses, showImmediately, timeline, noIdUpdate, user: rootState.users.currentUser, userId })
	},
	addNewNotifications ({ rootState, commit, dispatch, rootGetters }, { notifications, older }) {
	commit('addNewNotifications', { visibleNotificationTypes: visibleNotificationTypes(rootState), dispatch, notifications, older, rootGetters })
	},
	setError ({ rootState, commit }, { value }) {
	commit('setError', { value })
	},
	setErrorData ({ rootState, commit }, { value }) {
	commit('setErrorData', { value })
	},
	setNotificationsLoading ({ rootState, commit }, { value }) {
	commit('setNotificationsLoading', { value })
	},
	setNotificationsError ({ rootState, commit }, { value }) {
	commit('setNotificationsError', { value })
	},
	setNotificationsSilence ({ rootState, commit }, { value }) {
	commit('setNotificationsSilence', { value })
	},
	fetchStatus ({ rootState, dispatch }, id) {
	return rootState.api.backendInteractor.fetchStatus({ id })
	.then((status) => dispatch('addNewStatuses', { statuses: [status] }))
	},
	deleteStatus ({ rootState, commit }, status) {
	commit('setDeleted', { status })
	apiService.deleteStatus({ id: status.id, credentials: rootState.users.currentUser.credentials })
	},
	markStatusesAsDeleted ({ commit }, condition) {
	commit('setManyDeleted', condition)
	},
	favorite ({ rootState, commit }, status) {
	// Optimistic favoriting...
	commit('setFavorited', { status, value: true })
	rootState.api.backendInteractor.favorite({ id: status.id })
	.then(status => commit('setFavoritedConfirm', { status, user: rootState.users.currentUser }))
	},
	unfavorite ({ rootState, commit }, status) {
	// Optimistic unfavoriting...
	commit('setFavorited', { status, value: false })
	rootState.api.backendInteractor.unfavorite({ id: status.id })
	.then(status => commit('setFavoritedConfirm', { status, user: rootState.users.currentUser }))
	},
	fetchPinnedStatuses ({ rootState, dispatch }, userId) {
	rootState.api.backendInteractor.fetchPinnedStatuses({ id: userId })
	.then(statuses => dispatch('addNewStatuses', { statuses, timeline: 'user', userId, showImmediately: true, noIdUpdate: true }))
	},
	pinStatus ({ rootState, dispatch }, statusId) {
	return rootState.api.backendInteractor.pinOwnStatus({ id: statusId })
	.then((status) => dispatch('addNewStatuses', { statuses: [status] }))
	},
	unpinStatus ({ rootState, dispatch }, statusId) {
	rootState.api.backendInteractor.unpinOwnStatus({ id: statusId })
	.then((status) => dispatch('addNewStatuses', { statuses: [status] }))
	},
	muteConversation ({ rootState, commit }, statusId) {
	return rootState.api.backendInteractor.muteConversation({ id: statusId })
	.then((status) => commit('setMutedStatus', status))
	},
	unmuteConversation ({ rootState, commit }, statusId) {
	return rootState.api.backendInteractor.unmuteConversation({ id: statusId })
	.then((status) => commit('setMutedStatus', status))
	},
	retweet ({ rootState, commit }, status) {
	// Optimistic retweeting...
	commit('setRetweeted', { status, value: true })
	rootState.api.backendInteractor.retweet({ id: status.id })
	.then(status => commit('setRetweetedConfirm', { status: status.retweeted_status, user: rootState.users.currentUser }))
	},
	unretweet ({ rootState, commit }, status) {
	// Optimistic unretweeting...
	commit('setRetweeted', { status, value: false })
	rootState.api.backendInteractor.unretweet({ id: status.id })
	.then(status => commit('setRetweetedConfirm', { status, user: rootState.users.currentUser }))
	},
	queueFlush ({ rootState, commit }, { timeline, id }) {
	commit('queueFlush', { timeline, id })
	},
	markNotificationsAsSeen ({ rootState, commit }) {
	commit('markNotificationsAsSeen')
	apiService.markNotificationsAsSeen({
	id: rootState.statuses.notifications.maxId,
	credentials: rootState.users.currentUser.credentials
	})
	},
	+ markSingleNotificationAsSeen ({ rootState, commit }, { id }) {
	+ commit('markSingleNotificationAsSeen', { id })
	+ apiService.markNotificationsAsSeen({
	+ single: true,
	+ id,
	+ credentials: rootState.users.currentUser.credentials
	+ })
	+ },
	+ dismissNotificationLocal ({ rootState, commit }, { id }) {
	+ commit('dismissNotification', { id })
	+ },
	+ dismissNotification ({ rootState, commit }, { id }) {
	+ commit('dismissNotification', { id })
	+ rootState.api.backendInteractor.dismissNotification({ id })
	+ },
	+ updateNotification ({ rootState, commit }, { id, updater }) {
	+ commit('updateNotification', { id, updater })
	+ },
	fetchFavsAndRepeats ({ rootState, commit }, id) {
	Promise.all([
	rootState.api.backendInteractor.fetchFavoritedByUsers({ id }),
	rootState.api.backendInteractor.fetchRebloggedByUsers({ id })
	]).then(([favoritedByUsers, rebloggedByUsers]) => {
	commit('addFavs', { id, favoritedByUsers, currentUser: rootState.users.currentUser })
	commit('addRepeats', { id, rebloggedByUsers, currentUser: rootState.users.currentUser })
	})
	},
	reactWithEmoji ({ rootState, dispatch, commit }, { id, emoji }) {
	const currentUser = rootState.users.currentUser
	if (!currentUser) return

	commit('addOwnReaction', { id, emoji, currentUser })
	rootState.api.backendInteractor.reactWithEmoji({ id, emoji }).then(
	ok => {
	dispatch('fetchEmojiReactionsBy', id)
	}
	)
	},
	unreactWithEmoji ({ rootState, dispatch, commit }, { id, emoji }) {
	const currentUser = rootState.users.currentUser
	if (!currentUser) return

	commit('removeOwnReaction', { id, emoji, currentUser })
	rootState.api.backendInteractor.unreactWithEmoji({ id, emoji }).then(
	ok => {
	dispatch('fetchEmojiReactionsBy', id)
	}
	)
	},
	fetchEmojiReactionsBy ({ rootState, commit }, id) {
	rootState.api.backendInteractor.fetchEmojiReactions({ id }).then(
	emojiReactions => {
	commit('addEmojiReactionsBy', { id, emojiReactions, currentUser: rootState.users.currentUser })
	}
	)
	},
	fetchFavs ({ rootState, commit }, id) {
	rootState.api.backendInteractor.fetchFavoritedByUsers({ id })
	.then(favoritedByUsers => commit('addFavs', { id, favoritedByUsers, currentUser: rootState.users.currentUser }))
	},
	fetchRepeats ({ rootState, commit }, id) {
	rootState.api.backendInteractor.fetchRebloggedByUsers({ id })
	.then(rebloggedByUsers => commit('addRepeats', { id, rebloggedByUsers, currentUser: rootState.users.currentUser }))
	},
	search (store, { q, resolve, limit, offset, following }) {
	return store.rootState.api.backendInteractor.search2({ q, resolve, limit, offset, following })
	.then((data) => {
	store.commit('addNewUsers', data.accounts)
	store.commit('addNewStatuses', { statuses: data.statuses })
	return data
	})
	}
	},
	mutations
	}

	export default statuses
	diff --git a/src/services/api/api.service.js b/src/services/api/api.service.js
	index 7db1d09431..72c8874f18 100644
	--- a/src/services/api/api.service.js
	+++ b/src/services/api/api.service.js
	@@ -1,1184 +1,1195 @@
	import { each, map, concat, last, get } from 'lodash'
	import { parseStatus, parseUser, parseNotification, parseAttachment } from '../entity_normalizer/entity_normalizer.service.js'
	import 'whatwg-fetch'
	import { RegistrationError, StatusCodeError } from '../errors/errors'

	/* eslint-env browser */
	-const QVITTER_USER_NOTIFICATIONS_READ_URL = '/api/qvitter/statuses/notifications/read.json'
	const BLOCKS_IMPORT_URL = '/api/pleroma/blocks_import'
	const FOLLOW_IMPORT_URL = '/api/pleroma/follow_import'
	const DELETE_ACCOUNT_URL = '/api/pleroma/delete_account'
	const CHANGE_EMAIL_URL = '/api/pleroma/change_email'
	const CHANGE_PASSWORD_URL = '/api/pleroma/change_password'
	const TAG_USER_URL = '/api/pleroma/admin/users/tag'
	const PERMISSION_GROUP_URL = (screenName, right) => `/api/pleroma/admin/users/${screenName}/permission_group/${right}`
	const ACTIVATE_USER_URL = '/api/pleroma/admin/users/activate'
	const DEACTIVATE_USER_URL = '/api/pleroma/admin/users/deactivate'
	const ADMIN_USERS_URL = '/api/pleroma/admin/users'
	const SUGGESTIONS_URL = '/api/v1/suggestions'
	const NOTIFICATION_SETTINGS_URL = '/api/pleroma/notification_settings'
	+const NOTIFICATION_READ_URL = '/api/v1/pleroma/notifications/read'

	const MFA_SETTINGS_URL = '/api/pleroma/accounts/mfa'
	const MFA_BACKUP_CODES_URL = '/api/pleroma/accounts/mfa/backup_codes'

	const MFA_SETUP_OTP_URL = '/api/pleroma/accounts/mfa/setup/totp'
	const MFA_CONFIRM_OTP_URL = '/api/pleroma/accounts/mfa/confirm/totp'
	const MFA_DISABLE_OTP_URL = '/api/pleroma/accounts/mfa/totp'

	const MASTODON_LOGIN_URL = '/api/v1/accounts/verify_credentials'
	const MASTODON_REGISTRATION_URL = '/api/v1/accounts'
	const MASTODON_USER_FAVORITES_TIMELINE_URL = '/api/v1/favourites'
	const MASTODON_USER_NOTIFICATIONS_URL = '/api/v1/notifications'
	+const MASTODON_DISMISS_NOTIFICATION_URL = id => `/api/v1/notifications/${id}/dismiss`
	const MASTODON_FAVORITE_URL = id => `/api/v1/statuses/${id}/favourite`
	const MASTODON_UNFAVORITE_URL = id => `/api/v1/statuses/${id}/unfavourite`
	const MASTODON_RETWEET_URL = id => `/api/v1/statuses/${id}/reblog`
	const MASTODON_UNRETWEET_URL = id => `/api/v1/statuses/${id}/unreblog`
	const MASTODON_DELETE_URL = id => `/api/v1/statuses/${id}`
	const MASTODON_FOLLOW_URL = id => `/api/v1/accounts/${id}/follow`
	const MASTODON_UNFOLLOW_URL = id => `/api/v1/accounts/${id}/unfollow`
	const MASTODON_FOLLOWING_URL = id => `/api/v1/accounts/${id}/following`
	const MASTODON_FOLLOWERS_URL = id => `/api/v1/accounts/${id}/followers`
	const MASTODON_FOLLOW_REQUESTS_URL = '/api/v1/follow_requests'
	const MASTODON_APPROVE_USER_URL = id => `/api/v1/follow_requests/${id}/authorize`
	const MASTODON_DENY_USER_URL = id => `/api/v1/follow_requests/${id}/reject`
	const MASTODON_DIRECT_MESSAGES_TIMELINE_URL = '/api/v1/timelines/direct'
	const MASTODON_PUBLIC_TIMELINE = '/api/v1/timelines/public'
	const MASTODON_USER_HOME_TIMELINE_URL = '/api/v1/timelines/home'
	const MASTODON_STATUS_URL = id => `/api/v1/statuses/${id}`
	const MASTODON_STATUS_CONTEXT_URL = id => `/api/v1/statuses/${id}/context`
	const MASTODON_USER_URL = '/api/v1/accounts'
	const MASTODON_USER_RELATIONSHIPS_URL = '/api/v1/accounts/relationships'
	const MASTODON_USER_TIMELINE_URL = id => `/api/v1/accounts/${id}/statuses`
	const MASTODON_TAG_TIMELINE_URL = tag => `/api/v1/timelines/tag/${tag}`
	const MASTODON_USER_BLOCKS_URL = '/api/v1/blocks/'
	const MASTODON_USER_MUTES_URL = '/api/v1/mutes/'
	const MASTODON_BLOCK_USER_URL = id => `/api/v1/accounts/${id}/block`
	const MASTODON_UNBLOCK_USER_URL = id => `/api/v1/accounts/${id}/unblock`
	const MASTODON_MUTE_USER_URL = id => `/api/v1/accounts/${id}/mute`
	const MASTODON_UNMUTE_USER_URL = id => `/api/v1/accounts/${id}/unmute`
	const MASTODON_SUBSCRIBE_USER = id => `/api/v1/pleroma/accounts/${id}/subscribe`
	const MASTODON_UNSUBSCRIBE_USER = id => `/api/v1/pleroma/accounts/${id}/unsubscribe`
	const MASTODON_POST_STATUS_URL = '/api/v1/statuses'
	const MASTODON_MEDIA_UPLOAD_URL = '/api/v1/media'
	const MASTODON_VOTE_URL = id => `/api/v1/polls/${id}/votes`
	const MASTODON_POLL_URL = id => `/api/v1/polls/${id}`
	const MASTODON_STATUS_FAVORITEDBY_URL = id => `/api/v1/statuses/${id}/favourited_by`
	const MASTODON_STATUS_REBLOGGEDBY_URL = id => `/api/v1/statuses/${id}/reblogged_by`
	const MASTODON_PROFILE_UPDATE_URL = '/api/v1/accounts/update_credentials'
	const MASTODON_REPORT_USER_URL = '/api/v1/reports'
	const MASTODON_PIN_OWN_STATUS = id => `/api/v1/statuses/${id}/pin`
	const MASTODON_UNPIN_OWN_STATUS = id => `/api/v1/statuses/${id}/unpin`
	const MASTODON_MUTE_CONVERSATION = id => `/api/v1/statuses/${id}/mute`
	const MASTODON_UNMUTE_CONVERSATION = id => `/api/v1/statuses/${id}/unmute`
	const MASTODON_SEARCH_2 = `/api/v2/search`
	const MASTODON_USER_SEARCH_URL = '/api/v1/accounts/search'
	const MASTODON_DOMAIN_BLOCKS_URL = '/api/v1/domain_blocks'
	const MASTODON_STREAMING = '/api/v1/streaming'
	const PLEROMA_EMOJI_REACTIONS_URL = id => `/api/v1/pleroma/statuses/${id}/reactions`
	const PLEROMA_EMOJI_REACT_URL = (id, emoji) => `/api/v1/pleroma/statuses/${id}/reactions/${emoji}`
	const PLEROMA_EMOJI_UNREACT_URL = (id, emoji) => `/api/v1/pleroma/statuses/${id}/reactions/${emoji}`

	const oldfetch = window.fetch

	let fetch = (url, options) => {
	options = options \|\| {}
	const baseUrl = ''
	const fullUrl = baseUrl + url
	options.credentials = 'same-origin'
	return oldfetch(fullUrl, options)
	}

	const promisedRequest = ({ method, url, params, payload, credentials, headers = {} }) => {
	const options = {
	method,
	headers: {
	'Accept': 'application/json',
	'Content-Type': 'application/json',
	...headers
	}
	}
	if (params) {
	url += '?' + Object.entries(params)
	.map(([key, value]) => encodeURIComponent(key) + '=' + encodeURIComponent(value))
	.join('&')
	}
	if (payload) {
	options.body = JSON.stringify(payload)
	}
	if (credentials) {
	options.headers = {
	...options.headers,
	...authHeaders(credentials)
	}
	}
	return fetch(url, options)
	.then((response) => {
	return new Promise((resolve, reject) => response.json()
	.then((json) => {
	if (!response.ok) {
	return reject(new StatusCodeError(response.status, json, { url, options }, response))
	}
	return resolve(json)
	}))
	})
	}

	const updateNotificationSettings = ({ credentials, settings }) => {
	const form = new FormData()

	each(settings, (value, key) => {
	form.append(key, value)
	})

	return fetch(NOTIFICATION_SETTINGS_URL, {
	headers: authHeaders(credentials),
	method: 'PUT',
	body: form
	}).then((data) => data.json())
	}

	const updateAvatar = ({ credentials, avatar }) => {
	const form = new FormData()
	form.append('avatar', avatar)
	return fetch(MASTODON_PROFILE_UPDATE_URL, {
	headers: authHeaders(credentials),
	method: 'PATCH',
	body: form
	}).then((data) => data.json())
	.then((data) => parseUser(data))
	}

	const updateBg = ({ credentials, background }) => {
	const form = new FormData()
	form.append('pleroma_background_image', background)
	return fetch(MASTODON_PROFILE_UPDATE_URL, {
	headers: authHeaders(credentials),
	method: 'PATCH',
	body: form
	})
	.then((data) => data.json())
	.then((data) => parseUser(data))
	}

	const updateBanner = ({ credentials, banner }) => {
	const form = new FormData()
	form.append('header', banner)
	return fetch(MASTODON_PROFILE_UPDATE_URL, {
	headers: authHeaders(credentials),
	method: 'PATCH',
	body: form
	}).then((data) => data.json())
	.then((data) => parseUser(data))
	}

	const updateProfile = ({ credentials, params }) => {
	return promisedRequest({
	url: MASTODON_PROFILE_UPDATE_URL,
	method: 'PATCH',
	payload: params,
	credentials
	}).then((data) => parseUser(data))
	}

	// Params needed:
	// nickname
	// email
	// fullname
	// password
	// password_confirm
	//
	// Optional
	// bio
	// homepage
	// location
	// token
	const register = ({ params, credentials }) => {
	const { nickname, ...rest } = params
	return fetch(MASTODON_REGISTRATION_URL, {
	method: 'POST',
	headers: {
	...authHeaders(credentials),
	'Content-Type': 'application/json'
	},
	body: JSON.stringify({
	nickname,
	locale: 'en_US',
	agreement: true,
	...rest
	})
	})
	.then((response) => {
	if (response.ok) {
	return response.json()
	} else {
	return response.json().then((error) => { throw new RegistrationError(error) })
	}
	})
	}

	const getCaptcha = () => fetch('/api/pleroma/captcha').then(resp => resp.json())

	const authHeaders = (accessToken) => {
	if (accessToken) {
	return { 'Authorization': `Bearer ${accessToken}` }
	} else {
	return { }
	}
	}

	const followUser = ({ id, credentials, ...options }) => {
	let url = MASTODON_FOLLOW_URL(id)
	const form = {}
	if (options.reblogs !== undefined) { form['reblogs'] = options.reblogs }
	return fetch(url, {
	body: JSON.stringify(form),
	headers: {
	...authHeaders(credentials),
	'Content-Type': 'application/json'
	},
	method: 'POST'
	}).then((data) => data.json())
	}

	const unfollowUser = ({ id, credentials }) => {
	let url = MASTODON_UNFOLLOW_URL(id)
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const pinOwnStatus = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_PIN_OWN_STATUS(id), credentials, method: 'POST' })
	.then((data) => parseStatus(data))
	}

	const unpinOwnStatus = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_UNPIN_OWN_STATUS(id), credentials, method: 'POST' })
	.then((data) => parseStatus(data))
	}

	const muteConversation = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_MUTE_CONVERSATION(id), credentials, method: 'POST' })
	.then((data) => parseStatus(data))
	}

	const unmuteConversation = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_UNMUTE_CONVERSATION(id), credentials, method: 'POST' })
	.then((data) => parseStatus(data))
	}

	const blockUser = ({ id, credentials }) => {
	return fetch(MASTODON_BLOCK_USER_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const unblockUser = ({ id, credentials }) => {
	return fetch(MASTODON_UNBLOCK_USER_URL(id), {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const approveUser = ({ id, credentials }) => {
	let url = MASTODON_APPROVE_USER_URL(id)
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const denyUser = ({ id, credentials }) => {
	let url = MASTODON_DENY_USER_URL(id)
	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const fetchUser = ({ id, credentials }) => {
	let url = `${MASTODON_USER_URL}/${id}`
	return promisedRequest({ url, credentials })
	.then((data) => parseUser(data))
	}

	const fetchUserRelationship = ({ id, credentials }) => {
	let url = `${MASTODON_USER_RELATIONSHIPS_URL}/?id=${id}`
	return fetch(url, { headers: authHeaders(credentials) })
	.then((response) => {
	return new Promise((resolve, reject) => response.json()
	.then((json) => {
	if (!response.ok) {
	return reject(new StatusCodeError(response.status, json, { url }, response))
	}
	return resolve(json)
	}))
	})
	}

	const fetchFriends = ({ id, maxId, sinceId, limit = 20, credentials }) => {
	let url = MASTODON_FOLLOWING_URL(id)
	const args = [
	maxId && `max_id=${maxId}`,
	sinceId && `since_id=${sinceId}`,
	limit && `limit=${limit}`
	].filter(_ => _).join('&')

	url = url + (args ? '?' + args : '')
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const exportFriends = ({ id, credentials }) => {
	return new Promise(async (resolve, reject) => {
	try {
	let friends = []
	let more = true
	while (more) {
	const maxId = friends.length > 0 ? last(friends).id : undefined
	const users = await fetchFriends({ id, maxId, credentials })
	friends = concat(friends, users)
	if (users.length === 0) {
	more = false
	}
	}
	resolve(friends)
	} catch (err) {
	reject(err)
	}
	})
	}

	const fetchFollowers = ({ id, maxId, sinceId, limit = 20, credentials }) => {
	let url = MASTODON_FOLLOWERS_URL(id)
	const args = [
	maxId && `max_id=${maxId}`,
	sinceId && `since_id=${sinceId}`,
	limit && `limit=${limit}`
	].filter(_ => _).join('&')

	url += args ? '?' + args : ''
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchFollowRequests = ({ credentials }) => {
	const url = MASTODON_FOLLOW_REQUESTS_URL
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => data.json())
	.then((data) => data.map(parseUser))
	}

	const fetchConversation = ({ id, credentials }) => {
	let urlContext = MASTODON_STATUS_CONTEXT_URL(id)
	return fetch(urlContext, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline', data)
	})
	.then((data) => data.json())
	.then(({ ancestors, descendants }) => ({
	ancestors: ancestors.map(parseStatus),
	descendants: descendants.map(parseStatus)
	}))
	}

	const fetchStatus = ({ id, credentials }) => {
	let url = MASTODON_STATUS_URL(id)
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching timeline', data)
	})
	.then((data) => data.json())
	.then((data) => parseStatus(data))
	}

	const tagUser = ({ tag, credentials, user }) => {
	const screenName = user.screen_name
	const form = {
	nicknames: [screenName],
	tags: [tag]
	}

	const headers = authHeaders(credentials)
	headers['Content-Type'] = 'application/json'

	return fetch(TAG_USER_URL, {
	method: 'PUT',
	headers: headers,
	body: JSON.stringify(form)
	})
	}

	const untagUser = ({ tag, credentials, user }) => {
	const screenName = user.screen_name
	const body = {
	nicknames: [screenName],
	tags: [tag]
	}

	const headers = authHeaders(credentials)
	headers['Content-Type'] = 'application/json'

	return fetch(TAG_USER_URL, {
	method: 'DELETE',
	headers: headers,
	body: JSON.stringify(body)
	})
	}

	const addRight = ({ right, credentials, user }) => {
	const screenName = user.screen_name

	return fetch(PERMISSION_GROUP_URL(screenName, right), {
	method: 'POST',
	headers: authHeaders(credentials),
	body: {}
	})
	}

	const deleteRight = ({ right, credentials, user }) => {
	const screenName = user.screen_name

	return fetch(PERMISSION_GROUP_URL(screenName, right), {
	method: 'DELETE',
	headers: authHeaders(credentials),
	body: {}
	})
	}

	const activateUser = ({ credentials, user: { screen_name: nickname } }) => {
	return promisedRequest({
	url: ACTIVATE_USER_URL,
	method: 'PATCH',
	credentials,
	payload: {
	nicknames: [nickname]
	}
	}).then(response => get(response, 'users.0'))
	}

	const deactivateUser = ({ credentials, user: { screen_name: nickname } }) => {
	return promisedRequest({
	url: DEACTIVATE_USER_URL,
	method: 'PATCH',
	credentials,
	payload: {
	nicknames: [nickname]
	}
	}).then(response => get(response, 'users.0'))
	}

	const deleteUser = ({ credentials, user }) => {
	const screenName = user.screen_name
	const headers = authHeaders(credentials)

	return fetch(`${ADMIN_USERS_URL}?nickname=${screenName}`, {
	method: 'DELETE',
	headers: headers
	})
	}

	const fetchTimeline = ({
	timeline,
	credentials,
	since = false,
	until = false,
	userId = false,
	tag = false,
	- withMuted = false,
	- withMove = false
	+ withMuted = false
	}) => {
	const timelineUrls = {
	public: MASTODON_PUBLIC_TIMELINE,
	friends: MASTODON_USER_HOME_TIMELINE_URL,
	dms: MASTODON_DIRECT_MESSAGES_TIMELINE_URL,
	notifications: MASTODON_USER_NOTIFICATIONS_URL,
	'publicAndExternal': MASTODON_PUBLIC_TIMELINE,
	user: MASTODON_USER_TIMELINE_URL,
	media: MASTODON_USER_TIMELINE_URL,
	favorites: MASTODON_USER_FAVORITES_TIMELINE_URL,
	tag: MASTODON_TAG_TIMELINE_URL
	}
	const isNotifications = timeline === 'notifications'
	const params = []

	let url = timelineUrls[timeline]

	if (timeline === 'user' \|\| timeline === 'media') {
	url = url(userId)
	}

	if (since) {
	params.push(['since_id', since])
	}
	if (until) {
	params.push(['max_id', until])
	}
	if (tag) {
	url = url(tag)
	}
	if (timeline === 'media') {
	params.push(['only_media', 1])
	}
	if (timeline === 'public') {
	params.push(['local', true])
	}
	if (timeline === 'public' \|\| timeline === 'publicAndExternal') {
	params.push(['only_media', false])
	}
	- if (timeline === 'notifications') {
	- params.push(['with_move', withMove])
	- }

	- params.push(['count', 20])
	+ params.push(['limit', 20])
	params.push(['with_muted', withMuted])

	const queryString = map(params, (param) => `${param[0]}=${param[1]}`).join('&')
	url += `?${queryString}`
	let status = ''
	let statusText = ''
	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => {
	status = data.status
	statusText = data.statusText
	return data
	})
	.then((data) => data.json())
	.then((data) => {
	if (!data.error) {
	return data.map(isNotifications ? parseNotification : parseStatus)
	} else {
	data.status = status
	data.statusText = statusText
	return data
	}
	})
	}

	const fetchPinnedStatuses = ({ id, credentials }) => {
	const url = MASTODON_USER_TIMELINE_URL(id) + '?pinned=true'
	return promisedRequest({ url, credentials })
	.then((data) => data.map(parseStatus))
	}

	const verifyCredentials = (user) => {
	return fetch(MASTODON_LOGIN_URL, {
	headers: authHeaders(user)
	})
	.then((response) => {
	if (response.ok) {
	return response.json()
	} else {
	return {
	error: response
	}
	}
	})
	.then((data) => data.error ? data : parseUser(data))
	}

	const favorite = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_FAVORITE_URL(id), method: 'POST', credentials })
	.then((data) => parseStatus(data))
	}

	const unfavorite = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_UNFAVORITE_URL(id), method: 'POST', credentials })
	.then((data) => parseStatus(data))
	}

	const retweet = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_RETWEET_URL(id), method: 'POST', credentials })
	.then((data) => parseStatus(data))
	}

	const unretweet = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_UNRETWEET_URL(id), method: 'POST', credentials })
	.then((data) => parseStatus(data))
	}

	const postStatus = ({
	credentials,
	status,
	spoilerText,
	visibility,
	sensitive,
	poll,
	mediaIds = [],
	inReplyToStatusId,
	contentType
	}) => {
	const form = new FormData()
	const pollOptions = poll.options \|\| []

	form.append('status', status)
	form.append('source', 'Pleroma FE')
	if (spoilerText) form.append('spoiler_text', spoilerText)
	if (visibility) form.append('visibility', visibility)
	if (sensitive) form.append('sensitive', sensitive)
	if (contentType) form.append('content_type', contentType)
	mediaIds.forEach(val => {
	form.append('media_ids[]', val)
	})
	if (pollOptions.some(option => option !== '')) {
	const normalizedPoll = {
	expires_in: poll.expiresIn,
	multiple: poll.multiple
	}
	Object.keys(normalizedPoll).forEach(key => {
	form.append(`poll[${key}]`, normalizedPoll[key])
	})

	pollOptions.forEach(option => {
	form.append('poll[options][]', option)
	})
	}
	if (inReplyToStatusId) {
	form.append('in_reply_to_id', inReplyToStatusId)
	}

	return fetch(MASTODON_POST_STATUS_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => {
	if (response.ok) {
	return response.json()
	} else {
	return {
	error: response
	}
	}
	})
	.then((data) => data.error ? data : parseStatus(data))
	}

	const deleteStatus = ({ id, credentials }) => {
	return fetch(MASTODON_DELETE_URL(id), {
	headers: authHeaders(credentials),
	method: 'DELETE'
	})
	}

	const uploadMedia = ({ formData, credentials }) => {
	return fetch(MASTODON_MEDIA_UPLOAD_URL, {
	body: formData,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((data) => data.json())
	.then((data) => parseAttachment(data))
	}

	const importBlocks = ({ file, credentials }) => {
	const formData = new FormData()
	formData.append('list', file)
	return fetch(BLOCKS_IMPORT_URL, {
	body: formData,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.ok)
	}

	const importFollows = ({ file, credentials }) => {
	const formData = new FormData()
	formData.append('list', file)
	return fetch(FOLLOW_IMPORT_URL, {
	body: formData,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.ok)
	}

	const deleteAccount = ({ credentials, password }) => {
	const form = new FormData()

	form.append('password', password)

	return fetch(DELETE_ACCOUNT_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const changeEmail = ({ credentials, email, password }) => {
	const form = new FormData()

	form.append('email', email)
	form.append('password', password)

	return fetch(CHANGE_EMAIL_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const changePassword = ({ credentials, password, newPassword, newPasswordConfirmation }) => {
	const form = new FormData()

	form.append('password', password)
	form.append('new_password', newPassword)
	form.append('new_password_confirmation', newPasswordConfirmation)

	return fetch(CHANGE_PASSWORD_URL, {
	body: form,
	method: 'POST',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const settingsMFA = ({ credentials }) => {
	return fetch(MFA_SETTINGS_URL, {
	headers: authHeaders(credentials),
	method: 'GET'
	}).then((data) => data.json())
	}

	const mfaDisableOTP = ({ credentials, password }) => {
	const form = new FormData()

	form.append('password', password)

	return fetch(MFA_DISABLE_OTP_URL, {
	body: form,
	method: 'DELETE',
	headers: authHeaders(credentials)
	})
	.then((response) => response.json())
	}

	const mfaConfirmOTP = ({ credentials, password, token }) => {
	const form = new FormData()

	form.append('password', password)
	form.append('code', token)

	return fetch(MFA_CONFIRM_OTP_URL, {
	body: form,
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}
	const mfaSetupOTP = ({ credentials }) => {
	return fetch(MFA_SETUP_OTP_URL, {
	headers: authHeaders(credentials),
	method: 'GET'
	}).then((data) => data.json())
	}
	const generateMfaBackupCodes = ({ credentials }) => {
	return fetch(MFA_BACKUP_CODES_URL, {
	headers: authHeaders(credentials),
	method: 'GET'
	}).then((data) => data.json())
	}

	const fetchMutes = ({ credentials }) => {
	return promisedRequest({ url: MASTODON_USER_MUTES_URL, credentials })
	.then((users) => users.map(parseUser))
	}

	const muteUser = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_MUTE_USER_URL(id), credentials, method: 'POST' })
	}

	const unmuteUser = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_UNMUTE_USER_URL(id), credentials, method: 'POST' })
	}

	const subscribeUser = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_SUBSCRIBE_USER(id), credentials, method: 'POST' })
	}

	const unsubscribeUser = ({ id, credentials }) => {
	return promisedRequest({ url: MASTODON_UNSUBSCRIBE_USER(id), credentials, method: 'POST' })
	}

	const fetchBlocks = ({ credentials }) => {
	return promisedRequest({ url: MASTODON_USER_BLOCKS_URL, credentials })
	.then((users) => users.map(parseUser))
	}

	const fetchOAuthTokens = ({ credentials }) => {
	const url = '/api/oauth_tokens.json'

	return fetch(url, {
	headers: authHeaders(credentials)
	}).then((data) => {
	if (data.ok) {
	return data.json()
	}
	throw new Error('Error fetching auth tokens', data)
	})
	}

	const revokeOAuthToken = ({ id, credentials }) => {
	const url = `/api/oauth_tokens/${id}`

	return fetch(url, {
	headers: authHeaders(credentials),
	method: 'DELETE'
	})
	}

	const suggestions = ({ credentials }) => {
	return fetch(SUGGESTIONS_URL, {
	headers: authHeaders(credentials)
	}).then((data) => data.json())
	}

	-const markNotificationsAsSeen = ({ id, credentials }) => {
	+const markNotificationsAsSeen = ({ id, credentials, single = false }) => {
	const body = new FormData()

	- body.append('latest_id', id)
	+ if (single) {
	+ body.append('id', id)
	+ } else {
	+ body.append('max_id', id)
	+ }

	- return fetch(QVITTER_USER_NOTIFICATIONS_READ_URL, {
	+ return fetch(NOTIFICATION_READ_URL, {
	body,
	headers: authHeaders(credentials),
	method: 'POST'
	}).then((data) => data.json())
	}

	const vote = ({ pollId, choices, credentials }) => {
	const form = new FormData()
	form.append('choices', choices)

	return promisedRequest({
	url: MASTODON_VOTE_URL(encodeURIComponent(pollId)),
	method: 'POST',
	credentials,
	payload: {
	choices: choices
	}
	})
	}

	const fetchPoll = ({ pollId, credentials }) => {
	return promisedRequest(
	{
	url: MASTODON_POLL_URL(encodeURIComponent(pollId)),
	method: 'GET',
	credentials
	}
	)
	}

	const fetchFavoritedByUsers = ({ id, credentials }) => {
	return promisedRequest({
	url: MASTODON_STATUS_FAVORITEDBY_URL(id),
	method: 'GET',
	credentials
	}).then((users) => users.map(parseUser))
	}

	const fetchRebloggedByUsers = ({ id, credentials }) => {
	return promisedRequest({
	url: MASTODON_STATUS_REBLOGGEDBY_URL(id),
	method: 'GET',
	credentials
	}).then((users) => users.map(parseUser))
	}

	const fetchEmojiReactions = ({ id, credentials }) => {
	return promisedRequest({ url: PLEROMA_EMOJI_REACTIONS_URL(id), credentials })
	.then((reactions) => reactions.map(r => {
	r.accounts = r.accounts.map(parseUser)
	return r
	}))
	}

	const reactWithEmoji = ({ id, emoji, credentials }) => {
	return promisedRequest({
	url: PLEROMA_EMOJI_REACT_URL(id, emoji),
	method: 'PUT',
	credentials
	}).then(parseStatus)
	}

	const unreactWithEmoji = ({ id, emoji, credentials }) => {
	return promisedRequest({
	url: PLEROMA_EMOJI_UNREACT_URL(id, emoji),
	method: 'DELETE',
	credentials
	}).then(parseStatus)
	}

	const reportUser = ({ credentials, userId, statusIds, comment, forward }) => {
	return promisedRequest({
	url: MASTODON_REPORT_USER_URL,
	method: 'POST',
	payload: {
	'account_id': userId,
	'status_ids': statusIds,
	comment,
	forward
	},
	credentials
	})
	}

	const searchUsers = ({ credentials, query }) => {
	return promisedRequest({
	url: MASTODON_USER_SEARCH_URL,
	params: {
	q: query,
	resolve: true
	},
	credentials
	})
	.then((data) => data.map(parseUser))
	}

	const search2 = ({ credentials, q, resolve, limit, offset, following }) => {
	let url = MASTODON_SEARCH_2
	let params = []

	if (q) {
	params.push(['q', encodeURIComponent(q)])
	}

	if (resolve) {
	params.push(['resolve', resolve])
	}

	if (limit) {
	params.push(['limit', limit])
	}

	if (offset) {
	params.push(['offset', offset])
	}

	if (following) {
	params.push(['following', true])
	}

	let queryString = map(params, (param) => `${param[0]}=${param[1]}`).join('&')
	url += `?${queryString}`

	return fetch(url, { headers: authHeaders(credentials) })
	.then((data) => {
	if (data.ok) {
	return data
	}
	throw new Error('Error fetching search result', data)
	})
	.then((data) => { return data.json() })
	.then((data) => {
	data.accounts = data.accounts.slice(0, limit).map(u => parseUser(u))
	data.statuses = data.statuses.slice(0, limit).map(s => parseStatus(s))
	return data
	})
	}

	const fetchDomainMutes = ({ credentials }) => {
	return promisedRequest({ url: MASTODON_DOMAIN_BLOCKS_URL, credentials })
	}

	const muteDomain = ({ domain, credentials }) => {
	return promisedRequest({
	url: MASTODON_DOMAIN_BLOCKS_URL,
	method: 'POST',
	payload: { domain },
	credentials
	})
	}

	const unmuteDomain = ({ domain, credentials }) => {
	return promisedRequest({
	url: MASTODON_DOMAIN_BLOCKS_URL,
	method: 'DELETE',
	payload: { domain },
	credentials
	})
	}

	+const dismissNotification = ({ credentials, id }) => {
	+ return promisedRequest({
	+ url: MASTODON_DISMISS_NOTIFICATION_URL(id),
	+ method: 'POST',
	+ payload: { id },
	+ credentials
	+ })
	+}
	+
	export const getMastodonSocketURI = ({ credentials, stream, args = {} }) => {
	return Object.entries({
	...(credentials
	? { access_token: credentials }
	: {}
	),
	stream,
	...args
	}).reduce((acc, [key, val]) => {
	return acc + `${key}=${val}&`
	}, MASTODON_STREAMING + '?')
	}

	const MASTODON_STREAMING_EVENTS = new Set([
	'update',
	'notification',
	'delete',
	'filters_changed'
	])

	// A thin wrapper around WebSocket API that allows adding a pre-processor to it
	// Uses EventTarget and a CustomEvent to proxy events
	export const ProcessedWS = ({
	url,
	preprocessor = handleMastoWS,
	id = 'Unknown'
	}) => {
	const eventTarget = new EventTarget()
	const socket = new WebSocket(url)
	if (!socket) throw new Error(`Failed to create socket ${id}`)
	const proxy = (original, eventName, processor = a => a) => {
	original.addEventListener(eventName, (eventData) => {
	eventTarget.dispatchEvent(new CustomEvent(
	eventName,
	{ detail: processor(eventData) }
	))
	})
	}
	socket.addEventListener('open', (wsEvent) => {
	console.debug(`[WS][${id}] Socket connected`, wsEvent)
	})
	socket.addEventListener('error', (wsEvent) => {
	console.debug(`[WS][${id}] Socket errored`, wsEvent)
	})
	socket.addEventListener('close', (wsEvent) => {
	console.debug(
	`[WS][${id}] Socket disconnected with code ${wsEvent.code}`,
	wsEvent
	)
	})
	// Commented code reason: very spammy, uncomment to enable message debug logging
	/*
	socket.addEventListener('message', (wsEvent) => {
	console.debug(
	`[WS][${id}] Message received`,
	wsEvent
	)
	})
	/**/

	proxy(socket, 'open')
	proxy(socket, 'close')
	proxy(socket, 'message', preprocessor)
	proxy(socket, 'error')

	// 1000 = Normal Closure
	eventTarget.close = () => { socket.close(1000, 'Shutting down socket') }

	return eventTarget
	}

	export const handleMastoWS = (wsEvent) => {
	const { data } = wsEvent
	if (!data) return
	const parsedEvent = JSON.parse(data)
	const { event, payload } = parsedEvent
	if (MASTODON_STREAMING_EVENTS.has(event)) {
	// MastoBE and PleromaBE both send payload for delete as a PLAIN string
	if (event === 'delete') {
	return { event, id: payload }
	}
	const data = payload ? JSON.parse(payload) : null
	if (event === 'update') {
	return { event, status: parseStatus(data) }
	} else if (event === 'notification') {
	return { event, notification: parseNotification(data) }
	}
	} else {
	console.warn('Unknown event', wsEvent)
	return null
	}
	}

	const apiService = {
	verifyCredentials,
	fetchTimeline,
	fetchPinnedStatuses,
	fetchConversation,
	fetchStatus,
	fetchFriends,
	exportFriends,
	fetchFollowers,
	followUser,
	unfollowUser,
	pinOwnStatus,
	unpinOwnStatus,
	muteConversation,
	unmuteConversation,
	blockUser,
	unblockUser,
	fetchUser,
	fetchUserRelationship,
	favorite,
	unfavorite,
	retweet,
	unretweet,
	postStatus,
	deleteStatus,
	uploadMedia,
	fetchMutes,
	muteUser,
	unmuteUser,
	subscribeUser,
	unsubscribeUser,
	fetchBlocks,
	fetchOAuthTokens,
	revokeOAuthToken,
	tagUser,
	untagUser,
	deleteUser,
	addRight,
	deleteRight,
	activateUser,
	deactivateUser,
	register,
	getCaptcha,
	updateAvatar,
	updateBg,
	updateProfile,
	updateBanner,
	importBlocks,
	importFollows,
	deleteAccount,
	changeEmail,
	changePassword,
	settingsMFA,
	mfaDisableOTP,
	generateMfaBackupCodes,
	mfaSetupOTP,
	mfaConfirmOTP,
	fetchFollowRequests,
	approveUser,
	denyUser,
	suggestions,
	markNotificationsAsSeen,
	+ dismissNotification,
	vote,
	fetchPoll,
	fetchFavoritedByUsers,
	fetchRebloggedByUsers,
	fetchEmojiReactions,
	reactWithEmoji,
	unreactWithEmoji,
	reportUser,
	updateNotificationSettings,
	search2,
	searchUsers,
	fetchDomainMutes,
	muteDomain,
	unmuteDomain
	}

	export default apiService
	diff --git a/src/services/entity_normalizer/entity_normalizer.service.js b/src/services/entity_normalizer/entity_normalizer.service.js
	index 724dcc4ba3..6dac7c1570 100644
	--- a/src/services/entity_normalizer/entity_normalizer.service.js
	+++ b/src/services/entity_normalizer/entity_normalizer.service.js
	@@ -1,372 +1,371 @@
	import escape from 'escape-html'
	+import { isStatusNotification } from '../notification_utils/notification_utils.js'

	const qvitterStatusType = (status) => {
	if (status.is_post_verb) {
	return 'status'
	}

	if (status.retweeted_status) {
	return 'retweet'
	}

	if ((typeof status.uri === 'string' && status.uri.match(/(fave\|objectType=Favourite)/)) \|\|
	(typeof status.text === 'string' && status.text.match(/favorited/))) {
	return 'favorite'
	}

	if (status.text.match(/deleted notice {{tag/) \|\| status.qvitter_delete_notice) {
	return 'deletion'
	}

	if (status.text.match(/started following/) \|\| status.activity_type === 'follow') {
	return 'follow'
	}

	return 'unknown'
	}

	export const parseUser = (data) => {
	const output = {}
	const masto = data.hasOwnProperty('acct')
	// case for users in "mentions" property for statuses in MastoAPI
	const mastoShort = masto && !data.hasOwnProperty('avatar')

	output.id = String(data.id)

	if (masto) {
	output.screen_name = data.acct
	output.statusnet_profile_url = data.url

	// There's nothing else to get
	if (mastoShort) {
	return output
	}

	output.name = data.display_name
	output.name_html = addEmojis(escape(data.display_name), data.emojis)

	output.description = data.note
	output.description_html = addEmojis(data.note, data.emojis)

	output.fields = data.fields
	output.fields_html = data.fields.map(field => {
	return {
	name: addEmojis(field.name, data.emojis),
	value: addEmojis(field.value, data.emojis)
	}
	})

	// Utilize avatar_static for gif avatars?
	output.profile_image_url = data.avatar
	output.profile_image_url_original = data.avatar

	// Same, utilize header_static?
	output.cover_photo = data.header

	output.friends_count = data.following_count

	output.bot = data.bot

	if (data.pleroma) {
	const relationship = data.pleroma.relationship

	output.background_image = data.pleroma.background_image
	output.token = data.pleroma.chat_token

	if (relationship) {
	output.relationship = relationship
	}

	output.allow_following_move = data.pleroma.allow_following_move

	output.hide_follows = data.pleroma.hide_follows
	output.hide_followers = data.pleroma.hide_followers
	output.hide_follows_count = data.pleroma.hide_follows_count
	output.hide_followers_count = data.pleroma.hide_followers_count

	output.rights = {
	moderator: data.pleroma.is_moderator,
	admin: data.pleroma.is_admin
	}
	// TODO: Clean up in UI? This is duplication from what BE does for qvitterapi
	if (output.rights.admin) {
	output.role = 'admin'
	} else if (output.rights.moderator) {
	output.role = 'moderator'
	} else {
	output.role = 'member'
	}
	}

	if (data.source) {
	output.description = data.source.note
	output.default_scope = data.source.privacy
	output.fields = data.source.fields
	if (data.source.pleroma) {
	output.no_rich_text = data.source.pleroma.no_rich_text
	output.show_role = data.source.pleroma.show_role
	output.discoverable = data.source.pleroma.discoverable
	}
	}

	// TODO: handle is_local
	output.is_local = !output.screen_name.includes('@')
	} else {
	output.screen_name = data.screen_name

	output.name = data.name
	output.name_html = data.name_html

	output.description = data.description
	output.description_html = data.description_html

	output.profile_image_url = data.profile_image_url
	output.profile_image_url_original = data.profile_image_url_original

	output.cover_photo = data.cover_photo

	output.friends_count = data.friends_count

	// output.bot = ??? missing

	output.statusnet_profile_url = data.statusnet_profile_url

	output.is_local = data.is_local
	output.role = data.role
	output.show_role = data.show_role

	if (data.rights) {
	output.rights = {
	moderator: data.rights.delete_others_notice,
	admin: data.rights.admin
	}
	}
	output.no_rich_text = data.no_rich_text
	output.default_scope = data.default_scope
	output.hide_follows = data.hide_follows
	output.hide_followers = data.hide_followers
	output.hide_follows_count = data.hide_follows_count
	output.hide_followers_count = data.hide_followers_count
	output.background_image = data.background_image
	// Websocket token
	output.token = data.token

	// Convert relationsip data to expected format
	output.relationship = {
	muting: data.muted,
	blocking: data.statusnet_blocking,
	followed_by: data.follows_you,
	following: data.following
	}
	}

	output.created_at = new Date(data.created_at)
	output.locked = data.locked
	output.followers_count = data.followers_count
	output.statuses_count = data.statuses_count
	output.friendIds = []
	output.followerIds = []
	output.pinnedStatusIds = []

	if (data.pleroma) {
	output.follow_request_count = data.pleroma.follow_request_count

	output.tags = data.pleroma.tags
	output.deactivated = data.pleroma.deactivated

	output.notification_settings = data.pleroma.notification_settings
	}

	output.tags = output.tags \|\| []
	output.rights = output.rights \|\| {}
	output.notification_settings = output.notification_settings \|\| {}

	return output
	}

	export const parseAttachment = (data) => {
	const output = {}
	const masto = !data.hasOwnProperty('oembed')

	if (masto) {
	// Not exactly same...
	output.mimetype = data.pleroma ? data.pleroma.mime_type : data.type
	output.meta = data.meta // not present in BE yet
	output.id = data.id
	} else {
	output.mimetype = data.mimetype
	// output.meta = ??? missing
	}

	output.url = data.url
	output.description = data.description

	return output
	}
	export const addEmojis = (string, emojis) => {
	const matchOperatorsRegex = /[\|\\{}()[\]^$+*?.-]/g
	return emojis.reduce((acc, emoji) => {
	const regexSafeShortCode = emoji.shortcode.replace(matchOperatorsRegex, '\\$&')
	return acc.replace(
	new RegExp(`:${regexSafeShortCode}:`, 'g'),
	`<img src='${emoji.url}' alt='${emoji.shortcode}' title='${emoji.shortcode}' class='emoji' />`
	)
	}, string)
	}

	export const parseStatus = (data) => {
	const output = {}
	const masto = data.hasOwnProperty('account')

	if (masto) {
	output.favorited = data.favourited
	output.fave_num = data.favourites_count

	output.repeated = data.reblogged
	output.repeat_num = data.reblogs_count

	output.type = data.reblog ? 'retweet' : 'status'
	output.nsfw = data.sensitive

	output.statusnet_html = addEmojis(data.content, data.emojis)

	output.tags = data.tags

	if (data.pleroma) {
	const { pleroma } = data
	output.text = pleroma.content ? data.pleroma.content['text/plain'] : data.content
	output.summary = pleroma.spoiler_text ? data.pleroma.spoiler_text['text/plain'] : data.spoiler_text
	output.statusnet_conversation_id = data.pleroma.conversation_id
	output.is_local = pleroma.local
	output.in_reply_to_screen_name = data.pleroma.in_reply_to_account_acct
	output.thread_muted = pleroma.thread_muted
	output.emoji_reactions = pleroma.emoji_reactions
	} else {
	output.text = data.content
	output.summary = data.spoiler_text
	}

	output.in_reply_to_status_id = data.in_reply_to_id
	output.in_reply_to_user_id = data.in_reply_to_account_id
	output.replies_count = data.replies_count

	if (output.type === 'retweet') {
	output.retweeted_status = parseStatus(data.reblog)
	}

	output.summary_html = addEmojis(escape(data.spoiler_text), data.emojis)
	output.external_url = data.url
	output.poll = data.poll
	output.pinned = data.pinned
	output.muted = data.muted
	} else {
	output.favorited = data.favorited
	output.fave_num = data.fave_num

	output.repeated = data.repeated
	output.repeat_num = data.repeat_num

	// catchall, temporary
	// Object.assign(output, data)

	output.type = qvitterStatusType(data)

	if (data.nsfw === undefined) {
	output.nsfw = isNsfw(data)
	if (data.retweeted_status) {
	output.nsfw = data.retweeted_status.nsfw
	}
	} else {
	output.nsfw = data.nsfw
	}

	output.statusnet_html = data.statusnet_html
	output.text = data.text

	output.in_reply_to_status_id = data.in_reply_to_status_id
	output.in_reply_to_user_id = data.in_reply_to_user_id
	output.in_reply_to_screen_name = data.in_reply_to_screen_name
	output.statusnet_conversation_id = data.statusnet_conversation_id

	if (output.type === 'retweet') {
	output.retweeted_status = parseStatus(data.retweeted_status)
	}

	output.summary = data.summary
	output.summary_html = data.summary_html
	output.external_url = data.external_url
	output.is_local = data.is_local
	}

	output.id = String(data.id)
	output.visibility = data.visibility
	output.card = data.card
	output.created_at = new Date(data.created_at)

	// Converting to string, the right way.
	output.in_reply_to_status_id = output.in_reply_to_status_id
	? String(output.in_reply_to_status_id)
	: null
	output.in_reply_to_user_id = output.in_reply_to_user_id
	? String(output.in_reply_to_user_id)
	: null

	output.user = parseUser(masto ? data.account : data.user)

	output.attentions = ((masto ? data.mentions : data.attentions) \|\| []).map(parseUser)

	output.attachments = ((masto ? data.media_attachments : data.attachments) \|\| [])
	.map(parseAttachment)

	const retweetedStatus = masto ? data.reblog : data.retweeted_status
	if (retweetedStatus) {
	output.retweeted_status = parseStatus(retweetedStatus)
	}

	output.favoritedBy = []
	output.rebloggedBy = []

	return output
	}

	export const parseNotification = (data) => {
	const mastoDict = {
	'favourite': 'like',
	'reblog': 'repeat'
	}
	const masto = !data.hasOwnProperty('ntype')
	const output = {}

	if (masto) {
	output.type = mastoDict[data.type] \|\| data.type
	output.seen = data.pleroma.is_seen
	- output.status = output.type === 'follow' \|\| output.type === 'move'
	- ? null
	- : parseStatus(data.status)
	+ output.status = isStatusNotification(output.type) ? parseStatus(data.status) : null
	output.action = output.status // TODO: Refactor, this is unneeded
	output.target = output.type !== 'move'
	? null
	: parseUser(data.target)
	output.from_profile = parseUser(data.account)
	output.emoji = data.emoji
	} else {
	const parsedNotice = parseStatus(data.notice)
	output.type = data.ntype
	output.seen = Boolean(data.is_seen)
	output.status = output.type === 'like'
	? parseStatus(data.notice.favorited_status)
	: parsedNotice
	output.action = parsedNotice
	output.from_profile = parseUser(data.from_profile)
	}

	output.created_at = new Date(data.created_at)
	output.id = parseInt(data.id)

	return output
	}

	const isNsfw = (status) => {
	const nsfwRegex = /#nsfw/i
	return (status.tags \|\| []).includes('nsfw') \|\| !!(status.text \|\| '').match(nsfwRegex)
	}
	diff --git a/src/services/notification_utils/notification_utils.js b/src/services/notification_utils/notification_utils.js
	index b17bd7bf62..eb479227ca 100644
	--- a/src/services/notification_utils/notification_utils.js
	+++ b/src/services/notification_utils/notification_utils.js
	@@ -1,40 +1,45 @@
	-import { filter, sortBy } from 'lodash'
	+import { filter, sortBy, includes } from 'lodash'

	export const notificationsFromStore = store => store.state.statuses.notifications.data

	export const visibleTypes = store => ([
	store.state.config.notificationVisibility.likes && 'like',
	store.state.config.notificationVisibility.mentions && 'mention',
	store.state.config.notificationVisibility.repeats && 'repeat',
	store.state.config.notificationVisibility.follows && 'follow',
	+ store.state.config.notificationVisibility.followRequest && 'follow_request',
	store.state.config.notificationVisibility.moves && 'move',
	store.state.config.notificationVisibility.emojiReactions && 'pleroma:emoji_reaction'
	].filter(_ => _))

	+const statusNotifications = ['like', 'mention', 'repeat', 'pleroma:emoji_reaction']
	+
	+export const isStatusNotification = (type) => includes(statusNotifications, type)
	+
	const sortById = (a, b) => {
	const seqA = Number(a.id)
	const seqB = Number(b.id)
	const isSeqA = !Number.isNaN(seqA)
	const isSeqB = !Number.isNaN(seqB)
	if (isSeqA && isSeqB) {
	return seqA > seqB ? -1 : 1
	} else if (isSeqA && !isSeqB) {
	return 1
	} else if (!isSeqA && isSeqB) {
	return -1
	} else {
	return a.id > b.id ? -1 : 1
	}
	}

	export const filteredNotificationsFromStore = (store, types) => {
	// map is just to clone the array since sort mutates it and it causes some issues
	let sortedNotifications = notificationsFromStore(store).map(_ => _).sort(sortById)
	sortedNotifications = sortBy(sortedNotifications, 'seen')
	return sortedNotifications.filter(
	(notification) => (types \|\| visibleTypes(store)).includes(notification.type)
	)
	}

	export const unseenNotificationsFromStore = store =>
	filter(filteredNotificationsFromStore(store), ({ seen }) => !seen)
	diff --git a/src/services/notifications_fetcher/notifications_fetcher.service.js b/src/services/notifications_fetcher/notifications_fetcher.service.js
	index 864e32f878..64499a1b65 100644
	--- a/src/services/notifications_fetcher/notifications_fetcher.service.js
	+++ b/src/services/notifications_fetcher/notifications_fetcher.service.js
	@@ -1,69 +1,66 @@
	import apiService from '../api/api.service.js'

	const update = ({ store, notifications, older }) => {
	store.dispatch('setNotificationsError', { value: false })
	store.dispatch('addNewNotifications', { notifications, older })
	}

	const fetchAndUpdate = ({ store, credentials, older = false }) => {
	const args = { credentials }
	const { getters } = store
	const rootState = store.rootState \|\| store.state
	const timelineData = rootState.statuses.notifications
	const hideMutedPosts = getters.mergedConfig.hideMutedPosts
	- const allowFollowingMove = rootState.users.currentUser.allow_following_move

	args['withMuted'] = !hideMutedPosts

	- args['withMove'] = !allowFollowingMove
	-
	args['timeline'] = 'notifications'
	if (older) {
	if (timelineData.minId !== Number.POSITIVE_INFINITY) {
	args['until'] = timelineData.minId
	}
	return fetchNotifications({ store, args, older })
	} else {
	// fetch new notifications
	if (timelineData.maxId !== Number.POSITIVE_INFINITY) {
	args['since'] = timelineData.maxId
	}
	const result = fetchNotifications({ store, args, older })

	// load unread notifications repeatedly to provide consistency between browser tabs
	const notifications = timelineData.data
	const readNotifsIds = notifications.filter(n => n.seen).map(n => n.id)
	if (readNotifsIds.length) {
	args['since'] = Math.max(...readNotifsIds)
	fetchNotifications({ store, args, older })
	}

	return result
	}
	}

	const fetchNotifications = ({ store, args, older }) => {
	return apiService.fetchTimeline(args)
	.then((notifications) => {
	update({ store, notifications, older })
	return notifications
	}, () => store.dispatch('setNotificationsError', { value: true }))
	.catch(() => store.dispatch('setNotificationsError', { value: true }))
	}

	const startFetching = ({ credentials, store }) => {
	fetchAndUpdate({ credentials, store })
	const boundFetchAndUpdate = () => fetchAndUpdate({ credentials, store })
	// Initially there's set flag to silence all desktop notifications so
	// that there won't spam of them when user just opened up the FE we
	// reset that flag after a while to show new notifications once again.
	setTimeout(() => store.dispatch('setNotificationsSilence', false), 10000)
	return setInterval(boundFetchAndUpdate, 10000)
	}

	const notificationsFetcher = {
	fetchAndUpdate,
	startFetching
	}

	export default notificationsFetcher
	diff --git a/static/fontello.json b/static/fontello.json
	index 5a7086a231..7f0e7cdd53 100755
	--- a/static/fontello.json
	+++ b/static/fontello.json
	@@ -1,350 +1,368 @@
	{
	"name": "",
	"css_prefix_text": "icon-",
	"css_use_suffix": false,
	"hinting": true,
	"units_per_em": 1000,
	"ascent": 857,
	"glyphs": [
	{
	"uid": "9bd60140934a1eb9236fd7a8ab1ff6ba",
	"css": "spin4",
	"code": 59444,
	"src": "fontelico"
	},
	{
	"uid": "5211af474d3a9848f67f945e2ccaf143",
	"css": "cancel",
	"code": 59392,
	"src": "fontawesome"
	},
	{
	"uid": "eeec3208c90b7b48e804919d0d2d4a41",
	"css": "upload",
	"code": 59393,
	"src": "fontawesome"
	},
	{
	"uid": "2a6740fc2f9d0edea54205963f662594",
	"css": "spin3",
	"code": 59442,
	"src": "fontelico"
	},
	{
	"uid": "c6be5a58ee4e63a5ec399c2b0d15cf2c",
	"css": "reply",
	"code": 61714,
	"src": "fontawesome"
	},
	{
	"uid": "474656633f79ea2f1dad59ff63f6bf07",
	"css": "star",
	"code": 59394,
	"src": "fontawesome"
	},
	{
	"uid": "d17030afaecc1e1c22349b99f3c4992a",
	"css": "star-empty",
	"code": 59395,
	"src": "fontawesome"
	},
	{
	"uid": "09feb4465d9bd1364f4e301c9ddbaa92",
	"css": "retweet",
	"code": 59396,
	"src": "fontawesome"
	},
	{
	"uid": "7fd683b2c518ceb9e5fa6757f2276faa",
	"css": "eye-off",
	"code": 59397,
	"src": "fontawesome"
	},
	{
	"uid": "73ffeb70554099177620847206c12457",
	"css": "binoculars",
	"code": 61925,
	"src": "fontawesome"
	},
	{
	"uid": "e99461abfef3923546da8d745372c995",
	"css": "cog",
	"code": 59399,
	"src": "fontawesome"
	},
	{
	"uid": "1bafeeb1808a5fe24484c7890096901a",
	"css": "user-plus",
	"code": 62004,
	"src": "fontawesome"
	},
	{
	"uid": "559647a6f430b3aeadbecd67194451dd",
	"css": "menu",
	"code": 61641,
	"src": "fontawesome"
	},
	{
	"uid": "0d20938846444af8deb1920dc85a29fb",
	"css": "logout",
	"code": 59400,
	"src": "fontawesome"
	},
	{
	"uid": "ccddff8e8670dcd130e3cb55fdfc2fd0",
	"css": "down-open",
	"code": 59401,
	"src": "fontawesome"
	},
	{
	"uid": "44b9e75612c5fad5505edd70d071651f",
	"css": "attach",
	"code": 59402,
	"src": "entypo"
	},
	{
	"uid": "e15f0d620a7897e2035c18c80142f6d9",
	"css": "link-ext",
	"code": 61582,
	"src": "fontawesome"
	},
	{
	"uid": "e35de5ea31cd56970498e33efbcb8e36",
	"css": "link-ext-alt",
	"code": 61583,
	"src": "fontawesome"
	},
	{
	"uid": "381da2c2f7fd51f8de877c044d7f439d",
	"css": "picture",
	"code": 59403,
	"src": "fontawesome"
	},
	{
	"uid": "872d9516df93eb6b776cc4d94bd97dac",
	"css": "video",
	"code": 59404,
	"src": "fontawesome"
	},
	{
	"uid": "399ef63b1e23ab1b761dfbb5591fa4da",
	"css": "right-open",
	"code": 59405,
	"src": "fontawesome"
	},
	{
	"uid": "d870630ff8f81e6de3958ecaeac532f2",
	"css": "left-open",
	"code": 59406,
	"src": "fontawesome"
	},
	{
	"uid": "fe6697b391355dec12f3d86d6d490397",
	"css": "up-open",
	"code": 59407,
	"src": "fontawesome"
	},
	{
	"uid": "9c1376672bb4f1ed616fdd78a23667e9",
	"css": "comment-empty",
	"code": 61669,
	"src": "fontawesome"
	},
	{
	"uid": "ccc2329632396dc096bb638d4b46fb98",
	"css": "mail-alt",
	"code": 61664,
	"src": "fontawesome"
	},
	{
	"uid": "c1f1975c885aa9f3dad7810c53b82074",
	"css": "lock",
	"code": 59409,
	"src": "fontawesome"
	},
	{
	"uid": "05376be04a27d5a46e855a233d6e8508",
	"css": "lock-open-alt",
	"code": 61758,
	"src": "fontawesome"
	},
	{
	"uid": "197375a3cea8cb90b02d06e4ddf1433d",
	"css": "globe",
	"code": 59410,
	"src": "fontawesome"
	},
	{
	"uid": "b3a9e2dab4d19ea3b2f628242c926bfe",
	"css": "brush",
	"code": 59411,
	"src": "iconic"
	},
	{
	"uid": "9dd9e835aebe1060ba7190ad2b2ed951",
	"css": "search",
	"code": 59398,
	"src": "fontawesome"
	},
	{
	"uid": "ca90da02d2c6a3183f2458e4dc416285",
	"css": "adjust",
	"code": 59414,
	"src": "fontawesome"
	},
	{
	"uid": "5e2ab018e3044337bcef5f7e94098ea1",
	"css": "thumbs-up-alt",
	"code": 61796,
	"src": "fontawesome"
	},
	{
	"uid": "c76b7947c957c9b78b11741173c8349b",
	"css": "attention",
	"code": 59412,
	"src": "fontawesome"
	},
	{
	"uid": "1a5cfa186647e8c929c2b17b9fc4dac1",
	"css": "plus-squared",
	"code": 61694,
	"src": "fontawesome"
	},
	{
	"uid": "44e04715aecbca7f266a17d5a7863c68",
	"css": "plus",
	"code": 59413,
	"src": "fontawesome"
	},
	{
	"uid": "41087bc74d4b20b55059c60a33bf4008",
	"css": "edit",
	"code": 59415,
	"src": "fontawesome"
	},
	{
	"uid": "5717236f6134afe2d2a278a5c9b3927a",
	"css": "play-circled",
	"code": 61764,
	"src": "fontawesome"
	},
	{
	"uid": "d35a1d35efeb784d1dc9ac18b9b6c2b6",
	"css": "pencil",
	"code": 59416,
	"src": "fontawesome"
	},
	{
	"uid": "266d5d9adf15a61800477a5acf9a4462",
	"css": "chart-bar",
	"code": 59419,
	"src": "fontawesome"
	},
	{
	"uid": "d862a10e1448589215be19702f98f2c1",
	"css": "smile",
	"code": 61720,
	"src": "fontawesome"
	},
	{
	"uid": "671f29fa10dda08074a4c6a341bb4f39",
	"css": "bell-alt",
	"code": 61683,
	"src": "fontawesome"
	},
	{
	"uid": "5bb103cd29de77e0e06a52638527b575",
	"css": "wrench",
	"code": 59418,
	"src": "fontawesome"
	},
	{
	"uid": "5b0772e9484a1a11646793a82edd622a",
	"css": "pin",
	"code": 59417,
	"src": "fontawesome"
	},
	{
	"uid": "22411a88489225a018f68db737de3c77",
	"css": "ellipsis",
	"code": 61761,
	"src": "custom_icons",
	"selected": true,
	"svg": {
	"path": "M214 411V518Q214 540 199 556T161 571H54Q31 571 16 556T0 518V411Q0 388 16 373T54 357H161Q183 357 199 373T214 411ZM500 411V518Q500 540 484 556T446 571H339Q317 571 301 556T286 518V411Q286 388 301 373T339 357H446Q469 357 484 373T500 411ZM786 411V518Q786 540 770 556T732 571H625Q603 571 587 556T571 518V411Q571 388 587 373T625 357H732Q755 357 770 373T786 411Z",
	"width": 785.7
	},
	"search": [
	"ellipsis"
	]
	},
	{
	"uid": "0bef873af785ead27781fdf98b3ae740",
	"css": "bell-ringing-o",
	"code": 59408,
	"src": "custom_icons",
	"selected": true,
	"svg": {
	"path": "M497.8 0C468.3 0 444.4 23.9 444.4 53.3 444.4 61.1 446.1 68.3 448.9 75 301.7 96.7 213.3 213.3 213.3 320 213.3 588.3 117.8 712.8 35.6 782.2 35.6 821.1 67.8 853.3 106.7 853.3H355.6C355.6 931.7 419.4 995.6 497.8 995.6S640 931.7 640 853.3H888.9C927.8 853.3 960 821.1 960 782.2 877.8 712.8 782.2 588.3 782.2 320 782.2 213.3 693.9 96.7 546.7 75 549.4 68.3 551.1 61.1 551.1 53.3 551.1 23.9 527.2 0 497.8 0ZM189.4 44.8C108.4 118.6 70.5 215.1 71.1 320.2L142.2 319.8C141.7 231.2 170.4 158.3 237.3 97.4L189.4 44.8ZM806.2 44.8L758.3 97.4C825.2 158.3 853.9 231.2 853.3 319.8L924.4 320.2C925.1 215.1 887.2 118.6 806.2 44.8ZM408.9 844.4C413.9 844.4 417.8 848.3 417.8 853.3 417.8 897.2 453.9 933.3 497.8 933.3 502.8 933.3 506.7 937.2 506.7 942.2S502.8 951.1 497.8 951.1C443.9 951.1 400 907.2 400 853.3 400 848.3 403.9 844.4 408.9 844.4Z",
	"width": 1000
	},
	"search": [
	"bell-ringing-o"
	]
	},
	{
	"uid": "0b2b66e526028a6972d51a6f10281b4b",
	"css": "zoom-in",
	"code": 59420,
	"src": "fontawesome"
	},
	{
	"uid": "0bda4bc779d4c32623dec2e43bd67ee8",
	"css": "gauge",
	"code": 61668,
	"src": "fontawesome"
	},
	{
	"uid": "31972e4e9d080eaa796290349ae6c1fd",
	"css": "users",
	"code": 59421,
	"src": "fontawesome"
	},
	{
	"uid": "e82cedfa1d5f15b00c5a81c9bd731ea2",
	"css": "info-circled",
	"code": 59423,
	"src": "fontawesome"
	},
	{
	"uid": "w3nzesrlbezu6f30q7ytyq919p6gdlb6",
	"css": "home-2",
	"code": 59425,
	"src": "typicons"
	},
	{
	"uid": "dcedf50ab1ede3283d7a6c70e2fe32f3",
	"css": "chat",
	"code": 59422,
	"src": "fontawesome"
	},
	{
	"uid": "3a00327e61b997b58518bd43ed83c3df",
	"css": "login",
	"code": 59424,
	"src": "fontawesome"
	},
	{
	"uid": "f3ebd6751c15a280af5cc5f4a764187d",
	"css": "arrow-curved",
	"code": 59426,
	"src": "iconic"
	},
	{
	"uid": "0ddd3e8201ccc7d41f7b7c9d27eca6c1",
	"css": "link",
	"code": 59427,
	"src": "fontawesome"
	+ },
	+ {
	+ "uid": "4aad6bb50b02c18508aae9cbe14e784e",
	+ "css": "share",
	+ "code": 61920,
	+ "src": "fontawesome"
	+ },
	+ {
	+ "uid": "8b80d36d4ef43889db10bc1f0dc9a862",
	+ "css": "user",
	+ "code": 59428,
	+ "src": "fontawesome"
	+ },
	+ {
	+ "uid": "12f4ece88e46abd864e40b35e05b11cd",
	+ "css": "ok",
	+ "code": 59431,
	+ "src": "fontawesome"
	}
	]
	-}
	+}
	\ No newline at end of file

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 12:16 PM (1 d, 23 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737068
Default Alt Text: (279 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions