npm - @patch-adams/core - Versions diffs - 1.0.6 → 1.0.8 - Mend

@patch-adams/core 1.0.6 → 1.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/index.cjs ADDED Viewed

@@ -0,0 +1,1049 @@
+'use strict';
+var zod = require('zod');
+var fs = require('fs');
+var path = require('path');
+var url = require('url');
+var AdmZip = require('adm-zip');
+var yazl = require('yazl');
+var fastXmlParser = require('fast-xml-parser');
+var chalk = require('chalk');
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+var AdmZip__default = /*#__PURE__*/_interopDefault(AdmZip);
+var yazl__default = /*#__PURE__*/_interopDefault(yazl);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+// src/config/schema.ts
+var BlockingAssetConfigSchema = zod.z.object({
+  /** Filename for the asset */
+  filename: zod.z.string().min(1),
+  /** Whether this asset is enabled */
+  enabled: zod.z.boolean().default(true)
+});
+var AsyncAssetConfigSchema = zod.z.object({
+  /** Filename for the asset */
+  filename: zod.z.string().min(1),
+  /** Whether this asset is enabled */
+  enabled: zod.z.boolean().default(true),
+  /** Timeout in milliseconds for remote loading before falling back to local */
+  timeout: zod.z.number().min(1e3).max(3e4).default(5e3)
+});
+var LocalFoldersConfigSchema = zod.z.object({
+  /** Folder name for CSS files within scormcontent */
+  css: zod.z.string().default("css"),
+  /** Folder name for JS files within scormcontent */
+  js: zod.z.string().default("js")
+});
+var PatchAdamsConfigSchema = zod.z.object({
+  /** Remote domain for assets (e.g., "https://cdn.example.com/rise-overrides") */
+  remoteDomain: zod.z.string().url(),
+  /** CSS class added to <html> tag for specificity (default: "pa-patched") */
+  htmlClass: zod.z.string().default("pa-patched"),
+  /** CSS class added during loading, removed when ready (default: "pa-loading") */
+  loadingClass: zod.z.string().default("pa-loading"),
+  /** CSS loaded at start of <head> - blocking, prevents FOUC */
+  cssBefore: BlockingAssetConfigSchema.default({
+    filename: "before.css",
+    enabled: true
+  }),
+  /** CSS loaded at end of <head> - async with fallback, for overrides */
+  cssAfter: AsyncAssetConfigSchema.default({
+    filename: "after.css",
+    enabled: true,
+    timeout: 5e3
+  }),
+  /** JS loaded at start of <head> - blocking, for setup/interception */
+  jsBefore: BlockingAssetConfigSchema.default({
+    filename: "before.js",
+    enabled: true
+  }),
+  /** JS loaded at end of <body> - async with fallback, removes loading class */
+  jsAfter: AsyncAssetConfigSchema.default({
+    filename: "after.js",
+    enabled: true,
+    timeout: 5e3
+  }),
+  /** Local folder names for fallback files */
+  localFolders: LocalFoldersConfigSchema.default({}),
+  /** Whether to update manifest files (imsmanifest.xml, etc.) for SCORM compliance */
+  updateManifests: zod.z.boolean().default(true)
+});
+// src/config/defaults.ts
+var defaultConfig = {
+  remoteDomain: "https://cdn.example.com/rise-overrides",
+  htmlClass: "pa-patched",
+  loadingClass: "pa-loading",
+  cssBefore: {
+    filename: "before.css",
+    enabled: true
+  },
+  cssAfter: {
+    filename: "after.css",
+    enabled: true,
+    timeout: 5e3
+  },
+  jsBefore: {
+    filename: "before.js",
+    enabled: true
+  },
+  jsAfter: {
+    filename: "after.js",
+    enabled: true,
+    timeout: 5e3
+  },
+  localFolders: {
+    css: "css",
+    js: "js"
+  },
+  updateManifests: true
+};
+async function loadConfig(configPath) {
+  const absolutePath = path.resolve(configPath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Configuration file not found: ${absolutePath}`);
+  }
+  const ext = path.extname(absolutePath).toLowerCase();
+  let rawConfig;
+  if (ext === ".json") {
+    const content = fs.readFileSync(absolutePath, "utf-8");
+    rawConfig = JSON.parse(content);
+  } else if (ext === ".ts" || ext === ".js" || ext === ".mjs") {
+    const fileUrl = url.pathToFileURL(absolutePath).href;
+    const module = await import(fileUrl);
+    rawConfig = module.default ?? module;
+  } else {
+    throw new Error(`Unsupported config file extension: ${ext}. Use .ts, .js, .mjs, or .json`);
+  }
+  const validated = PatchAdamsConfigSchema.parse(rawConfig);
+  return validated;
+}
+function mergeWithDefaults(partial) {
+  return PatchAdamsConfigSchema.parse({
+    ...defaultConfig,
+    ...partial
+  });
+}
+function generateConfigTemplate() {
+  return `import type { PatchAdamsConfig } from '@patch-adams/core';
+const config: PatchAdamsConfig = {
+  // Remote domain where your CSS/JS files are hosted
+  remoteDomain: 'https://cdn.example.com/rise-overrides',
+  // HTML classes for specificity and loading state
+  htmlClass: 'pa-patched',      // Always present on <html>
+  loadingClass: 'pa-loading',   // Removed when assets are loaded
+  // CSS loaded at start of <head> - BLOCKING
+  // Use this to hide content and prevent flash of unstyled content
+  cssBefore: {
+    filename: 'before.css',
+    enabled: true,
+  },
+  // CSS loaded at end of <head> - ASYNC with fallback
+  // Use this for style overrides
+  cssAfter: {
+    filename: 'after.css',
+    enabled: true,
+    timeout: 5000, // ms before falling back to local
+  },
+  // JS loaded at start of <head> - BLOCKING
+  // Use this for setup, API interception, globals
+  jsBefore: {
+    filename: 'before.js',
+    enabled: true,
+  },
+  // JS loaded at end of <body> - ASYNC with fallback
+  // Use this for DOM manipulation after Rise loads
+  // This should remove the loadingClass when done
+  jsAfter: {
+    filename: 'after.js',
+    enabled: true,
+    timeout: 5000, // ms before falling back to local
+  },
+  // Folder names for local fallback files within scormcontent/
+  localFolders: {
+    css: 'css',
+    js: 'js',
+  },
+  // Update manifest files for SCORM compliance
+  updateManifests: true,
+};
+export default config;
+`;
+}
+// src/templates/css-before.ts
+function generateCssBeforeLoader(options) {
+  const { remoteUrl, localPath, htmlClass, loadingClass } = options;
+  return `<!-- === PATCH-ADAMS: CSS BEFORE (blocking) === -->
+<style data-pa="css-before-critical">
+/* Critical: Hide content until ready */
+html.${htmlClass}.${loadingClass} body {
+  visibility: hidden !important;
+}
+</style>
+<script data-pa="css-before-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+  function loadCSSSync(url) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    link.setAttribute('data-pa', 'css-before');
+    document.head.appendChild(link);
+    return link;
+  }
+  // Try remote first
+  var link = loadCSSSync(REMOTE_URL);
+  link.onerror = function() {
+    console.warn('[Patch-Adams] CSS before failed to load from remote, using local fallback');
+    document.head.removeChild(link);
+    loadCSSSync(LOCAL_PATH);
+  };
+  link.onload = function() {
+    console.log('[Patch-Adams] CSS before loaded from remote:', REMOTE_URL);
+  };
+})();
+</script>`;
+}
+function buildCssBeforeOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.cssBefore.filename}`,
+    localPath: `${config.localFolders.css}/${config.cssBefore.filename}`,
+    htmlClass: config.htmlClass,
+    loadingClass: config.loadingClass
+  };
+}
+// src/templates/css-after.ts
+function generateCssAfterLoader(options) {
+  const { remoteUrl, localPath, timeout } = options;
+  return `<!-- === PATCH-ADAMS: CSS AFTER (async with fallback) === -->
+<script data-pa="css-after-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+  var TIMEOUT = ${timeout};
+  function loadCSS(url, onSuccess, onError) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    link.setAttribute('data-pa', 'css-after');
+    link.onload = function() {
+      if (onSuccess) onSuccess();
+    };
+    link.onerror = function() {
+      if (onError) onError();
+    };
+    document.head.appendChild(link);
+    return link;
+  }
+  function loadCSSWithFallback() {
+    var loaded = false;
+    var timeoutId;
+    // Try remote first
+    var remoteLink = loadCSS(
+      REMOTE_URL,
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        console.log('[Patch-Adams] CSS after loaded from remote:', REMOTE_URL);
+      },
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        loadLocalFallback();
+      }
+    );
+    // Timeout fallback
+    timeoutId = setTimeout(function() {
+      if (loaded) return;
+      loaded = true;
+      console.warn('[Patch-Adams] CSS after timed out, using local fallback');
+      if (remoteLink.parentNode) {
+        document.head.removeChild(remoteLink);
+      }
+      loadLocalFallback();
+    }, TIMEOUT);
+  }
+  function loadLocalFallback() {
+    loadCSS(
+      LOCAL_PATH,
+      function() {
+        console.log('[Patch-Adams] CSS after loaded from local fallback:', LOCAL_PATH);
+      },
+      function() {
+        console.error('[Patch-Adams] CSS after failed to load from both remote and local');
+      }
+    );
+  }
+  // Execute immediately
+  loadCSSWithFallback();
+})();
+</script>`;
+}
+function buildCssAfterOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.cssAfter.filename}`,
+    localPath: `${config.localFolders.css}/${config.cssAfter.filename}`,
+    timeout: config.cssAfter.timeout
+  };
+}
+// src/templates/js-before.ts
+function generateJsBeforeLoader(options) {
+  const { remoteUrl, localPath, htmlClass, loadingClass } = options;
+  return `<!-- === PATCH-ADAMS: JS BEFORE (blocking) === -->
+<script data-pa="js-before-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+  // Initialize Patch-Adams global namespace
+  window.PatchAdams = window.PatchAdams || {
+    version: '1.0.0',
+    htmlClass: '${htmlClass}',
+    loadingClass: '${loadingClass}',
+    loaded: {
+      cssBefore: false,
+      cssAfter: false,
+      jsBefore: false,
+      jsAfter: false
+    }
+  };
+  function loadJSSync(url) {
+    var script = document.createElement('script');
+    script.src = url;
+    script.setAttribute('data-pa', 'js-before');
+    // Note: For truly blocking behavior, we use document.write
+    // but that's fragile. Instead we'll handle errors gracefully.
+    document.head.appendChild(script);
+    return script;
+  }
+  // Try remote first
+  var script = loadJSSync(REMOTE_URL);
+  script.onerror = function() {
+    console.warn('[Patch-Adams] JS before failed to load from remote, using local fallback');
+    document.head.removeChild(script);
+    var fallback = loadJSSync(LOCAL_PATH);
+    fallback.onload = function() {
+      window.PatchAdams.loaded.jsBefore = true;
+      console.log('[Patch-Adams] JS before loaded from local fallback:', LOCAL_PATH);
+    };
+    fallback.onerror = function() {
+      console.error('[Patch-Adams] JS before failed to load from both remote and local');
+    };
+  };
+  script.onload = function() {
+    window.PatchAdams.loaded.jsBefore = true;
+    console.log('[Patch-Adams] JS before loaded from remote:', REMOTE_URL);
+  };
+})();
+</script>`;
+}
+function buildJsBeforeOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.jsBefore.filename}`,
+    localPath: `${config.localFolders.js}/${config.jsBefore.filename}`,
+    htmlClass: config.htmlClass,
+    loadingClass: config.loadingClass
+  };
+}
+// src/templates/js-after.ts
+function generateJsAfterLoader(options) {
+  const { remoteUrl, localPath, timeout, loadingClass } = options;
+  return `<!-- === PATCH-ADAMS: JS AFTER (async with fallback) === -->
+<script data-pa="js-after-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+  var TIMEOUT = ${timeout};
+  var LOADING_CLASS = "${loadingClass}";
+  function loadJS(url, onSuccess, onError) {
+    var script = document.createElement('script');
+    script.src = url;
+    script.async = true;
+    script.setAttribute('data-pa', 'js-after');
+    script.onload = function() {
+      if (onSuccess) onSuccess();
+    };
+    script.onerror = function() {
+      if (onError) onError();
+    };
+    document.body.appendChild(script);
+    return script;
+  }
+  function removeLoadingClass() {
+    document.documentElement.classList.remove(LOADING_CLASS);
+    if (window.PatchAdams) {
+      window.PatchAdams.loaded.jsAfter = true;
+    }
+    console.log('[Patch-Adams] Loading complete, content revealed');
+  }
+  function loadJSWithFallback() {
+    var loaded = false;
+    var timeoutId;
+    // Try remote first
+    var remoteScript = loadJS(
+      REMOTE_URL,
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        console.log('[Patch-Adams] JS after loaded from remote:', REMOTE_URL);
+        // Give the script a moment to execute, then remove loading class
+        setTimeout(removeLoadingClass, 50);
+      },
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        loadLocalFallback();
+      }
+    );
+    // Timeout fallback
+    timeoutId = setTimeout(function() {
+      if (loaded) return;
+      loaded = true;
+      console.warn('[Patch-Adams] JS after timed out, using local fallback');
+      if (remoteScript.parentNode) {
+        document.body.removeChild(remoteScript);
+      }
+      loadLocalFallback();
+    }, TIMEOUT);
+  }
+  function loadLocalFallback() {
+    loadJS(
+      LOCAL_PATH,
+      function() {
+        console.log('[Patch-Adams] JS after loaded from local fallback:', LOCAL_PATH);
+        setTimeout(removeLoadingClass, 50);
+      },
+      function() {
+        console.error('[Patch-Adams] JS after failed to load from both remote and local');
+        // Still remove loading class so content is visible even if JS fails
+        removeLoadingClass();
+      }
+    );
+  }
+  // Execute after DOM is ready to ensure Rise has loaded
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', function() {
+      // Small delay to ensure Rise has initialized
+      setTimeout(loadJSWithFallback, 100);
+    });
+  } else {
+    // DOM is already ready
+    setTimeout(loadJSWithFallback, 100);
+  }
+})();
+</script>`;
+}
+function buildJsAfterOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.jsAfter.filename}`,
+    localPath: `${config.localFolders.js}/${config.jsAfter.filename}`,
+    timeout: config.jsAfter.timeout,
+    loadingClass: config.loadingClass
+  };
+}
+// src/patcher/html-injector.ts
+var HtmlInjector = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Inject all loaders into HTML
+   */
+  inject(html) {
+    let result = html;
+    result = this.addHtmlClasses(result);
+    if (this.config.cssBefore.enabled) {
+      result = this.injectCssBefore(result);
+    }
+    if (this.config.jsBefore.enabled) {
+      result = this.injectJsBefore(result);
+    }
+    if (this.config.cssAfter.enabled) {
+      result = this.injectCssAfter(result);
+    }
+    if (this.config.jsAfter.enabled) {
+      result = this.injectJsAfter(result);
+    }
+    return result;
+  }
+  /**
+   * Add pa-patched and pa-loading classes to <html> tag
+   */
+  addHtmlClasses(html) {
+    const { htmlClass, loadingClass } = this.config;
+    const classes = `${htmlClass} ${loadingClass}`;
+    const htmlTagPattern = /<html([^>]*)>/i;
+    const match = html.match(htmlTagPattern);
+    if (!match) {
+      return html;
+    }
+    const attributes = match[1];
+    if (/class\s*=\s*["'][^"']*["']/i.test(attributes)) {
+      return html.replace(
+        htmlTagPattern,
+        (_match, attrs) => {
+          const newAttrs = attrs.replace(
+            /class\s*=\s*["']([^"']*)["']/i,
+            (_fullMatch, existingClasses) => `class="${existingClasses} ${classes}"`
+          );
+          return `<html${newAttrs}>`;
+        }
+      );
+    } else {
+      return html.replace(htmlTagPattern, `<html${attributes} class="${classes}">`);
+    }
+  }
+  /**
+   * Inject CSS Before loader at start of <head>
+   */
+  injectCssBefore(html) {
+    const options = buildCssBeforeOptions(this.config);
+    const loader = generateCssBeforeLoader(options);
+    return html.replace(/<head([^>]*)>/i, `<head$1>
+${loader}`);
+  }
+  /**
+   * Inject JS Before loader at start of <head> (after CSS Before if present)
+   */
+  injectJsBefore(html) {
+    const options = buildJsBeforeOptions(this.config);
+    const loader = generateJsBeforeLoader(options);
+    const cssBeforeMarker = "<!-- === PATCH-ADAMS: CSS BEFORE";
+    if (html.includes(cssBeforeMarker)) {
+      const cssBeforeEndPattern = /<\/script>\s*(?=\n|<)/;
+      const cssBeforeStart = html.indexOf(cssBeforeMarker);
+      const afterCssBefore = html.substring(cssBeforeStart);
+      const endMatch = afterCssBefore.match(cssBeforeEndPattern);
+      if (endMatch && endMatch.index !== void 0) {
+        const insertPos = cssBeforeStart + endMatch.index + endMatch[0].length;
+        return html.slice(0, insertPos) + "\n" + loader + html.slice(insertPos);
+      }
+    }
+    return html.replace(/<head([^>]*)>/i, `<head$1>
+${loader}`);
+  }
+  /**
+   * Inject CSS After loader at end of <head>
+   */
+  injectCssAfter(html) {
+    const options = buildCssAfterOptions(this.config);
+    const loader = generateCssAfterLoader(options);
+    return html.replace(/<\/head>/i, `${loader}
+</head>`);
+  }
+  /**
+   * Inject JS After loader at end of <body> (after __loadEntry)
+   */
+  injectJsAfter(html) {
+    const options = buildJsAfterOptions(this.config);
+    const loader = generateJsAfterLoader(options);
+    const loadEntryPattern = /(<script>__loadEntry\(\)<\/script>)/i;
+    if (loadEntryPattern.test(html)) {
+      return html.replace(loadEntryPattern, `$1
+${loader}`);
+    }
+    return html.replace(/<\/body>/i, `${loader}
+</body>`);
+  }
+};
+var ManifestUpdater = class {
+  config;
+  parser;
+  builder;
+  constructor(config) {
+    this.config = config;
+    this.parser = new fastXmlParser.XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      preserveOrder: false,
+      parseAttributeValue: false,
+      trimValues: true
+    });
+    this.builder = new fastXmlParser.XMLBuilder({
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      format: true,
+      indentBy: "  ",
+      suppressEmptyNode: true
+    });
+  }
+  /**
+   * Update manifest files based on package format
+   */
+  update(zip, format, paths) {
+    const modified = [];
+    switch (format) {
+      case "scorm12":
+      case "scorm2004-3":
+      case "scorm2004-4":
+        modified.push(...this.updateImsManifest(zip, paths));
+        break;
+      case "cmi5":
+        modified.push(...this.updateImsManifest(zip, paths));
+        break;
+      case "xapi":
+        break;
+      case "aicc":
+        const aiccManifest = zip.getEntry("imsmanifest.xml");
+        if (aiccManifest) {
+          modified.push(...this.updateImsManifest(zip, paths));
+        }
+        break;
+    }
+    return modified;
+  }
+  /**
+   * Update imsmanifest.xml to include new file references
+   */
+  updateImsManifest(zip, paths) {
+    const entry = zip.getEntry("imsmanifest.xml");
+    if (!entry) {
+      return [];
+    }
+    try {
+      const xmlContent = entry.getData().toString("utf-8");
+      const parsed = this.parser.parse(xmlContent);
+      this.addFilesToManifest(parsed, paths);
+      const xmlDeclaration = this.extractXmlDeclaration(xmlContent);
+      const updatedXml = xmlDeclaration + this.builder.build(parsed);
+      zip.updateFile("imsmanifest.xml", Buffer.from(updatedXml, "utf-8"));
+      return ["imsmanifest.xml"];
+    } catch (error) {
+      console.error("[Patch-Adams] Failed to update imsmanifest.xml:", error);
+      return [];
+    }
+  }
+  /**
+   * Extract XML declaration from original content
+   */
+  extractXmlDeclaration(xml) {
+    const match = xml.match(/<\?xml[^?]*\?>/);
+    return match ? match[0] + "\n" : '<?xml version="1.0" encoding="UTF-8"?>\n';
+  }
+  /**
+   * Add file entries to the manifest
+   */
+  addFilesToManifest(parsed, paths) {
+    const manifest = parsed.manifest;
+    if (!manifest) return;
+    const resources = manifest.resources;
+    if (!resources) return;
+    let resource = resources.resource;
+    if (!resource) return;
+    if (Array.isArray(resource)) {
+      resource = resource[0];
+    }
+    if (!resource.file) {
+      resource.file = [];
+    }
+    let files = resource.file;
+    if (!Array.isArray(files)) {
+      files = [files];
+      resource.file = files;
+    }
+    const filesToAdd = [
+      paths.cssBefore,
+      paths.cssAfter,
+      paths.jsBefore,
+      paths.jsAfter
+    ].filter(Boolean);
+    for (const filePath of filesToAdd) {
+      const exists = files.some((f) => f["@_href"] === filePath);
+      if (!exists) {
+        files.push({ "@_href": filePath });
+      }
+    }
+  }
+  /**
+   * Get the file paths that will be added to the package
+   */
+  getFilePaths() {
+    const paths = {};
+    if (this.config.cssBefore.enabled) {
+      paths.cssBefore = `scormcontent/${this.config.localFolders.css}/${this.config.cssBefore.filename}`;
+    }
+    if (this.config.cssAfter.enabled) {
+      paths.cssAfter = `scormcontent/${this.config.localFolders.css}/${this.config.cssAfter.filename}`;
+    }
+    if (this.config.jsBefore.enabled) {
+      paths.jsBefore = `scormcontent/${this.config.localFolders.js}/${this.config.jsBefore.filename}`;
+    }
+    if (this.config.jsAfter.enabled) {
+      paths.jsAfter = `scormcontent/${this.config.localFolders.js}/${this.config.jsAfter.filename}`;
+    }
+    return paths;
+  }
+};
+// src/detectors/format-detector.ts
+var FormatDetector = class {
+  /**
+   * Detect the package format from a ZIP file
+   */
+  detect(zip) {
+    if (zip.getEntry("cmi5.xml")) {
+      return "cmi5";
+    }
+    if (zip.getEntry("tincan.xml")) {
+      return "xapi";
+    }
+    const manifest = zip.getEntry("imsmanifest.xml");
+    if (manifest) {
+      const content = manifest.getData().toString("utf-8");
+      return this.detectScormVersion(content);
+    }
+    if (this.hasAiccFiles(zip)) {
+      return "aicc";
+    }
+    return "unknown";
+  }
+  /**
+   * Detect SCORM version from manifest content
+   */
+  detectScormVersion(content) {
+    if (content.includes("4th Edition") || content.includes("CAM 1.4")) {
+      return "scorm2004-4";
+    }
+    if (content.includes("3rd Edition") || content.includes("2004 3rd") || content.includes("adlcp_v1p3")) {
+      return "scorm2004-3";
+    }
+    if (content.includes("2004") && content.includes("adlseq")) {
+      return "scorm2004-3";
+    }
+    if (content.includes("1.2") || content.includes("adlcp_rootv1p2") || content.includes("imscp_rootv1p1p2")) {
+      return "scorm12";
+    }
+    if (content.toLowerCase().includes("aicc")) {
+      return "aicc";
+    }
+    return "scorm12";
+  }
+  /**
+   * Check for AICC-specific files
+   */
+  hasAiccFiles(zip) {
+    const aiccExtensions = [".crs", ".au", ".des", ".cst"];
+    const entries = zip.getEntries();
+    for (const entry of entries) {
+      const name = entry.entryName.toLowerCase();
+      if (aiccExtensions.some((ext) => name.endsWith(ext))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get a human-readable format name
+   */
+  getFormatDisplayName(format) {
+    const names = {
+      scorm12: "SCORM 1.2",
+      "scorm2004-3": "SCORM 2004 3rd Edition",
+      "scorm2004-4": "SCORM 2004 4th Edition",
+      cmi5: "cmi5",
+      xapi: "xAPI (Tin Can)",
+      aicc: "AICC",
+      unknown: "Unknown"
+    };
+    return names[format];
+  }
+};
+// src/patcher/index.ts
+var DEFAULT_CSS_BEFORE = `/* Patch-Adams: CSS Before (blocking)
+ * This file loads at the start of <head> and blocks rendering.
+ * Use it to hide content and prevent flash of unstyled content.
+ *
+ * Example:
+ * html.pa-patched.pa-loading body {
+ *   visibility: hidden !important;
+ * }
+ */
+`;
+var DEFAULT_CSS_AFTER = `/* Patch-Adams: CSS After (async)
+ * This file loads at the end of <head> with remote fallback.
+ * Use it for style overrides that take precedence over Rise styles.
+ *
+ * Example:
+ * html.pa-patched .blocks-text {
+ *   font-family: 'Your Font', sans-serif !important;
+ * }
+ */
+`;
+var DEFAULT_JS_BEFORE = `// Patch-Adams: JS Before (blocking)
+// This file loads at the start of <head> and blocks rendering.
+// Use it for setup, API interception, and preparing globals.
+//
+// Example:
+// window.PatchAdams.customConfig = {
+//   theme: 'dark',
+//   analytics: true
+// };
+console.log('[Patch-Adams] JS Before loaded');
+`;
+var DEFAULT_JS_AFTER = `// Patch-Adams: JS After (async)
+// This file loads at the end of <body> with remote fallback.
+// Use it for DOM manipulation after Rise has initialized.
+//
+// IMPORTANT: This script should NOT remove the loading class.
+// The loader script handles that automatically after this script loads.
+//
+// Example:
+// document.querySelectorAll('.blocks-text').forEach(function(el) {
+//   // Your modifications here
+// });
+console.log('[Patch-Adams] JS After loaded');
+`;
+var Patcher = class {
+  config;
+  htmlInjector;
+  manifestUpdater;
+  formatDetector;
+  constructor(config) {
+    this.config = config;
+    this.htmlInjector = new HtmlInjector(config);
+    this.manifestUpdater = new ManifestUpdater(config);
+    this.formatDetector = new FormatDetector();
+  }
+  /**
+   * Patch a Rise course ZIP file
+   * @param inputBuffer - Input ZIP file as Buffer
+   * @param options - Additional patching options
+   * @returns Patched ZIP file as Buffer and result details
+   */
+  async patch(inputBuffer, options = {}) {
+    const result = {
+      success: false,
+      format: "unknown",
+      formatDisplayName: "Unknown",
+      filesModified: [],
+      filesAdded: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const zip = new AdmZip__default.default(inputBuffer);
+      result.format = this.formatDetector.detect(zip);
+      result.formatDisplayName = this.formatDetector.getFormatDisplayName(result.format);
+      if (result.format === "unknown") {
+        result.warnings.push("Could not determine package format, proceeding anyway");
+      }
+      const indexHtmlEntry = zip.getEntry("scormcontent/index.html");
+      if (!indexHtmlEntry) {
+        throw new Error("Could not find scormcontent/index.html in package. Is this a valid Rise export?");
+      }
+      const originalHtml = indexHtmlEntry.getData().toString("utf-8");
+      const patchedHtml = this.htmlInjector.inject(originalHtml);
+      zip.updateFile("scormcontent/index.html", Buffer.from(patchedHtml, "utf-8"));
+      result.filesModified.push("scormcontent/index.html");
+      const addedFiles = this.addFallbackFiles(zip, options);
+      result.filesAdded.push(...addedFiles);
+      if (this.config.updateManifests) {
+        const manifestPaths = this.manifestUpdater.getFilePaths();
+        const modifiedManifests = this.manifestUpdater.update(zip, result.format, manifestPaths);
+        result.filesModified.push(...modifiedManifests);
+      }
+      const outputBuffer = await this.writeZipWithYazl(zip);
+      result.success = true;
+      return { buffer: outputBuffer, result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors.push(message);
+      throw error;
+    }
+  }
+  /**
+   * Write ZIP using yazl for better compatibility
+   * adm-zip's toBuffer() sets the data descriptor bit flag which causes
+   * issues with some ZIP parsers. yazl produces standard ZIP output.
+   */
+  writeZipWithYazl(admZip) {
+    return new Promise((resolve2, reject) => {
+      const zipFile = new yazl__default.default.ZipFile();
+      const entries = admZip.getEntries();
+      for (const entry of entries) {
+        const entryName = entry.entryName;
+        const mtime = entry.header.time ? new Date(entry.header.time) : /* @__PURE__ */ new Date();
+        if (entry.isDirectory) {
+          zipFile.addEmptyDirectory(entryName, { mtime });
+          continue;
+        }
+        const entryData = entry.getData();
+        zipFile.addBuffer(entryData, entryName, {
+          compress: true,
+          mtime
+        });
+      }
+      const chunks = [];
+      zipFile.outputStream.on("data", (chunk) => chunks.push(chunk));
+      zipFile.outputStream.on("end", () => resolve2(Buffer.concat(chunks)));
+      zipFile.outputStream.on("error", reject);
+      zipFile.end();
+    });
+  }
+  /**
+   * Add local fallback files to the ZIP
+   */
+  addFallbackFiles(zip, options) {
+    const added = [];
+    const cssFolder = `scormcontent/${this.config.localFolders.css}`;
+    const jsFolder = `scormcontent/${this.config.localFolders.js}`;
+    if (this.config.cssBefore.enabled) {
+      const path = `${cssFolder}/${this.config.cssBefore.filename}`;
+      const content = options.cssBeforeContent ?? DEFAULT_CSS_BEFORE;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    if (this.config.cssAfter.enabled) {
+      const path = `${cssFolder}/${this.config.cssAfter.filename}`;
+      const content = options.cssAfterContent ?? DEFAULT_CSS_AFTER;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    if (this.config.jsBefore.enabled) {
+      const path = `${jsFolder}/${this.config.jsBefore.filename}`;
+      const content = options.jsBeforeContent ?? DEFAULT_JS_BEFORE;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    if (this.config.jsAfter.enabled) {
+      const path = `${jsFolder}/${this.config.jsAfter.filename}`;
+      const content = options.jsAfterContent ?? DEFAULT_JS_AFTER;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    return added;
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Convenience method to patch a buffer and return only the patched buffer.
+   * Used by package-uploader integration.
+   * @param buffer - Input ZIP file as Buffer
+   * @returns Patched ZIP file as Buffer
+   */
+  async patchBuffer(buffer) {
+    console.log(`[Patcher] patchBuffer called with ${buffer.length} bytes`);
+    const { buffer: patchedBuffer, result } = await this.patch(buffer);
+    console.log(`[Patcher] Patch result:`, JSON.stringify(result, null, 2));
+    console.log(`[Patcher] Returning ${patchedBuffer.length} bytes`);
+    return patchedBuffer;
+  }
+};
+var Logger = class {
+  level;
+  constructor(level = "info") {
+    this.level = level;
+  }
+  shouldLog(level) {
+    const levels = ["debug", "info", "warn", "error", "silent"];
+    return levels.indexOf(level) >= levels.indexOf(this.level);
+  }
+  debug(...args) {
+    if (this.shouldLog("debug")) {
+      console.log(chalk__default.default.gray("[DEBUG]"), ...args);
+    }
+  }
+  info(...args) {
+    if (this.shouldLog("info")) {
+      console.log(chalk__default.default.blue("[INFO]"), ...args);
+    }
+  }
+  success(...args) {
+    if (this.shouldLog("info")) {
+      console.log(chalk__default.default.green("[SUCCESS]"), ...args);
+    }
+  }
+  warn(...args) {
+    if (this.shouldLog("warn")) {
+      console.log(chalk__default.default.yellow("[WARN]"), ...args);
+    }
+  }
+  error(...args) {
+    if (this.shouldLog("error")) {
+      console.error(chalk__default.default.red("[ERROR]"), ...args);
+    }
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+};
+exports.AsyncAssetConfigSchema = AsyncAssetConfigSchema;
+exports.BlockingAssetConfigSchema = BlockingAssetConfigSchema;
+exports.FormatDetector = FormatDetector;
+exports.HtmlInjector = HtmlInjector;
+exports.LocalFoldersConfigSchema = LocalFoldersConfigSchema;
+exports.Logger = Logger;
+exports.ManifestUpdater = ManifestUpdater;
+exports.PatchAdamsConfigSchema = PatchAdamsConfigSchema;
+exports.Patcher = Patcher;
+exports.defaultConfig = defaultConfig;
+exports.generateConfigTemplate = generateConfigTemplate;
+exports.generateCssAfterLoader = generateCssAfterLoader;
+exports.generateCssBeforeLoader = generateCssBeforeLoader;
+exports.generateJsAfterLoader = generateJsAfterLoader;
+exports.generateJsBeforeLoader = generateJsBeforeLoader;
+exports.loadConfig = loadConfig;
+exports.mergeWithDefaults = mergeWithDefaults;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map