@universal-pwa/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1368 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ManifestSchema: () => ManifestSchema,
+  STANDARD_ICON_SIZES: () => STANDARD_ICON_SIZES,
+  STANDARD_SPLASH_SIZES: () => STANDARD_SPLASH_SIZES,
+  checkHttps: () => checkHttps,
+  checkProjectHttps: () => checkProjectHttps,
+  detectArchitecture: () => detectArchitecture,
+  detectAssets: () => detectAssets,
+  detectFramework: () => detectFramework,
+  detectProjectUrl: () => detectProjectUrl,
+  elementExists: () => elementExists,
+  findAllElements: () => findAllElements,
+  findElement: () => findElement,
+  generateAndWriteManifest: () => generateAndWriteManifest,
+  generateAndWriteServiceWorker: () => generateAndWriteServiceWorker,
+  generateAppleTouchIcon: () => generateAppleTouchIcon,
+  generateFavicon: () => generateFavicon,
+  generateIcons: () => generateIcons,
+  generateIconsOnly: () => generateIconsOnly,
+  generateManifest: () => generateManifest,
+  generateReport: () => generateReport,
+  generateServiceWorker: () => generateServiceWorker,
+  generateSimpleServiceWorker: () => generateSimpleServiceWorker,
+  generateSplashScreensOnly: () => generateSplashScreensOnly,
+  injectMetaTags: () => injectMetaTags,
+  injectMetaTagsInFile: () => injectMetaTagsInFile,
+  parseHTML: () => parseHTML,
+  parseHTMLFile: () => parseHTMLFile,
+  scanProject: () => scanProject,
+  serializeHTML: () => serializeHTML,
+  validateProjectPath: () => validateProjectPath,
+  writeManifest: () => writeManifest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/scanner/index.ts
+var import_fs4 = require("fs");
+
+// src/scanner/framework-detector.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function detectFramework(projectPath) {
+  const indicators = [];
+  let framework = null;
+  let confidence = "low";
+  if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "wp-config.php"))) {
+    indicators.push("wp-config.php");
+    if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "wp-content"))) {
+      indicators.push("wp-content/");
+      framework = "wordpress";
+      confidence = "high";
+      return { framework, confidence, indicators };
+    }
+  }
+  const composerPath = (0, import_path.join)(projectPath, "composer.json");
+  if ((0, import_fs.existsSync)(composerPath)) {
+    try {
+      const composerContent = JSON.parse((0, import_fs.readFileSync)(composerPath, "utf-8"));
+      const dependencies = {
+        ...composerContent.require ?? {},
+        ...composerContent["require-dev"] ?? {}
+      };
+      if (dependencies["symfony/symfony"] || dependencies["symfony/framework-bundle"]) {
+        indicators.push("composer.json: symfony/*");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "public"))) {
+          indicators.push("public/");
+          framework = "symfony";
+          confidence = "high";
+          return { framework, confidence, indicators };
+        }
+      }
+      if (dependencies["laravel/framework"]) {
+        indicators.push("composer.json: laravel/framework");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, "public"))) {
+          indicators.push("public/");
+          framework = "laravel";
+          confidence = "high";
+          return { framework, confidence, indicators };
+        }
+      }
+    } catch {
+    }
+  }
+  const packageJsonPath = (0, import_path.join)(projectPath, "package.json");
+  if ((0, import_fs.existsSync)(packageJsonPath)) {
+    try {
+      const packageContent = JSON.parse((0, import_fs.readFileSync)(packageJsonPath, "utf-8"));
+      const dependencies = {
+        ...packageContent.dependencies ?? {},
+        ...packageContent.devDependencies ?? {}
+      };
+      if (dependencies.next) {
+        indicators.push("package.json: next");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, ".next"))) {
+          indicators.push(".next/");
+          framework = "nextjs";
+          confidence = "high";
+          return { framework, confidence, indicators };
+        }
+      }
+      if (dependencies.nuxt) {
+        indicators.push("package.json: nuxt");
+        if ((0, import_fs.existsSync)((0, import_path.join)(projectPath, ".nuxt"))) {
+          indicators.push(".nuxt/");
+          framework = "nuxt";
+          confidence = "high";
+          return { framework, confidence, indicators };
+        }
+      }
+      if (dependencies.react) {
+        indicators.push("package.json: react");
+        framework = "react";
+        confidence = framework ? "high" : "medium";
+      }
+      if (dependencies.vue) {
+        indicators.push("package.json: vue");
+        if (!framework) {
+          framework = "vue";
+          confidence = "high";
+        }
+      }
+      if (dependencies["@angular/core"]) {
+        indicators.push("package.json: @angular/core");
+        if (!framework) {
+          framework = "angular";
+          confidence = "high";
+        }
+      }
+    } catch {
+    }
+  }
+  if (!framework) {
+    const htmlFiles = ["index.html", "index.htm"];
+    const hasHtml = htmlFiles.some((file) => (0, import_fs.existsSync)((0, import_path.join)(projectPath, file)));
+    if (hasHtml) {
+      indicators.push("HTML files present");
+      framework = "static";
+      confidence = "medium";
+    }
+  }
+  return { framework, confidence, indicators };
+}
+
+// src/scanner/asset-detector.ts
+var import_glob = require("glob");
+var import_path2 = require("path");
+var import_fs2 = require("fs");
+var IGNORED_PATTERNS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/build/**",
+  "**/coverage/**"
+];
+var JS_EXTENSIONS = [".js", ".mjs", ".ts", ".tsx", ".jsx"];
+var CSS_EXTENSIONS = [".css", ".scss", ".sass", ".less"];
+var IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".svg", ".webp", ".gif", ".ico"];
+var FONT_EXTENSIONS = [".woff", ".woff2", ".ttf", ".otf", ".eot"];
+var API_PATTERNS = [
+  "/api/**",
+  "/graphql",
+  "/rest/**",
+  "/v1/**",
+  "/v2/**"
+];
+async function detectAssets(projectPath) {
+  const result = {
+    javascript: [],
+    css: [],
+    images: [],
+    fonts: [],
+    apiRoutes: []
+  };
+  const jsExtensionsStr = JS_EXTENSIONS.map((ext) => ext.slice(1)).join(",");
+  const jsPattern = `**/*.{${jsExtensionsStr}}`;
+  const jsRootPattern = `*.{${jsExtensionsStr}}`;
+  const [jsFiles, jsRootFiles] = await Promise.all([
+    (0, import_glob.glob)(jsPattern, {
+      cwd: projectPath,
+      ignore: IGNORED_PATTERNS,
+      absolute: true,
+      nodir: true
+    }),
+    (0, import_glob.glob)(jsRootPattern, {
+      cwd: projectPath,
+      ignore: IGNORED_PATTERNS,
+      absolute: true,
+      nodir: true
+    })
+  ]);
+  const allJsFiles = /* @__PURE__ */ new Set([...jsFiles, ...jsRootFiles]);
+  result.javascript.push(...allJsFiles);
+  const cssExtensionsStr = CSS_EXTENSIONS.map((ext) => ext.slice(1)).join(",");
+  const cssPattern = `**/*.{${cssExtensionsStr}}`;
+  const cssFiles = await (0, import_glob.glob)(cssPattern, {
+    cwd: projectPath,
+    ignore: IGNORED_PATTERNS,
+    absolute: false,
+    nodir: true
+  });
+  const cssRootPattern = `*.{${cssExtensionsStr}}`;
+  const cssRootFiles = await (0, import_glob.glob)(cssRootPattern, {
+    cwd: projectPath,
+    ignore: IGNORED_PATTERNS,
+    absolute: false,
+    nodir: true
+  });
+  const allCssFiles = [.../* @__PURE__ */ new Set([...cssFiles, ...cssRootFiles])];
+  result.css.push(...allCssFiles.map((f) => (0, import_path2.join)(projectPath, f)));
+  const imagePatterns = IMAGE_EXTENSIONS.flatMap((ext) => [`**/*${ext}`, `*${ext}`]);
+  const allImageFiles = /* @__PURE__ */ new Set();
+  for (const pattern of imagePatterns) {
+    const files = await (0, import_glob.glob)(pattern, {
+      cwd: projectPath,
+      ignore: IGNORED_PATTERNS,
+      absolute: false,
+      nodir: true
+    });
+    files.forEach((f) => allImageFiles.add(f));
+  }
+  result.images.push(...Array.from(allImageFiles).map((f) => (0, import_path2.join)(projectPath, f)));
+  const fontPatterns = FONT_EXTENSIONS.flatMap((ext) => [`**/*${ext}`, `*${ext}`]);
+  const allFontFiles = /* @__PURE__ */ new Set();
+  for (const pattern of fontPatterns) {
+    const files = await (0, import_glob.glob)(pattern, {
+      cwd: projectPath,
+      ignore: IGNORED_PATTERNS,
+      absolute: false,
+      nodir: true
+    });
+    files.forEach((f) => allFontFiles.add(f));
+  }
+  result.fonts.push(...Array.from(allFontFiles).map((f) => (0, import_path2.join)(projectPath, f)));
+  const routeFiles = await (0, import_glob.glob)(`**/*{route,api,graphql}*.{js,ts,json}`, {
+    cwd: projectPath,
+    ignore: IGNORED_PATTERNS,
+    absolute: false,
+    nodir: true
+  });
+  if (routeFiles.length > 0) {
+    result.apiRoutes.push(...API_PATTERNS);
+  }
+  result.javascript = result.javascript.filter((f) => {
+    try {
+      return (0, import_fs2.statSync)(f).isFile();
+    } catch {
+      return false;
+    }
+  });
+  result.css = result.css.filter((f) => {
+    try {
+      return (0, import_fs2.statSync)(f).isFile();
+    } catch {
+      return false;
+    }
+  });
+  result.images = result.images.filter((f) => {
+    try {
+      return (0, import_fs2.statSync)(f).isFile();
+    } catch {
+      return false;
+    }
+  });
+  result.fonts = result.fonts.filter((f) => {
+    try {
+      return (0, import_fs2.statSync)(f).isFile();
+    } catch {
+      return false;
+    }
+  });
+  return result;
+}
+
+// src/scanner/architecture-detector.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_glob2 = require("glob");
+async function detectArchitecture(projectPath) {
+  const indicators = [];
+  let architecture = "static";
+  let buildTool = null;
+  let confidence = "low";
+  const packageJsonPath = (0, import_path3.join)(projectPath, "package.json");
+  if ((0, import_fs3.existsSync)(packageJsonPath)) {
+    try {
+      const packageContent = JSON.parse((0, import_fs3.readFileSync)(packageJsonPath, "utf-8"));
+      const dependencies = {
+        ...packageContent.dependencies ?? {},
+        ...packageContent.devDependencies ?? {}
+      };
+      if (dependencies.vite || packageContent.devDependencies?.["vite"]) {
+        indicators.push("package.json: vite");
+        buildTool = "vite";
+        confidence = "high";
+      } else if (dependencies.webpack || packageContent.devDependencies?.["webpack"]) {
+        indicators.push("package.json: webpack");
+        buildTool = "webpack";
+        confidence = "high";
+      } else if (dependencies.rollup || packageContent.devDependencies?.["rollup"]) {
+        indicators.push("package.json: rollup");
+        buildTool = "rollup";
+        confidence = "high";
+      } else if (dependencies.esbuild || packageContent.devDependencies?.["esbuild"]) {
+        indicators.push("package.json: esbuild");
+        buildTool = "esbuild";
+        confidence = "high";
+      } else if (dependencies.parcel || packageContent.devDependencies?.["parcel"]) {
+        indicators.push("package.json: parcel");
+        buildTool = "parcel";
+        confidence = "high";
+      } else if (dependencies["@turbo/gen"] || packageContent.devDependencies?.["@turbo/gen"]) {
+        indicators.push("package.json: turbopack");
+        buildTool = "turbopack";
+        confidence = "high";
+      }
+      if (dependencies.next || packageContent.dependencies?.["next"] || packageContent.devDependencies?.["next"]) {
+        architecture = "ssr";
+        confidence = "high";
+        indicators.push("Next.js detected \u2192 SSR");
+      } else if (dependencies.nuxt || packageContent.dependencies?.["nuxt"] || packageContent.devDependencies?.["nuxt"]) {
+        architecture = "ssr";
+        confidence = "high";
+        indicators.push("Nuxt detected \u2192 SSR");
+      }
+    } catch {
+    }
+  }
+  const htmlPatterns = ["**/*.html", "*.html", "index.html"];
+  const allHtmlFiles = /* @__PURE__ */ new Set();
+  for (const pattern of htmlPatterns) {
+    const files = await (0, import_glob2.glob)(pattern, {
+      cwd: projectPath,
+      ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**"],
+      absolute: false,
+      nodir: true
+    });
+    files.forEach((f) => allHtmlFiles.add(f));
+  }
+  if (allHtmlFiles.size > 0 && architecture !== "ssr") {
+    const htmlArray = Array.from(allHtmlFiles);
+    const firstHtml = htmlArray.find((f) => f === "index.html" || f.endsWith("/index.html")) || htmlArray[0];
+    const htmlPath = (0, import_path3.join)(projectPath, firstHtml);
+    try {
+      const htmlContent = (0, import_fs3.readFileSync)(htmlPath, "utf-8").toLowerCase();
+      const spaPatterns = [
+        /<div[^>]*id=["']root["']/i,
+        /<div[^>]*id=["']app["']/i,
+        /<div[^>]*id=["']main["']/i,
+        /react-dom/i,
+        /mount\(/i,
+        /createRoot\(/i
+      ];
+      const ssrPatterns = [
+        /<body[^>]*>[\s\S]{100,}/i,
+        // Body avec beaucoup de contenu
+        /<article/i,
+        /<main[^>]*>[\s\S]{50,}/i,
+        /hydrat/i,
+        /__next/i,
+        /__next_data__/i,
+        /nuxt/i
+      ];
+      const hasSpaPattern = spaPatterns.some((pattern) => pattern.test(htmlContent));
+      const hasSsrPattern = ssrPatterns.some((pattern) => pattern.test(htmlContent));
+      const isLargeContent = htmlContent.length > 2e3;
+      const hasRealContent = htmlContent.replace(/<[^>]+>/g, "").trim().length > 100;
+      if (isLargeContent && hasRealContent && !hasSsrPattern) {
+        indicators.push("HTML: very large content with real text \u2192 SSR");
+        if (hasSpaPattern) {
+          indicators.push("HTML: SPA pattern but large content \u2192 SSR");
+        }
+        architecture = "ssr";
+        confidence = "high";
+      } else if (hasSsrPattern && htmlContent.length > 1e3) {
+        indicators.push("HTML: SSR patterns detected (large content)");
+        if (isLargeContent && hasRealContent) {
+          indicators.push("HTML: very large content with real text \u2192 SSR");
+        }
+        if (hasSpaPattern) {
+          indicators.push("HTML: SPA pattern but large content \u2192 SSR");
+        }
+        architecture = "ssr";
+        confidence = "high";
+      } else if (hasSsrPattern && !hasSpaPattern) {
+        indicators.push("HTML: SSR patterns detected");
+        if (htmlContent.length > 500) {
+          indicators.push("HTML: large content");
+        }
+        architecture = "ssr";
+        confidence = "high";
+      } else if (hasSpaPattern) {
+        if (isLargeContent && hasRealContent) {
+          indicators.push("HTML: SPA pattern but large content \u2192 SSR");
+          architecture = "ssr";
+          confidence = "medium";
+        } else {
+          indicators.push("HTML: SPA patterns detected");
+          architecture = "spa";
+          confidence = "high";
+        }
+      } else if (htmlContent.length > 500) {
+        indicators.push("HTML: large content");
+        architecture = "ssr";
+        confidence = "medium";
+      } else {
+        indicators.push("HTML: minimal content");
+        architecture = "static";
+        confidence = "medium";
+      }
+    } catch {
+    }
+  }
+  const jsFiles = await (0, import_glob2.glob)("**/*.{js,ts,tsx,jsx}", {
+    cwd: projectPath,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.next/**", "**/.nuxt/**", "**/*.test.*", "**/*.spec.*"],
+    absolute: false,
+    nodir: true
+  });
+  if (jsFiles.length > 0 && architecture === "static") {
+    let routerFilesFound = 0;
+    for (const jsFile of jsFiles.slice(0, 10)) {
+      try {
+        const jsPath = (0, import_path3.join)(projectPath, jsFile);
+        const jsContent = (0, import_fs3.readFileSync)(jsPath, "utf-8").toLowerCase();
+        const routerPatterns = [
+          /react-router/i,
+          /vue-router/i,
+          /@angular\/router/i,
+          /next\/router/i,
+          /nuxt/i,
+          /createBrowserRouter/i,
+          /BrowserRouter/i,
+          /Router/i
+        ];
+        if (routerPatterns.some((pattern) => pattern.test(jsContent))) {
+          routerFilesFound++;
+        }
+      } catch {
+      }
+    }
+    if (routerFilesFound > 0) {
+      indicators.push(`JS: router patterns found (${routerFilesFound} files)`);
+      if (architecture === "static") {
+        architecture = "spa";
+        confidence = confidence === "low" ? "medium" : confidence;
+      }
+    }
+  }
+  return { architecture, buildTool, confidence, indicators };
+}
+
+// src/scanner/index.ts
+async function scanProject(options) {
+  const { projectPath, includeAssets = true, includeArchitecture = true } = options;
+  const frameworkCandidate = detectFramework(projectPath);
+  const framework = isFrameworkDetectionResult(frameworkCandidate) ? frameworkCandidate : { framework: null, confidence: "low", indicators: [] };
+  const assetsCandidate = includeAssets ? await detectAssets(projectPath) : getEmptyAssets();
+  const assets = isAssetDetectionResult(assetsCandidate) ? assetsCandidate : getEmptyAssets();
+  const architectureCandidate = includeArchitecture ? await detectArchitecture(projectPath) : getEmptyArchitecture();
+  const architecture = isArchitectureDetectionResult(architectureCandidate) ? architectureCandidate : getEmptyArchitecture();
+  return {
+    framework,
+    assets,
+    architecture,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    projectPath
+  };
+}
+function generateReport(result) {
+  return JSON.stringify(result, null, 2);
+}
+function validateProjectPath(projectPath) {
+  try {
+    return (0, import_fs4.existsSync)(projectPath);
+  } catch {
+    return false;
+  }
+}
+function isFrameworkDetectionResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return (v.framework === null || typeof v.framework === "string") && (v.confidence === "low" || v.confidence === "medium" || v.confidence === "high") && Array.isArray(v.indicators);
+}
+function isAssetDetectionResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  const isStringArray = (x) => Array.isArray(x) && x.every((i) => typeof i === "string");
+  return isStringArray(v.javascript) && isStringArray(v.css) && isStringArray(v.images) && isStringArray(v.fonts) && isStringArray(v.apiRoutes);
+}
+function isArchitectureDetectionResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  const isArch = v.architecture === "spa" || v.architecture === "ssr" || v.architecture === "static";
+  const isBuildTool = v.buildTool === null || v.buildTool === "vite" || v.buildTool === "webpack" || v.buildTool === "rollup";
+  const isConfidence = v.confidence === "low" || v.confidence === "medium" || v.confidence === "high";
+  return isArch && isBuildTool && isConfidence && Array.isArray(v.indicators);
+}
+function getEmptyAssets() {
+  return {
+    javascript: [],
+    css: [],
+    images: [],
+    fonts: [],
+    apiRoutes: []
+  };
+}
+function getEmptyArchitecture() {
+  return {
+    architecture: "static",
+    buildTool: null,
+    confidence: "low",
+    indicators: []
+  };
+}
+
+// src/generator/manifest-generator.ts
+var import_zod = require("zod");
+var import_fs5 = require("fs");
+var import_path4 = require("path");
+var ManifestIconSchema = import_zod.z.object({
+  src: import_zod.z.string(),
+  sizes: import_zod.z.string(),
+  type: import_zod.z.string().optional(),
+  purpose: import_zod.z.string().optional()
+});
+var ManifestSplashScreenSchema = import_zod.z.object({
+  src: import_zod.z.string(),
+  sizes: import_zod.z.string(),
+  type: import_zod.z.string().optional()
+});
+var ManifestSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1),
+  short_name: import_zod.z.string().min(1).max(12),
+  description: import_zod.z.string().optional(),
+  start_url: import_zod.z.string().default("/"),
+  scope: import_zod.z.string().default("/"),
+  display: import_zod.z.enum(["standalone", "fullscreen", "minimal-ui", "browser"]).default("standalone"),
+  orientation: import_zod.z.enum(["any", "portrait", "landscape"]).optional(),
+  theme_color: import_zod.z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+  background_color: import_zod.z.string().regex(/^#[0-9A-Fa-f]{6}$/).optional(),
+  icons: import_zod.z.array(ManifestIconSchema).min(1),
+  splash_screens: import_zod.z.array(ManifestSplashScreenSchema).optional(),
+  categories: import_zod.z.array(import_zod.z.string()).optional(),
+  lang: import_zod.z.string().optional(),
+  dir: import_zod.z.enum(["ltr", "rtl", "auto"]).optional(),
+  prefer_related_applications: import_zod.z.boolean().optional(),
+  related_applications: import_zod.z.array(import_zod.z.unknown()).optional()
+});
+function generateManifest(options) {
+  const manifest = {
+    name: options.name,
+    short_name: options.shortName,
+    start_url: options.startUrl ?? "/",
+    scope: options.scope ?? "/",
+    display: options.display ?? "standalone",
+    icons: options.icons
+  };
+  if (options.description) {
+    manifest.description = options.description;
+  }
+  if (options.orientation) {
+    manifest.orientation = options.orientation;
+  }
+  if (options.themeColor) {
+    manifest.theme_color = options.themeColor;
+  }
+  if (options.backgroundColor) {
+    manifest.background_color = options.backgroundColor;
+  }
+  if (options.splashScreens && options.splashScreens.length > 0) {
+    manifest.splash_screens = options.splashScreens;
+  }
+  if (options.categories && options.categories.length > 0) {
+    manifest.categories = options.categories;
+  }
+  if (options.lang) {
+    manifest.lang = options.lang;
+  }
+  if (options.dir) {
+    manifest.dir = options.dir;
+  }
+  if (options.preferRelatedApplications !== void 0) {
+    manifest.prefer_related_applications = options.preferRelatedApplications;
+  }
+  if (options.relatedApplications && options.relatedApplications.length > 0) {
+    manifest.related_applications = options.relatedApplications;
+  }
+  return ManifestSchema.parse(manifest);
+}
+function writeManifest(manifest, outputDir) {
+  const manifestPath = (0, import_path4.join)(outputDir, "manifest.json");
+  const manifestJson = JSON.stringify(manifest, null, 2);
+  (0, import_fs5.writeFileSync)(manifestPath, manifestJson, "utf-8");
+  return manifestPath;
+}
+function generateAndWriteManifest(options, outputDir) {
+  const manifest = generateManifest(options);
+  return writeManifest(manifest, outputDir);
+}
+
+// src/generator/icon-generator.ts
+var import_sharp = __toESM(require("sharp"), 1);
+var import_fs6 = require("fs");
+var import_path5 = require("path");
+var STANDARD_ICON_SIZES = [
+  { width: 72, height: 72, name: "icon-72x72.png" },
+  { width: 96, height: 96, name: "icon-96x96.png" },
+  { width: 128, height: 128, name: "icon-128x128.png" },
+  { width: 144, height: 144, name: "icon-144x144.png" },
+  { width: 152, height: 152, name: "icon-152x152.png" },
+  { width: 192, height: 192, name: "icon-192x192.png" },
+  { width: 384, height: 384, name: "icon-384x384.png" },
+  { width: 512, height: 512, name: "icon-512x512.png" }
+];
+var STANDARD_SPLASH_SIZES = [
+  { width: 640, height: 1136, name: "splash-640x1136.png" },
+  // iPhone 5
+  { width: 750, height: 1334, name: "splash-750x1334.png" },
+  // iPhone 6/7/8
+  { width: 828, height: 1792, name: "splash-828x1792.png" },
+  // iPhone XR
+  { width: 1125, height: 2436, name: "splash-1125x2436.png" },
+  // iPhone X/XS
+  { width: 1242, height: 2688, name: "splash-1242x2688.png" },
+  // iPhone XS Max
+  { width: 1536, height: 2048, name: "splash-1536x2048.png" },
+  // iPad
+  { width: 2048, height: 2732, name: "splash-2048x2732.png" }
+  // iPad Pro
+];
+async function generateIcons(options) {
+  const {
+    sourceImage,
+    outputDir,
+    iconSizes = STANDARD_ICON_SIZES,
+    splashSizes = STANDARD_SPLASH_SIZES,
+    format = "png",
+    quality = 90
+  } = options;
+  if (!(0, import_fs6.existsSync)(sourceImage)) {
+    throw new Error(`Source image not found: ${sourceImage}`);
+  }
+  (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
+  const generatedFiles = [];
+  const icons = [];
+  const splashScreens = [];
+  const image = (0, import_sharp.default)(sourceImage);
+  const metadata = await image.metadata();
+  if (!metadata.width || !metadata.height) {
+    throw new Error("Unable to read image dimensions");
+  }
+  for (const size of iconSizes) {
+    const outputPath = (0, import_path5.join)(outputDir, size.name);
+    try {
+      let pipeline = image.clone().resize(size.width, size.height, {
+        fit: "cover",
+        position: "center"
+      });
+      if (format === "png") {
+        pipeline = pipeline.png({ quality, compressionLevel: 9 });
+      } else {
+        pipeline = pipeline.webp({ quality });
+      }
+      await pipeline.toFile(outputPath);
+      generatedFiles.push(outputPath);
+      icons.push({
+        src: `/${size.name}`,
+        sizes: `${size.width}x${size.height}`,
+        type: format === "png" ? "image/png" : "image/webp",
+        purpose: size.width >= 192 && size.width <= 512 ? "any" : void 0
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to generate icon ${size.name}: ${message}`);
+    }
+  }
+  for (const size of splashSizes) {
+    const outputPath = (0, import_path5.join)(outputDir, size.name);
+    try {
+      let pipeline = image.clone().resize(size.width, size.height, {
+        fit: "cover",
+        position: "center"
+      });
+      if (format === "png") {
+        pipeline = pipeline.png({ quality, compressionLevel: 9 });
+      } else {
+        pipeline = pipeline.webp({ quality });
+      }
+      await pipeline.toFile(outputPath);
+      generatedFiles.push(outputPath);
+      splashScreens.push({
+        src: `/${size.name}`,
+        sizes: `${size.width}x${size.height}`,
+        type: format === "png" ? "image/png" : "image/webp"
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to generate splash screen ${size.name}: ${message}`);
+    }
+  }
+  return {
+    icons,
+    splashScreens,
+    generatedFiles
+  };
+}
+async function generateIconsOnly(options) {
+  const result = await generateIcons({
+    ...options,
+    splashSizes: []
+  });
+  return {
+    icons: result.icons,
+    generatedFiles: result.generatedFiles
+  };
+}
+async function generateSplashScreensOnly(options) {
+  const result = await generateIcons({
+    ...options,
+    iconSizes: []
+  });
+  return {
+    splashScreens: result.splashScreens,
+    generatedFiles: result.generatedFiles
+  };
+}
+async function generateFavicon(sourceImage, outputDir) {
+  if (!(0, import_fs6.existsSync)(sourceImage)) {
+    throw new Error(`Source image not found: ${sourceImage}`);
+  }
+  (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
+  const faviconPath = (0, import_path5.join)(outputDir, "favicon.ico");
+  try {
+    await (0, import_sharp.default)(sourceImage).resize(32, 32, {
+      fit: "cover",
+      position: "center"
+    }).png().toFile(faviconPath);
+    return faviconPath;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to generate favicon: ${message}`);
+  }
+}
+async function generateAppleTouchIcon(sourceImage, outputDir) {
+  if (!(0, import_fs6.existsSync)(sourceImage)) {
+    throw new Error(`Source image not found: ${sourceImage}`);
+  }
+  (0, import_fs6.mkdirSync)(outputDir, { recursive: true });
+  const appleIconPath = (0, import_path5.join)(outputDir, "apple-touch-icon.png");
+  try {
+    await (0, import_sharp.default)(sourceImage).resize(180, 180, {
+      fit: "cover",
+      position: "center"
+    }).png({ quality: 90, compressionLevel: 9 }).toFile(appleIconPath);
+    return appleIconPath;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to generate apple-touch-icon: ${message}`);
+  }
+}
+
+// src/generator/service-worker-generator.ts
+var import_workbox_build = require("workbox-build");
+var import_fs7 = require("fs");
+var import_path6 = require("path");
+var import_templates = require("@universal-pwa/templates");
+async function generateServiceWorker(options) {
+  const {
+    projectPath,
+    outputDir,
+    architecture,
+    framework,
+    templateType,
+    globDirectory,
+    globPatterns = ["**/*.{js,css,html,png,jpg,jpeg,svg,webp,woff,woff2,ttf,otf}"],
+    swDest = "sw.js",
+    offlinePage
+  } = options;
+  (0, import_fs7.mkdirSync)(outputDir, { recursive: true });
+  const finalTemplateType = templateType ?? (0, import_templates.determineTemplateType)(architecture, framework ?? null);
+  const template = (0, import_templates.getServiceWorkerTemplate)(finalTemplateType);
+  const swSrcPath = (0, import_path6.join)(outputDir, "sw-src.js");
+  (0, import_fs7.writeFileSync)(swSrcPath, template.content, "utf-8");
+  const swDestPath = (0, import_path6.join)(outputDir, swDest);
+  const workboxConfig = {
+    globDirectory: globDirectory ?? projectPath,
+    globPatterns,
+    swDest: swDestPath,
+    swSrc: swSrcPath,
+    // Injection du manifest dans le template
+    injectionPoint: "self.__WB_MANIFEST"
+  };
+  if (offlinePage) {
+    workboxConfig.globPatterns = [...workboxConfig.globPatterns ?? [], offlinePage];
+  }
+  try {
+    const result = await (0, import_workbox_build.injectManifest)(workboxConfig);
+    try {
+      if ((0, import_fs7.existsSync)(swSrcPath)) {
+      }
+    } catch {
+    }
+    const resultFilePaths = result.filePaths ?? [];
+    const normalizedOffline = offlinePage ? offlinePage.replace(/^\.\//, "") : void 0;
+    const finalFilePaths = normalizedOffline && !resultFilePaths.some((p) => p.includes(normalizedOffline)) ? [...resultFilePaths, normalizedOffline] : resultFilePaths;
+    return {
+      swPath: swDestPath,
+      count: result.count,
+      size: result.size,
+      warnings: result.warnings ?? [],
+      filePaths: finalFilePaths
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to generate service worker: ${message}`);
+  }
+}
+async function generateSimpleServiceWorker(options) {
+  const {
+    projectPath,
+    outputDir,
+    globDirectory,
+    globPatterns = ["**/*.{js,css,html,png,jpg,jpeg,svg,webp,woff,woff2,ttf,otf}"],
+    swDest = "sw.js",
+    skipWaiting = true,
+    clientsClaim = true,
+    runtimeCaching
+  } = options;
+  (0, import_fs7.mkdirSync)(outputDir, { recursive: true });
+  const swDestPath = (0, import_path6.join)(outputDir, swDest);
+  const workboxConfig = {
+    globDirectory: globDirectory ?? projectPath,
+    globPatterns,
+    swDest: swDestPath,
+    skipWaiting,
+    clientsClaim,
+    mode: "production",
+    sourcemap: false
+  };
+  if (runtimeCaching && runtimeCaching.length > 0) {
+    workboxConfig.runtimeCaching = runtimeCaching.map((cache) => {
+      const handlerMap = {
+        NetworkFirst: "NetworkFirst",
+        CacheFirst: "CacheFirst",
+        StaleWhileRevalidate: "StaleWhileRevalidate",
+        NetworkOnly: "NetworkOnly",
+        CacheOnly: "CacheOnly"
+      };
+      const handler = handlerMap[cache.handler] ?? cache.handler;
+      return {
+        urlPattern: typeof cache.urlPattern === "string" ? new RegExp(cache.urlPattern) : cache.urlPattern,
+        handler,
+        options: cache.options ? {
+          cacheName: cache.options.cacheName,
+          expiration: cache.options.expiration ? {
+            maxEntries: cache.options.expiration.maxEntries,
+            maxAgeSeconds: cache.options.expiration.maxAgeSeconds
+          } : void 0
+        } : void 0
+      };
+    });
+  }
+  try {
+    const result = await (0, import_workbox_build.generateSW)(workboxConfig);
+    return {
+      swPath: swDestPath,
+      count: result.count,
+      size: result.size,
+      warnings: result.warnings ?? [],
+      filePaths: (result.manifestEntries ?? []).map(
+        (entry) => typeof entry === "string" ? entry : entry.url
+      )
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to generate service worker: ${message}`);
+  }
+}
+async function generateAndWriteServiceWorker(options) {
+  return generateServiceWorker(options);
+}
+
+// src/generator/https-checker.ts
+var import_fs8 = require("fs");
+var import_path7 = require("path");
+function checkHttps(url, allowHttpLocalhost = true) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    return {
+      isSecure: false,
+      isLocalhost: false,
+      isProduction: false,
+      protocol: "unknown",
+      hostname: null,
+      warning: "Invalid URL format",
+      recommendation: "Provide a valid URL (e.g., https://example.com or http://localhost:3000)"
+    };
+  }
+  const protocol = parsedUrl.protocol.replace(":", "");
+  const hostname = parsedUrl.hostname;
+  const isHttps = protocol === "https";
+  const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.startsWith("192.168.") || hostname.startsWith("10.") || hostname.startsWith("172.16.") || hostname.endsWith(".local");
+  const isSecure = isHttps || isLocalhost && allowHttpLocalhost;
+  const isProduction = isHttps && !isLocalhost;
+  let warning;
+  let recommendation;
+  if (!isSecure) {
+    if (isLocalhost && !allowHttpLocalhost) {
+      warning = "Service Workers require HTTPS in production. HTTP is only allowed on localhost for development.";
+      recommendation = "Use HTTPS in production or enable allowHttpLocalhost option for development.";
+    } else if (!isLocalhost) {
+      warning = "Service Workers require HTTPS in production. HTTP is not secure and will not work.";
+      recommendation = "Deploy your PWA with HTTPS. Consider using services like Vercel, Netlify, or Cloudflare that provide HTTPS by default.";
+    }
+  }
+  return {
+    isSecure,
+    isLocalhost,
+    isProduction,
+    protocol,
+    hostname,
+    warning,
+    recommendation
+  };
+}
+function detectProjectUrl(projectPath) {
+  const configFiles = [
+    { file: "package.json", key: "homepage" },
+    { file: "package.json", key: "url" },
+    { file: ".env", pattern: /^.*URL.*=(.+)$/i },
+    { file: ".env.local", pattern: /^.*URL.*=(.+)$/i },
+    { file: "vercel.json", key: "url" },
+    { file: "netlify.toml", pattern: /^.*url.*=.*["'](.+)["']/i },
+    { file: "next.config.js", pattern: /baseUrl.*["'](.+)["']/ },
+    { file: "next.config.ts", pattern: /baseUrl.*["'](.+)["']/ }
+  ];
+  for (const config of configFiles) {
+    const filePath = (0, import_path7.join)(projectPath, config.file);
+    if ((0, import_fs8.existsSync)(filePath)) {
+      try {
+        if (config.file.endsWith(".json") && config.key) {
+          const parsed = JSON.parse((0, import_fs8.readFileSync)(filePath, "utf-8"));
+          const content = parsed;
+          const value = content[config.key];
+          if (value && typeof value === "string") {
+            return value;
+          }
+        } else if (config.file.endsWith(".toml") && config.pattern) {
+          const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+          const match = config.pattern ? content.match(config.pattern) : null;
+          if (match && match[1]) {
+            return match[1];
+          }
+        } else if ((config.file.endsWith(".js") || config.file.endsWith(".ts")) && config.pattern) {
+          const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+          const match = config.pattern ? content.match(config.pattern) : null;
+          if (match && match[1]) {
+            return match[1];
+          }
+        } else if (config.file.startsWith(".env") && config.pattern) {
+          const content = (0, import_fs8.readFileSync)(filePath, "utf-8");
+          const lines = content.split("\n");
+          for (const line of lines) {
+            const match = config.pattern ? line.match(config.pattern) : null;
+            if (match && match[1]) {
+              return match[1].trim();
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function checkProjectHttps(options = {}) {
+  const { url, projectPath, allowHttpLocalhost = true } = options;
+  if (url) {
+    return checkHttps(url, allowHttpLocalhost);
+  }
+  if (projectPath) {
+    const detectedUrl = detectProjectUrl(projectPath);
+    if (detectedUrl) {
+      return checkHttps(detectedUrl, allowHttpLocalhost);
+    }
+  }
+  return {
+    isSecure: false,
+    isLocalhost: false,
+    isProduction: false,
+    protocol: "unknown",
+    hostname: null,
+    warning: "Unable to determine project URL. HTTPS check cannot be performed.",
+    recommendation: "Provide a URL explicitly or ensure your project has a valid configuration file (package.json, .env, etc.)."
+  };
+}
+
+// src/injector/html-parser.ts
+var import_htmlparser2 = require("htmlparser2");
+var import_fs9 = require("fs");
+function parseHTMLFile(filePath, options = {}) {
+  const content = (0, import_fs9.readFileSync)(filePath, "utf-8");
+  return parseHTML(content, options);
+}
+function parseHTML(htmlContent, options = {}) {
+  const {
+    decodeEntities = true,
+    lowerCaseAttributeNames = true
+  } = options;
+  const document = (0, import_htmlparser2.parseDocument)(htmlContent, {
+    decodeEntities,
+    lowerCaseAttributeNames,
+    lowerCaseTags: true
+  });
+  let head = null;
+  let body = null;
+  let html = null;
+  const findElements = (node) => {
+    if (node.type === "tag") {
+      const element = node;
+      const tagName = element.tagName.toLowerCase();
+      if (tagName === "head" && !head) {
+        head = element;
+      } else if (tagName === "body" && !body) {
+        body = element;
+      } else if (tagName === "html" && !html) {
+        html = element;
+      }
+      if (element.children) {
+        for (const child of element.children) {
+          findElements(child);
+        }
+      }
+    }
+  };
+  if (document.children) {
+    for (const child of document.children) {
+      findElements(child);
+    }
+  }
+  return {
+    document,
+    head,
+    body,
+    html,
+    originalContent: htmlContent
+  };
+}
+function findElement(parsed, tagName, attribute) {
+  const searchIn = parsed.head || parsed.document;
+  const search = (node) => {
+    if (node.type === "tag") {
+      const element = node;
+      if (element.tagName.toLowerCase() === tagName.toLowerCase()) {
+        if (!attribute) {
+          return element;
+        }
+        const attrValue = element.attributes?.find((attr) => attr.name.toLowerCase() === attribute.name.toLowerCase())?.value;
+        if (attrValue === attribute.value) {
+          return element;
+        }
+      }
+      if (element.children) {
+        for (const child of element.children) {
+          const found = search(child);
+          if (found) {
+            return found;
+          }
+        }
+      }
+    }
+    return null;
+  };
+  if (searchIn) {
+    if (searchIn.type === "tag") {
+      return search(searchIn);
+    }
+    if ("children" in searchIn && searchIn.children) {
+      for (const child of searchIn.children) {
+        const found = search(child);
+        if (found) {
+          return found;
+        }
+      }
+    }
+  }
+  return null;
+}
+function findAllElements(parsed, tagName, attribute) {
+  const results = [];
+  const targetTagName = tagName.toLowerCase();
+  const search = (node, isRoot = false) => {
+    if (node.type === "tag") {
+      const element = node;
+      const nodeTagName = element.tagName.toLowerCase();
+      if (nodeTagName === targetTagName && (!isRoot || targetTagName === "html" || targetTagName === "head" || targetTagName === "body")) {
+        if (!attribute) {
+          results.push(element);
+        } else {
+          const attrValue = element.attributes?.find((attr) => attr.name.toLowerCase() === attribute.name.toLowerCase())?.value;
+          if (attribute.value === void 0 || attrValue === attribute.value) {
+            results.push(element);
+          }
+        }
+      }
+      if (element.children) {
+        for (const child of element.children) {
+          const childElement = child;
+          const childIsRoot = isRoot && childElement.type === "tag" && (childElement.tagName.toLowerCase() === "html" || childElement.tagName.toLowerCase() === "head" || childElement.tagName.toLowerCase() === "body");
+          search(child, childIsRoot);
+        }
+      }
+    }
+  };
+  if (parsed.head) {
+    search(parsed.head, true);
+  } else {
+    if (parsed.document.children) {
+      for (const child of parsed.document.children) {
+        const childElement = child;
+        const childIsRoot = childElement.type === "tag" && (childElement.tagName.toLowerCase() === "html" || childElement.tagName.toLowerCase() === "head" || childElement.tagName.toLowerCase() === "body");
+        search(child, childIsRoot);
+      }
+    }
+  }
+  return results;
+}
+function elementExists(parsed, tagName, attribute) {
+  return findElement(parsed, tagName, attribute) !== null;
+}
+function serializeHTML(parsed) {
+  return parsed.originalContent;
+}
+
+// src/injector/meta-injector.ts
+var import_fs10 = require("fs");
+var import_dom_serializer = require("dom-serializer");
+function injectMetaTags(htmlContent, options = {}) {
+  const parsed = parseHTML(htmlContent);
+  const result = {
+    injected: [],
+    skipped: [],
+    warnings: []
+  };
+  let head = parsed.head;
+  if (!head) {
+    if (parsed.html) {
+      const headElement = {
+        type: "tag",
+        name: "head",
+        tagName: "head",
+        attribs: {},
+        children: [],
+        parent: parsed.html,
+        next: null,
+        prev: null
+      };
+      if (parsed.html.children) {
+        parsed.html.children.unshift(headElement);
+      } else {
+        parsed.html.children = [headElement];
+      }
+      head = headElement;
+      result.warnings.push("Created <head> tag (was missing)");
+    } else {
+      result.warnings.push("No <html> or <head> tag found, meta tags may not be injected correctly");
+      return { html: htmlContent, result };
+    }
+  }
+  if (options.manifestPath) {
+    const manifestHref = options.manifestPath.startsWith("/") ? options.manifestPath : `/${options.manifestPath}`;
+    if (!elementExists(parsed, "link", { name: "rel", value: "manifest" })) {
+      injectLinkTag(head, "manifest", manifestHref);
+      result.injected.push(`<link rel="manifest" href="${manifestHref}">`);
+    } else {
+      result.skipped.push("manifest link (already exists)");
+    }
+  }
+  if (options.themeColor) {
+    const existingThemeColor = findElement(parsed, "meta", { name: "name", value: "theme-color" });
+    if (existingThemeColor) {
+      updateMetaContent(existingThemeColor, options.themeColor);
+      result.injected.push(`<meta name="theme-color" content="${options.themeColor}"> (updated)`);
+    } else if (!elementExists(parsed, "meta", { name: "theme-color", value: options.themeColor })) {
+      injectMetaTag(head, "theme-color", options.themeColor);
+      result.injected.push(`<meta name="theme-color" content="${options.themeColor}">`);
+    } else {
+      result.skipped.push("theme-color (already exists)");
+    }
+  }
+  if (options.appleTouchIcon) {
+    const iconHref = options.appleTouchIcon.startsWith("/") ? options.appleTouchIcon : `/${options.appleTouchIcon}`;
+    if (!elementExists(parsed, "link", { name: "rel", value: "apple-touch-icon" })) {
+      injectLinkTag(head, "apple-touch-icon", iconHref);
+      result.injected.push(`<link rel="apple-touch-icon" href="${iconHref}">`);
+    } else {
+      result.skipped.push("apple-touch-icon (already exists)");
+    }
+  }
+  if (options.appleMobileWebAppCapable !== void 0) {
+    const content = options.appleMobileWebAppCapable ? "yes" : "no";
+    if (!elementExists(parsed, "meta", { name: "apple-mobile-web-app-capable", value: content })) {
+      injectMetaTag(head, "apple-mobile-web-app-capable", content);
+      result.injected.push(`<meta name="apple-mobile-web-app-capable" content="${content}">`);
+    } else {
+      result.skipped.push("apple-mobile-web-app-capable (already exists)");
+    }
+  }
+  if (options.appleMobileWebAppStatusBarStyle) {
+    if (!elementExists(parsed, "meta", { name: "apple-mobile-web-app-status-bar-style", value: options.appleMobileWebAppStatusBarStyle })) {
+      injectMetaTag(head, "apple-mobile-web-app-status-bar-style", options.appleMobileWebAppStatusBarStyle);
+      result.injected.push(`<meta name="apple-mobile-web-app-status-bar-style" content="${options.appleMobileWebAppStatusBarStyle}">`);
+    } else {
+      result.skipped.push("apple-mobile-web-app-status-bar-style (already exists)");
+    }
+  }
+  if (options.appleMobileWebAppTitle) {
+    if (!elementExists(parsed, "meta", { name: "apple-mobile-web-app-title", value: options.appleMobileWebAppTitle })) {
+      injectMetaTag(head, "apple-mobile-web-app-title", options.appleMobileWebAppTitle);
+      result.injected.push(`<meta name="apple-mobile-web-app-title" content="${options.appleMobileWebAppTitle}">`);
+    } else {
+      result.skipped.push("apple-mobile-web-app-title (already exists)");
+    }
+  }
+  const modifiedHtml = (0, import_dom_serializer.render)(parsed.document, { decodeEntities: false });
+  if (options.serviceWorkerPath) {
+    const swPath = options.serviceWorkerPath.startsWith("/") ? options.serviceWorkerPath : `/${options.serviceWorkerPath}`;
+    if (!htmlContent.includes("navigator.serviceWorker")) {
+      const swScript = `
+<script>
+if ('serviceWorker' in navigator) {
+  window.addEventListener('load', () => {
+    navigator.serviceWorker.register('${swPath}')
+      .then((registration) => console.log('SW registered:', registration))
+      .catch((error) => console.error('SW registration failed:', error));
+  });
+}
+</script>`;
+      const finalHtml = modifiedHtml.replace("</body>", `${swScript}
+</body>`);
+      result.injected.push("Service Worker registration script");
+      return { html: finalHtml, result };
+    } else {
+      result.skipped.push("Service Worker registration (already exists)");
+    }
+  }
+  return { html: modifiedHtml, result };
+}
+function injectLinkTag(head, rel, href) {
+  const linkElement = {
+    type: "tag",
+    name: "link",
+    tagName: "link",
+    attribs: {
+      rel,
+      href
+    },
+    children: [],
+    parent: head,
+    next: null,
+    prev: null
+  };
+  if (!head.children) {
+    head.children = [];
+  }
+  head.children.push(linkElement);
+}
+function injectMetaTag(head, name, content) {
+  const metaElement = {
+    type: "tag",
+    name: "meta",
+    tagName: "meta",
+    attribs: {
+      name,
+      content
+    },
+    children: [],
+    parent: head,
+    next: null,
+    prev: null
+  };
+  if (!head.children) {
+    head.children = [];
+  }
+  head.children.push(metaElement);
+}
+function updateMetaContent(metaElement, newContent) {
+  if (metaElement.attribs) {
+    metaElement.attribs.content = newContent;
+  } else {
+    metaElement.attribs = { content: newContent };
+  }
+}
+function injectMetaTagsInFile(filePath, options = {}) {
+  const parsed = parseHTMLFile(filePath);
+  const { html, result } = injectMetaTags(parsed.originalContent, options);
+  (0, import_fs10.writeFileSync)(filePath, html, "utf-8");
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ManifestSchema,
+  STANDARD_ICON_SIZES,
+  STANDARD_SPLASH_SIZES,
+  checkHttps,
+  checkProjectHttps,
+  detectArchitecture,
+  detectAssets,
+  detectFramework,
+  detectProjectUrl,
+  elementExists,
+  findAllElements,
+  findElement,
+  generateAndWriteManifest,
+  generateAndWriteServiceWorker,
+  generateAppleTouchIcon,
+  generateFavicon,
+  generateIcons,
+  generateIconsOnly,
+  generateManifest,
+  generateReport,
+  generateServiceWorker,
+  generateSimpleServiceWorker,
+  generateSplashScreensOnly,
+  injectMetaTags,
+  injectMetaTagsInFile,
+  parseHTML,
+  parseHTMLFile,
+  scanProject,
+  serializeHTML,
+  validateProjectPath,
+  writeManifest
+});