scorm-kit 0.2.0

package/src/diff/diff.js

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+/*
+ * scorm-diff — structured diff between two SCORM 1.2 packages.
+ *
+ *   scorm-diff before.zip after.zip
+ *   scorm-diff before.zip after.zip --json
+ *
+ * Output sections:
+ *   - Manifest changes (parsed: identifier, title, masteryscore, schema, …)
+ *   - Asset list (added, removed, modified)
+ *   - Per-file detail:
+ *       text files (HTML/CSS/JS/JSON/XML/VTT) → unified line diff
+ *       binary files                          → size + sha256 change
+ *
+ * Use it for content PR review (treat SCORM as a reviewable diff, not a
+ * binary blob) or in CI to gate large unintended changes.
+ *
+ * Exit codes: 0 = no changes, 1 = changes present, 2 = error.
+ */
+"use strict";
+
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var crypto = require("crypto");
+var { spawnSync } = require("child_process");
+var verifyConfinement = require("../confine");
+
+// ---------- args -----------------------------------------------------------
+
+function parseArgs(argv) {
+  var a = {
+    before: "", after: "", json: false, noColor: false,
+    maxTextDiffKB: 256, maxDiffLines: 200,
+  };
+  for (var i = 0; i < argv.length; i++) {
+    var k = argv[i];
+    if (k === "--json") a.json = true;
+    else if (k === "--no-color") a.noColor = true;
+    else if (k === "--max-text-kb") a.maxTextDiffKB = +argv[++i];
+    else if (k === "--max-diff-lines") a.maxDiffLines = +argv[++i];
+    else if (k === "-h" || k === "--help") { usage(); process.exit(0); }
+    else if (k[0] === "-") { console.error("Unknown flag: " + k); process.exit(2); }
+    else if (!a.before) a.before = k;
+    else if (!a.after) a.after = k;
+    else { console.error("Unexpected arg: " + k); process.exit(2); }
+  }
+  if (!a.before || !a.after) { usage(); process.exit(2); }
+  return a;
+}
+function usage() {
+  console.error("Usage: scorm-diff <before.zip|dir> <after.zip|dir> [options]");
+  console.error("  --json                  emit JSON");
+  console.error("  --no-color              disable ANSI colors");
+  console.error("  --max-text-kb N         skip line-diff on text files > N KB (default 256)");
+  console.error("  --max-diff-lines N      truncate per-file diff to N lines (default 200)");
+}
+
+// ---------- unpacking ------------------------------------------------------
+
+function unpack(input) {
+  var st = fs.statSync(input);
+  if (st.isDirectory()) return { root: path.resolve(input), cleanup: function () {} };
+  var tmp = fs.mkdtempSync(path.join(os.tmpdir(), "scorm-diff-"));
+  var r = spawnSync("unzip", ["-q", "-o", input, "-d", tmp]);
+  if (r.status !== 0) throw new Error("unzip " + input + ": " + r.stderr.toString());
+  verifyConfinement(tmp);
+  return { root: tmp, cleanup: function () { try { fs.rmSync(tmp, { recursive: true, force: true }); } catch (e) {} } };
+}
+
+function walk(dir, acc, prefix) {
+  acc = acc || []; prefix = prefix || "";
+  for (var name of fs.readdirSync(dir)) {
+    var p = path.join(dir, name);
+    var rel = prefix ? prefix + "/" + name : name;
+    var st = fs.statSync(p);
+    if (st.isDirectory()) walk(p, acc, rel);
+    else acc.push({ rel: rel, abs: p, size: st.size });
+  }
+  return acc;
+}
+
+// ---------- manifest parsing -----------------------------------------------
+
+function parseManifest(root) {
+  var p = path.join(root, "imsmanifest.xml");
+  if (!fs.existsSync(p)) return null;
+  var xml = fs.readFileSync(p, "utf8");
+  function pluck(re) { var m = re.exec(xml); return m ? m[1].trim() : null; }
+  return {
+    identifier: pluck(/<manifest\b[^>]*\bidentifier\s*=\s*["']([^"']+)["']/i),
+    version: pluck(/<manifest\b[^>]*\bversion\s*=\s*["']([^"']+)["']/i),
+    schema: pluck(/<schema>\s*([^<]+?)\s*<\/schema>/i),
+    schemaversion: pluck(/<schemaversion>\s*([^<]+?)\s*<\/schemaversion>/i),
+    title: pluck(/<title>\s*([^<]+?)\s*<\/title>/i),
+    masteryscore: pluck(/<adlcp:masteryscore>\s*([^<]+?)\s*<\/adlcp:masteryscore>/i),
+    launchHref: pluck(/<resource\b[^>]*\bscormtype\s*=\s*["']sco["'][^>]*\bhref\s*=\s*["']([^"']+)["']/i)
+             || pluck(/<resource\b[^>]*\bhref\s*=\s*["']([^"']+)["'][^>]*\bscormtype\s*=\s*["']sco["']/i)
+             || pluck(/<resource\b[^>]*\bhref\s*=\s*["']([^"']+)["']/i),
+  };
+}
+
+function diffManifest(a, b) {
+  var out = [];
+  if (!a && !b) return out;
+  if (!a) return [{ kind: "added", key: "manifest", value: "(no manifest before)" }];
+  if (!b) return [{ kind: "removed", key: "manifest", value: "(no manifest after)" }];
+  var keys = Object.keys(a).concat(Object.keys(b))
+    .filter(function (k, i, arr) { return arr.indexOf(k) === i; });
+  keys.sort();
+  keys.forEach(function (k) {
+    var x = a[k], y = b[k];
+    if (x === y) return;
+    if (x == null) out.push({ kind: "added", key: k, value: y });
+    else if (y == null) out.push({ kind: "removed", key: k, value: x });
+    else out.push({ kind: "changed", key: k, before: x, after: y });
+  });
+  return out;
+}
+
+// ---------- file hashing + classification ---------------------------------
+
+var TEXT_EXT = new Set([".html", ".htm", ".css", ".js", ".json", ".xml", ".vtt", ".txt", ".md", ".srt"]);
+function isText(rel) { return TEXT_EXT.has(path.extname(rel).toLowerCase()); }
+
+function sha256(absPath) {
+  var h = crypto.createHash("sha256");
+  h.update(fs.readFileSync(absPath));
+  return h.digest("hex");
+}
+
+function indexFiles(root) {
+  var files = walk(root);
+  // Manifest is reported in its own section.
+  files = files.filter(function (f) { return f.rel !== "imsmanifest.xml"; });
+  var byRel = new Map();
+  files.forEach(function (f) {
+    f.hash = sha256(f.abs);
+    byRel.set(f.rel, f);
+  });
+  return byRel;
+}
+
+// ---------- text diff (shell out to `diff -u`) ----------------------------
+
+function unifiedDiff(beforePath, afterPath, maxLines) {
+  var r = spawnSync("diff", ["-u", "--label", "before", "--label", "after", beforePath, afterPath]);
+  // diff exit code is 1 when files differ (not an error), 2 on real errors.
+  if (r.status === 2) return ["(diff failed: " + r.stderr.toString().trim() + ")"];
+  var text = r.stdout.toString();
+  if (!text) {
+    // Content hash differed but unified diff is empty — usually BOM, line
+    // endings, or trailing-newline changes. Surface this instead of silently
+    // showing nothing under the "modified" header.
+    return ["(no line-level changes — likely encoding / line-ending / trailing-newline only)"];
+  }
+  var lines = text.split("\n");
+  if (lines.length > maxLines) {
+    lines = lines.slice(0, maxLines).concat(["… (" + (text.split("\n").length - maxLines) + " more lines truncated)"]);
+  }
+  return lines;
+}
+
+// ---------- core diff ----------------------------------------------------
+
+function compareAssets(aMap, bMap, args) {
+  var changes = { added: [], removed: [], modified: [] };
+  bMap.forEach(function (bf, rel) {
+    var af = aMap.get(rel);
+    if (!af) { changes.added.push({ rel: rel, size: bf.size }); return; }
+    if (af.hash === bf.hash) return; // unchanged
+    var mod = {
+      rel: rel,
+      beforeSize: af.size,
+      afterSize: bf.size,
+      beforeHash: af.hash.slice(0, 12),
+      afterHash: bf.hash.slice(0, 12),
+      text: isText(rel),
+      diff: null,
+    };
+    if (mod.text && af.size <= args.maxTextDiffKB * 1024 && bf.size <= args.maxTextDiffKB * 1024) {
+      mod.diff = unifiedDiff(af.abs, bf.abs, args.maxDiffLines);
+    }
+    changes.modified.push(mod);
+  });
+  aMap.forEach(function (af, rel) {
+    if (!bMap.has(rel)) changes.removed.push({ rel: rel, size: af.size });
+  });
+  return changes;
+}
+
+// ---------- rendering ----------------------------------------------------
+
+function color(s, code, on) { return on ? "\x1b[" + code + "m" + s + "\x1b[0m" : s; }
+function fmtSize(n) {
+  if (n < 1024) return n + " B";
+  if (n < 1024 * 1024) return (n / 1024).toFixed(1) + " KB";
+  return (n / (1024 * 1024)).toFixed(1) + " MB";
+}
+
+function renderText(report, useColor) {
+  var out = [];
+  // Manifest
+  if (report.manifest.length) {
+    out.push(color("=== Manifest ===", 1, useColor));
+    report.manifest.forEach(function (m) {
+      if (m.kind === "added")
+        out.push(color("+ " + m.key + ": " + JSON.stringify(m.value), 32, useColor));
+      else if (m.kind === "removed")
+        out.push(color("- " + m.key + ": " + JSON.stringify(m.value), 31, useColor));
+      else
+        out.push(color("~ " + m.key + ": ", 33, useColor) +
+                 JSON.stringify(m.before) + " → " + JSON.stringify(m.after));
+    });
+    out.push("");
+  }
+  // Assets
+  var a = report.assets;
+  if (a.added.length + a.removed.length + a.modified.length > 0) {
+    out.push(color("=== Assets ===", 1, useColor));
+    a.added.forEach(function (f) {
+      out.push(color("+ " + f.rel.padEnd(40), 32, useColor) + "  " + fmtSize(f.size));
+    });
+    a.removed.forEach(function (f) {
+      out.push(color("- " + f.rel.padEnd(40), 31, useColor) + "  " + fmtSize(f.size));
+    });
+    a.modified.forEach(function (f) {
+      var sizeNote = (f.beforeSize === f.afterSize)
+        ? fmtSize(f.afterSize)
+        : fmtSize(f.beforeSize) + " → " + fmtSize(f.afterSize);
+      var hashNote = " (" + f.beforeHash + " → " + f.afterHash + ")";
+      out.push(color("~ " + f.rel.padEnd(40), 33, useColor) + "  " + sizeNote + hashNote);
+      if (f.diff && f.diff.length > 0) {
+        f.diff.forEach(function (line) {
+          var c = line.startsWith("+") && !line.startsWith("+++") ? 32 :
+                  line.startsWith("-") && !line.startsWith("---") ? 31 :
+                  line.startsWith("@@") ? 36 : 0;
+          out.push("    " + color(line, c, useColor));
+        });
+      }
+    });
+    out.push("");
+  }
+  // Summary
+  out.push(color("=== Summary ===", 1, useColor));
+  out.push("Manifest: " + report.manifest.length + " change(s)");
+  out.push("Assets:   " + a.added.length + " added, " + a.removed.length + " removed, " + a.modified.length + " modified");
+  return out.join("\n");
+}
+
+// ---------- main ---------------------------------------------------------
+
+function main() {
+  var args = parseArgs(process.argv.slice(2));
+  if (!fs.existsSync(args.before)) { console.error("Not found: " + args.before); process.exit(2); }
+  if (!fs.existsSync(args.after)) { console.error("Not found: " + args.after); process.exit(2); }
+
+  var aBox = unpack(args.before), bBox = unpack(args.after);
+  try {
+    var manifestDiff = diffManifest(parseManifest(aBox.root), parseManifest(bBox.root));
+    var assetDiff = compareAssets(indexFiles(aBox.root), indexFiles(bBox.root), args);
+    var report = { manifest: manifestDiff, assets: assetDiff };
+
+    if (args.json) {
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      var useColor = !args.noColor && process.stdout.isTTY;
+      console.log(renderText(report, useColor));
+    }
+    var changed = manifestDiff.length + assetDiff.added.length + assetDiff.removed.length + assetDiff.modified.length;
+    process.exit(changed > 0 ? 1 : 0);
+  } finally {
+    aBox.cleanup(); bBox.cleanup();
+  }
+}
+
+main();

package/src/i18n/i18n-cli.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+/*
+ * scorm-i18n — bundle a translation pack into a SCORM 1.2 package.
+ *
+ *   scorm-i18n <package.zip | dir> --strings strings.json [opts]
+ *
+ * What this tool does NOT do: auto-translate. It bundles strings the author
+ * already provides, and ships a runtime that swaps text + media at page load.
+ *
+ * What the author must do upfront in their course HTML:
+ *
+ *   <h1 data-i18n="title">Welcome</h1>            ← default (en) text;
+ *                                                   runtime replaces it.
+ *   <button data-i18n="btn.submit">Submit</button>
+ *   <input  data-i18n-attr="placeholder:input.name.placeholder">
+ *   <video>
+ *     <source data-i18n-source src="lesson.en.mp4">
+ *     <track  data-i18n-track  src="lesson.en.vtt" kind="captions">
+ *   </video>
+ *
+ * The CLI bundles the strings.json + the runtime, injects two <script>
+ * tags into the launch HTML, and re-zips.
+ *
+ * strings.json shape:
+ *
+ *   {
+ *     "defaultLang": "en",
+ *     "names":       { "en": "English", "hi": "हिन्दी" },
+ *     "rtl":         ["ar","he"],
+ *     "strings": {
+ *       "en": { "title": "Welcome", "btn.submit": "Submit" },
+ *       "hi": { "title": "स्वागत", "btn.submit": "जमा करें" }
+ *     }
+ *   }
+ *
+ * The CLI validates the file and warns about missing keys per language.
+ */
+"use strict";
+
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var { spawnSync } = require("child_process");
+var verifyConfinement = require("../confine");
+
+// ---------- args -----------------------------------------------------------
+
+function parseArgs(argv) {
+  var a = { input: "", strings: "", out: "", hideSwitcher: false, dryRun: false };
+  for (var i = 0; i < argv.length; i++) {
+    var k = argv[i];
+    if (k === "--strings") a.strings = argv[++i];
+    else if (k === "--out") a.out = argv[++i];
+    else if (k === "--hide-switcher") a.hideSwitcher = true;
+    else if (k === "--dry-run") a.dryRun = true;
+    else if (k === "-h" || k === "--help") { usage(); process.exit(0); }
+    else if (k[0] === "-") { console.error("Unknown flag: " + k); process.exit(2); }
+    else if (!a.input) a.input = k;
+    else { console.error("Unexpected arg: " + k); process.exit(2); }
+  }
+  if (!a.input || !a.strings) { usage(); process.exit(2); }
+  return a;
+}
+function usage() {
+  console.error("Usage: scorm-i18n <package.zip | dir> --strings file.json [options]");
+  console.error("  --out <path>        output zip path");
+  console.error("  --hide-switcher     bundle without the floating lang selector UI");
+  console.error("  --dry-run           print plan, change nothing");
+}
+
+// ---------- zip ------------------------------------------------------------
+
+function unzipToTemp(zipPath) {
+  var tmp = fs.mkdtempSync(path.join(os.tmpdir(), "scorm-i18n-"));
+  var r = spawnSync("unzip", ["-q", "-o", zipPath, "-d", tmp]);
+  if (r.status !== 0) throw new Error("unzip: " + r.stderr.toString());
+  verifyConfinement(tmp);
+  return tmp;
+}
+function zipFromDir(dir, outZip) {
+  if (fs.existsSync(outZip)) fs.unlinkSync(outZip);
+  var r = spawnSync("zip", ["-qrX", outZip, "."], { cwd: dir });
+  if (r.status !== 0) throw new Error("zip: " + r.stderr.toString());
+}
+
+// ---------- manifest + injection ------------------------------------------
+
+function findLaunchHref(root) {
+  var mPath = path.join(root, "imsmanifest.xml");
+  if (!fs.existsSync(mPath)) return null;
+  var xml = fs.readFileSync(mPath, "utf8");
+  var m = /<resource\b[^>]*\bscormtype\s*=\s*["']sco["'][^>]*\bhref\s*=\s*["']([^"']+)["']/i.exec(xml);
+  if (!m) m = /<resource\b[^>]*\bhref\s*=\s*["']([^"']+)["'][^>]*\bscormtype\s*=\s*["']sco["']/i.exec(xml);
+  if (!m) m = /<resource\b[^>]*\bhref\s*=\s*["']([^"']+)["']/i.exec(xml);
+  return m ? m[1] : null;
+}
+
+function injectScripts(html, stringsName, runtimeName) {
+  if (/<script\s+[^>]*src=["']i18n-strings\.js["']/i.test(html) &&
+      /<script\s+[^>]*src=["']i18n\.js["']/i.test(html)) return { html: html, injected: false };
+  var tags =
+    '<script src="' + stringsName + '"></script>\n' +
+    '<script src="' + runtimeName + '"></script>\n';
+  if (/<\/head>/i.test(html)) {
+    return { html: html.replace(/<\/head>/i, tags + "</head>"), injected: true };
+  }
+  if (/<head\b[^>]*>/i.test(html)) {
+    return { html: html.replace(/<head\b[^>]*>/i, function (m) { return m + "\n" + tags; }), injected: true };
+  }
+  if (/<html\b[^>]*>/i.test(html)) {
+    return { html: html.replace(/<html\b[^>]*>/i, function (m) { return m + "\n<head>\n" + tags + "</head>"; }), injected: true };
+  }
+  return { html: tags + html, injected: true };
+}
+
+// ---------- strings validation --------------------------------------------
+
+function validateStrings(strings) {
+  var problems = [];
+  if (!strings || typeof strings !== "object") {
+    problems.push("strings.json is empty or not an object");
+    return problems;
+  }
+  if (!strings.strings || typeof strings.strings !== "object") {
+    problems.push("missing top-level `strings` map");
+    return problems;
+  }
+  var langs = Object.keys(strings.strings);
+  if (langs.length < 2) problems.push("only " + langs.length + " language(s) — i18n needs ≥ 2");
+  if (strings.defaultLang && !strings.strings[strings.defaultLang]) {
+    problems.push("defaultLang \"" + strings.defaultLang + "\" not in strings map");
+  }
+  // Key parity
+  if (langs.length >= 2) {
+    var base = strings.defaultLang || langs[0];
+    var baseKeys = new Set(Object.keys(strings.strings[base]));
+    langs.forEach(function (l) {
+      if (l === base) return;
+      var ks = new Set(Object.keys(strings.strings[l]));
+      var missing = [], extra = [];
+      baseKeys.forEach(function (k) { if (!ks.has(k)) missing.push(k); });
+      ks.forEach(function (k) { if (!baseKeys.has(k)) extra.push(k); });
+      if (missing.length) problems.push("[" + l + "] missing " + missing.length + " key(s): " + missing.slice(0, 5).join(", ") + (missing.length > 5 ? "…" : ""));
+      if (extra.length) problems.push("[" + l + "] " + extra.length + " key(s) not in " + base + ": " + extra.slice(0, 5).join(", ") + (extra.length > 5 ? "…" : ""));
+    });
+  }
+  return problems;
+}
+
+// ---------- main -----------------------------------------------------------
+
+function main() {
+  var args = parseArgs(process.argv.slice(2));
+  if (!fs.existsSync(args.input)) { console.error("Not found: " + args.input); process.exit(2); }
+  if (!fs.existsSync(args.strings)) { console.error("Strings file not found: " + args.strings); process.exit(2); }
+
+  var strings;
+  try { strings = JSON.parse(fs.readFileSync(args.strings, "utf8")); }
+  catch (e) { console.error("strings.json is not valid JSON: " + e.message); process.exit(2); }
+  if (args.hideSwitcher) strings.hideSwitcher = true;
+
+  var problems = validateStrings(strings);
+  problems.forEach(function (p) { console.warn("warn  " + p); });
+
+  var runtimeSrc = path.join(__dirname, "runtime", "i18n.js");
+  if (!fs.existsSync(runtimeSrc)) { console.error("Runtime missing at " + runtimeSrc); process.exit(2); }
+
+  var inputIsZip = fs.statSync(args.input).isFile();
+  var root, cleanup = function () {};
+  if (inputIsZip) {
+    root = unzipToTemp(args.input);
+    cleanup = function () { try { fs.rmSync(root, { recursive: true, force: true }); } catch (e) {} };
+  } else {
+    root = path.resolve(args.input);
+  }
+
+  try {
+    var launchHref = findLaunchHref(root);
+    if (!launchHref) { console.error("No launch HTML in manifest."); process.exit(2); }
+    var launchPath = path.resolve(root, launchHref.split("?")[0]);
+    if (!fs.existsSync(launchPath)) { console.error("Launch HTML missing: " + launchHref); process.exit(2); }
+
+    var langs = Object.keys(strings.strings || {});
+    console.log("languages:  " + langs.join(", "));
+    console.log("default:    " + (strings.defaultLang || langs[0]));
+    console.log("rtl:        " + ((strings.rtl || []).join(", ") || "none"));
+    console.log("strings:    " + (strings.strings[langs[0]] ? Object.keys(strings.strings[langs[0]]).length : 0) + " keys per language");
+
+    if (args.dryRun) {
+      console.log("\n(dry-run) would write i18n-strings.js + i18n.js next to launch HTML, inject 2 <script> tags");
+      return;
+    }
+
+    var launchDir = path.dirname(launchPath);
+    fs.copyFileSync(runtimeSrc, path.join(launchDir, "i18n.js"));
+    fs.writeFileSync(
+      path.join(launchDir, "i18n-strings.js"),
+      "window.I18N_STRINGS = " + JSON.stringify(strings, null, 2) + ";\n"
+    );
+
+    var html = fs.readFileSync(launchPath, "utf8");
+    var inj = injectScripts(html, "i18n-strings.js", "i18n.js");
+    if (inj.injected) {
+      fs.writeFileSync(launchPath, inj.html);
+      console.log("injected    " + path.relative(root, launchPath));
+    } else {
+      console.log("inject      skipped (already wrapped); strings refreshed");
+    }
+    console.log("copied      i18n.js");
+    console.log("wrote       i18n-strings.js");
+
+    if (inputIsZip) {
+      var out = args.out || args.input.replace(/\.zip$/i, "") + "-i18n.zip";
+      zipFromDir(root, path.resolve(out));
+      console.log("\nwrote " + out);
+    }
+  } finally {
+    cleanup();
+  }
+}
+
+main();

package/src/i18n/runtime/i18n.js

@@ -0,0 +1,168 @@
+/*
+ * scorm-i18n runtime — runs in the course window at page load.
+ *
+ * Reads window.I18N_STRINGS (injected by the CLI), determines the active
+ * language from (in order):
+ *   1. ?lang=xx query param
+ *   2. cmi.student_preference.language (if SCORM API is available)
+ *   3. <html lang="..."> attribute
+ *   4. config.defaultLang
+ *
+ * Then walks the DOM and:
+ *   - replaces textContent on [data-i18n="key"] elements with strings[key]
+ *   - rewrites src on <track data-i18n-track="suffix"> from
+ *       "video.vtt"  →  "video.{lang}.vtt"
+ *   - rewrites src on <source data-i18n-source="suffix"> the same way
+ *   - sets <html lang> to the active language
+ *   - injects a small language switcher in the top-right
+ */
+(function () {
+  "use strict";
+  var data = window.I18N_STRINGS;
+  if (!data || !data.strings) { console.warn("[scorm-i18n] no strings"); return; }
+
+  var langs = Object.keys(data.strings);
+  var defaultLang = data.defaultLang || langs[0];
+
+  function findApi() {
+    var win = window, d = 500;
+    while (win && d-- > 0) {
+      if (win.API) return win.API;
+      if (win.parent && win.parent !== win) { win = win.parent; continue; }
+      break;
+    }
+    return null;
+  }
+  function getScormLang() {
+    // Read without calling LMSInitialize — initializing here would emit a
+    // premature `launched` xAPI statement when paired with scorm-xapi, and
+    // could also conflict with the course's own init sequence. If the LMS
+    // hasn't been initialized yet, LMSGetValue returns "" and we move on.
+    var api = findApi();
+    if (!api) return null;
+    try {
+      var v = api.LMSGetValue("cmi.student_preference.language");
+      return v || null;
+    } catch (e) { return null; }
+  }
+
+  function pick() {
+    var q = (location.search.match(/[?&]lang=([^&]+)/) || [])[1];
+    if (q && data.strings[q]) return q;
+    var scorm = getScormLang();
+    if (scorm && data.strings[scorm]) return scorm;
+    try {
+      var ls = localStorage.getItem("scormI18nLang");
+      if (ls && data.strings[ls]) return ls;
+    } catch (e) {}
+    var htmlLang = document.documentElement.getAttribute("lang");
+    if (htmlLang && data.strings[htmlLang]) return htmlLang;
+    return defaultLang;
+  }
+
+  function applyText(lang) {
+    var strings = data.strings[lang] || {};
+    document.querySelectorAll("[data-i18n]").forEach(function (el) {
+      var key = el.getAttribute("data-i18n");
+      if (strings[key] != null) el.textContent = strings[key];
+    });
+    document.querySelectorAll("[data-i18n-attr]").forEach(function (el) {
+      // data-i18n-attr="title:tooltipKey,aria-label:labelKey"
+      el.getAttribute("data-i18n-attr").split(",").forEach(function (pair) {
+        var p = pair.split(":");
+        if (p.length === 2 && strings[p[1].trim()] != null) {
+          el.setAttribute(p[0].trim(), strings[p[1].trim()]);
+        }
+      });
+    });
+  }
+
+  function applyMedia(lang) {
+    function rewrite(src, lang) {
+      // Split off query / hash so a "foo.en.mp4?v=2" round-trips correctly.
+      var qi = src.search(/[?#]/);
+      var base = qi >= 0 ? src.slice(0, qi) : src;
+      var tail = qi >= 0 ? src.slice(qi) : "";
+      // foo.vtt → foo.<lang>.vtt ; foo.en.vtt → foo.<lang>.vtt
+      var m = base.match(/^(.+?)(?:\.[a-z]{2,3}(?:-[A-Z]{2})?)?(\.[a-z0-9]+)$/i);
+      if (!m) return src;
+      return m[1] + "." + lang + m[2] + tail;
+    }
+    document.querySelectorAll("track[data-i18n-track]").forEach(function (el) {
+      var orig = el.getAttribute("data-i18n-track-orig") || el.getAttribute("src");
+      if (!el.getAttribute("data-i18n-track-orig")) el.setAttribute("data-i18n-track-orig", orig);
+      el.setAttribute("src", rewrite(orig, lang));
+      el.setAttribute("srclang", lang);
+    });
+    document.querySelectorAll("source[data-i18n-source]").forEach(function (el) {
+      var orig = el.getAttribute("data-i18n-source-orig") || el.getAttribute("src");
+      if (!el.getAttribute("data-i18n-source-orig")) el.setAttribute("data-i18n-source-orig", orig);
+      el.setAttribute("src", rewrite(orig, lang));
+    });
+    // Force <video> elements to reload their selected source after we changed it.
+    document.querySelectorAll("video").forEach(function (v) {
+      if (v.querySelector("source[data-i18n-source]")) {
+        var t = v.currentTime;
+        v.load();
+        v.currentTime = t;
+      }
+    });
+  }
+
+  function persistChoice(lang) {
+    try {
+      var api = (function f(w, d) {
+        while (w && d-- > 0) { if (w.API) return w.API; if (w.parent && w.parent !== w) w = w.parent; else break; }
+        return null;
+      })(window, 500);
+      if (api) api.LMSSetValue("cmi.student_preference.language", lang);
+    } catch (e) {}
+    try { localStorage.setItem("scormI18nLang", lang); } catch (e) {}
+  }
+
+  function injectSwitcher(current) {
+    if (langs.length < 2 || data.hideSwitcher) return;
+    var wrap = document.createElement("div");
+    wrap.id = "i18n-switcher";
+    wrap.setAttribute("role", "region");
+    wrap.setAttribute("aria-label", "Language selector");
+    wrap.style.cssText = "position:fixed;top:8px;right:8px;z-index:99999;background:#fff;" +
+      "border:1px solid #ccc;border-radius:6px;padding:4px 8px;font:13px system-ui,sans-serif;" +
+      "box-shadow:0 1px 3px rgba(0,0,0,0.1);";
+    var sel = document.createElement("select");
+    sel.setAttribute("aria-label", "Language");
+    sel.style.cssText = "border:0;background:transparent;font:inherit;cursor:pointer;";
+    langs.forEach(function (l) {
+      var o = document.createElement("option");
+      o.value = l;
+      o.textContent = (data.names && data.names[l]) || l.toUpperCase();
+      if (l === current) o.selected = true;
+      sel.appendChild(o);
+    });
+    sel.addEventListener("change", function () {
+      var newLang = sel.value;
+      persistChoice(newLang);
+      apply(newLang);
+    });
+    wrap.appendChild(sel);
+    document.body.appendChild(wrap);
+  }
+
+  function apply(lang) {
+    document.documentElement.setAttribute("lang", lang);
+    document.documentElement.setAttribute("dir",
+      data.rtl && data.rtl.indexOf(lang) >= 0 ? "rtl" : "ltr");
+    applyText(lang);
+    applyMedia(lang);
+    var sel = document.querySelector("#i18n-switcher select");
+    if (sel && sel.value !== lang) sel.value = lang;
+  }
+
+  function boot() {
+    var lang = pick();
+    apply(lang);
+    injectSwitcher(lang);
+  }
+  if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", boot);
+  else boot();
+})();