mega-stream-proxy 0.1.9

package/dist/subtitles/index.d.ts

@@ -0,0 +1,9 @@
+export { parseSubtitles, detectSubtitleFormat, type SubCue, type SubtitleFormat, } from "./parse.js";
+export { loadSubtitles, type LoadSubtitlesOptions } from "./load.js";
+import type { SubtitleFormat } from "./parse.js";
+/** A playable subtitle track for the player components. */
+export type SubtitleTrack = {
+    lang: string;
+    url: string;
+    format?: SubtitleFormat;
+};

package/dist/subtitles/index.js

@@ -0,0 +1,2 @@
+export { parseSubtitles, detectSubtitleFormat, } from "./parse.js";
+export { loadSubtitles } from "./load.js";

package/dist/subtitles/load.d.ts

@@ -0,0 +1,18 @@
+import { type SubCue, type SubtitleFormat } from "./parse.js";
+export type LoadSubtitlesOptions = {
+    format?: SubtitleFormat;
+    /**
+     * Reads a local file URI (e.g. an ExoPlayer/RNFS cached subtitle). Pass your
+     * app's file reader here (e.g. `expo-file-system` `readAsStringAsync`) —
+     * the package stays decoupled from any file-system implementation.
+     */
+    readLocalFile?: (uri: string) => Promise<string>;
+};
+/**
+ * Fetches a subtitle file and parses it (srt/ass/vtt).
+ * MEGA links are downloaded + decrypted through the same pipeline the videos
+ * use (a plain fetch would hit MEGA's HTML page / CORS block and parse nothing);
+ * any other host must allow CORS on web.
+ * Throws on failure so callers can surface the reason (network, MEGA quota…).
+ */
+export declare function loadSubtitles(url: string, options?: LoadSubtitlesOptions): Promise<SubCue[]>;

package/dist/subtitles/load.js

@@ -0,0 +1,58 @@
+import { Buffer } from "buffer";
+import { collectMegaFileStream } from "../stream.js";
+import { detectSubtitleFormat, parseSubtitles, stripBom, } from "./parse.js";
+const IS_MEGA_LINK = /mega(\.co)?\.nz|mega\.io/i;
+/** reading a MEGA link is capped at this many bytes (subtitle files are small) */
+const MAX_MEGA_BYTES = 8 * 1024 * 1024;
+const MEGA_TIMEOUT_MS = 60_000;
+/**
+ * Downloads + decrypts the whole (small) MEGA file into memory. Subtitle files
+ * are tiny by nature, so buffering the stream is fine here.
+ */
+async function readMegaToBuffer(url) {
+    const chunks = [];
+    let total = 0;
+    const timeout = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("Subtitle download timed out.")), MEGA_TIMEOUT_MS);
+    });
+    const load = collectMegaFileStream(url, async (chunk) => {
+        if (total + chunk.length > MAX_MEGA_BYTES) {
+            throw new Error("Subtitle file is unexpectedly large.");
+        }
+        chunks.push(chunk);
+        total += chunk.length;
+    }).then(() => Buffer.concat(chunks.map((c) => Buffer.from(c))));
+    return Promise.race([load, timeout]);
+}
+/**
+ * Fetches a subtitle file and parses it (srt/ass/vtt).
+ * MEGA links are downloaded + decrypted through the same pipeline the videos
+ * use (a plain fetch would hit MEGA's HTML page / CORS block and parse nothing);
+ * any other host must allow CORS on web.
+ * Throws on failure so callers can surface the reason (network, MEGA quota…).
+ */
+export async function loadSubtitles(url, options) {
+    const format = options?.format;
+    let text;
+    if (IS_MEGA_LINK.test(url)) {
+        const buf = await readMegaToBuffer(url);
+        text = buf.toString("utf8");
+    }
+    else if (/^(file|content):|^\//.test(url)) {
+        // a local file already on disk (offline subtitle)
+        if (!options?.readLocalFile) {
+            throw new Error("Local subtitle file requested but no readLocalFile reader was provided.");
+        }
+        text = await options.readLocalFile(url);
+    }
+    else {
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`Subtitles HTTP ${res.status}`);
+        text = await res.text();
+    }
+    const fmt = format ?? detectSubtitleFormat(url);
+    // MEGA links never carry an extension, so a URL guess is unreliable: let the
+    // parser sniff ASS content when no explicit format was supplied.
+    return parseSubtitles(stripBom(text), format ? fmt : undefined);
+}

package/dist/subtitles/parse.d.ts

@@ -0,0 +1,19 @@
+export type SubCue = {
+    /** seconds */
+    start: number;
+    /** seconds */
+    end: number;
+    text: string;
+};
+export type SubtitleFormat = "srt" | "ass" | "vtt";
+/** Strip a leading UTF-8 BOM (\uFEFF) if present */
+export declare const stripBom: (s: string) => string;
+/**
+ * Derive the format from a URL/file name when not explicitly given.
+ * NOTE: MEGA links are `https://mega.nz/file/<id>#<key>` (or `/#!id!key`, or
+ * `/folder/…`) so they carry NO file extension — this returns a neutral
+ * default and the content is sniffed later in loadSubtitles/parseSubtitles.
+ */
+export declare function detectSubtitleFormat(url: string): SubtitleFormat;
+/** Minimal WebVTT/SRT parser -> flat cue list */
+export declare function parseSubtitles(raw: string, format?: SubtitleFormat): SubCue[];

package/dist/subtitles/parse.js

@@ -0,0 +1,95 @@
+/** supports 00:00:01.000 (VTT) and 00:00:01,000 (SRT/ASS) */
+const toSeconds = (ts) => {
+    const m = ts.trim().match(/^(?:(\d+):)?(\d{1,2}):(\d{1,2})[.,](\d{1,3})$/);
+    if (!m)
+        return NaN;
+    const h = Number(m[1] ?? 0);
+    const min = Number(m[2]);
+    const s = Number(m[3]);
+    const ms = Number(m[4].padEnd(3, "0"));
+    return h * 3600 + min * 60 + s + ms / 1000;
+};
+/** Strip a leading UTF-8 BOM (\uFEFF) if present */
+export const stripBom = (s) => s.charCodeAt(0) === 0xfeff ? s.slice(1) : s;
+/**
+ * Derive the format from a URL/file name when not explicitly given.
+ * NOTE: MEGA links are `https://mega.nz/file/<id>#<key>` (or `/#!id!key`, or
+ * `/folder/…`) so they carry NO file extension — this returns a neutral
+ * default and the content is sniffed later in loadSubtitles/parseSubtitles.
+ */
+export function detectSubtitleFormat(url) {
+    const clean = url.split("?")[0].split("#")[0] ?? "";
+    const ext = (clean.split(".").pop() ?? "").toLowerCase();
+    if (ext === "ass" || ext === "ssa")
+        return "ass";
+    if (ext === "srt")
+        return "srt";
+    if (ext === "vtt")
+        return "vtt";
+    // extensionless (MEGA links, direct embed endpoints) — not enough info
+    return "srt";
+}
+const stripAssTags = (t) => t
+    .replace(/\{[^}]*\}/g, "")
+    .replace(/\\N/gi, "\n")
+    .replace(/\\n/gi, "\n")
+    .replace(/\\h/gi, " ")
+    .trim();
+/** True when the raw text looks like an ASS/SSA script (content sniff) */
+function isAssLike(raw) {
+    return /^\s*\[(?:Script Info|V4\+? Styles|Events)\s*\]/m.test(raw);
+}
+/** Minimal ASS/SSA parser: reads the [Events] section Dialogue lines */
+function parseAss(raw) {
+    const cues = [];
+    const body = raw.replace(/\r/g, "").split(/\n+/);
+    for (const line of body) {
+        if (!/^Dialogue\s*:/.test(line))
+            continue;
+        // Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV,
+        //         Effect, Text  — the first 9 commas separate fields.
+        const commaParts = line.split(",");
+        if (commaParts.length < 10)
+            continue;
+        const start = toSeconds(commaParts[1].trim());
+        const end = toSeconds(commaParts[2].trim());
+        const text = stripAssTags(commaParts.slice(9).join(","));
+        if (!Number.isFinite(start) || !Number.isFinite(end) || !text)
+            continue;
+        cues.push({ start, end, text });
+    }
+    return cues;
+}
+/** Minimal WebVTT/SRT parser -> flat cue list */
+export function parseSubtitles(raw, format) {
+    const text = stripBom(raw);
+    // ASS must be detected by content: MEGA-stored urls have no extension, so a
+    // URL-derived "srt"/"vtt" guess would silently drop every ASS cue.
+    if (format === "ass" || (!format && isAssLike(text)))
+        return parseAss(text);
+    const cues = [];
+    const blocks = text
+        .replace(/\r/g, "")
+        .replace(/^WEBVTT.*$/m, "")
+        .split(/\n\n+/);
+    for (const block of blocks) {
+        const lines = block.split("\n").filter((l) => l.trim() !== "");
+        const tIdx = lines.findIndex((l) => l.includes("-->"));
+        if (tIdx === -1)
+            continue;
+        const [a, b] = lines[tIdx].split("-->");
+        const start = toSeconds(a);
+        const endRaw = b.split(/\s+/).filter(Boolean)[0] ?? "";
+        const end = toSeconds(endRaw);
+        if (!Number.isFinite(start) || !Number.isFinite(end))
+            continue;
+        const text = lines
+            .slice(tIdx + 1)
+            .join("\n")
+            .replace(/<[^>]+>/g, "")
+            .trim();
+        if (text)
+            cues.push({ start, end, text });
+    }
+    return cues;
+}

package/dist/swDefine.d.ts

@@ -0,0 +1,5 @@
+/**
+ * URL prefix for streaming URLs answered by the bundled Service Worker.
+ * Keep in sync with `src/proxy/sw/sw.js` (asserted by tests).
+ */
+export declare const SW_MARKER = "/__mmstream__/";

package/dist/swDefine.js

@@ -0,0 +1,5 @@
+/**
+ * URL prefix for streaming URLs answered by the bundled Service Worker.
+ * Keep in sync with `src/proxy/sw/sw.js` (asserted by tests).
+ */
+export const SW_MARKER = "/__mmstream__/";

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "mega-stream-proxy",
+  "version": "0.1.9",
+  "description": "Stream decrypted MEGA files over HTTP byte ranges on Android (react-native-tcp-socket) and the web (Service Worker), play them with an Expo Video player + subtitles, and manage MEGA accounts with pluggable storage. Zero-config: runtime native deps are regular dependencies (auto-linked).",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./native": {
+      "types": "./dist/proxy/native.d.ts",
+      "default": "./dist/proxy/native.js"
+    },
+    "./web": {
+      "types": "./dist/proxy/web.d.ts",
+      "default": "./dist/proxy/web.js"
+    },
+    "./accounts": {
+      "types": "./dist/accounts/index.d.ts",
+      "default": "./dist/accounts/index.js"
+    },
+    "./sw": {
+      "types": "./dist/proxy/sw/bundle.d.ts",
+      "default": "./dist/proxy/sw/bundle.js"
+    },
+    "./player": {
+      "types": "./dist/Player/playerweb/index.d.ts",
+      "default": "./dist/Player/playerweb/index.js"
+    },
+    "./playerAndroid": {
+      "types": "./dist/Player/playerAndroid/index.d.ts",
+      "default": "./dist/Player/playerAndroid/index.js"
+    },
+    "./subtitles": {
+      "types": "./dist/subtitles/index.d.ts",
+      "default": "./dist/subtitles/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "android",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/copy-sw-assets.js",
+    "typecheck": "tsc --noEmit",
+    "test": "npm run build && node --test \"tests/*.test.mjs\"",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^2.0.0",
+    "buffer": "^6.0.3",
+    "megajs": "^1.3.0",
+    "react-native-tcp-socket": "^6.1.0"
+  },
+  "peerDependencies": {
+    "@expo/vector-icons": ">=13",
+    "expo-font": ">=13",
+    "expo-video": ">=1.0",
+    "react": ">=18",
+    "react-native": ">=0.71"
+  },
+  "peerDependenciesMeta": {
+    "@expo/vector-icons": {
+      "optional": true
+    },
+    "expo-font": {
+      "optional": true
+    },
+    "expo-video": {
+      "optional": true
+    },
+    "react-native-video": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@expo/vector-icons": "~14.0.4",
+    "@types/node": "^22.0.0",
+    "@types/react": "~18.3.12",
+    "buffer": "^6.0.3",
+    "expo-font": "~13.0.4",
+    "expo-video": "~2.0.6",
+    "megajs": "^1.3.0",
+    "react": "18.3.1",
+    "react-native": "0.76.9",
+    "react-native-tcp-socket": "^6.1.0",
+    "react-native-video": ">=6",
+    "typescript": "^5.5.0"
+  },
+  "keywords": [
+    "mega",
+    "megajs",
+    "streaming",
+    "http-range",
+    "react-native",
+    "expo",
+    "video",
+    "subtitles",
+    "service-worker",
+    "proxy",
+    "accounts"
+  ],
+  "license": "MIT"
+}