roxxie-proxy-u-prod 0.1.0

package/source/packages/scramjet/packages/core/src/shared/mime.ts

@@ -0,0 +1,234 @@
+// WARNING: SLOP FILE
+// DO NOT TRUST THIS CODE
+
+import { _Set } from "./snapshot";
+
+/**
+ * MIME type groups (WHATWG-style), for classifying MIME types.
+ * @see https://mimesniff.spec.whatwg.org/#mime-type-groups
+ */
+
+const HTTP_WHITESPACE = /^[\t\n\f\r ]+|[\t\n\f\r ]+$/g;
+
+function trimHttpWhitespace(s: string): string {
+	return s.replace(HTTP_WHITESPACE, "");
+}
+
+function asciiLower(s: string): string {
+	return s.toLowerCase();
+}
+
+export interface ParsedMimeType {
+	type: string;
+	subtype: string;
+	/** `type`/`subtype` in ASCII lowercase; excludes parameters. */
+	essence: string;
+}
+
+/**
+ * Parses a MIME type string (e.g. a Content-Type value) into type, subtype, and essence.
+ * Returns null if the input is not a valid MIME type.
+ */
+export function parseMimeType(input: string): ParsedMimeType | null {
+	const trimmed = trimHttpWhitespace(input);
+	if (!trimmed) return null;
+
+	const semicolon = trimmed.indexOf(";");
+	const typeAndSubtype =
+		semicolon === -1 ? trimmed : trimmed.slice(0, semicolon);
+	const main = trimHttpWhitespace(typeAndSubtype);
+	if (!main) return null;
+
+	const slash = main.indexOf("/");
+	if (slash <= 0 || slash === main.length - 1) return null;
+
+	const type = trimHttpWhitespace(main.slice(0, slash));
+	const subtype = trimHttpWhitespace(main.slice(slash + 1));
+	if (!type || !subtype) return null;
+
+	return {
+		type,
+		subtype,
+		essence: `${asciiLower(type)}/${asciiLower(subtype)}`,
+	};
+}
+
+function asParsed(mime: string | ParsedMimeType): ParsedMimeType | null {
+	return typeof mime === "string" ? parseMimeType(mime) : mime;
+}
+
+const FONT_ESSENCES = new _Set([
+	"application/font-cff",
+	"application/font-otf",
+	"application/font-sfnt",
+	"application/font-ttf",
+	"application/font-woff",
+	"application/vnd.ms-fontobject",
+	"application/vnd.ms-opentype",
+]);
+
+const ARCHIVE_ESSENCES = new _Set([
+	"application/x-rar-compressed",
+	"application/zip",
+	"application/x-gzip",
+]);
+
+const JAVASCRIPT_ESSENCES = new _Set([
+	"application/ecmascript",
+	"application/javascript",
+	"application/x-ecmascript",
+	"application/x-javascript",
+	"text/ecmascript",
+	"text/javascript",
+	"text/javascript1.0",
+	"text/javascript1.1",
+	"text/javascript1.2",
+	"text/javascript1.3",
+	"text/javascript1.4",
+	"text/javascript1.5",
+	"text/jscript",
+	"text/livescript",
+	"text/x-ecmascript",
+	"text/x-javascript",
+]);
+
+/** A MIME type whose type is "image". */
+export function isImageMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	return p !== null && asciiLower(p.type) === "image";
+}
+
+/** Audio, video, or essence `application/ogg`. */
+export function isAudioOrVideoMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	if (!p) return false;
+	const t = asciiLower(p.type);
+	if (t === "audio" || t === "video") return true;
+	return p.essence === "application/ogg";
+}
+
+/** Type `font` or a registered font essence. */
+export function isFontMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	if (!p) return false;
+	if (asciiLower(p.type) === "font") return true;
+	return FONT_ESSENCES.has(p.essence);
+}
+
+/** Subtype ends with `+zip` or essence `application/zip`. */
+export function isZipBasedMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	if (!p) return false;
+	if (p.essence === "application/zip") return true;
+	return asciiLower(p.subtype).endsWith("+zip");
+}
+
+/** One of the archive essences. */
+export function isArchiveMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	return p !== null && ARCHIVE_ESSENCES.has(p.essence);
+}
+
+/** Subtype ends with `+xml` or essence `text/xml` / `application/xml`. */
+export function isXmlMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	if (!p) return false;
+	if (asciiLower(p.subtype).endsWith("+xml")) return true;
+	return p.essence === "text/xml" || p.essence === "application/xml";
+}
+
+/** Essence `text/html`. */
+export function isHtmlMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	return p !== null && p.essence === "text/html";
+}
+
+/** XML, HTML, or `application/pdf`. */
+export function isScriptableMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	if (!p) return false;
+	if (isXmlMimeType(p)) return true;
+	if (isHtmlMimeType(p)) return true;
+	return p.essence === "application/pdf";
+}
+
+/** Essence is one of the JavaScript MIME type essences. */
+export function isJavascriptMimeType(mime: string | ParsedMimeType): boolean {
+	const p = asParsed(mime);
+	return p !== null && JAVASCRIPT_ESSENCES.has(p.essence);
+}
+
+/**
+ * True if the string is an ASCII case-insensitive match for one of the
+ * JavaScript MIME type essence strings (not necessarily a full parsed MIME type).
+ */
+export function isJavascriptMimeTypeEssenceMatch(s: string): boolean {
+	const t = trimHttpWhitespace(s);
+	if (!t) return false;
+	return JAVASCRIPT_ESSENCES.has(asciiLower(t));
+}
+
+/**
+ * Script block type string for a `<script>` element (prepare a script).
+ * Resolves `type` when present; otherwise maps obsolete `language` to `text/…`.
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#prepare-a-script
+ */
+export function getScriptBlockTypeString(
+	type: string | null | undefined,
+	language: string | null | undefined,
+	hasTypeAttribute = type != null,
+	hasLanguageAttribute = language != null
+): string {
+	if (
+		(hasTypeAttribute && (type ?? "") === "") ||
+		(!hasTypeAttribute && hasLanguageAttribute && (language ?? "") === "") ||
+		(!hasTypeAttribute && !hasLanguageAttribute)
+	) {
+		return "text/javascript";
+	}
+
+	if (hasTypeAttribute) {
+		return trimHttpWhitespace(type ?? "");
+	}
+
+	return `text/${language ?? ""}`;
+}
+
+/**
+ * Whether a `<script type="...">` value denotes executable JavaScript
+ * (classic or module script), not a data block or import map.
+ * @see https://html.spec.whatwg.org/multipage/scripting.html#attr-script-type
+ */
+export function isScriptType(type: string | null | undefined): boolean {
+	if (type == null) return true;
+	const t = trimHttpWhitespace(type);
+	if (!t) return true;
+	if (asciiLower(t) === "module") return true;
+	return isJavascriptMimeTypeEssenceMatch(t);
+}
+
+/** Whether `type` denotes a JavaScript module script. */
+export function isModuleScriptType(type: string | null | undefined): boolean {
+	if (type == null) return false;
+	const t = trimHttpWhitespace(type);
+	return t !== "" && asciiLower(t) === "module";
+}
+
+/**
+ * MIME types typically shown inline in a browsing context (navigation / iframe),
+ * as opposed to triggering a download when Content-Disposition is absent.
+ */
+export function isInlineDisplayableMimeType(
+	mime: string | ParsedMimeType
+): boolean {
+	const p = asParsed(mime);
+	if (!p) return false;
+	if (asciiLower(p.type) === "text") return true;
+	if (isImageMimeType(p) || isFontMimeType(p)) return true;
+	if (isAudioOrVideoMimeType(p)) return true;
+	if (isHtmlMimeType(p) || isJavascriptMimeType(p) || isXmlMimeType(p))
+		return true;
+	if (p.essence === "application/pdf" || p.essence === "application/json")
+		return true;
+	return false;
+}

package/source/packages/scramjet/packages/core/src/shared/refresh.ts

@@ -0,0 +1,164 @@
+/**
+ * this is vibe slop for parsing the content of a meta refresh element, which is a bit of a mess
+ * @see https://html.spec.whatwg.org/multipage/semantics.html#the-meta-element:the-declarative-refresh-syntax
+ */
+import { Number_parseInt } from "./snapshot";
+export type ParsedDeclarativeRefresh = {
+	time: number;
+	urlStart: number;
+	urlEnd: number;
+	url: string | null;
+};
+
+function isAsciiWhitespace(codePoint: number): boolean {
+	return (
+		codePoint === 0x09 ||
+		codePoint === 0x0a ||
+		codePoint === 0x0c ||
+		codePoint === 0x0d ||
+		codePoint === 0x20
+	);
+}
+
+function skipAsciiWhitespace(input: string, position: number): number {
+	while (position < input.length) {
+		if (!isAsciiWhitespace(input.charCodeAt(position))) {
+			break;
+		}
+		position += 1;
+	}
+
+	return position;
+}
+
+function isAsciiDigit(codePoint: number): boolean {
+	return codePoint >= 0x30 && codePoint <= 0x39;
+}
+
+function isAsciiAlpha(codePoint: number): boolean {
+	return (
+		(codePoint >= 0x41 && codePoint <= 0x5a) ||
+		(codePoint >= 0x61 && codePoint <= 0x7a)
+	);
+}
+
+export function parseDeclarativeRefresh(
+	input: string
+): ParsedDeclarativeRefresh | null {
+	if (input.length === 0) {
+		return null;
+	}
+
+	let position = 0;
+	position = skipAsciiWhitespace(input, position);
+
+	const timeStart = position;
+	while (position < input.length && isAsciiDigit(input.charCodeAt(position))) {
+		position += 1;
+	}
+	const timeString = input.slice(timeStart, position);
+
+	if (timeString.length === 0) {
+		if (input.charCodeAt(position) !== 0x2e) {
+			return null;
+		}
+	}
+
+	const time = timeString.length > 0 ? Number_parseInt(timeString, 10) : 0;
+
+	while (position < input.length) {
+		const codePoint = input.charCodeAt(position);
+		if (isAsciiDigit(codePoint) || codePoint === 0x2e) {
+			position += 1;
+			continue;
+		}
+		break;
+	}
+
+	if (position >= input.length) {
+		return {
+			time,
+			urlStart: -1,
+			urlEnd: -1,
+			url: null,
+		};
+	}
+
+	const separator = input.charCodeAt(position);
+	if (
+		separator !== 0x3b &&
+		separator !== 0x2c &&
+		!isAsciiWhitespace(separator)
+	) {
+		return null;
+	}
+
+	position = skipAsciiWhitespace(input, position);
+	if (position < input.length) {
+		const maybeSeparator = input.charCodeAt(position);
+		if (maybeSeparator === 0x3b || maybeSeparator === 0x2c) {
+			position += 1;
+		}
+	}
+	position = skipAsciiWhitespace(input, position);
+
+	if (position >= input.length) {
+		return {
+			time,
+			urlStart: -1,
+			urlEnd: -1,
+			url: null,
+		};
+	}
+
+	let urlPosition = position;
+	const urlLabel = input.slice(position, position + 3);
+	if (urlLabel.length === 3) {
+		const first = input.charCodeAt(position);
+		const second = input.charCodeAt(position + 1);
+		const third = input.charCodeAt(position + 2);
+		const hasUrlLabel =
+			isAsciiAlpha(first) &&
+			isAsciiAlpha(second) &&
+			isAsciiAlpha(third) &&
+			(urlLabel[0] === "U" || urlLabel[0] === "u") &&
+			(urlLabel[1] === "R" || urlLabel[1] === "r") &&
+			(urlLabel[2] === "L" || urlLabel[2] === "l");
+
+		if (hasUrlLabel) {
+			let next = position + 3;
+			next = skipAsciiWhitespace(input, next);
+			if (input.charCodeAt(next) === 0x3d) {
+				next += 1;
+				next = skipAsciiWhitespace(input, next);
+				urlPosition = next;
+			}
+		}
+	}
+
+	let quote = "";
+	if (urlPosition < input.length) {
+		const quoteCode = input.charCodeAt(urlPosition);
+		if (quoteCode === 0x22 || quoteCode === 0x27) {
+			quote = input[urlPosition];
+			urlPosition += 1;
+		}
+	}
+
+	let urlEnd = input.length;
+	if (quote !== "") {
+		const closingQuote = input.indexOf(quote, urlPosition);
+		if (closingQuote !== -1) {
+			urlEnd = closingQuote;
+		}
+	}
+
+	const url = input.slice(urlPosition, urlEnd);
+
+	return {
+		time,
+		urlStart: urlPosition,
+		urlEnd,
+		url,
+	};
+}

package/source/packages/scramjet/packages/core/src/shared/rewriters/css.ts

@@ -0,0 +1,67 @@
+import { URLMeta, rewriteUrl, unrewriteUrl } from "@rewriters/url";
+import { ScramjetContext } from "@/shared";
+import { String } from "@/shared/snapshot";
+
+export function rewriteCss(
+	css: string,
+	context: ScramjetContext,
+	meta: URLMeta
+) {
+	return handleCss("rewrite", css, context, meta);
+}
+
+export function unrewriteCss(css: string, context: ScramjetContext) {
+	return handleCss("unrewrite", css, context);
+}
+
+function handleCss(
+	type: "rewrite" | "unrewrite",
+	css: string,
+	context: ScramjetContext,
+	meta?: URLMeta
+) {
+	// regex from vk6 (https://github.com/ading2210)
+	const urlRegex =
+		/url\((?:\s*"((?:\\.|[^"])+)"\s*|\s*'((?:\\.|[^'])+)'\s*|((?!\s*['"])(?!\s*\))(?:\\.|[^)])+?))\)/gim;
+	const Atruleregex =
+		/@import\s+(url\s*?\(.{0,9999}?\)|['"].{0,9999}?['"]|.{0,9999}?)($|\s|;)/gim;
+	css = String(css);
+	css = css.replace(
+		urlRegex,
+		(
+			match,
+			doubleQuotedUrl: string | undefined,
+			singleQuotedUrl: string | undefined,
+			unquotedUrl: string | undefined
+		) => {
+			const url = doubleQuotedUrl ?? singleQuotedUrl ?? unquotedUrl;
+			const encodedUrl =
+				type === "rewrite"
+					? rewriteUrl(url.trim(), context, meta!)
+					: unrewriteUrl(url.trim(), context);
+
+			return match.replace(url, encodedUrl);
+		}
+	);
+	css = css.replace(Atruleregex, (match, importStatement: string) => {
+		return match.replace(
+			importStatement,
+			importStatement.replace(
+				/^(url\(['"]?|['"]|)(.+?)(['"]|['"]?\)|)$/gm,
+				(match: string, firstQuote: string, url: string, endQuote: string) => {
+					if (firstQuote.startsWith("url")) {
+						return match;
+					}
+					const encodedUrl =
+						type === "rewrite"
+							? rewriteUrl(url.trim(), context, meta!)
+							: unrewriteUrl(url.trim(), context);
+
+					return `${firstQuote}${encodedUrl}${endQuote}`;
+				}
+			)
+		);
+	});
+
+	return css;
+}