Fix two subscription bugs

* Added support for quarantined subreddits

* Added confirmation wall for quarantined subreddits

* Added quarantine walls to other routes and fixed case issue

* Correct obsolete use of cookie()

* Refactor param() and quarantine()

Co-authored-by: Spike <19519553+spikecodes@users.noreply.github.com>

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,24 +1,33 @@
 ---
-name: Bug report
+name: 🐛 Bug report
 about: Create a report to help us improve
-title: Bug Report | [title]
+title: ''
 labels: bug
 assignees: ''
 
 ---
 
-**Describe the bug**
+## Describe the bug
-A clear and concise description of what the bug is.
+<!--
+  A clear and concise description of what the bug is.
+-->
 
-**To reproduce**
+## To reproduce
+
+<!--
 Steps to reproduce the behavior:
 1. Go to '...'
 2. Click on '....'
 3. Scroll down to '....'
 4. See error
+-->
 
-**Expected behavior**
+## Expected behavior
-A clear and concise description of what you expected to happen.
+<!-- 
+  A clear and concise description of what you expected to happen.
+-->
 
-**Additional context**
+## Additional context
-Add any other context about the problem here.
+<!--
+  Add any other context about the problem here.
+-->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +1,28 @@
 ---
-name: Feature request
+name: 💡 Feature request
 about: Suggest an idea for this project
-title: Feature Request | [title]
+title: ''
 labels: enhancement
 assignees: ''
 
 ---
 
-**Is your feature request related to a problem? Please describe.**
+## Is your feature request related to a problem? Please describe.
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+<!--
+  A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+-->
 
-**Describe the solution you'd like**
+## Describe the solution you'd like
-A clear and concise description of what you want to happen.
+<!--
+  A clear and concise description of what you want to happen.
+-->
 
-**Describe alternatives you've considered**
+## Describe alternatives you've considered
-A clear and concise description of any alternative solutions or features you've considered.
+<!--
+  A clear and concise description of any alternative solutions or features you've considered.
+-->
 
-**Additional context**
+## Additional context
-Add any other context or screenshots about the feature request here.
+<!--
+  Add any other context or screenshots about the feature request here.
+-->

.github/workflows/docker-arm.yml

@@ -1,4 +1,4 @@
-name: Docker Multi-Architecture Build
+name: Docker ARM Build
 
 on:
   push:
@@ -30,7 +30,7 @@ jobs:
         uses: docker/build-push-action@v2
         with:
           context: .
-          file: ./Dockerfile
+          file: ./Dockerfile.arm
-          platforms: linux/amd64,linux/arm64
+          platforms: linux/arm64
           push: true
-          tags: spikecodes/libreddit:latest
+          tags: spikecodes/libreddit:arm

.github/workflows/rust.yml

@@ -21,9 +21,35 @@ jobs:
 
       - name: Build
         run: cargo build --release
-
+      
       - uses: actions/upload-artifact@v2.2.1
         name: Upload a Build Artifact
         with:
           name: libreddit
           path: target/release/libreddit
+        
+      - name: Versions
+        id: version
+        run: |
+          echo "::set-output name=version::$(cargo metadata --format-version 1 --no-deps | jq .packages[0].version -r | sed 's/^/v/')"
+          echo "::set-output name=tag::$(git describe --tags)"
+          
+      - name: Calculate SHA512 checksum
+        run: sha512sum target/release/libreddit > libreddit.sha512
+        
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        if: github.base_ref != 'master'
+        with:
+          tag_name: ${{ steps.version.outputs.version }}
+          name: ${{ steps.version.outputs.version }} - NAME
+          draft: true
+          files: |
+            target/release/libreddit
+            libreddit.sha512
+          body: |
+            - ${{ github.event.head_commit.message }} ${{ github.sha }} 
+
+            See full list of changes [here](https://github.com/spikecodes/libreddit/compare/${{ steps.version.outputs.tag }}...${{ steps.version.outputs.version }}).
+        env:
+          GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}

.gitignore

@@ -1,2 +1 @@
-/target
+/target
-Cargo.lock

Cargo.toml

@@ -3,7 +3,7 @@ name = "libreddit"
 description = " Alternative private front-end to Reddit"
 license = "AGPL-3.0"
 repository = "https://github.com/spikecodes/libreddit"
-version = "0.5.1"
+version = "0.14.3"
 authors = ["spikecodes <19519553+spikecodes@users.noreply.github.com>"]
 edition = "2018"
 
@@ -12,14 +12,14 @@ askama = { version = "0.10.5", default-features = false }
 async-recursion = "0.3.2"
 cached = "0.23.0"
 clap = { version = "2.33.3", default-features = false }
-regex = "1.4.5"
+regex = "1.5.4"
-serde = { version = "1.0.124", features = ["derive"] }
+serde = { version = "1.0.126", features = ["derive"] }
 cookie = "0.15.0"
 futures-lite = "1.11.3"
-hyper = { version = "0.14.4", features = ["full"] }
+hyper = { version = "0.14.7", features = ["full"] }
 hyper-rustls = "0.22.1"
 route-recognizer = "0.3.0"
 serde_json = "1.0.64"
-tokio = { version = "1.3.0", features = ["full"] }
+tokio = { version = "1.6.0", features = ["full"] }
 time = "0.2.26"
-url = "2.2.1"
+url = "2.2.2"

Dockerfile

@@ -1,17 +1,36 @@
-FROM rust:latest as builder
+####################################################################################################
+## Builder
+####################################################################################################
+FROM rust:alpine AS builder
+
+RUN apk add --no-cache musl-dev
+
+WORKDIR /libreddit
 
-WORKDIR /usr/src/libreddit
 COPY . .
-RUN cargo install --path .
 
+RUN cargo build --target x86_64-unknown-linux-musl --release
 
-FROM debian:buster-slim
+####################################################################################################
+## Final image
+####################################################################################################
+FROM alpine:latest
 
-RUN apt-get update && apt-get install -y libcurl4 && rm -rf /var/lib/apt/lists/*
+# Import ca-certificates from builder
-COPY --from=builder /usr/local/cargo/bin/libreddit /usr/local/bin/libreddit
+COPY --from=builder /usr/share/ca-certificates /usr/share/ca-certificates
-RUN useradd --system --user-group --home-dir /nonexistent --no-create-home --shell /usr/sbin/nologin libreddit
+COPY --from=builder /etc/ssl/certs /etc/ssl/certs
+
+# Copy our build
+COPY --from=builder /libreddit/target/x86_64-unknown-linux-musl/release/libreddit /usr/local/bin/libreddit
+
+# Use an unprivileged user.
+RUN adduser --home /nonexistent --no-create-home --disabled-password libreddit
 USER libreddit
 
+# Tell Docker to expose port 8080
 EXPOSE 8080
 
-CMD ["libreddit"]
+# Run a healthcheck every minute to make sure Libreddit is functional
+HEALTHCHECK --interval=1m --timeout=3s CMD wget --spider --q http://localhost:8080/settings || exit 1
+
+CMD ["libreddit"]

Dockerfile.arm

@@ -0,0 +1,36 @@
+####################################################################################################
+## Builder
+####################################################################################################
+FROM rust:alpine AS builder
+
+RUN apk add --no-cache g++
+
+WORKDIR /usr/src/libreddit
+
+COPY . .
+
+RUN cargo install --path .
+
+####################################################################################################
+## Final image
+####################################################################################################
+FROM alpine:latest
+
+# Import ca-certificates from builder
+COPY --from=builder /usr/share/ca-certificates /usr/share/ca-certificates
+COPY --from=builder /etc/ssl/certs /etc/ssl/certs
+
+# Copy our build
+COPY --from=builder /usr/local/cargo/bin/libreddit /usr/local/bin/libreddit
+
+# Use an unprivileged user.
+RUN adduser --home /nonexistent --no-create-home --disabled-password libreddit
+USER libreddit
+
+# Tell Docker to expose port 8080
+EXPOSE 8080
+
+# Run a healthcheck every minute to make sure Libreddit is functional
+HEALTHCHECK --interval=1m --timeout=3s CMD wget --spider --q http://localhost:8080/settings || exit 1
+
+CMD ["libreddit"]

README.md

@@ -2,7 +2,7 @@
 
 > An alternative private front-end to Reddit 
 
-![screenshot](https://i.ibb.co/74gZ4pd/libreddit-rust.png)
+![screenshot](https://i.ibb.co/QYbqTQt/libreddit-rust.png)
 
 ---
 
@@ -21,20 +21,6 @@
 
 ---
 
-## Jump to...
-- [About](#about)
-  - [Teddit Comparison](#how-does-it-compare-to-teddit)
-- [Comparison](#comparison)
-- [Installation](#installation)
-  - [Cargo](#1-cargo)
-  - [Docker](#2-docker)
-  - [AUR](#3-aur)
-  - [GitHub Releases](#4-github-releases)
-  - [Replit](#5-replit)
-- [Deployment](#deployment)
-
----
-
 # Instances
 
 Feel free to [open an issue](https://github.com/spikecodes/libreddit/issues/new) to have your [selfhosted instance](#deployment) listed here!
@@ -45,13 +31,19 @@ Feel free to [open an issue](https://github.com/spikecodes/libreddit/issues/new)
 | [libreddit.spike.codes](https://libreddit.spike.codes) (official) | 🇺🇸 US |  |
 | [libreddit.dothq.co](https://libreddit.dothq.co) | 🇺🇸 US |  |
 | [libreddit.kavin.rocks](https://libreddit.kavin.rocks) | 🇮🇳 IN | ✅ |
-| [libreddit.himiko.cloud](https://libreddit.himiko.cloud) | 🇫🇮 FI |  |
 | [libreddit.bcow.xyz](https://libreddit.bcow.xyz) | 🇺🇸 US |  |
 | [libreddit.40two.app](https://libreddit.40two.app) | 🇳🇱 NL |  |
+| [reddit.invak.id](https://reddit.invak.id) | 🇧🇬 BG |  |
+| [reddit.phii.me](https://reddit.phii.me) | 🇺🇸 US |  |
+| [lr.riverside.rocks](https://lr.riverside.rocks) | 🇺🇸 US |  |
+| [libreddit.silkky.cloud](https://libreddit.silkky.cloud) | 🇫🇮 FI |  |
+| [libreddit.database.red](https://libreddit.database.red) | 🇺🇸 US | ✅ |
+| [libreddit.exonip.de](https://libreddit.exonip.de) | 🇩🇪 DE  |  |
+| [libreddit.domain.glass](https://libreddit.domain.glass) | 🇺🇸 US | ✅ |
 | [spjmllawtheisznfs7uryhxumin26ssv2draj7oope3ok3wuhy43eoyd.onion](http://spjmllawtheisznfs7uryhxumin26ssv2draj7oope3ok3wuhy43eoyd.onion) | 🇮🇳 IN  |  |
 | [fwhhsbrbltmrct5hshrnqlqygqvcgmnek3cnka55zj4y7nuus5muwyyd.onion](http://fwhhsbrbltmrct5hshrnqlqygqvcgmnek3cnka55zj4y7nuus5muwyyd.onion) | 🇩🇪 DE  |  |
-| [libreddit.himiko7xl2skojc6odi7hykl626gt4qki3vxdbv33u2u3af76d6k32ad.onion](http://libreddit.himiko7xl2skojc6odi7hykl626gt4qki3vxdbv33u2u3af76d6k32ad.onion) | 🇫🇮 FI |  |
 | [dflv6yjt7il3n3tggf4qhcmkzbti2ppytqx3o7pjrzwgntutpewscyid.onion](http://dflv6yjt7il3n3tggf4qhcmkzbti2ppytqx3o7pjrzwgntutpewscyid.onion/) | 🇺🇸 US |  |
+| [kphht2jcflojtqte4b4kyx7p2ahagv4debjj32nre67dxz7y57seqwyd.onion](http://kphht2jcflojtqte4b4kyx7p2ahagv4debjj32nre67dxz7y57seqwyd.onion/) | 🇳🇱 NL |  |
 
 A checkmark in the "Cloudflare" category here refers to the use of the reverse proxy, [Cloudflare](https://cloudflare). The checkmark will not be listed for a site which uses Cloudflare DNS but rather the proxying service which grants Cloudflare the ability to monitor traffic to the website.
 
@@ -64,9 +56,9 @@ Find Libreddit on 💬 [Matrix](https://matrix.to/#/#libreddit:kde.org), 🐋 [D
 ## Built with
 
 - [Rust](https://www.rust-lang.org/) - Programming language
-- [Tide](https://github.com/http-rs/tide) - Web server
+- [Hyper](https://github.com/hyperium/hyper) - HTTP server and client
 - [Askama](https://github.com/djc/askama) - Templating engine
-- [Surf](https://github.com/http-rs/surf) - HTTP client
+- [Rustls](https://github.com/ctz/rustls) - TLS library
 
 ## Info
 Libreddit hopes to provide an easier way to browse Reddit, without the ads, trackers, and bloat. Libreddit was inspired by other alternative front-ends to popular services such as [Invidious](https://github.com/iv-org/invidious) for YouTube, [Nitter](https://github.com/zedeus/nitter) for Twitter, and [Bibliogram](https://sr.ht/~cadence/bibliogram/) for Instagram.
@@ -79,7 +71,7 @@ Teddit is another awesome open source project designed to provide an alternative
 
 If you are looking to compare, the biggest differences I have noticed are:
 - Libreddit is themed around Reddit's redesign whereas Teddit appears to stick much closer to Reddit's old design. This may suit some users better as design is always subjective.
-- Libreddit is written in [Rust](https://www.rust-lang.org) for speed and memory safety. It uses [Actix Web](https://actix.rs), which was [benchmarked as the fastest web server for single queries](https://www.techempower.com/benchmarks/#hw=ph&test=db).
+- Libreddit is written in [Rust](https://www.rust-lang.org) for speed and memory safety. It uses [Hyper](https://hyper.rs), a speedy and lightweight HTTP server/client implementation.
 
 ---
 
@@ -168,6 +160,8 @@ docker pull spikecodes/libreddit
 docker run -d --name libreddit -p 80:8080 spikecodes/libreddit
 ```
 
+To deploy on `arm64` platforms, simply replace `spikecodes/libreddit` in the commands above with `spikecodes/libreddit:arm`.
+
 ## 3) AUR
 
 For ArchLinux users, Libreddit is available from the AUR as [`libreddit-git`](https://aur.archlinux.org/packages/libreddit-git).
@@ -200,6 +194,32 @@ Once installed, deploy Libreddit to `0.0.0.0:8080` by running:
 libreddit
 ```
 
+## Change Default Settings
+
+Assign a default value for each setting by passing environment variables to Libreddit in the format `LIBREDDIT_DEFAULT_{X}`. Replace `{X}` with the setting name (see list below) in capital letters.
+
+| Name                  | Possible values                                                                        | Default value |
+|-----------------------|----------------------------------------------------------------------------------------|---------------|
+| theme                 | ["system", "light", "dark", "black", "dracula", "nord", "laserwave", "violet", "gold"] | system        |
+| front_page            | ["default", "popular", "all"]                                                          | default       |
+| layout                | ["card", "clean", "compact"]                                                           | card          |
+| wide                  | ["on", "off"]                                                                          | off           |
+| comment_sort          | ["hot", "new", "top", "rising", "controversial"]                                       | hot           |
+| post_sort             | ["confidence", "top", "new", "controversial", "old"]                                   | confidence    |
+| show_nsfw             | ["on", "off"]                                                                          | off           |
+| use_hls               | ["on", "off"]                                                                          | off           |
+| hide_hls_notification | ["on", "off"]                                                                          | off           |
+
+### Examples
+
+```bash
+LIBREDDIT_DEFAULT_SHOW_NSFW=on libreddit
+```
+
+```bash
+LIBREDDIT_DEFAULT_WIDE=on LIBREDDIT_DEFAULT_THEME=dark libreddit -r
+```
+
 ## Proxying using NGINX
 
 **NOTE** If you're [proxying Libreddit through a NGINX Reverse Proxy](https://github.com/spikecodes/libreddit/issues/122#issuecomment-782226853), add

docker-compose.yml

@@ -0,0 +1,13 @@
+version: "3.8"
+
+services:
+  web:
+    build: .
+    restart: always
+    container_name: "libreddit"
+    ports:
+      - 8080:8080
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/settings"]
+      interval: 5m
+      timeout: 3s

src/client.rs

@@ -3,21 +3,20 @@ use futures_lite::{future::Boxed, FutureExt};
 use hyper::{body::Buf, client, Body, Request, Response, Uri};
 use serde_json::Value;
 use std::{result::Result, str::FromStr};
-// use async_recursion::async_recursion;
 
 use crate::server::RequestExt;
 
 pub async fn proxy(req: Request<Body>, format: &str) -> Result<Response<Body>, String> {
-	let mut url = format.to_string();
+	let mut url = format!("{}?{}", format, req.uri().query().unwrap_or_default());
 
 	for (name, value) in req.params().iter() {
 		url = url.replace(&format!("{{{}}}", name), value);
 	}
 
-	stream(&url).await
+	stream(&url, &req).await
 }
 
-async fn stream(url: &str) -> Result<Response<Body>, String> {
+async fn stream(url: &str, req: &Request<Body>) -> Result<Response<Body>, String> {
 	// First parameter is target URL (mandatory).
 	let url = Uri::from_str(url).map_err(|_| "Couldn't parse URL".to_string())?;
 
@@ -27,8 +26,20 @@ async fn stream(url: &str) -> Result<Response<Body>, String> {
 	// Build the hyper client from the HTTPS connector.
 	let client: client::Client<_, hyper::Body> = client::Client::builder().build(https);
 
+	let mut builder = Request::get(url);
+
+	// Copy useful headers from original request
+	let headers = req.headers();
+	for &key in &["Range", "If-Modified-Since", "Cache-Control"] {
+		if let Some(value) = headers.get(key) {
+			builder = builder.header(key, value);
+		}
+	}
+
+	let stream_request = builder.body(Body::default()).expect("stream");
+
 	client
-		.get(url)
+		.request(stream_request)
 		.await
 		.map(|mut res| {
 			let mut rm = |key: &str| res.headers_mut().remove(key);
@@ -41,13 +52,15 @@ async fn stream(url: &str) -> Result<Response<Body>, String> {
 			rm("x-cdn-client-region");
 			rm("x-cdn-name");
 			rm("x-cdn-server-region");
+			rm("x-reddit-cdn");
+			rm("x-reddit-video-features");
 
 			res
 		})
 		.map_err(|e| e.to_string())
 }
 
-fn request(url: String) -> Boxed<Result<Response<Body>, String>> {
+fn request(url: String, quarantine: bool) -> Boxed<Result<Response<Body>, String>> {
 	// Prepare the HTTPS connector.
 	let https = hyper_rustls::HttpsConnector::with_native_roots();
 
@@ -62,6 +75,7 @@ fn request(url: String) -> Boxed<Result<Response<Body>, String>> {
 		.header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8")
 		.header("Accept-Language", "en-US,en;q=0.5")
 		.header("Connection", "keep-alive")
+		.header("Cookie", if quarantine { "_options=%7B%22pref_quarantine_optin%22%3A%20true%7D" } else { "" })
 		.body(Body::empty());
 
 	async move {
@@ -76,6 +90,7 @@ fn request(url: String) -> Boxed<Result<Response<Body>, String>> {
 								.map(|val| val.to_str().unwrap_or_default())
 								.unwrap_or_default()
 								.to_string(),
+							quarantine,
 						)
 						.await
 					} else {
@@ -92,7 +107,7 @@ fn request(url: String) -> Boxed<Result<Response<Body>, String>> {
 
 // Make a request to a Reddit API and parse the JSON response
 #[cached(size = 100, time = 30, result = true)]
-pub async fn json(path: String) -> Result<Value, String> {
+pub async fn json(path: String, quarantine: bool) -> Result<Value, String> {
 	// Build Reddit url from path
 	let url = format!("https://www.reddit.com{}", path);
 
@@ -103,7 +118,7 @@ pub async fn json(path: String) -> Result<Value, String> {
 	};
 
 	// Fetch the url...
-	match request(url.clone()).await {
+	match request(url.clone(), quarantine).await {
 		Ok(response) => {
 			// asynchronously aggregate the chunks of the body
 			match hyper::body::aggregate(response).await {
@@ -135,6 +150,6 @@ pub async fn json(path: String) -> Result<Value, String> {
 				Err(e) => err("Failed receiving body from Reddit", e.to_string()),
 			}
 		}
-		Err(e) => err("Couldn't send request to Reddit", e.to_string()),
+		Err(e) => err("Couldn't send request to Reddit", e),
 	}
 }

src/main.rs

@@ -6,7 +6,8 @@
 	clippy::match_wildcard_for_single_variants,
 	clippy::cast_possible_truncation,
 	clippy::similar_names,
-	clippy::cast_possible_wrap
+	clippy::cast_possible_wrap,
+	clippy::find_map
 )]
 
 // Reference local files
@@ -65,6 +66,16 @@ async fn favicon() -> Result<Response<Body>, String> {
 	)
 }
 
+async fn font() -> Result<Response<Body>, String> {
+	Ok(
+		Response::builder()
+			.status(200)
+			.header("content-type", "font/woff2")
+			.body(include_bytes!("../static/Inter.var.woff2").as_ref().into())
+			.unwrap_or_default(),
+	)
+}
+
 async fn resource(body: &str, content_type: &str, cache: bool) -> Result<Response<Body>, String> {
 	let mut res = Response::builder()
 		.status(200)
@@ -73,11 +84,8 @@ async fn resource(body: &str, content_type: &str, cache: bool) -> Result<Respons
 		.unwrap_or_default();
 
 	if cache {
-		match HeaderValue::from_str("public, max-age=1209600, s-maxage=86400") {
+		if let Ok(val) = HeaderValue::from_str("public, max-age=1209600, s-maxage=86400") {
-			Ok(val) => {
+			res.headers_mut().insert("Cache-Control", val);
-				res.headers_mut().insert("Cache-Control", val);
-			}
-			Err(_) => (),
 		}
 	}
 
@@ -114,11 +122,20 @@ async fn main() {
 				.help("Redirect all HTTP requests to HTTPS (no longer functional)")
 				.takes_value(false),
 		)
+		.arg(
+			Arg::with_name("hsts")
+				.short("H")
+				.long("hsts")
+				.value_name("EXPIRE_TIME")
+				.help("HSTS header to tell browsers that this site should only be accessed over HTTPS")
+				.default_value("604800")
+				.takes_value(true),
+		)
 		.get_matches();
 
 	let address = matches.value_of("address").unwrap_or("0.0.0.0");
 	let port = matches.value_of("port").unwrap_or("8080");
-	let _force_https = matches.is_present("redirect-https");
+	let hsts = matches.value_of("hsts");
 
 	let listener = format!("{}:{}", address, port);
 
@@ -132,9 +149,15 @@ async fn main() {
 		"Referrer-Policy" => "no-referrer",
 		"X-Content-Type-Options" => "nosniff",
 		"X-Frame-Options" => "DENY",
-		"Content-Security-Policy" => "default-src 'none'; manifest-src 'self'; media-src 'self'; style-src 'self' 'unsafe-inline'; base-uri 'none'; img-src 'self' data:; form-action 'self'; frame-ancestors 'none';"
+		"Content-Security-Policy" => "default-src 'none'; font-src 'self'; script-src 'self' blob:; manifest-src 'self'; media-src 'self' data: blob: about:; style-src 'self' 'unsafe-inline'; base-uri 'none'; img-src 'self' data:; form-action 'self'; frame-ancestors 'none'; connect-src 'self'; worker-src blob:;"
 	};
 
+	if let Some(expire_time) = hsts {
+		if let Ok(val) = HeaderValue::from_str(&format!("max-age={}", expire_time)) {
+			app.default_headers.insert("Strict-Transport-Security", val);
+		}
+	}
+
 	// Read static files
 	app.at("/style.css").get(|_| resource(include_str!("../static/style.css"), "text/css", false).boxed());
 	app
@@ -143,15 +166,23 @@ async fn main() {
 	app.at("/robots.txt").get(|_| resource("User-agent: *\nAllow: /", "text/plain", true).boxed());
 	app.at("/favicon.ico").get(|_| favicon().boxed());
 	app.at("/logo.png").get(|_| pwa_logo().boxed());
+	app.at("/Inter.var.woff2").get(|_| font().boxed());
 	app.at("/touch-icon-iphone.png").get(|_| iphone_logo().boxed());
 	app.at("/apple-touch-icon.png").get(|_| iphone_logo().boxed());
+	app
+		.at("/playHLSVideo.js")
+		.get(|_| resource(include_str!("../static/playHLSVideo.js"), "text/javascript", false).boxed());
+	app
+		.at("/hls.min.js")
+		.get(|_| resource(include_str!("../static/hls.min.js"), "text/javascript", false).boxed());
 
 	// Proxy media through Libreddit
 	app.at("/vid/:id/:size").get(|r| proxy(r, "https://v.redd.it/{id}/DASH_{size}").boxed());
+	app.at("/hls/:id/*path").get(|r| proxy(r, "https://v.redd.it/{id}/{path}").boxed());
 	app.at("/img/:id").get(|r| proxy(r, "https://i.redd.it/{id}").boxed());
 	app.at("/thumb/:point/:id").get(|r| proxy(r, "https://{point}.thumbs.redditmedia.com/{id}").boxed());
 	app.at("/emoji/:id/:name").get(|r| proxy(r, "https://emoji.redditmedia.com/{id}/{name}").boxed());
-	app.at("/preview/:loc/:id/:query").get(|r| proxy(r, "https://{loc}view.redd.it/{id}?{query}").boxed());
+	app.at("/preview/:loc/:id").get(|r| proxy(r, "https://{loc}view.redd.it/{id}").boxed());
 	app.at("/style/*path").get(|r| proxy(r, "https://styles.redditmedia.com/{path}").boxed());
 	app.at("/static/*path").get(|r| proxy(r, "https://www.redditstatic.com/{path}").boxed());
 
@@ -171,9 +202,17 @@ async fn main() {
 	// Configure settings
 	app.at("/settings").get(|r| settings::get(r).boxed()).post(|r| settings::set(r).boxed());
 	app.at("/settings/restore").get(|r| settings::restore(r).boxed());
+	app.at("/settings/update").get(|r| settings::update(r).boxed());
 
 	// Subreddit services
-	app.at("/r/:sub").get(|r| subreddit::community(r).boxed());
+	app
+		.at("/r/:sub")
+		.get(|r| subreddit::community(r).boxed())
+		.post(|r| subreddit::add_quarantine_exception(r).boxed());
+
+	app
+		.at("/r/u_:name")
+		.get(|r| async move { Ok(redirect(format!("/user/{}", r.param("name").unwrap_or_default()))) }.boxed());
 
 	app.at("/r/:sub/subscribe").post(|r| subreddit::subscriptions(r).boxed());
 	app.at("/r/:sub/unsubscribe").post(|r| subreddit::subscriptions(r).boxed());
@@ -188,10 +227,12 @@ async fn main() {
 		.at("/r/:sub/w")
 		.get(|r| async move { Ok(redirect(format!("/r/{}/wiki", r.param("sub").unwrap_or_default()))) }.boxed());
 	app
-		.at("/r/:sub/w/:page")
+		.at("/r/:sub/w/*page")
 		.get(|r| async move { Ok(redirect(format!("/r/{}/wiki/{}", r.param("sub").unwrap_or_default(), r.param("wiki").unwrap_or_default()))) }.boxed());
 	app.at("/r/:sub/wiki").get(|r| subreddit::wiki(r).boxed());
-	app.at("/r/:sub/wiki/:page").get(|r| subreddit::wiki(r).boxed());
+	app.at("/r/:sub/wiki/*page").get(|r| subreddit::wiki(r).boxed());
+
+	app.at("/r/:sub/about/sidebar").get(|r| subreddit::sidebar(r).boxed());
 
 	app.at("/r/:sub/:sort").get(|r| subreddit::community(r).boxed());
 
@@ -202,12 +243,12 @@ async fn main() {
 	app.at("/").get(|r| subreddit::community(r).boxed());
 
 	// View Reddit wiki
-	app.at("/w").get(|_| async move { Ok(redirect("/wiki".to_string())) }.boxed());
+	app.at("/w").get(|_| async { Ok(redirect("/wiki".to_string())) }.boxed());
 	app
-		.at("/w/:page")
+		.at("/w/*page")
 		.get(|r| async move { Ok(redirect(format!("/wiki/{}", r.param("page").unwrap_or_default()))) }.boxed());
 	app.at("/wiki").get(|r| subreddit::wiki(r).boxed());
-	app.at("/wiki/:page").get(|r| subreddit::wiki(r).boxed());
+	app.at("/wiki/*page").get(|r| subreddit::wiki(r).boxed());
 
 	// Search all of Reddit
 	app.at("/search").get(|r| search::find(r).boxed());
@@ -215,18 +256,13 @@ async fn main() {
 	// Handle about pages
 	app.at("/about").get(|req| error(req, "About pages aren't added yet".to_string()).boxed());
 
-	app.at("/:id").get(|req: Request<Body>| {
+	app.at("/:id").get(|req: Request<Body>| match req.param("id").as_deref() {
-		async {
+		// Sort front page
-			match req.param("id").as_deref() {
+		Some("best") | Some("hot") | Some("new") | Some("top") | Some("rising") | Some("controversial") => subreddit::community(req).boxed(),
-				// Sort front page
+		// Short link for post
-				Some("best") | Some("hot") | Some("new") | Some("top") | Some("rising") | Some("controversial") => subreddit::community(req).await,
+		Some(id) if id.len() > 4 && id.len() < 7 => post::item(req).boxed(),
-				// Short link for post
+		// Error message for unknown pages
-				Some(id) if id.len() > 4 && id.len() < 7 => post::item(req).await,
+		_ => error(req, "Nothing here".to_string()).boxed(),
-				// Error message for unknown pages
-				_ => error(req, "Nothing here".to_string()).await,
-			}
-		}
-		.boxed()
 	});
 
 	// Default service in case no routes match

src/post.rs

@@ -2,7 +2,9 @@
 use crate::client::json;
 use crate::esc;
 use crate::server::RequestExt;
-use crate::utils::{cookie, error, format_num, format_url, param, rewrite_urls, template, time, val, Author, Comment, Flags, Flair, FlairPart, Media, Post, Preferences};
+use crate::subreddit::{can_access_quarantine, quarantine};
+use crate::utils::{error, format_num, format_url, param, rewrite_urls, setting, template, time, val, Author, Comment, Flags, Flair, FlairPart, Media, Post, Preferences};
+
 use hyper::{Body, Request, Response};
 
 use async_recursion::async_recursion;
@@ -23,28 +25,32 @@ struct PostTemplate {
 pub async fn item(req: Request<Body>) -> Result<Response<Body>, String> {
 	// Build Reddit API path
 	let mut path: String = format!("{}.json?{}&raw_json=1", req.uri().path(), req.uri().query().unwrap_or_default());
+	let sub = req.param("sub").unwrap_or_default();
+	let quarantined = can_access_quarantine(&req, &sub);
 
 	// Set sort to sort query parameter
-	let mut sort: String = param(&path, "sort");
+	let sort = param(&path, "sort").unwrap_or_else(|| {
+		// Grab default comment sort method from Cookies
+		let default_sort = setting(&req, "comment_sort");
 
-	// Grab default comment sort method from Cookies
+		// If there's no sort query but there's a default sort, set sort to default_sort
-	let default_sort = cookie(&req, "comment_sort");
+		if default_sort.is_empty() {
-
+			String::new()
-	// If there's no sort query but there's a default sort, set sort to default_sort
+		} else {
-	if sort.is_empty() && !default_sort.is_empty() {
+			path = format!("{}.json?{}&sort={}&raw_json=1", req.uri().path(), req.uri().query().unwrap_or_default(), default_sort);
-		sort = default_sort;
+			default_sort
-		path = format!("{}.json?{}&sort={}&raw_json=1", req.uri().path(), req.uri().query().unwrap_or_default(), sort);
+		}
-	}
+	});
 
 	// Log the post ID being fetched in debug mode
 	#[cfg(debug_assertions)]
 	dbg!(req.param("id").unwrap_or_default());
 
-	let single_thread = &req.param("comment_id").is_some();
+	let single_thread = req.param("comment_id").is_some();
 	let highlighted_comment = &req.param("comment_id").unwrap_or_default();
 
 	// Send a request to the url, receive JSON in response
-	match json(path).await {
+	match json(path, quarantined).await {
 		// Otherwise, grab the JSON output from the request
 		Ok(res) => {
 			// Parse the JSON into Post and Comment structs
@@ -57,11 +63,18 @@ pub async fn item(req: Request<Body>) -> Result<Response<Body>, String> {
 				post,
 				sort,
 				prefs: Preferences::new(req),
-				single_thread: *single_thread,
+				single_thread,
 			})
 		}
 		// If the Reddit API returns an error, exit and send error page to user
-		Err(msg) => error(req, msg).await,
+		Err(msg) => {
+			if msg == "quarantined" {
+				let sub = req.param("sub").unwrap_or_default();
+				quarantine(req, sub)
+			} else {
+				error(req, msg).await
+			}
+		}
 	}
 }
 
@@ -106,6 +119,7 @@ async fn parse_post(json: &serde_json::Value) -> Post {
 		media,
 		thumbnail: Media {
 			url: format_url(val(post, "thumbnail").as_str()),
+			alt_url: String::new(),
 			width: post["data"]["thumbnail_width"].as_i64().unwrap_or_default(),
 			height: post["data"]["thumbnail_height"].as_i64().unwrap_or_default(),
 			poster: "".to_string(),
@@ -199,7 +213,7 @@ async fn parse_comments(json: &serde_json::Value, post_link: &str, post_author:
 				distinguished: val(&comment, "distinguished"),
 			},
 			score: if data["score_hidden"].as_bool().unwrap_or_default() {
-				"\u{2022}".to_string()
+				("\u{2022}".to_string(), "Hidden".to_string())
 			} else {
 				format_num(score)
 			},

src/search.rs

@@ -1,6 +1,10 @@
 // CRATES
-use crate::utils::{cookie, error, param, template, val, Post, Preferences};
+use crate::utils::{catch_random, error, format_num, format_url, param, setting, template, val, Post, Preferences};
-use crate::{client::json, RequestExt};
+use crate::{
+	client::json,
+	subreddit::{can_access_quarantine, quarantine},
+	RequestExt,
+};
 use askama::Template;
 use hyper::{Body, Request, Response};
 
@@ -18,8 +22,9 @@ struct SearchParams {
 struct Subreddit {
 	name: String,
 	url: String,
+	icon: String,
 	description: String,
-	subscribers: i64,
+	subscribers: (String, String),
 }
 
 #[derive(Template)]
@@ -30,28 +35,31 @@ struct SearchTemplate {
 	sub: String,
 	params: SearchParams,
 	prefs: Preferences,
+	url: String,
 }
 
 // SERVICES
 pub async fn find(req: Request<Body>) -> Result<Response<Body>, String> {
-	let nsfw_results = if cookie(&req, "show_nsfw") == "on" { "&include_over_18=on" } else { "" };
+	let nsfw_results = if setting(&req, "show_nsfw") == "on" { "&include_over_18=on" } else { "" };
 	let path = format!("{}.json?{}{}", req.uri().path(), req.uri().query().unwrap_or_default(), nsfw_results);
 	let sub = req.param("sub").unwrap_or_default();
-	let query = param(&path, "q");
+	let quarantined = can_access_quarantine(&req, &sub);
+	// Handle random subreddits
+	if let Ok(random) = catch_random(&sub, "/find").await {
+		return Ok(random);
+	}
+	let query = param(&path, "q").unwrap_or_default();
 
-	let sort = if param(&path, "sort").is_empty() {
+	let sort = param(&path, "sort").unwrap_or_else(|| "relevance".to_string());
-		"relevance".to_string()
+
-	} else {
+	let subreddits = match param(&path, "restrict_sr") {
-		param(&path, "sort")
+		None => search_subreddits(&query).await,
+		Some(_) => Vec::new(),
 	};
 
-	let subreddits = if param(&path, "restrict_sr").is_empty() {
+	let url = String::from(req.uri().path_and_query().map_or("", |val| val.as_str()));
-		search_subreddits(&query).await
-	} else {
-		Vec::new()
-	};
 
-	match Post::fetch(&path, String::new()).await {
+	match Post::fetch(&path, String::new(), quarantined).await {
 		Ok((posts, after)) => template(SearchTemplate {
 			posts,
 			subreddits,
@@ -59,14 +67,22 @@ pub async fn find(req: Request<Body>) -> Result<Response<Body>, String> {
 			params: SearchParams {
 				q: query.replace('"', "&quot;"),
 				sort,
-				t: param(&path, "t"),
+				t: param(&path, "t").unwrap_or_default(),
-				before: param(&path, "after"),
+				before: param(&path, "after").unwrap_or_default(),
 				after,
-				restrict_sr: param(&path, "restrict_sr"),
+				restrict_sr: param(&path, "restrict_sr").unwrap_or_default(),
 			},
 			prefs: Preferences::new(req),
+			url,
 		}),
-		Err(msg) => error(req, msg).await,
+		Err(msg) => {
+			if msg == "quarantined" {
+				let sub = req.param("sub").unwrap_or_default();
+				quarantine(req, sub)
+			} else {
+				error(req, msg).await
+			}
+		}
 	}
 }
 
@@ -74,18 +90,29 @@ async fn search_subreddits(q: &str) -> Vec<Subreddit> {
 	let subreddit_search_path = format!("/subreddits/search.json?q={}&limit=3", q.replace(' ', "+"));
 
 	// Send a request to the url
-	match json(subreddit_search_path).await {
+	match json(subreddit_search_path, false).await {
 		// If success, receive JSON in response
 		Ok(response) => {
 			match response["data"]["children"].as_array() {
 				// For each subreddit from subreddit list
 				Some(list) => list
 					.iter()
-					.map(|subreddit| Subreddit {
+					.map(|subreddit| {
-						name: val(subreddit, "display_name_prefixed"),
+						// Fetch subreddit icon either from the community_icon or icon_img value
-						url: val(subreddit, "url"),
+						let community_icon: &str = subreddit["data"]["community_icon"].as_str().map_or("", |s| s.split('?').collect::<Vec<&str>>()[0]);
-						description: val(subreddit, "public_description"),
+						let icon = if community_icon.is_empty() {
-						subscribers: subreddit["data"]["subscribers"].as_f64().unwrap_or_default() as i64,
+							val(&subreddit, "icon_img")
+						} else {
+							community_icon.to_string()
+						};
+
+						Subreddit {
+							name: val(subreddit, "display_name_prefixed"),
+							url: val(subreddit, "url"),
+							icon: format_url(&icon),
+							description: val(subreddit, "public_description"),
+							subscribers: format_num(subreddit["data"]["subscribers"].as_f64().unwrap_or_default() as i64),
+						}
 					})
 					.collect::<Vec<Subreddit>>(),
 				_ => Vec::new(),

src/server.rs

@@ -28,9 +28,8 @@ macro_rules! headers(
 		{
 			let mut m = hyper::HeaderMap::new();
 			$(
-				match hyper::header::HeaderValue::from_str($value) {
+				if let Ok(val) = hyper::header::HeaderValue::from_str($value) {
-					Ok(val) => { m.insert($key, val); }
+					m.insert($key, val);
-					Err(_) => ()
 				}
 			)+
 			m
@@ -62,7 +61,7 @@ impl RequestExt for Request<Body> {
 	}
 
 	fn param(&self, name: &str) -> Option<String> {
-		self.params().find(name).map(|s| s.to_owned())
+		self.params().find(name).map(std::borrow::ToOwned::to_owned)
 	}
 
 	fn set_params(&mut self, params: Params) -> Option<Params> {
@@ -73,14 +72,14 @@ impl RequestExt for Request<Body> {
 		let mut cookies = Vec::new();
 		if let Some(header) = self.headers().get("Cookie") {
 			for cookie in header.to_str().unwrap_or_default().split("; ") {
-				cookies.push(Cookie::parse(cookie).unwrap_or(Cookie::named("")));
+				cookies.push(Cookie::parse(cookie).unwrap_or_else(|_| Cookie::named("")));
 			}
 		}
 		cookies
 	}
 
 	fn cookie(&self, name: &str) -> Option<Cookie> {
-		self.cookies().iter().find(|c| c.name() == name).map(|c| c.to_owned())
+		self.cookies().iter().find(|c| c.name() == name).map(std::borrow::ToOwned::to_owned)
 	}
 }
 
@@ -96,11 +95,8 @@ impl ResponseExt for Response<Body> {
 	}
 
 	fn insert_cookie(&mut self, cookie: Cookie) {
-		match HeaderValue::from_str(&cookie.to_string()) {
+		if let Ok(val) = HeaderValue::from_str(&cookie.to_string()) {
-			Ok(val) => {
+			self.headers_mut().append("Set-Cookie", val);
-				self.headers_mut().append("Set-Cookie", val);
-			}
-			Err(_) => (),
 		}
 	}
 
@@ -108,11 +104,8 @@ impl ResponseExt for Response<Body> {
 		let mut cookie = Cookie::named(name);
 		cookie.set_path("/");
 		cookie.set_max_age(Duration::second());
-		match HeaderValue::from_str(&cookie.to_string()) {
+		if let Ok(val) = HeaderValue::from_str(&cookie.to_string()) {
-			Ok(val) => {
+			self.headers_mut().append("Set-Cookie", val);
-				self.headers_mut().append("Set-Cookie", val);
-			}
-			Err(_) => (),
 		}
 	}
 }
@@ -178,9 +171,9 @@ impl Server {
 							parammed.set_params(found.params().to_owned());
 
 							// Run the route's function
-							let yeet = (found.handler().to_owned().to_owned())(parammed);
+							let func = (found.handler().to_owned().to_owned())(parammed);
 							async move {
-								let res: Result<Response<Body>, String> = yeet.await;
+								let res: Result<Response<Body>, String> = func.await;
 								// Add default headers to response
 								res.map(|mut response| {
 									response.headers_mut().extend(headers);

src/settings.rs

@@ -16,18 +16,19 @@ struct SettingsTemplate {
 	prefs: Preferences,
 }
 
-#[derive(serde::Deserialize, Default, Debug)]
+// CONSTANTS
-#[serde(default)]
+
-pub struct Form {
+const PREFS: [&str; 9] = [
-	theme: Option<String>,
+	"theme",
-	front_page: Option<String>,
+	"front_page",
-	layout: Option<String>,
+	"layout",
-	wide: Option<String>,
+	"wide",
-	comment_sort: Option<String>,
+	"comment_sort",
-	show_nsfw: Option<String>,
+	"post_sort",
-	redirect: Option<String>,
+	"show_nsfw",
-	subscriptions: Option<String>,
+	"use_hls",
-}
+	"hide_hls_notification",
+];
 
 // FUNCTIONS
 
@@ -63,9 +64,7 @@ pub async fn set(req: Request<Body>) -> Result<Response<Body>, String> {
 
 	let mut res = redirect("/settings".to_string());
 
-	let names = vec!["theme", "front_page", "layout", "wide", "comment_sort", "show_nsfw", "subscriptions"];
+	for &name in &PREFS {
-
-	for name in names {
 		match form.get(name) {
 			Some(value) => res.insert_cookie(
 				Cookie::build(name.to_owned(), value.to_owned())
@@ -81,8 +80,7 @@ pub async fn set(req: Request<Body>) -> Result<Response<Body>, String> {
 	Ok(res)
 }
 
-// Set cookies using response "Set-Cookie" header
+fn set_cookies_method(req: Request<Body>, remove_cookies: bool) -> Response<Body> {
-pub async fn restore(req: Request<Body>) -> Result<Response<Body>, String> {
 	// Split the body into parts
 	let (parts, _) = req.into_parts();
 
@@ -98,16 +96,14 @@ pub async fn restore(req: Request<Body>) -> Result<Response<Body>, String> {
 
 	let form = url::form_urlencoded::parse(query).collect::<HashMap<_, _>>();
 
-	let names = vec!["theme", "front_page", "layout", "wide", "comment_sort", "show_nsfw", "subscriptions"];
-
 	let path = match form.get("redirect") {
-		Some(value) => format!("/{}/", value),
+		Some(value) => format!("/{}", value.replace("%26", "&").replace("%23", "#")),
 		None => "/".to_string(),
 	};
 
 	let mut res = redirect(path);
 
-	for name in names {
+	for name in [PREFS.to_vec(), vec!["subscriptions"]].concat() {
 		match form.get(name) {
 			Some(value) => res.insert_cookie(
 				Cookie::build(name.to_owned(), value.to_owned())
@@ -116,9 +112,22 @@ pub async fn restore(req: Request<Body>) -> Result<Response<Body>, String> {
 					.expires(OffsetDateTime::now_utc() + Duration::weeks(52))
 					.finish(),
 			),
-			None => res.remove_cookie(name.to_string()),
+			None => {
+				if remove_cookies {
+					res.remove_cookie(name.to_string())
+				}
+			}
 		};
 	}
 
-	Ok(res)
+	res
+}
+
+// Set cookies using response "Set-Cookie" header
+pub async fn restore(req: Request<Body>) -> Result<Response<Body>, String> {
+	Ok(set_cookies_method(req, true))
+}
+
+pub async fn update(req: Request<Body>) -> Result<Response<Body>, String> {
+	Ok(set_cookies_method(req, false))
 }

src/subreddit.rs

@@ -1,6 +1,6 @@
 // CRATES
 use crate::esc;
-use crate::utils::{cookie, error, format_num, format_url, param, redirect, rewrite_urls, template, val, Post, Preferences, Subreddit};
+use crate::utils::{catch_random, error, format_num, format_url, param, redirect, rewrite_urls, setting, template, val, Post, Preferences, Subreddit};
 use crate::{client::json, server::ResponseExt, RequestExt};
 use askama::Template;
 use cookie::Cookie;
@@ -16,6 +16,7 @@ struct SubredditTemplate {
 	sort: (String, String),
 	ends: (String, String),
 	prefs: Preferences,
+	url: String,
 }
 
 #[derive(Template)]
@@ -27,14 +28,26 @@ struct WikiTemplate {
 	prefs: Preferences,
 }
 
+#[derive(Template)]
+#[template(path = "wall.html", escape = "none")]
+struct WallTemplate {
+	title: String,
+	sub: String,
+	msg: String,
+	prefs: Preferences,
+	url: String,
+}
+
 // SERVICES
 pub async fn community(req: Request<Body>) -> Result<Response<Body>, String> {
 	// Build Reddit API path
-	let subscribed = cookie(&req, "subscriptions");
+	let root = req.uri().path() == "/";
-	let front_page = cookie(&req, "front_page");
+	let subscribed = setting(&req, "subscriptions");
-	let sort = req.param("sort").unwrap_or_else(|| req.param("id").unwrap_or("hot".to_string()));
+	let front_page = setting(&req, "front_page");
+	let post_sort = req.cookie("post_sort").map_or_else(|| "hot".to_string(), |c| c.value().to_string());
+	let sort = req.param("sort").unwrap_or_else(|| req.param("id").unwrap_or(post_sort));
 
-	let sub = req.param("sub").map(String::from).unwrap_or(if front_page == "default" || front_page.is_empty() {
+	let sub = req.param("sub").unwrap_or(if front_page == "default" || front_page.is_empty() {
 		if subscribed.is_empty() {
 			"popular".to_string()
 		} else {
@@ -43,19 +56,29 @@ pub async fn community(req: Request<Body>) -> Result<Response<Body>, String> {
 	} else {
 		front_page.to_owned()
 	});
+	let quarantined = can_access_quarantine(&req, &sub) || root;
+
+	// Handle random subreddits
+	if let Ok(random) = catch_random(&sub, "").await {
+		return Ok(random);
+	}
+
+	if req.param("sub").is_some() && sub.starts_with("u_") {
+		return Ok(redirect(["/user/", &sub[2..]].concat()));
+	}
 
 	let path = format!("/r/{}/{}.json?{}&raw_json=1", sub, sort, req.uri().query().unwrap_or_default());
 
-	match Post::fetch(&path, String::new()).await {
+	match Post::fetch(&path, String::new(), quarantined).await {
 		Ok((posts, after)) => {
 			// If you can get subreddit posts, also request subreddit metadata
 			let sub = if !sub.contains('+') && sub != subscribed && sub != "popular" && sub != "all" {
 				// Regular subreddit
-				subreddit(&sub).await.unwrap_or_default()
+				subreddit(&sub, quarantined).await.unwrap_or_default()
 			} else if sub == subscribed {
 				// Subscription feed
 				if req.uri().path().starts_with("/r/") {
-					subreddit(&sub).await.unwrap_or_default()
+					subreddit(&sub, quarantined).await.unwrap_or_default()
 				} else {
 					Subreddit::default()
 				}
@@ -69,16 +92,19 @@ pub async fn community(req: Request<Body>) -> Result<Response<Body>, String> {
 				Subreddit::default()
 			};
 
+			let url = String::from(req.uri().path_and_query().map_or("", |val| val.as_str()));
+
 			template(SubredditTemplate {
 				sub,
 				posts,
-				sort: (sort, param(&path, "t")),
+				sort: (sort, param(&path, "t").unwrap_or_default()),
-				ends: (param(&path, "after"), after),
+				ends: (param(&path, "after").unwrap_or_default(), after),
 				prefs: Preferences::new(req),
+				url,
 			})
 		}
 		Err(msg) => match msg.as_str() {
-			"quarantined" => error(req, format!("r/{} has been quarantined by Reddit", sub)).await,
+			"quarantined" => quarantine(req, sub),
 			"private" => error(req, format!("r/{} is a private community", sub)).await,
 			"banned" => error(req, format!("r/{} has been banned from Reddit", sub)).await,
 			_ => error(req, msg).await,
@@ -86,16 +112,85 @@ pub async fn community(req: Request<Body>) -> Result<Response<Body>, String> {
 	}
 }
 
+pub fn quarantine(req: Request<Body>, sub: String) -> Result<Response<Body>, String> {
+	let wall = WallTemplate {
+		title: format!("r/{} is quarantined", sub),
+		msg: "Please click the button below to continue to this subreddit.".to_string(),
+		url: req.uri().to_string(),
+		sub,
+		prefs: Preferences::new(req),
+	};
+
+	Ok(
+		Response::builder()
+			.status(403)
+			.header("content-type", "text/html")
+			.body(wall.render().unwrap_or_default().into())
+			.unwrap_or_default(),
+	)
+}
+
+pub async fn add_quarantine_exception(req: Request<Body>) -> Result<Response<Body>, String> {
+	let subreddit = req.param("sub").ok_or("Invalid URL")?;
+	let redir = param(&format!("?{}", req.uri().query().unwrap_or_default()), "redir").ok_or("Invalid URL")?;
+	let mut res = redirect(redir);
+	res.insert_cookie(
+		Cookie::build(&format!("allow_quaran_{}", subreddit.to_lowercase()), "true")
+			.path("/")
+			.http_only(true)
+			.expires(cookie::Expiration::Session)
+			.finish(),
+	);
+	Ok(res)
+}
+
+pub fn can_access_quarantine(req: &Request<Body>, sub: &str) -> bool {
+	// Determine if the subreddit can be accessed
+	setting(&req, &format!("allow_quaran_{}", sub.to_lowercase())).parse().unwrap_or_default()
+}
+
 // Sub or unsub by setting subscription cookie using response "Set-Cookie" header
 pub async fn subscriptions(req: Request<Body>) -> Result<Response<Body>, String> {
-	let sub = req.param("sub").unwrap_or_default().to_string();
+	let sub = req.param("sub").unwrap_or_default();
+	// Handle random subreddits
+	if sub == "random" || sub == "randnsfw" {
+		return Err("Can't subscribe to random subreddit!".to_string());
+	}
+
 	let query = req.uri().query().unwrap_or_default().to_string();
 	let action: Vec<String> = req.uri().path().split('/').map(String::from).collect();
 
 	let mut sub_list = Preferences::new(req).subscriptions;
 
+	// Retrieve list of posts for these subreddits to extract display names
+	let posts = json(format!("/r/{}/hot.json?raw_json=1", sub), true).await?;
+	let display_lookup: Vec<(String, &str)> = posts["data"]["children"]
+		.as_array()
+		.map(|list| {
+			list
+				.iter()
+				.map(|post| {
+					let display_name = post["data"]["subreddit"].as_str().unwrap_or_default();
+					(display_name.to_lowercase(), display_name)
+				})
+				.collect::<Vec<_>>()
+		})
+		.unwrap_or_default();
+
 	// Find each subreddit name (separated by '+') in sub parameter
 	for part in sub.split('+') {
+		// Retrieve display name for the subreddit
+		let display;
+		let part = if let Some(&(_, display)) = display_lookup.iter().find(|x| x.0 == part.to_lowercase()) {
+			// This is already known, doesn't require seperate request
+			display
+		} else {
+			// This subreddit display name isn't known, retrieve it
+			let path: String = format!("/r/{}/about.json?raw_json=1", part);
+			display = json(path, true).await?;
+			display["data"]["display_name"].as_str().ok_or_else(|| "Failed to query subreddit name".to_string())?
+		};
+
 		// Modify sub list based on action
 		if action.contains(&"subscribe".to_string()) && !sub_list.contains(&part.to_owned()) {
 			// Add each sub name to the subscribed list
@@ -104,17 +199,16 @@ pub async fn subscriptions(req: Request<Body>) -> Result<Response<Body>, String>
 			sub_list.sort_by_key(|a| a.to_lowercase())
 		} else if action.contains(&"unsubscribe".to_string()) {
 			// Remove sub name from subscribed list
-			sub_list.retain(|s| s != part);
+			sub_list.retain(|s| s.to_lowercase() != part.to_lowercase());
 		}
 	}
 
 	// Redirect back to subreddit
 	// check for redirect parameter if unsubscribing from outside sidebar
-	let redirect_path = param(&format!("/?{}", query), "redirect");
+	let path = if let Some(redirect_path) = param(&format!("?{}", query), "redirect") {
-	let path = if redirect_path.is_empty() {
-		format!("/r/{}", sub)
-	} else {
 		format!("/{}/", redirect_path)
+	} else {
+		format!("/r/{}", sub)
 	};
 
 	let mut res = redirect(path);
@@ -136,28 +230,109 @@ pub async fn subscriptions(req: Request<Body>) -> Result<Response<Body>, String>
 }
 
 pub async fn wiki(req: Request<Body>) -> Result<Response<Body>, String> {
-	let sub = req.param("sub").unwrap_or("reddit.com".to_string());
+	let sub = req.param("sub").unwrap_or_else(|| "reddit.com".to_string());
-	let page = req.param("page").unwrap_or("index".to_string());
+	let quarantined = can_access_quarantine(&req, &sub);
+	// Handle random subreddits
+	if let Ok(random) = catch_random(&sub, "/wiki").await {
+		return Ok(random);
+	}
+
+	let page = req.param("page").unwrap_or_else(|| "index".to_string());
 	let path: String = format!("/r/{}/wiki/{}.json?raw_json=1", sub, page);
 
-	match json(path).await {
+	match json(path, quarantined).await {
 		Ok(response) => template(WikiTemplate {
 			sub,
-			wiki: rewrite_urls(response["data"]["content_html"].as_str().unwrap_or_default()),
+			wiki: rewrite_urls(response["data"]["content_html"].as_str().unwrap_or("<h3>Wiki not found</h3>")),
 			page,
 			prefs: Preferences::new(req),
 		}),
-		Err(msg) => error(req, msg).await,
+		Err(msg) => {
+			if msg == "quarantined" {
+				quarantine(req, sub)
+			} else {
+				error(req, msg).await
+			}
+		}
 	}
 }
 
-// SUBREDDIT
+pub async fn sidebar(req: Request<Body>) -> Result<Response<Body>, String> {
-async fn subreddit(sub: &str) -> Result<Subreddit, String> {
+	let sub = req.param("sub").unwrap_or_else(|| "reddit.com".to_string());
+	let quarantined = can_access_quarantine(&req, &sub);
+	// Handle random subreddits
+	if let Ok(random) = catch_random(&sub, "/about/sidebar").await {
+		return Ok(random);
+	}
+
 	// Build the Reddit JSON API url
 	let path: String = format!("/r/{}/about.json?raw_json=1", sub);
 
 	// Send a request to the url
-	match json(path).await {
+	match json(path, quarantined).await {
+		// If success, receive JSON in response
+		Ok(response) => template(WikiTemplate {
+			wiki: format!(
+				"{}<hr><h1>Moderators</h1><br><ul>{}</ul>",
+				rewrite_urls(&val(&response, "description_html").replace("\\", "")),
+				moderators(&sub, quarantined).await?.join(""),
+			),
+			sub,
+			page: "Sidebar".to_string(),
+			prefs: Preferences::new(req),
+		}),
+		Err(msg) => {
+			if msg == "quarantined" {
+				quarantine(req, sub)
+			} else {
+				error(req, msg).await
+			}
+		}
+	}
+}
+
+pub async fn moderators(sub: &str, quarantined: bool) -> Result<Vec<String>, String> {
+	// Retrieve and format the html for the moderators list
+	Ok(
+		moderators_list(sub, quarantined)
+			.await?
+			.iter()
+			.map(|m| format!("<li><a style=\"color: var(--accent)\" href=\"/u/{name}\">{name}</a></li>", name = m))
+			.collect(),
+	)
+}
+
+async fn moderators_list(sub: &str, quarantined: bool) -> Result<Vec<String>, String> {
+	// Build the moderator list URL
+	let path: String = format!("/r/{}/about/moderators.json?raw_json=1", sub);
+
+	// Retrieve response
+	let response = json(path, quarantined).await?["data"]["children"].clone();
+	Ok(
+		// Traverse json tree and format into list of strings
+		response
+			.as_array()
+			.unwrap_or(&Vec::new())
+			.iter()
+			.filter_map(|moderator| {
+				let name = moderator["name"].as_str().unwrap_or_default();
+				if name.is_empty() {
+					None
+				} else {
+					Some(name.to_string())
+				}
+			})
+			.collect::<Vec<_>>(),
+	)
+}
+
+// SUBREDDIT
+async fn subreddit(sub: &str, quarantined: bool) -> Result<Subreddit, String> {
+	// Build the Reddit JSON API url
+	let path: String = format!("/r/{}/about.json?raw_json=1", sub);
+
+	// Send a request to the url
+	match json(path, quarantined).await {
 		// If success, receive JSON in response
 		Ok(res) => {
 			// Metadata regarding the subreddit
@@ -165,7 +340,7 @@ async fn subreddit(sub: &str) -> Result<Subreddit, String> {
 			let active: i64 = res["data"]["accounts_active"].as_u64().unwrap_or_default() as i64;
 
 			// Fetch subreddit icon either from the community_icon or icon_img value
-			let community_icon: &str = res["data"]["community_icon"].as_str().map_or("", |s| s.split('?').collect::<Vec<&str>>()[0]);
+			let community_icon: &str = res["data"]["community_icon"].as_str().unwrap_or_default();
 			let icon = if community_icon.is_empty() { val(&res, "icon_img") } else { community_icon.to_string() };
 
 			let sub = Subreddit {
@@ -173,6 +348,7 @@ async fn subreddit(sub: &str) -> Result<Subreddit, String> {
 				title: esc!(&res, "title"),
 				description: esc!(&res, "public_description"),
 				info: rewrite_urls(&val(&res, "description_html").replace("\\", "")),
+				moderators: moderators_list(sub, quarantined).await?,
 				icon: format_url(&icon),
 				members: format_num(members),
 				active: format_num(active),

src/user.rs

@@ -16,6 +16,7 @@ struct UserTemplate {
 	sort: (String, String),
 	ends: (String, String),
 	prefs: Preferences,
+	url: String,
 }
 
 // FUNCTIONS
@@ -23,16 +24,17 @@ pub async fn profile(req: Request<Body>) -> Result<Response<Body>, String> {
 	// Build the Reddit JSON API path
 	let path = format!(
 		"/user/{}.json?{}&raw_json=1",
-		req.param("name").unwrap_or("reddit".to_string()),
+		req.param("name").unwrap_or_else(|| "reddit".to_string()),
 		req.uri().query().unwrap_or_default()
 	);
 
 	// Retrieve other variables from Libreddit request
-	let sort = param(&path, "sort");
+	let sort = param(&path, "sort").unwrap_or_default();
 	let username = req.param("name").unwrap_or_default();
 
 	// Request user posts/comments from Reddit
-	let posts = Post::fetch(&path, "Comment".to_string()).await;
+	let posts = Post::fetch(&path, "Comment".to_string(), false).await;
+	let url = String::from(req.uri().path_and_query().map_or("", |val| val.as_str()));
 
 	match posts {
 		Ok((posts, after)) => {
@@ -42,9 +44,10 @@ pub async fn profile(req: Request<Body>) -> Result<Response<Body>, String> {
 			template(UserTemplate {
 				user,
 				posts,
-				sort: (sort, param(&path, "t")),
+				sort: (sort, param(&path, "t").unwrap_or_default()),
-				ends: (param(&path, "after"), after),
+				ends: (param(&path, "after").unwrap_or_default(), after),
 				prefs: Preferences::new(req),
+				url,
 			})
 		}
 		// If there is an error show error page
@@ -58,7 +61,7 @@ async fn user(name: &str) -> Result<User, String> {
 	let path: String = format!("/user/{}/about.json?raw_json=1", name);
 
 	// Send a request to the url
-	match json(path).await {
+	match json(path, false).await {
 		// If success, receive JSON in response
 		Ok(res) => {
 			// Grab creation date as unix timestamp

src/utils.rs

@@ -75,6 +75,7 @@ pub struct Flags {
 
 pub struct Media {
 	pub url: String,
+	pub alt_url: String,
 	pub width: i64,
 	pub height: i64,
 	pub poster: String,
@@ -85,12 +86,28 @@ impl Media {
 		let mut gallery = Vec::new();
 
 		// If post is a video, return the video
-		let (post_type, url_val) = if data["preview"]["reddit_video_preview"]["fallback_url"].is_string() {
+		let (post_type, url_val, alt_url_val) = if data["preview"]["reddit_video_preview"]["fallback_url"].is_string() {
 			// Return reddit video
-			("video", &data["preview"]["reddit_video_preview"]["fallback_url"])
+			(
+				if data["preview"]["reddit_video_preview"]["is_gif"].as_bool().unwrap_or(false) {
+					"gif"
+				} else {
+					"video"
+				},
+				&data["preview"]["reddit_video_preview"]["fallback_url"],
+				Some(&data["preview"]["reddit_video_preview"]["hls_url"]),
+			)
 		} else if data["secure_media"]["reddit_video"]["fallback_url"].is_string() {
 			// Return reddit video
-			("video", &data["secure_media"]["reddit_video"]["fallback_url"])
+			(
+				if data["preview"]["reddit_video_preview"]["is_gif"].as_bool().unwrap_or(false) {
+					"gif"
+				} else {
+					"video"
+				},
+				&data["secure_media"]["reddit_video"]["fallback_url"],
+				Some(&data["secure_media"]["reddit_video"]["hls_url"]),
+			)
 		} else if data["post_hint"].as_str().unwrap_or("") == "image" {
 			// Handle images, whether GIFs or pics
 			let preview = &data["preview"]["images"][0];
@@ -98,26 +115,26 @@ impl Media {
 
 			if mp4.is_object() {
 				// Return the mp4 if the media is a gif
-				("gif", &mp4["source"]["url"])
+				("gif", &mp4["source"]["url"], None)
 			} else {
 				// Return the picture if the media is an image
 				if data["domain"] == "i.redd.it" {
-					("image", &data["url"])
+					("image", &data["url"], None)
 				} else {
-					("image", &preview["source"]["url"])
+					("image", &preview["source"]["url"], None)
 				}
 			}
 		} else if data["is_self"].as_bool().unwrap_or_default() {
 			// If type is self, return permalink
-			("self", &data["permalink"])
+			("self", &data["permalink"], None)
 		} else if data["is_gallery"].as_bool().unwrap_or_default() {
 			// If this post contains a gallery of images
 			gallery = GalleryMedia::parse(&data["gallery_data"]["items"], &data["media_metadata"]);
 
-			("gallery", &data["url"])
+			("gallery", &data["url"], None)
 		} else {
 			// If type can't be determined, return url
-			("link", &data["url"])
+			("link", &data["url"], None)
 		};
 
 		let source = &data["preview"]["images"][0]["source"];
@@ -128,10 +145,13 @@ impl Media {
 			format_url(url_val.as_str().unwrap_or_default())
 		};
 
+		let alt_url = alt_url_val.map_or(String::new(), |val| format_url(val.as_str().unwrap_or_default()));
+
 		(
 			post_type.to_string(),
 			Self {
 				url,
+				alt_url,
 				width: source["width"].as_i64().unwrap_or_default(),
 				height: source["height"].as_i64().unwrap_or_default(),
 				poster: format_url(source["url"].as_str().unwrap_or_default()),
@@ -181,7 +201,7 @@ pub struct Post {
 	pub body: String,
 	pub author: Author,
 	pub permalink: String,
-	pub score: String,
+	pub score: (String, String),
 	pub upvote_ratio: i64,
 	pub post_type: String,
 	pub flair: Flair,
@@ -191,18 +211,18 @@ pub struct Post {
 	pub domain: String,
 	pub rel_time: String,
 	pub created: String,
-	pub comments: String,
+	pub comments: (String, String),
 	pub gallery: Vec<GalleryMedia>,
 }
 
 impl Post {
 	// Fetch posts of a user or subreddit and return a vector of posts and the "after" value
-	pub async fn fetch(path: &str, fallback_title: String) -> Result<(Vec<Self>, String), String> {
+	pub async fn fetch(path: &str, fallback_title: String, quarantine: bool) -> Result<(Vec<Self>, String), String> {
 		let res;
 		let post_list;
 
 		// Send a request to the url
-		match json(path.to_string()).await {
+		match json(path.to_string(), quarantine).await {
 			// If success, receive JSON in response
 			Ok(response) => {
 				res = response;
@@ -251,7 +271,7 @@ impl Post {
 					distinguished: val(post, "distinguished"),
 				},
 				score: if data["hide_score"].as_bool().unwrap_or_default() {
-					"\u{2022}".to_string()
+					("\u{2022}".to_string(), "Hidden".to_string())
 				} else {
 					format_num(score)
 				},
@@ -259,6 +279,7 @@ impl Post {
 				post_type,
 				thumbnail: Media {
 					url: format_url(val(post, "thumbnail").as_str()),
+					alt_url: String::new(),
 					width: data["thumbnail_width"].as_i64().unwrap_or_default(),
 					height: data["thumbnail_height"].as_i64().unwrap_or_default(),
 					poster: "".to_string(),
@@ -307,7 +328,7 @@ pub struct Comment {
 	pub post_author: String,
 	pub body: String,
 	pub author: Author,
-	pub score: String,
+	pub score: (String, String),
 	pub rel_time: String,
 	pub created: String,
 	pub edited: (String, String),
@@ -341,9 +362,10 @@ pub struct Subreddit {
 	pub title: String,
 	pub description: String,
 	pub info: String,
+	pub moderators: Vec<String>,
 	pub icon: String,
-	pub members: String,
+	pub members: (String, String),
-	pub active: String,
+	pub active: (String, String),
 	pub wiki: bool,
 }
 
@@ -364,7 +386,10 @@ pub struct Preferences {
 	pub layout: String,
 	pub wide: String,
 	pub show_nsfw: String,
+	pub hide_hls_notification: String,
+	pub use_hls: String,
 	pub comment_sort: String,
+	pub post_sort: String,
 	pub subscriptions: Vec<String>,
 }
 
@@ -372,13 +397,16 @@ impl Preferences {
 	// Build preferences from cookies
 	pub fn new(req: Request<Body>) -> Self {
 		Self {
-			theme: cookie(&req, "theme"),
+			theme: setting(&req, "theme"),
-			front_page: cookie(&req, "front_page"),
+			front_page: setting(&req, "front_page"),
-			layout: cookie(&req, "layout"),
+			layout: setting(&req, "layout"),
-			wide: cookie(&req, "wide"),
+			wide: setting(&req, "wide"),
-			show_nsfw: cookie(&req, "show_nsfw"),
+			show_nsfw: setting(&req, "show_nsfw"),
-			comment_sort: cookie(&req, "comment_sort"),
+			use_hls: setting(&req, "use_hls"),
-			subscriptions: cookie(&req, "subscriptions").split('+').map(String::from).filter(|s| !s.is_empty()).collect(),
+			hide_hls_notification: setting(&req, "hide_hls_notification"),
+			comment_sort: setting(&req, "comment_sort"),
+			post_sort: setting(&req, "post_sort"),
+			subscriptions: setting(&req, "subscriptions").split('+').map(String::from).filter(|s| !s.is_empty()).collect(),
 		}
 	}
 }
@@ -388,17 +416,46 @@ impl Preferences {
 //
 
 // Grab a query parameter from a url
-pub fn param(path: &str, value: &str) -> String {
+pub fn param(path: &str, value: &str) -> Option<String> {
-	match Url::parse(format!("https://libredd.it/{}", path).as_str()) {
+	Some(
-		Ok(url) => url.query_pairs().into_owned().collect::<HashMap<_, _>>().get(value).unwrap_or(&String::new()).to_owned(),
+		Url::parse(format!("https://libredd.it/{}", path).as_str())
-		_ => String::new(),
+			.ok()?
-	}
+			.query_pairs()
+			.into_owned()
+			.collect::<HashMap<_, _>>()
+			.get(value)?
+			.to_owned(),
+	)
 }
 
-// Parse a cookie value from request
+// Retrieve the value of a setting by name
-pub fn cookie(req: &Request<Body>, name: &str) -> String {
+pub fn setting(req: &Request<Body>, name: &str) -> String {
-	let cookie = req.cookie(name).unwrap_or_else(|| Cookie::named(name));
+	// Parse a cookie value from request
-	cookie.value().to_string()
+	req
+		.cookie(name)
+		.unwrap_or_else(|| {
+			// If there is no cookie for this setting, try receiving a default from an environment variable
+			if let Ok(default) = std::env::var(format!("LIBREDDIT_DEFAULT_{}", name.to_uppercase())) {
+				Cookie::new(name, default)
+			} else {
+				Cookie::named(name)
+			}
+		})
+		.value()
+		.to_string()
+}
+
+// Detect and redirect in the event of a random subreddit
+pub async fn catch_random(sub: &str, additional: &str) -> Result<Response<Body>, String> {
+	if (sub == "random" || sub == "randnsfw") && !sub.contains('+') {
+		let new_sub = json(format!("/r/{}/about.json?raw_json=1", sub), false).await?["data"]["display_name"]
+			.as_str()
+			.unwrap_or_default()
+			.to_string();
+		Ok(redirect(format!("/r/{}{}", new_sub, additional)))
+	} else {
+		Err("No redirect needed".to_string())
+	}
 }
 
 // Direct urls to proxy if proxy is enabled
@@ -414,8 +471,8 @@ pub fn format_url(url: &str) -> String {
 					Regex::new(regex)
 						.map(|re| match re.captures(url) {
 							Some(caps) => match segments {
-								1 => [format, &caps[1], "/"].join(""),
+								1 => [format, &caps[1]].join(""),
-								2 => [format, &caps[1], "/", &caps[2], "/"].join(""),
+								2 => [format, &caps[1], "/", &caps[2]].join(""),
 								_ => String::new(),
 							},
 							None => String::new(),
@@ -423,14 +480,38 @@ pub fn format_url(url: &str) -> String {
 						.unwrap_or_default()
 				};
 
+				macro_rules! chain {
+					() => {
+						{
+							String::new()
+						}
+					};
+
+					( $first_fn:expr, $($other_fns:expr), *) => {
+						{
+							let result = $first_fn;
+							if result.is_empty() {
+								chain!($($other_fns,)*)
+							}
+							else
+							{
+								result
+							}
+						}
+					};
+				}
+
 				match domain {
-					"v.redd.it" => capture(r"https://v\.redd\.it/(.*)/DASH_([0-9]{2,4}(\.mp4|$))", "/vid/", 2),
+					"v.redd.it" => chain!(
+						capture(r"https://v\.redd\.it/(.*)/DASH_([0-9]{2,4}(\.mp4|$))", "/vid/", 2),
+						capture(r"https://v\.redd\.it/(.+)/(HLSPlaylist\.m3u8.*)$", "/hls/", 2)
+					),
 					"i.redd.it" => capture(r"https://i\.redd\.it/(.*)", "/img/", 1),
 					"a.thumbs.redditmedia.com" => capture(r"https://a\.thumbs\.redditmedia\.com/(.*)", "/thumb/a/", 1),
 					"b.thumbs.redditmedia.com" => capture(r"https://b\.thumbs\.redditmedia\.com/(.*)", "/thumb/b/", 1),
 					"emoji.redditmedia.com" => capture(r"https://emoji\.redditmedia\.com/(.*)/(.*)", "/emoji/", 2),
-					"preview.redd.it" => capture(r"https://preview\.redd\.it/(.*)\?(.*)", "/preview/pre/", 2),
+					"preview.redd.it" => capture(r"https://preview\.redd\.it/(.*)", "/preview/pre/", 1),
-					"external-preview.redd.it" => capture(r"https://external\-preview\.redd\.it/(.*)\?(.*)", "/preview/external-pre/", 2),
+					"external-preview.redd.it" => capture(r"https://external\-preview\.redd\.it/(.*)", "/preview/external-pre/", 1),
 					"styles.redditmedia.com" => capture(r"https://styles\.redditmedia\.com/(.*)", "/style/", 1),
 					"www.redditstatic.com" => capture(r"https://www\.redditstatic\.com/(.*)", "/static/", 1),
 					_ => String::new(),
@@ -442,22 +523,36 @@ pub fn format_url(url: &str) -> String {
 }
 
 // Rewrite Reddit links to Libreddit in body of text
-pub fn rewrite_urls(text: &str) -> String {
+pub fn rewrite_urls(input_text: &str) -> String {
-	match Regex::new(r#"href="(https|http|)://(www.|old.|np.|)(reddit).(com)/"#) {
+	let text1 = match Regex::new(r#"href="(https|http|)://(www.|old.|np.|amp.|)(reddit).(com)/"#) {
-		Ok(re) => re.replace_all(text, r#"href="/"#).to_string(),
+		Ok(re) => re.replace_all(input_text, r#"href="/"#).to_string(),
+		Err(_) => String::new(),
+	};
+
+	// Rewrite external media previews to Libreddit
+	match Regex::new(r"https://external-preview\.redd\.it(.*)[^?]") {
+		Ok(re) => {
+			if re.is_match(&text1) {
+				re.replace_all(&text1, format_url(re.find(&text1).map(|x| x.as_str()).unwrap_or_default())).to_string()
+			} else {
+				text1
+			}
+		}
 		Err(_) => String::new(),
 	}
 }
 
 // Append `m` and `k` for millions and thousands respectively
-pub fn format_num(num: i64) -> String {
+pub fn format_num(num: i64) -> (String, String) {
-	if num >= 1_000_000 {
+	let truncated = if num >= 1_000_000 || num <= -1_000_000 {
 		format!("{}m", num / 1_000_000)
-	} else if num >= 1000 {
+	} else if num >= 1000 || num <= -1000 {
 		format!("{}k", num / 1_000)
 	} else {
 		num.to_string()
-	}
+	};
+
+	(truncated, num.to_string())
 }
 
 // Parse a relative and absolute time from a UNIX timestamp
@@ -539,49 +634,3 @@ pub async fn error(req: Request<Body>, msg: String) -> Result<Response<Body>, St
 
 	Ok(Response::builder().status(404).header("content-type", "text/html").body(body.into()).unwrap_or_default())
 }
-
-// #[async_recursion]
-// async fn connect(path: String) -> io::Result<String> {
-
-// 	// Construct an HTTP request body
-// 	let req = format!(
-// 		"GET {} HTTP/1.1\r\nHost: www.reddit.com\r\nAccept: */*\r\nConnection: close\r\nUser-Agent: {}\r\n\r\n",
-// 		path, user_agent
-// 	);
-
-// 	// Open a TCP connection
-// 	let tcp_stream = TcpStream::connect("www.reddit.com:443").await?;
-
-// 	// Initialize TLS connector for requests
-// 	let connector = TlsConnector::default();
-
-// 	// Use the connector to start the handshake process
-// 	let mut tls_stream = connector.connect("www.reddit.com", tcp_stream).await?;
-
-// 	// Write the crafted HTTP request to the stream
-// 	tls_stream.write_all(req.as_bytes()).await?;
-
-// 	// And read the response
-// 	let mut writer = Vec::new();
-// 	io::copy(&mut tls_stream, &mut writer).await?;
-// 	let response = String::from_utf8_lossy(&writer).to_string();
-
-// 	let split = response.split("\r\n\r\n").collect::<Vec<&str>>();
-
-// 	let headers = split[0].split("\r\n").collect::<Vec<&str>>();
-// 	let status: i16 = headers[0].split(' ').collect::<Vec<&str>>()[1].parse().unwrap_or(200);
-// 	let body = split[1].to_string();
-
-// 	if (300..400).contains(&status) {
-// 		let location = headers
-// 			.iter()
-// 			.find(|header| header.starts_with("location:"))
-// 			.map(|f| f.to_owned())
-// 			.unwrap_or_default()
-// 			.split(": ")
-// 			.collect::<Vec<&str>>()[1];
-// 		connect(location.replace("https://www.reddit.com", "")).await
-// 	} else {
-// 		Ok(body)
-// 	}
-// }

static/playHLSVideo.js

@@ -0,0 +1,77 @@
+// @license http://www.gnu.org/licenses/agpl-3.0.html AGPL-3.0
+(function () {
+    if (Hls.isSupported()) {
+        var videoSources = document.querySelectorAll("video source[type='application/vnd.apple.mpegurl']");
+        videoSources.forEach(function (source) {
+            var playlist = source.src;
+
+            var oldVideo = source.parentNode;
+            var autoplay = oldVideo.classList.contains("hls_autoplay");
+
+            // If HLS is supported natively then don't use hls.js
+            if (oldVideo.canPlayType(source.type)) {
+                if (autoplay) {
+                    oldVideo.play();
+                }
+                return;
+            }
+
+            // Replace video with copy that will have all "source" elements removed
+            var newVideo = oldVideo.cloneNode(true);
+            var allSources = newVideo.querySelectorAll("source");
+            allSources.forEach(function (source) {
+                source.remove();
+            });
+
+            // Empty source to enable play event
+            newVideo.src = "about:blank";
+
+            oldVideo.parentNode.replaceChild(newVideo, oldVideo);
+
+            function initializeHls() {
+                newVideo.removeEventListener('play', initializeHls);
+
+                var hls = new Hls({ autoStartLoad: false });
+                hls.loadSource(playlist);
+                hls.attachMedia(newVideo);
+                hls.on(Hls.Events.MANIFEST_PARSED, function () {
+                    hls.loadLevel = hls.levels.length - 1;
+                    hls.startLoad();
+                    newVideo.play();
+                });
+
+                hls.on(Hls.Events.ERROR, function (event, data) {
+                    var errorType = data.type;
+                    var errorFatal = data.fatal;
+                    if (errorFatal) {
+                        switch (errorType) {
+                            case Hls.ErrorType.NETWORK_ERROR:
+                                hls.startLoad();
+                                break;
+                            case Hls.ErrorType.MEDIA_ERROR:
+                                hls.recoverMediaError();
+                                break;
+                            default:
+                                hls.destroy();
+                                break;
+                        }
+                    }
+
+                    console.error("HLS error", data);
+                });
+            }
+
+            newVideo.addEventListener('play', initializeHls);
+
+            if (autoplay) {
+                newVideo.play();
+            }
+        });
+    } else {
+        var videos = document.querySelectorAll("video.hls_autoplay");
+        videos.forEach(function (video) {
+            video.setAttribute("autoplay", "");
+        });
+    }
+})();
+// @license-end

static/style.css

@@ -6,6 +6,12 @@
 	--admin: #ea0027;
 }
 
+@font-face {
+	font-family: 'Inter';
+	src: url('/Inter.var.woff2') format('woff2-variations');
+	font-style: normal;
+}
+
 /* Automatic theme selection */
 :root, .dark{
 	/* Default & fallback theme (dark) */
@@ -65,6 +71,75 @@
 	--shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
 }
 
+/* Dracula theme setting */
+.dracula {
+	--accent: #bd93f9;
+	--green: #50fa7b;
+	--text: #f8f8f2;
+	--foreground: #3d4051;
+	--background: #282a36;
+	--outside: #44475a;
+	--post: #44475a;
+	--panel-border: 2px solid #44475a;
+	--highlighted: #4e5267;
+	--shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+/* Nord theme setting */
+.nord {
+	--accent: #8fbcbb; 
+	--green: #a3be8c;
+	--text: #eceff4;
+	--foreground: #3b4252;
+	--background: #2e3440;
+	--outside: #434c5e;
+	--post: #434c5e;
+	--panel-border: 2px solid #4c566a;
+	--highlighted: #3b4252;
+	--shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+/* Laserwave theme setting */
+.laserwave {
+	--accent: #eb64b9;
+	--green: #74dfc4;
+	--text: #e0dfe1;
+	--foreground: #302a36;
+	--background: #27212e;
+	--outside: #3e3647;
+	--post: #3e3647;
+	--panel-border: 2px solid #2f2738;
+	--highlighted: #302a36;
+	--shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+/* Violet theme setting */
+.violet {
+	--accent: #7c71dd;
+	--green: #5cff85;
+	--text: white;
+	--foreground: #1F2347;
+	--background: #12152b;
+	--outside: #181c3a;
+	--post: #181c3a;
+	--panel-border: 1px solid #1F2347;
+	--highlighted: #1F2347;
+	--shadow: 0 2px 5px rgba(0, 0, 0, 0.5);
+}
+
+/* Gold theme setting */
+.gold {
+	--accent: #f2aa4c;
+	--green: #5cff85;
+	--text: white;
+	--foreground: #234;
+	--background: #101820;
+	--outside: #1b2936;
+	--post: #1b2936;
+	--panel-border: 0px solid black;
+	--highlighted: #234;
+	--shadow: 0 2px 5px rgba(0, 0, 0, 0.5);
+}
 
 /* General */
 
@@ -81,7 +156,7 @@ html, body, div, h1, h2, h3, h4, h5, h6, ul, ol, dl, li, dt, dd, p, blockquote,
 pre, form, fieldset, table, th, td, select, input {
 	margin: 0;
 	color: var(--text);
-	font-family: sans-serif;
+	font-family: "Inter";
 }
 
 body {
@@ -281,7 +356,7 @@ aside {
 
 /* Subscriptions */
 
-#sub_subscription {
+#sub_subscription, #user_subscription {
 	margin-top: 20px;
 }
 
@@ -522,7 +597,26 @@ button.submit:hover > svg { stroke: var(--accent); }
 
 .search_subreddit { 
 	padding: 16px 20px;
-	display: block;
+	display: flex;
+}
+
+.search_subreddit_left {
+	display: flex;
+	align-items: center;
+}
+
+.search_subreddit_left:not(:empty) {
+	margin-right: 10px;
+}
+
+.search_subreddit_left img {
+	width: 35px;
+	height: 35px;
+	border-radius: 100%;
+}
+
+.search_subreddit_right {
+	overflow: auto;
 }
 
 a.search_subreddit:hover {
@@ -576,6 +670,7 @@ a.search_subreddit:hover {
 			"post_score post_title  post_thumbnail" 1fr
 			"post_score post_media  post_thumbnail" auto
 			"post_score post_body   post_thumbnail" auto
+			"post_score post_notification post_thumbnail" auto
 			"post_score post_footer post_thumbnail" auto
 			/ minmax(40px, auto) minmax(0, 1fr) fit-content(min(20%, 152px));
 }
@@ -618,6 +713,17 @@ a.search_subreddit:hover {
 	grid-area: post_title;
 }
 
+.post_notification {
+	grid-area: post_notification;
+	margin: 5px 15px;
+	text-align: center;
+	font-size: 12px;
+}
+
+.post_notification a {
+	text-decoration: underline;
+}
+
 .post_flair {
 	background: var(--accent);
 	color: var(--background);
@@ -1084,6 +1190,8 @@ input[type="submit"] {
 
 .md table {
 	margin: 5px;
+	display: block;
+	overflow-x: auto;
 }
 
 .md code {
@@ -1166,6 +1274,7 @@ td, th {
 				"post_title  post_title  post_thumbnail" 1fr
 				"post_media  post_media  post_thumbnail" auto
 				"post_body   post_body   post_thumbnail" auto
+				"post_notification post_notification post_thumbnail" auto
 				"post_score  post_footer post_thumbnail" auto
 				/ auto 1fr fit-content(min(20%, 152px));
 	}
@@ -1200,9 +1309,9 @@ td, th {
 
 	/* .thread { margin-left: -5px; } */
 	.comment_right { padding: 5px 0 10px 2px; }
-	.comment_author { margin-left: 5px; }
+	.comment_author { margin-left: 12px; }
 	.comment_data { margin-left: 12px; }
-	.comment_data::marker { font-size: 22px; }
+	.comment_data::marker { font-size: 25px; }
 	.created { width: 100%; }
 
 	.comment_score {
@@ -1212,4 +1321,4 @@ td, th {
 		padding: 7px 0px;
 		margin-right: -5px;
 	}
-}
+}

templates/comment.html

@@ -5,7 +5,7 @@
 {% else if kind == "t1"  %}
 <div id="{{ id }}" class="comment">
 	<div class="comment_left">
-		<p class="comment_score">{{ score }}</p>
+		<p class="comment_score" title="{{ score.1 }}">{{ score.0 }}</p>
 		<div class="line"></div>
 	</div>
 	<details class="comment_right" open>

templates/post.html

@@ -68,7 +68,17 @@
 				</svg>
 			</a>
 			{% else if post.post_type == "video" || post.post_type == "gif" %}
+			{% if prefs.use_hls == "on" && !post.media.alt_url.is_empty() %}
+			<script src="/hls.min.js"></script>
+			<video class="post_media_video short hls_autoplay" width="{{ post.media.width }}" height="{{ post.media.height }}" poster="{{ post.media.poster }}" controls preload="none">
+				<source src="{{ post.media.alt_url }}" type="application/vnd.apple.mpegurl" />
+				<source src="{{ post.media.url }}" type="video/mp4" />
+			</video>
+			<script src="/playHLSVideo.js"></script>
+			{% else %}
 			<video class="post_media_video" src="{{ post.media.url }}" controls autoplay loop><a href={{ post.media.url }}>Video</a></video>
+			{% call utils::render_hls_notification(post.permalink[1..]) %}
+			{% endif %}
 			{% else if post.post_type == "gallery" %}
 			<div class="gallery">
 			{% for image in post.gallery -%}
@@ -77,23 +87,23 @@
 					<figcaption>
 						<p>{{ image.caption }}</p>
 						{% if image.outbound_url.len() > 0 %}
-						<p><a class="outbound_url" href="{{ image.outbound_url }}">{{ image.outbound_url }}</a>
+						<p><a class="outbound_url" href="{{ image.outbound_url }}" rel="nofollow">{{ image.outbound_url }}</a>
 						{% endif %}
 					</figcaption>
 				</figure>
 			{%- endfor %}
 			</div>			
 			{% else if post.post_type == "link" %}
-			<a id="post_url" href="{{ post.media.url }}">{{ post.media.url }}</a>
+			<a id="post_url" href="{{ post.media.url }}" rel="nofollow">{{ post.media.url }}</a>
 			{% endif %}
 
 			<!-- POST BODY -->
 			<div class="post_body">{{ post.body }}</div>
-			<div class="post_score">{{ post.score }}<span class="label"> Upvotes</span></div>
+			<div class="post_score" title="{{ post.score.1 }}">{{ post.score.0 }}<span class="label"> Upvotes</span></div>
 			<div class="post_footer">
 				<ul id="post_links">
 					<li><a href="/{{ post.id }}">permalink</a></li>
-					<li><a href="https://reddit.com/{{ post.id }}">reddit</a></li>
+					<li><a href="https://reddit.com/{{ post.id }}" rel="nofollow">reddit</a></li>
 				</ul>
 				<p>{{ post.upvote_ratio }}% Upvoted</p>
 			</div>

templates/search.html

@@ -34,12 +34,15 @@
 		<div id="search_subreddits">
 			{% for subreddit in subreddits %}
 			<a href="{{ subreddit.url }}" class="search_subreddit">
-				<p class="search_subreddit_header"> 
+				<div class="search_subreddit_left">{% if subreddit.icon != "" %}<img src="{{ subreddit.icon }}" alt="r/{{ subreddit.name }} icon">{% endif %}</div>
-					<span class="search_subreddit_name">{{ subreddit.name }}</span>
+				<div class="search_subreddit_right">
-					<span class="dot">&bull;</span>
+					<p class="search_subreddit_header"> 
-					<span class="search_subreddit_members">{{ subreddit.subscribers }} Members</span>
+						<span class="search_subreddit_name">{{ subreddit.name }}</span>
-				</p>
+						<span class="dot">&bull;</span>
-				<p class="search_subreddit_description">{{ subreddit.description }}</p>
+						<span class="search_subreddit_members" title="{{ subreddit.subscribers.1 }} Members">{{ subreddit.subscribers.0 }} Members</span>
+					</p>
+					<p class="search_subreddit_description">{{ subreddit.description }}</p>
+				</div>
 			</a>
 			{% endfor %}
 		</div>
@@ -52,7 +55,7 @@
 		{% else %}
 			<div class="comment">
 				<div class="comment_left">
-					<p class="comment_score">{{ post.score }}</p>
+					<p class="comment_score" title="{{ post.score.1 }}">{{ post.score.0 }}</p>
 					<div class="line"></div>
 				</div>
 				<details class="comment_right" open>

templates/settings.html

@@ -15,7 +15,7 @@
 			<div id="theme">
 				<label for="theme">Theme:</label>
 				<select name="theme"> 
-					{% call utils::options(prefs.theme, ["system", "light", "dark", "black"], "system") %}
+					{% call utils::options(prefs.theme, ["system", "light", "dark", "black", "dracula", "nord", "laserwave", "violet", "gold"], "system") %}
 				</select>
 			</div>
 			<p>Interface</p>
@@ -33,9 +33,16 @@
 			</div>
 			<div id="wide">
 				<label for="wide">Wide UI:</label>
+				<input type="hidden" value="off" name="wide">
 				<input type="checkbox" name="wide" {% if prefs.wide == "on" %}checked{% endif %}>
 			</div>
 			<p>Content</p>
+			<div id="post_sort">
+				<label for="post_sort" title="Applies only to subreddit feeds">Default subreddit post sort:</label>
+				<select name="post_sort"> 
+					{% call utils::options(prefs.post_sort, ["hot", "new", "top", "rising", "controversial"], "hot") %}
+				</select>
+			</div>
 			<div id="comment_sort">
 				<label for="comment_sort">Default comment sort:</label>
 				<select name="comment_sort"> 
@@ -44,17 +51,28 @@
 			</div>
 			<div id="show_nsfw">
 				<label for="show_nsfw">Show NSFW posts:</label>
+				<input type="hidden" value="off" name="show_nsfw">
 				<input type="checkbox" name="show_nsfw" {% if prefs.show_nsfw == "on" %}checked{% endif %}>
 			</div>
+			<div id="use_hls">
+				<label for="use_hls">Use HLS for videos</label>
+				<input type="hidden" value="off" name="use_hls">
+				<input type="checkbox" name="use_hls" {% if prefs.use_hls == "on" %}checked{% endif %}>
+			</div>
+			<div id="hide_hls_notification">
+				<label for="hide_hls_notification">Hide notification about possible HLS usage</label>
+				<input type="hidden" value="off" name="hide_hls_notification">
+				<input type="checkbox" name="hide_hls_notification" {% if prefs.hide_hls_notification == "on" %}checked{% endif %}>
+			</div>
 			<input id="save" type="submit" value="Save">
 		</div>
 	</form>
 	{% if prefs.subscriptions.len() > 0 %}
 		<div class="prefs" id="settings_subs">
-			<p>Subscribed Subreddits</p>
+			<p>Subscribed Feeds</p>
 			{% for sub in prefs.subscriptions %}
 			<div>
-				<span>{{ sub }}</span>
+				<span>{% if sub.starts_with("u_") -%}{{ format!("u/{}", &sub[2..]) }}{% else -%}{{ format!("r/{}", sub) }}{% endif -%}</span>
 				<form action="/r/{{ sub }}/unsubscribe/?redirect=settings" method="POST">
 						<button class="unsubscribe">Unsubscribe</button>
 				</form>
@@ -62,10 +80,10 @@
 			{% endfor %}
 		</div>
 	{% endif %}
-	
+
 	<div id="settings_note">
 		<p><b>Note:</b> settings and subscriptions are saved in browser cookies. Clearing your cookies will reset them.</p><br>
-		<p>You can restore your current settings and subscriptions after clearing your cookies using <a href="/settings/restore/?theme={{ prefs.theme }}&front_page={{ prefs.front_page }}&layout={{ prefs.layout }}&wide={{ prefs.wide }}&comment_sort={{ prefs.comment_sort }}&show_nsfw={{ prefs.show_nsfw }}&subscriptions={{ prefs.subscriptions.join("%2B") }}">this link</a>.</p>
+		<p>You can restore your current settings and subscriptions after clearing your cookies using <a href="/settings/restore/?theme={{ prefs.theme }}&front_page={{ prefs.front_page }}&layout={{ prefs.layout }}&wide={{ prefs.wide }}&comment_sort={{ prefs.comment_sort }}&show_nsfw={{ prefs.show_nsfw }}&use_hls={{ prefs.use_hls }}&hide_hls_notification={{ prefs.hide_hls_notification }}&subscriptions={{ prefs.subscriptions.join("%2B") }}">this link</a>.</p>
 	</div>
 </div>
 

templates/subreddit.html

@@ -52,6 +52,10 @@
 			{% call utils::post_in_list(post) %}
 			{% endif %}
 			{% endfor %}
+			{% if prefs.use_hls == "on" %}
+			<script src="/hls.min.js"></script>
+			<script src="/playHLSVideo.js"></script>
+			{% endif %}
 			</div>
 
 			<footer>
@@ -81,8 +85,8 @@
 					<div id="sub_details">
 						<label>Members</label>
 						<label>Active</label>
-						<div>{{ sub.members }}</div>
+						<div title="{{ sub.members.1 }}">{{ sub.members.0 }}</div>
-						<div>{{ sub.active }}</div>
+						<div title="{{ sub.active.1 }}">{{ sub.active.0 }}</div>
 					</div>
 					<div id="sub_subscription">
 						{% if prefs.subscriptions.contains(sub.name) %}
@@ -99,7 +103,17 @@
 			</div>
 			<details class="panel" id="sidebar">
 				<summary id="sidebar_label">Sidebar</summary>
-				<div id="sidebar_contents">{{ sub.info }}</div>
+				<div id="sidebar_contents">
+                                  {{ sub.info }}
+                                  <hr>
+                                  <h2>Moderators</h2>
+                                  <br>
+                                  <ul>
+                                  {% for moderator in sub.moderators %}
+                                  <li><a style="color: var(--accent)" href="/u/{{ moderator }}">{{ moderator }}</a></li>
+                                  {% endfor %}
+                                  </ul>
+                                </div>
 			</details>
 		</aside>
 		{% endif %}

templates/user.html

@@ -37,7 +37,7 @@
 			{% else %}
 			<div class="comment">
 				<div class="comment_left">
-					<p class="comment_score">{{ post.score }}</p>
+					<p class="comment_score" title="{{ post.score.1 }}">{{ post.score.0 }}</p>
 					<div class="line"></div>
 				</div>
 				<details class="comment_right" open>
@@ -75,6 +75,18 @@
 					<div>{{ user.karma }}</div>
 					<div>{{ user.created }}</div>
 				</div>
+				<div id="user_subscription">
+					{% let name = ["u_", user.name.as_str()].join("") %}
+					{% if prefs.subscriptions.contains(name) %}
+						<form action="/r/u_{{ user.name }}/unsubscribe" method="POST">
+							<button class="unsubscribe">Unfollow</button>
+						</form>
+					{% else %}
+						<form action="/r/u_{{ user.name }}/subscribe" method="POST">
+							<button class="subscribe">Follow</button>
+						</form>
+					{% endif %}
+				</div>
 			</div>
 		</aside>
 	</main>

templates/utils.html

@@ -55,10 +55,22 @@
 {% endif %}
 {%- endmacro %}
 
+{% macro render_hls_notification(redirect_url) -%}
+{% if post.post_type == "video" && !post.media.alt_url.is_empty() && prefs.hide_hls_notification != "on" %}
+<div class="post_notification"><p><a href="/settings/update/?use_hls=on&redirect={{ redirect_url }}">Enable HLS</a> to view with audio, or <a href="/settings/update/?hide_hls_notification=on&redirect={{ redirect_url }}">disable this notification</a></p></div>
+{% endif %}
+{%- endmacro %}
+
 {% macro post_in_list(post) -%}
-<div class="post {% if post.flags.stickied %}stickied{% endif %}">	
+<div class="post {% if post.flags.stickied %}stickied{% endif %}" id="{{ post.id }}">
 	<p class="post_header">
-		<a class="post_subreddit" href="/r/{{ post.community }}">r/{{ post.community }}</a>
+		{% let community -%}
+		{% if post.community.starts_with("u_") -%}
+			{% let community = format!("u/{}", &post.community[2..]) -%}
+		{% else -%}
+			{% let community = format!("r/{}", post.community) -%}
+		{% endif -%}
+		<a class="post_subreddit" href="/{{ community }}">{{ community }}</a>
 		<span class="dot">&bull;</span>
 		<a class="post_author" href="/u/{{ post.author.name }}">u/{{ post.author.name }}</a>
 		<span class="dot">&bull;</span>
@@ -68,7 +80,8 @@
 		{% if post.flair.flair_parts.len() > 0 %}
 			<a href="/r/{{ post.community }}/search?q=flair_name%3A%22{{ post.flair.text }}%22&restrict_sr=on"
 				class="post_flair"
-				style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};">{% call render_flair(post.flair.flair_parts) %}</a>
+				style="color:{{ post.flair.foreground_color }}; background:{{ post.flair.background_color }};"
+				dir="ltr">{% call render_flair(post.flair.flair_parts) %}</a>
 		{% endif %}
 		<a href="{{ post.permalink }}">{{ post.title }}</a>{% if post.flags.nsfw %} <small class="nsfw">NSFW</small>{% endif %}
 	</p>
@@ -88,9 +101,17 @@
 	{% else if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "gif" %}
 	<video class="post_media_video short" src="{{ post.media.url }}" width="{{ post.media.width }}" height="{{ post.media.height }}" controls loop autoplay><a href={{ post.media.url }}>Video</a></video>
 	{% else if (prefs.layout.is_empty() || prefs.layout == "card") && post.post_type == "video" %}
+	{% if prefs.use_hls == "on" && !post.media.alt_url.is_empty() %}
+	<video class="post_media_video short" width="{{ post.media.width }}" height="{{ post.media.height }}" poster="{{ post.media.poster }}" controls preload="none">
+		<source src="{{ post.media.alt_url }}" type="application/vnd.apple.mpegurl" />
+		<source src="{{ post.media.url }}" type="video/mp4" />
+	</video>
+	{% else %}
 	<video class="post_media_video short" src="{{ post.media.url }}" width="{{ post.media.width }}" height="{{ post.media.height }}" poster="{{ post.media.poster }}" preload="none" controls autoplay><a href={{ post.media.url }}>Video</a></video>
+	{% call render_hls_notification(format!("{}%23{}", &self.url[1..].replace("&", "%26"), post.id)) %}
+	{% endif %}
 	{% else if post.post_type != "self" %}
-	<a class="post_thumbnail {% if post.thumbnail.url.is_empty() %}no_thumbnail{% endif %}" href="{% if post.post_type == "link" %}{{ post.media.url }}{% else %}{{ post.permalink }}{% endif %}">
+	<a class="post_thumbnail {% if post.thumbnail.url.is_empty() %}no_thumbnail{% endif %}" href="{% if post.post_type == "link" %}{{ post.media.url }}{% else %}{{ post.permalink }}{% endif %}" rel="nofollow">
 		{% if post.thumbnail.url.is_empty() %}
 		<svg viewBox="0 0 100 106" width="140" height="53" xmlns="http://www.w3.org/2000/svg">
 			<title>Thumbnail</title>
@@ -108,9 +129,9 @@
 	</a>
 	{% endif %}
 
-	<div class="post_score">{{ post.score }}<span class="label"> Upvotes</span></div>
+	<div class="post_score" title="{{ post.score.1 }}">{{ post.score.0 }}<span class="label"> Upvotes</span></div>
 	<div class="post_footer">
-		<a href="{{ post.permalink }}" class="post_comments">{{ post.comments }} comments</a>
+		<a href="{{ post.permalink }}" class="post_comments" title="{{ post.comments.1 }} comments">{{ post.comments.0 }} comments</a>
 	</div>
 </div>
 {%- endmacro %}

templates/wall.html

@@ -0,0 +1,13 @@
+{% extends "base.html" %}
+{% block title %}{{ msg }}{% endblock %}
+{% block sortstyle %}{% endblock %}
+{% block content %}
+	<div id="wall">
+		<h1>{{ title }}</h1>
+                <br>
+		<p>{{ msg }}</p>
+                <form action="/r/{{ sub }}?redir={{ url }}" method="POST">
+			<input id="save" type="submit" value="Continue">
+                </form>
+	</div>
+{% endblock %}